anchor.diff:      Updates = decode_au_txn_ops(Ops),
       Clock = binary_to_term(BClock),
       Response =
  -        case Clock of 
  -            ignore -> 
  +        case Clock of
  +            ignore ->
                   antidote:clocksi_bulk_update(Updates);
  -            _ -> 
  +            _ ->
                   antidote:clocksi_bulk_update(Clock, Updates)
           end,
  -    case Response of 
  +    case Response of
           {error, _Reason} ->
               {reply, #fpbatomicupdatetxnresp{success = false}, State};
           {ok, {_Txid, _ReadSet, CommitTime}} ->
  
positive.code:     ReadReqs = decode_snapshot_read_ops(Ops),
      %%TODO: change this to interactive reads
      Clock = binary_to_term(BClock),
      Response = 
          case Clock of 
              ignore -> 
                  antidote:clocksi_execute_tx(ReadReqs);
              _ -> antidote:clocksi_execute_tx(Clock, ReadReqs)
          end,
      case Response of 
          {ok, {_TxId, ReadSet, CommitTime}} ->
              Zipped = lists:zip(ReadReqs, ReadSet),
              Reply = encode_snapshot_read_response(Zipped),
  
negative.code: process_stream(_,_,State) ->
      {ignore, State}.
  
  %% @doc decode_au_txn_ops : converts the pb messages for atomic update
  %% transaction into update messages for interface in antidote.erl
  -spec decode_au_txn_ops([#fpbatomicupdatetxnop{}]) ->
                                 [{update, key(), type(), op()}].
  decode_au_txn_ops(Ops) ->
      lists:foldl(fun(Op, Acc) ->
  