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:                 erlang:monotonic_time(),
                  erlang:unique_integer()),
  
      {ok, Actor} = lasp_unique:unique(),
  
      Counter = 0,
  
negative.code:     end,
      {reply, Result, State};
  
  %% Naive anti-entropy mechanism; periodically re-broadcast all messages.
  handle_call(exchange, _From, #state{store=Store}=State) ->
      Function = fun({Id, #dv{type=Type, metadata=Metadata, value=Value}}, Acc0) ->
                      case orddict:find(dynamic, Metadata) of
                          {ok, true} ->
                              %% Ignore: this is a dynamic variable.
                              ok;
                          _ ->
                              broadcast({Id, Type, Metadata, Value})
                      end,
                      [{ok, {Id, Type, Metadata, Value}}|Acc0]
                 end,
      Pid = spawn(fun() -> do(fold, [Store, Function, []]) end),
      {reply, {ok, Pid}, State};
  
  %% @private
  handle_call(Msg, _From, State) ->
      _ = lager:warning("Unhandled messages: ~p", [Msg]),
      {reply, ok, State}.
  
  -spec handle_cast(term(), #state{}) -> {noreply, #state{}}.
  %% Anti-entropy mechanism for causal consistency of delta-CRDT;
  %% periodically ship delta-interval or entire state.
  handle_cast({exchange, Peer}, #state{store=Store, gc_counter=GCCounter}=State) ->
      lager:info("Exchange starting for ~p", [Peer]),
  
      Function = fun({Id, #dv{value=Value, type=Type, metadata=Metadata,
                              delta_counter=Counter, delta_map=DeltaMap,
                              delta_ack_map=AckMap}},
  