anchor.diff:          Removed
       ),
   
  -    State#state{all_members = NewAllMembers,
  -                common_eagers=NewCommonEagers,
  -                common_lazys=NewCommonLazys,
  -                eager_sets=NewEagerSets,
  -                lazy_sets=NewLazySets}.
  +    State#state{
  +        all_members = NewAllMembers,
  +        common_eagers = NewCommonEagers,
  +        common_lazys = NewCommonLazys,
  +        eager_sets = NewEagerSets,
  +        lazy_sets = NewLazySets
  +    }.
   
   eager_push(MessageId, Message, Mod, State) ->
  -    eager_push(MessageId, Message, Mod, 0, partisan:node_spec(), partisan:node_spec(), State).
  +    eager_push(
  +        MessageId, Message, Mod, 0, partisan:node(), partisan:node(), State
  +    ).
   
   eager_push(MessageId, Message, Mod, Round, Root, From, State) ->
       Peers = eager_peers(Root, From, State),
       ?LOG_DEBUG("eager push to peers: ~p", [Peers]),
  -    _ = send({broadcast, MessageId, Message, Mod, Round, Root, partisan:node_spec()}, Mod, Peers),
  +    ok = send(
  +        {broadcast, MessageId, Message, Mod, Round, Root, partisan:node()},
  +        Mod,
  +        Peers
  +    ),
       State.
   
   schedule_lazy_push(MessageId, Mod, State) ->
  -    schedule_lazy_push(MessageId, Mod, 0, partisan:node_spec(), partisan:node_spec(), State).
  +    schedule_lazy_push(
  +        MessageId, Mod, 0, partisan:node(), partisan:node(), State
  +    ).
   
   schedule_lazy_push(MessageId, Mod, Round, Root, From, State) ->
       Peers = lazy_peers(Root, From, State),
  -    ?LOG_DEBUG("scheduling lazy push to peers ~p: ~p",
  -               [Peers, {MessageId, Mod, Round, Root, From}]),
  +    ?LOG_DEBUG(
  +        "scheduling lazy push to peers ~p: ~p",
  +        [Peers, {MessageId, Mod, Round, Root, From}]
  +    ),
       ok = add_all_outstanding(MessageId, Mod, Round, Root, Peers),
       State.
   
   
   send_lazy() ->
       ok = ets:foldl(
  -        fun({Peer, Message}, Acc) -> _ = send_lazy(Message, Peer), Acc end,
  +        fun({Peer, Message}, Acc) ->
  +            ok = send_lazy(Message, Peer), Acc
  +        end,
           ok,
           ?PLUMTREE_OUTSTANDING
       ).
   
   
  --spec send_lazy(outstanding(), any()) -> ok.
  +-spec send_lazy(outstanding(), node()) -> ok.
   
   send_lazy({MessageId, Mod, Round, Root}, Peer) ->
       ?LOG_DEBUG(#{
           description => "sending lazy push ~p",
  -        message => {i_have, MessageId, Mod, Round, Root, partisan:node_spec()}
  +        message => {i_have, MessageId, Mod, Round, Root, partisan:node()}
       }),
  -    send({i_have, MessageId, Mod, Round, Root, partisan:node_spec()}, Mod, Peer).
  +    send({i_have, MessageId, Mod, Round, Root, partisan:node()}, Mod, Peer).
  +
   
   maybe_exchange(State) ->
       Root = random_root(State),
  
positive.code:                      ordsets:to_list(OrdSet))
      end.
  
  ack_outstanding(MessageId, Mod, Round, Root, From) ->
      true = ets:delete_object(
          ?PLUMTREE_OUTSTANDING, {From, {MessageId, Mod, Round, Root}}
      ),
      ok.
  
  add_all_outstanding(MessageId, Mod, Round, Root, Peers) ->
      Message = {MessageId, Mod, Round, Root},
  
negative.code:     State2 = neighbors_down(Removed, State1),
      {noreply, State2}.
  
  
  -spec handle_info(
      'exchange_tick' | 'lazy_tick' | {'DOWN', _, 'process', _, _}, state()) ->
      {noreply, state()}.
  
  handle_info(lazy_tick, #state{lazy_tick_period = Period} = State) ->
      ok = send_lazy(),
      schedule_lazy_tick(Period),
      {noreply, State};
  handle_info(exchange_tick, #state{exchange_tick_period = Period} = State) ->
      State1 = maybe_exchange(State),
      schedule_exchange_tick(Period),
      {noreply, State1};
  handle_info(
      {'DOWN', Ref, process, _Pid, _Reason}, State=#state{exchanges=Exchanges}) ->
      Exchanges1 = lists:keydelete(Ref, 3, Exchanges),
      {noreply, State#state{exchanges=Exchanges1}}.
  
  
  -spec terminate(term(), state()) -> term().
  
  terminate(_Reason, _State) ->
      ok.
  
  
  -spec code_change(term() | {down, term()}, state(), term()) -> {ok, state()}.
  
  code_change(_OldVsn, State, _Extra) ->
      {ok, State}.
  
  
  
  %% =============================================================================
  %% PRIVATE
  %% =============================================================================
  
  
  
  handle_broadcast(
      false, _MessageId, _Message, Mod, _Round, Root, From, State) ->
      %% stale msg
      %% remove sender from eager and set as lazy
      ?LOG_DEBUG("moving peer ~p from eager to lazy", [From]),
      State1 = add_lazy(From, Root, State),
      ok = send({prune, Root, partisan:node()}, Mod, From),
      State1;
  
  handle_broadcast(true, MessageId, Message, Mod, Round, Root, From, State) ->
      %% valid msg
      %% remove sender from lazy and set as eager
      State1 = add_eager(From, Root, State),
      State2 = eager_push(MessageId, Message, Mod, Round + 1, Root, From, State1),
      schedule_lazy_push(MessageId, Mod, Round + 1, Root, From, State2).
  
  handle_ihave(true, MessageId, Mod, Round, Root, From, State) ->
      %% stale i_have
      ok = send(
          {ignored_i_have, MessageId, Mod, Round, Root, partisan:node()},
          Mod,
          From
      ),
      State;
  handle_ihave(false, MessageId, Mod, Round, Root, From, State) ->
      %% valid i_have
      %% TODO: don't graft immediately
      ok = send(
          {graft, MessageId, Mod, Round, Root, partisan:node()}, Mod, From
      ),
      add_eager(From, Root, State).
  
  handle_graft(stale, MessageId, Mod, Round, Root, From, State) ->
      %% There has been a subsequent broadcast that is causally newer than this
      %% message according to Mod. We ack the outstanding message since the
      %% outstanding entry for the newer message exists.
      ok = ack_outstanding(MessageId, Mod, Round, Root, From),
      State;
  
  handle_graft({ok, Message}, MessageId, Mod, Round, Root, From, State) ->
      %% We don't ack outstanding here because the broadcast may fail to be
      %% delivered.
      %% Instead we will allow the i_have to be sent once more and let the
      %% subsequent ignore serve as the ack.
      State1 = add_eager(From, Root, State),
      ok = send(
          {broadcast, MessageId, Message, Mod, Round, Root, partisan:node()},
          Mod,
          From
      ),
      State1;
  
  handle_graft({error, Reason}, _MessageId, Mod, _Round, _Root, _From, State) ->
      ?LOG_ERROR(#{
          description => "Unable to graft message",
  