anchor.diff:  
   on({reconcile, {get_chunk_response, {RestI, DBList0}}} = _Msg,
      State = #rr_recon_state{stage = reconciliation,     initiator = true,
  -                           method = RMethod,           struct = SyncStruct})
  +                           method = RMethod,           params = Params})
     when RMethod =:= merkle_tree orelse RMethod =:= art->
       ?TRACE1(_Msg, State),
       % no need to map keys since the other node's bloom filter was created with
       % keys mapped to our interval
       DBList = [encodeBlob(KeyX, VersionX) || {KeyX, VersionX} <- DBList0],
       MySyncI = case RMethod of
  -                  merkle_tree -> case merkle_tree:is_merkle_tree(SyncStruct) of
  -                                     false -> SyncStruct#merkle_params.interval;
  -                                     true  -> merkle_tree:get_interval(SyncStruct)
  -                                 end;
  -                  art         -> art:get_interval(SyncStruct)
  +                  merkle_tree -> Params#merkle_params.interval;
  +                  art         -> art:get_interval(Params)
                 end,
       build_struct(DBList, MySyncI, RestI, State);
   
  
positive.code:     
      DhtNodePid = State#rr_recon_state.dhtNodePid,
      send_chunk_req(DhtNodePid, self(), MySyncI, MySyncI, get_max_items(RMethod), true),
      State#rr_recon_state{stage = reconciliation, struct = SyncStruct,
                           method = RMethod, initiator = true,
                           dest_recon_pid = DestReconPid};
  
  on({reconcile, {get_chunk_response, {RestI, DBList0}}} = _Msg,
     State = #rr_recon_state{stage = reconciliation,     initiator = true,
                             method = bloom,             dhtNodePid = DhtNodePid,
                             struct = #bloom_recon_struct{bloom = BF},
                             dest_rr_pid = DestRU_Pid,   stats = Stats,
                             ownerPid = OwnerL}) ->
      ?TRACE1(_Msg, State),
  
negative.code:          dest_recon_pid     = undefined                                 :: comm:mypid() | undefined, %dest recon process pid
           method             = undefined                                 :: method() | undefined,
           dest_interval      = intervals:empty()                         :: intervals:interval(),
           params             = {}                                        :: parameters() | {}, % parameters from the other node
           struct             = {}                                        :: sync_struct() | {}, % my recon structure
           stage              = req_shared_interval                       :: stage(),
           initiator          = false                                     :: boolean(),
           stats              = rr_recon_stats:new()                      :: rr_recon_stats:stats()
  