anchor.diff:  
       DecoderName1 = case DecoderName of
                          [] -> "fuse_messages";
  -                       _ -> DecoderName
  +                       _  -> DecoderName
                      end,
   
       {Decoder, DecodingFun} = try
  -        {list_to_existing_atom(DecoderName1 ++ "_pb"), list_to_existing_atom("decode_" ++ MsgType)}
  -                             catch
  -                                 _:_ -> throw({message_not_supported, MsgId})
  -                             end,
  +      {list_to_existing_atom(DecoderName1 ++ "_pb"), list_to_existing_atom("decode_" ++ MsgType)}
  +    catch
  +      _:_ -> throw({message_not_supported, MsgId})
  +    end,
   
       Msg = try
           erlang:apply(Decoder, DecodingFun, [Input])
  
positive.code:     ?debug("Handshake request: ~p", [HReq]),
      NewFuseId = genFuseId(HReq),
      UID = case DnString =:= undefined of %% Fetch user's ID
                false ->
                    case user_logic:get_user({dn, DnString}) of
                        {ok, #veil_document{uuid = UID1}} ->
                            UID1;
                        {error, Error} ->
                            case user_logic:get_user({unverified_dn, DnString}) of
                                {ok, #veil_document{uuid = UID1, record = #user{login = Login}} = UserDoc} ->
                                    case CertConfirmation of
                                        #handshakerequest_certconfirmation{login = Login, result = Result} ->
                                            % Remove the DN from unverified DNs as it has been confirmed or declined
                                            {ok, UserDoc2} = user_logic:update_unverified_dn_list(UserDoc, user_logic:get_unverified_dn_list(UserDoc) -- [DnString]),
                                            case Result of
                                                false ->
                                                    ?alert("Private key owner denied having added a certificate with DN: ~p (added by ~p)", [DnString, Login]),
                                                    throw({cert_denied_by_user, MsgId});
                                                true ->
                                                    {ok, _} = user_logic:update_dn_list(UserDoc2, user_logic:get_dn_list(UserDoc2) ++ [DnString]),
                                                    ?debug("User ~p confirmed a certificate with DN: ~p", [Login, DnString]),
                                                    UID1
                                            end;
                                        _ ->
                                            ?debug("Handshake request is missing confirmation of certificate with DN: ~p. Denying connection.", [DnString]),
                                            throw({cert_confirmation_required, Login, MsgId})
                                    end;
                                {error, _} ->
                                    ?error("VeilClient handshake failed. User (DN: ~p) data is not available due to DAO error: ~p", [DnString, Error]),
                                    throw({no_user_found_error, Error, MsgId})
                            end
                    end;
  
                true ->
                    case user_logic:get_user({global_id, vcn_utils:ensure_list(GRUID)}) of
                        {ok, #veil_document{uuid = UID1}} ->
                            UID1;
                        {error, Error} ->
                            ?error("VeilClient handshake failed. User (GRUID: ~p) data is not available due to DAO error: ~p", [GRUID, Error]),
                            throw({no_user_found_error, Error, MsgId})
                    end
            end,
  
      %% Env Vars list. Entry format: {Name :: atom(), value :: string()}
      EnvVars = [{list_to_atom(string:to_lower(Name)), Value} || #handshakerequest_envvariable{name = Name, value = Value} <- Vars],
  
negative.code:             %% Session data found, and its user ID matches -> send OK status and update current connection state
              ?debug("User ~p assigned FUSE ID ~p to the connection (PID: ~p)", [UserKey, NewFuseId, self()]),
              {reply, {binary, encode_answer(ok, MsgId, Answer_type, Answer_decoder_name, #atom{value = ?VOK})}, Req,
                          State#handler_state{fuse_id = NewFuseId, connection_id = ConnID, access_token = vcn_utils:ensure_binary(AccessToken), user_global_id = vcn_utils:ensure_binary(UserGID)}};
  
          {ok, #veil_document{record = #fuse_session{uid = OtherUID}}} ->
              %% Current user does not match session owner
  