anchor.diff:  -spec(correct_redundancies(binary()) ->
                ok | {error, any()}).
   correct_redundancies(Key) ->
  -    {ok, #redundancies{nodes = Redundancies,
  -                       id    = AddrId}} = leo_redundant_manager_api:get_redundancies_by_key(Key),
  -    Redundancies_1 = get_redundancies_with_replicas(
  -                       AddrId, Key, Redundancies),
  -    correct_redundancies_1(Key, AddrId, Redundancies_1, [], []).
  +    case leo_redundant_manager_api:get_redundancies_by_key(Key) of
  +        {ok, #redundancies{nodes = Redundancies,
  +                           id    = AddrId}} ->
  +            Redundancies_1 = get_redundancies_with_replicas(
  +                               AddrId, Key, Redundancies),
  +            correct_redundancies_1(Key, AddrId, Redundancies_1, [], []);
  +        _Error ->
  +            {error, ?ERROR_COULD_NOT_GET_REDUNDANCY}
  +    end.
   
   %% correct_redundancies_1/5 - next.
   %%
   -spec(correct_redundancies_1(binary(), integer(), list(), list(), list()) ->
                ok | {error, any()}).
   correct_redundancies_1(_Key,_AddrId, [], [], _ErrorNodes) ->
  -    {error, not_found};
  +    {error, not_solved};
   
   correct_redundancies_1(_Key,_AddrId, [], Metadatas, ErrorNodes) ->
       correct_redundancies_2(Metadatas, ErrorNodes);
  
positive.code: -spec(correct_redundancies_2(list(), list()) ->
               ok | {error, any()}).
  correct_redundancies_2(ListOfMetadata, ErrorNodes) ->
      [{_, Metadata} = H|_] = lists:sort(
                                fun({_, M1}, {_, M2}) ->
                                        M1#?METADATA.clock >= M2#?METADATA.clock;
                                   (_,_) ->
                                        false
                                end, ListOfMetadata),
  
      {_, CorrectNodes, InconsistentNodes} =
          lists:foldl(
            fun({Node, _},
                {{DestNode, _Metadata} = Dest, C, R}) when Node =:= DestNode ->
                    {Dest, [Node|C], R};
               ({Node, #?METADATA{clock = Clock}},
                {{DestNode, #?METADATA{clock = DestClock}} = Dest, C, R}) when Node  =/= DestNode,
                                                                               Clock =:= DestClock ->
                    {Dest, [Node|C], R};
               ({Node, #?METADATA{clock = Clock}},
                {{DestNode, #?METADATA{clock = DestClock}} = Dest, C, R}) when Node  =/= DestNode,
                                                                               Clock =/= DestClock ->
                    {Dest, C, [Node|R]}
            end, {H, [], []}, ListOfMetadata),
      correct_redundancies_3(ErrorNodes ++ InconsistentNodes, CorrectNodes, Metadata).
  
negative.code:                 {value, {ok, Metadata}} ->
                      correct_redundancies_1(Key, AddrId, T,
                                             [{Node, Metadata}|Metadatas], ErrorNodes);
                  {value, not_found} ->
                      correct_redundancies_1(Key, AddrId, T,
                                             [{Node, #?METADATA{key = Key,
                                                                addr_id = AddrId,
                                                                del = ?DEL_TRUE}}|Metadatas], ErrorNodes);
                  _Error ->
                      correct_redundancies_1(Key, AddrId, T,
                                             Metadatas, [Node|ErrorNodes])
  