5.4 Programs
5.4.1 Validity
5.4.2 Modules
5.4.3 Steps
5.4.4 Local Steps
5.4.5 Consensus Steps
5.4.6 Computations
On this page: Statements commit
commit only and each Participant.set and .set while
while continue
continue parallel_  reduce
parallel_  reduce Expressions this transfer
transfer require
require check  Commitment
check  Commitment
5.4.5 Consensus Steps

A Reach consensus step occurs in the continuation of a consensus transfer statement. It represents the actions taken by the consensus network contract of an application. Statements

Any statements valid for a computation are valid for a consensus step. However, some additional statements are allowed. commit


A commit statement, written commit();, commits to statement’s continuation as the next step of the DApp computation. In other words, it ends the current consensus step and allows more local steps. only and each

only and each are allowed in consensus steps and are executed by backends once they observe the completion of the consensus step (i.e., after the associated commit statement.) Participant.set and .set

Participant.set(PART, ADDR);

After execution, the given participant is fixed to the given address. It is invalid to attempt to .set a participant class. If a backend is running for this participant and its address does not match the given address, then it will abort. This may only occur within a consensus step.

Workshop: Relay Account is a good introductory project that demonstrates how to use this feature of Reach. while

var [ heap1, heap2 ] = [ 21, 21 ];
invariant(balance() == 2 * wagerAmount);
while ( heap1 + heap2 > 0 ) {
  [ heap1, heap2 ] = [ heap1 - 1, heap2 ];
  continue; } 

A while statement may occur within a consensus step and is written:


where LHS is a valid left-hand side of an identifier definition where the expression INIT_EXPR is the right-hand side, and INVARIANT_EXPR is an expression, called the loop invariant, that must be true before and after every execution of the block BLOCK, and if COND_EXPR is true, then the block executes, and if not, then the loop terminates and control transfers to the continuation of the while statement. The identifiers bound by LHS are bound within INVARIANT_EXPR, COND_EXPR, BLOCK, and the tail of the while statement.

Read about finding loop invariants in the Reach guide. continue

[ heap1, heap2 ] = [ heap1 - 1, heap2 ];

A continue statement may occur within a while statement’s block and is written:


where the identifiers bound by LHS are a subset of the variables bound by the nearest enclosing while statement and UPDATE_EXPR is an expression which may be bound by LHS.

A continue statement is a terminator statement, so it must have an empty tail.

A continue statement may be written without the preceding identifier update, which is equivalent to writing

[] = [];

A continue statement must be dominated by a consensus transfer, which means that the body of a while statement must always commit(); before calling continue;. This restriction may be lifted in future versions of Reach, which will perform termination checking. parallel_reduce

const [ keepGoing, as, bs ] =
  parallel_reduce([ true, 0, 0 ])
  .invariant(balance() == 2 * wager)
  .case(Alice, (() => ({
    when: declassify(interact.keepGoing()) })),
    () => {
      each([Alice, Bob], () => {
        interact.roundWinnerWas(true); });
      return [ true, 1 + as, bs ]; })
  .case(Bob, (() => ({
    when: declassify(interact.keepGoing()) })),
    () => {
      each([Alice, Bob], () => {
        interact.roundWinnerWas(false); });
      return [ true, as, 1 + bs ]; })
  .timeout(deadline, () => {
    race(Alice, Bob).publish();
    return [ false, as, bs ]; });

A parallel reduce statement is written:

const LHS =
  .timeout(DELAY_EXPR, () =>

The LHS and INIT_EXPR are like the initialization component of a while loop; and, the .invariant and .while components are like the invariant and condition of a while loop; while the .case and .timeout components are like the corresponding components of a fork statement.

The .case component may be repeated many times, provided the PART_EXPRs each evaluate to a unique participant, just like in a fork statement.

A parallel reduce statement is essentially an abbreviation of pattern of a while loop combined with a fork statement that you could write yourself. This is an extremely common pattern in decentralized applications.

The idea is that there are some values (the LHS) which after intialization will be repeatedly updated uniquely by each of the racing participants until the condition does not hold.

while(COND_EXPR) {
    () => {
      continue; })
  .timeout(DELAY_EXPR, () =>
} Expressions

Any expressions valid for a computation are valid for a consensus step. However, some additional expressions are allowed. this

Inside of a consensus step, this refers to the address of the participant that performed the consensus transfer. This is useful when the consensus transfer was initiated by a race expression. transfer


A transfer expression, written transfer(AMOUNT_EXPR).to(PART), where AMOUNT_EXPR is an expression that evaluates to a natural number and PART is a participant identifier, performs a transfer of network tokens from the contract to the named participant. AMOUNT_EXPR must evaluate to less than or equal to the balance of network tokens in the contract account. A transfer expression may only occur within a consensus step. require

require( claim, [msg] ) 

A requirement where claim evaluates to true with honest participants. This may only appear in a consensus step. It accepts an optional bytes argument, which is included in any reported violation. checkCommitment

checkCommitment( commitment, salt, x ) 

Makes a requirement that commitment is the digest of salt and x. This is used in a consensus step after makeCommitment was used in a local step.