anchor.diff:  %% @doc Anti-entropy mechanism.
   -spec exchange(node()) -> {ok, pid()}.
   exchange(Peer) ->
  +    lager:info("Exchange triggered for peer: ~p", [Peer]),
  +
       case lasp_config:get(mode, state_based) of
           delta_based ->
  -            %% Anti-entropy mechanism for causal consistency of delta-CRDT.
  -            {ok, Pid, GCCounter} = gen_server:call(?MODULE, {exchange, Peer}, infinity),
  -            MaxGCCounter = lasp_config:get(delta_mode_max_gc_counter, ?MAX_GC_COUNTER),
  -            case GCCounter == MaxGCCounter of
  -                true ->
  -                    gen_server:call(?MODULE, delta_gc, infinity);
  -                false ->
  -                    {ok, Pid}
  -            end;
  +            %% Delta anti-entropy mechanism; ship buffered updates.
  +            init_delta_sync(Peer);
           state_based ->
               %% Naive anti-entropy mechanism; re-broadcast all messages.
               gen_server:call(?MODULE, exchange, infinity)
  
positive.code:                         end
                  end
          end,
      Pid = spawn(
              fun() ->
                      {ok, Results} = do(fold, [Store, Function, []]),
                      lists:foreach(
                        fun({ok, Id, DeltaMap, RemovedAckMap}) ->
                                case do(get, [Store, Id]) of
                                    {ok, Object} ->
                                        _ = do(put,
                                               [Store, Id,
                                                Object#dv{delta_map=DeltaMap,
                                                          delta_ack_map=RemovedAckMap}]),
                                        ok;
                                    _ ->
                                        ok
                                end
                        end, Results)
              end),
      {reply, {ok, Pid}, State#state{gc_counter=0}};
  
  %% @private
  handle_call(Msg, _From, State) ->
      _ = lager:warning("Unhandled messages: ~p", [Msg]),
      {reply, ok, State}.
  
  -spec handle_cast(term(), #state{}) -> {noreply, #state{}}.
  handle_cast({delta_send, From, {Id, Type, _Metadata, Deltas}, Counter},
              #state{store=Store, actor=Actor}=State) ->
      ?CORE:receive_delta(Store, {delta_send,
                                 {Id, Type, _Metadata, Deltas},
                                 ?CLOCK_INCR(Actor),
                                 ?CLOCK_INIT(Actor)}),
      send({delta_ack, node(), Id, Counter}, From),
      {noreply, State};
  
  handle_cast({delta_ack, From, Id, Counter}, #state{store=Store}=State) ->
      ?CORE:receive_delta(Store, {delta_ack, Id, From, Counter}),
      {noreply, State};
  
  %% @private
  handle_cast(Msg, State) ->
      _ = lager:warning("Unhandled messages: ~p", [Msg]),
      {noreply, State}.
  
  %% @private
  -spec handle_info(term(), #state{}) -> {noreply, #state{}}.
  handle_info(memory_report, State) ->
      %% Log
      memory_report(),
  
      %% Schedule report.
      schedule_memory_report(),
  
      {noreply, State};
  handle_info(Msg, State) ->
      _ = lager:warning("Unhandled messages: ~p", [Msg]),
      {noreply, State}.
  
negative.code:                 erlang:monotonic_time(),
                  erlang:unique_integer()),
  
      schedule_delta_synchronization(),
      schedule_delta_garbage_collection(),
  
      {ok, Actor} = lasp_unique:unique(),
  
      Counter = 0,
  