anchor.diff:  -spec monitor_node(node() | node_spec()) -> true.
   
   monitor_node(Node) when is_atom(Node) ->
  -    monitor_node(Node, true).
  +    case Node == partisan_peer_service:mynode() of
  +        true ->
  +            true;
  +        false ->
  +            partisan_gen_server:call(?MODULE, {monitor_node, Node})
  +    end.
   
   
   %% -----------------------------------------------------------------------------
  
positive.code: 
      %% Every time a node goes down we will get a {nodedown, Node} message
      Fun = fun(Node) -> Me ! {nodedown, Node} end,
      Mod = partisan_peer_service:manager(),
      ok = Mod:on_down('_', Fun),
  
      {ok, #{}}.
  
  %% @private
  handle_call({monitor, PidAsList}, {PartisanRemote, _PartisanRemoteRef}, State0) ->
      %% We monitor the process
      Pid = list_to_pid(PidAsList),
      Ref = erlang:monitor(process, Pid),
  
      PartisanRef = partisan_util:ref(Ref),
      State1 = maps:put(Ref, {PartisanRef, PartisanRemote}, State0),
      State2 = maps:put(PartisanRef, Ref, State1),
  
      %% We store a mapping from remote Node name so that we can cleanup monitors
      %% when the PartisanRemote node goes down
      {partisan_remote_reference, Name, _} = PartisanRemote,
      StateFinal = append_ref_by_node(Name, PartisanRef, State2),
  
      {reply, PartisanRef, StateFinal};
  
  handle_call({demonitor, PartisanRef}, _From, State) ->
      StateFinal = do_demonitor(PartisanRef, State),
      {reply, true, StateFinal};
  
  handle_call({monitor_node, Node, true}, {PartisanRemote, _} = From, State0) ->
      %% The caller is always a local process
      {partisan_remote_reference, MyNode,
           {partisan_process_reference, PidAsList}} = PartisanRemote,
  
      case MyNode == Node of
          true ->
              {reply, false, State0};
          false ->
              Pid = list_to_pid(PidAsList),
              Mod = partisan_peer_service:manager(),
  
              case Mod:member(Node) of
                  true ->
                      StateFinal = append_pid_by_node(Node, Pid, State0),
                      {reply, true, StateFinal};
                  false ->
                      ok = partisan_gen_server:reply(From, true),
                      Pid ! {nodedown, Node},
                      {noreply, State0}
              end
      end;
  
  handle_call({monitor_node, Node, false}, From, State) ->
      StateFinal = remove_pid_by_node(Node, From, State),
      {reply, true, StateFinal};
  
  handle_call(_Msg, _From, State) ->
      {reply, ok, State}.
  
negative.code:     {noreply, State}.
  
  %% @private
  handle_info({'DOWN', MRef, process, Pid, Reason}, State0) ->
      State = case take_process_monitor(MRef, State0) of
          {{Pid, RemotePid}, State1} ->
              ok = send_process_down(RemotePid, MRef, Pid, Reason),
              State1;
  
          error ->
              State0
      end,
  
      {noreply, State};
  
  handle_info({nodedown, Node} = Msg, State0) ->
      %% We need to notify all local processes monitoring Node
      {Pids, State1} = take_node_monitors(Node, State0),
      [partisan_peer_service:forward_message(Pid, Msg) || Pid <- Pids],
  
      %% We need to demonitor all monitors associated with Node
      Refs = refs_by_node(Node, State1),
  
      State = lists:foldl(
          fun(Ref, Acc) -> do_demonitor(Ref, Acc) end,
          State1,
          Refs
      ),
  
      {noreply, State};
  
  handle_info(_Msg, State) ->
      {noreply, State}.
  
  
  %% @private
  terminate(_Reason, _State) ->
      ok.
  
  
  %% @private
  code_change(_OldVsn, State, _Extra) ->
      {ok, State}.
  