anchor.diff:  
   
   %% @private
  -decode_ref(
  -    {partisan_remote_reference, _, {partisan_encoded_reference, RefAsList}}) ->
  -    erlang:list_to_ref(RefAsList);
  -
   decode_ref(Ref) when is_reference(Ref) ->
  -    Ref.
  -
  -
  -decode_pid(
  -    {partisan_remote_reference, _, {partisan_process_reference, PidAsList}}) ->
  -    list_to_pid(PidAsList);
  -
  +    Ref;
  +
  +decode_ref(RemoteRef) ->
  +    partisan_remote_ref:to_term(RemoteRef).
  +
  +
  +%% @private
   decode_pid(Pid) when is_pid(Pid) ->
  -    Pid.
  +    Pid;
  +
  +decode_pid(RemoteRef) ->
  +    partisan_remote_ref:to_term(RemoteRef).
   
   
   %% @private
  
positive.code:     %% require to implement monitors
      {reply, {error, not_implemented}, State};
  
  handle_call({monitor, Ref, _Opts}, {RemotePid, _RemoteRef}, State0) ->
      %% A remote process wants to monitor Ref on this node
      %% TODO Implement {tag, UserDefinedTag} option
      try
          {partisan_remote_reference, Nodename, _} = RemotePid,
  
          MPid = case Ref of
              {partisan_process_reference, Val} ->
                  list_to_pid(Val);
              {partisan_registered_name_reference, Val} ->
                  list_to_atom(Val)
          end,
  
          %% We monitor the process on behalf of the remote caller
          MRef = erlang:monitor(process, MPid),
  
          %% We track the ref to match the 'DOWN' signal
          State = add_process_monitor(Nodename, MRef, {MPid, RemotePid}, State0),
  
          %% We reply the encoded monitor reference
          Reply = {ok, partisan_util:ref(MRef)},
  
          {reply, Reply, State}
      catch
  
negative.code:     ),
  
      State = State0#state{
          up_nodes = sets:add_element(Node, State0#state.up_nodes)
      },
  
      {noreply, State};
  