anchor.diff:  %%% Node Functions
   %%%===================================================================
   
  --record(node_state, {}).
  +-record(node_state, {messages}).
   
   %% What node-specific operations should be called.
   node_commands() ->
       [
  -        {call, ?MODULE, submit_transaction, [node_name()]},
  -        {call, ?MODULE, wait, [node_name()]}
  +        {call, ?MODULE, submit_transaction, [node_name(), message()]}
       ].
   
   %% Assertion commands.
   node_assertion_functions() ->
  -    [].
  +    [check].
   
   %% Global functions.
   node_global_functions() ->
  -    [sleep].
  +    [sleep, check].
   
   %% What should the initial node state be.
   node_initial_state() ->
       node_debug("initializing", []),
  -    #node_state{}.
  +    #node_state{messages=[]}.
   
   %% Names of the node functions so we kow when we can dispatch to the node
   %% pre- and postconditions.
  
positive.code:     lists:map(fun({call, _Mod, Fun, _Args}) -> Fun end, node_commands()).
  
  %% Precondition.
  node_precondition(_NodeState, {call, ?MODULE, submit_transaction, [_Node]}) ->
      true;
  node_precondition(_NodeState, {call, ?MODULE, wait, [_Node]}) ->
      true;
  node_precondition(_NodeState, {call, ?MODULE, sleep, []}) ->
      true;
  node_precondition(_NodeState, _Command) ->
      false.
  
  %% Next state.
  node_next_state(_State, NodeState, _Response, _Command) ->
      NodeState.
  
  %% Postconditions for node commands.
  node_postcondition(_NodeState, {call, ?MODULE, submit_transaction, [_Node]}, _Result) ->
      true;
  node_postcondition(_NodeState, {call, ?MODULE, wait, [_Node]}, _Result) ->
      true;
  node_postcondition(_NodeState, {call, ?MODULE, sleep, []}, _Result) ->
      true;
  node_postcondition(_NodeState, Command, Response) ->
      node_debug("generic postcondition fired (this probably shouldn't be hit) for command: ~p with response: ~p", 
                 [Command, Response]),
  
negative.code: -define(NAME, fun(Name) -> [{_, NodeName}] = ets:lookup(?ETS, Name), NodeName end).
  
  %% @private
  check() ->
      %% Get workers.
      [{workers, Workers}] = ets:lookup(prop_partisan, workers),
  
      %% Wait for all the worker's mailboxes to settle and wait for the chains to converge.
      ok = wait_until(fun() ->
                              Chains = sets:from_list(lists:map(fun({_Node, {ok, W}}) ->
                                                                        {ok, Blocks} = partisan_hbbft_worker:get_blocks(W),
                                                                        Blocks
                                                                end, Workers)),
  
                              0 == lists:sum([element(2, rpc:call(?NAME(Name1), erlang, process_info, [W, message_queue_len])) || {{Name1, _}, {ok, W}} <- Workers]) andalso
                              1 == sets:size(Chains) andalso
                              0 /= length(hd(sets:to_list(Chains)))
                      end, 60*2, 500),
  
      Chains = sets:from_list(lists:map(fun({_Node, {ok, Worker}}) ->
                                                {ok, Blocks} = partisan_hbbft_worker:get_blocks(Worker),
                                                Blocks
                                        end, Workers)),
      ct:pal("~p distinct chains~n", [sets:size(Chains)]),
  
      Chains.
  
  %% @private
  submit_transaction(Node, Message) ->
      ?PROPERTY_MODULE:command_preamble(Node, [submit_transaction, Node]),
  
      %% Get number of nodes.
  