anchor.diff:  %% @doc Contact the leader computed in the prepare state for it to execute the
   %%      operation, wait for it to finish (synchronous) and go to the prepareOP
   %%       to execute the next operation.
  -%% TODO these seem to only get triggered by internal timeouts
  -execute_op(timeout, _TimeoutPeriod, State = #tx_coord_state{operations = Operations, from = From}) ->
  +%% internal state timeout
  +execute_op(state_timeout, timeout, State = #tx_coord_state{operations = Operations, from = From}) ->
       execute_op({call, From}, Operations, State);
   
   %% update kept for backwards compatibility with tests.
  
positive.code: %% Used by static update and read transactions
  start_tx(cast, {start_tx, From, ClientClock, Properties, Operation}, SD) ->
      {next_state, execute_op, start_tx_internal(From, ClientClock, Properties,
          SD#tx_coord_state{is_static = true, operations = Operation, from = From}), 0}.
  
  
  
  
negative.code: 
  %%%== receive_logging_responses
  
  %% internal state timeout
  receive_logging_responses(state_timeout, timeout, State) ->
      receive_logging_responses(cast, timeout, State);
  %% @doc This state reached after an execute_op(update_objects[Params]).
  %% update_objects calls the perform_update function, which asynchronously
  %% sends a log operation per update, to the vnode responsible of the updated
  %% key. After sending all those messages, the coordinator reaches this state
  %% to receive the responses of the vnodes.
  receive_logging_responses(cast, Response, S0 = #tx_coord_state{
      is_static = IsStatic,
      num_to_read = NumToReply,
  