anchor.diff:      rm_loop:unsubscribe(self(), RMSubscrTag),
       State1 = dht_node_state:rm_db_range(State, slide_op:get_interval(SlideOp1)),
       State2 = dht_node_state:rm_msg_fwd(State1, slide_op:get_interval(SlideOp1)),
  -    abort_slide(State2, slide_op:get_node(SlideOp1), slide_op:get_id(SlideOp1),
  +    % set a 'null' slide_op if there was an old one with the given ID
  +    Type = slide_op:get_type(SlideOp1),
  +    PredOrSucc = slide_op:get_predORsucc(Type),
  +    State3 = dht_node_state:set_slide(State2, PredOrSucc, null),
  +    NewDB = ?DB:stop_record_changes(dht_node_state:get(State3, db),
  +                                    slide_op:get_interval(SlideOp)),
  +    State4 = dht_node_state:set_db(State3, NewDB),
  +    abort_slide(State4, slide_op:get_node(SlideOp1), slide_op:get_id(SlideOp1),
                   slide_op:get_phase(SlideOp1),
                   slide_op:get_source_pid(SlideOp1), slide_op:get_tag(SlideOp1),
  -                slide_op:get_type(SlideOp1), Reason, NotifyNode).
  +                Type, Reason, NotifyNode).
   
   %% @doc Like abort_slide/5 but does not need a slide operation in order to
   %%      work. Note: prefer using abort_slide/5 when a slide operation is
  
positive.code:     MoveFullId = util:get_global_uid(),
      MyNode = dht_node_state:get(State, node),
      TargetNode = dht_node_state:get(State, PredOrSucc),
      setup_slide_with(State, {slide, PredOrSucc, SendOrReceive},
                       MoveFullId, MyNode, TargetNode, TargetId, Tag,
                       get_max_transport_bytes(), SourcePid, true).
  
  %% @doc Creates a slide with the node's predecessor. The predecessor will
  %%      change its ID to TargetId, SourcePid will be notified about the result.
  
negative.code:                   NotifyNode::boolean()) -> dht_node_state:state().
  abort_slide(State, Node, SlideOpId, Phase, SourcePid, Tag, Type, Reason, NotifyNode) ->
      PredOrSucc = slide_op:get_predORsucc(Type),
      % abort slide on the (other) node:
      case NotifyNode of
          true ->
              PredOrSuccOther = case PredOrSucc of
                                    pred -> succ;
                                    succ -> pred
                                end,
              comm:send(node:pidX(Node),
                        {move, slide_abort, PredOrSuccOther, SlideOpId, Reason});
          _ -> ok
      end,
      notify_source_pid(SourcePid, {move, result, Tag, Reason}),
      % re-start a leaving slide on the leaving node if it hasn't left the ring yet:
      case slide_op:is_leave(Type, 'send') andalso
               not slide_op:is_jump(Type) andalso
               lists:member(Phase, [null, wait_for_succ_ack]) of
          true -> make_slide_leave(State);
          _    -> State
      end.
  
  %% @doc Creates a slide with the node's successor or predecessor. TargetId will
  