anchor.diff:                  %% given TokenAuth).
                   case VerificationResult of
                       {ok, ?USER(UserId), _} ->
  -                        case user_logic:get(TokenAuth, UserId) of
  -                            {ok, _} ->
  -                                VerificationResult;
  -                            {error, _} = Error ->
  -                                Error
  -                        end;
  +                        user_logic:get(TokenAuth, UserId);
                       _ ->
  -                        VerificationResult
  -                end
  +                        ok
  +                end,
  +                VerificationResult
               catch Type:Reason ->
                   ?error_stacktrace("Cannot verify user auth due to ~p:~p", [
                       Type, Reason
  
positive.code: 
  
  %% @private
  -spec verify_token_auth(token_auth()) ->
      {token_ref(), verification_result()}.
  verify_token_auth(#token_auth{
      access_token = AccessToken,
      peer_ip = PeerIp,
      interface = Interface,
      data_access_caveats_policy = DataAccessCaveatsPolicy
  }) ->
      case deserialize_token(AccessToken) of
          {ok, #token{subject = Subject} = Token} ->
              case token_logic:verify_access_token(
                  AccessToken, PeerIp, Interface,
                  DataAccessCaveatsPolicy
              ) of
                  {ok, Subject, TokenTTL} ->
                      TokenExpiration = case TokenTTL of
                          undefined -> undefined;
                          _ -> ?NOW() + TokenTTL
                      end,
                      Auth = #auth{
                          subject = Subject,
                          caveats = tokens:get_caveats(Token)
                      },
                      {get_token_ref(Token), {ok, Auth, TokenExpiration}};
                  {error, _} = VerificationError ->
                      {undefined, VerificationError}
              end;
          {error, _} = DeserializationError ->
              {undefined, DeserializationError}
      end.
  
  
  %% @private
  -spec deserialize_token(tokens:serialized()) ->
      {ok, tokens:token()} | errors:error().
  deserialize_token(SerializedToken) ->
      case tokens:deserialize(SerializedToken) of
          {ok, #token{subject = ?SUB(user, UserId)} = Token} ->
              case provider_logic:has_eff_user(UserId) of
  
negative.code: 
  
  %% @private
  -spec verify_token_auth(token_auth()) -> verification_result().
  verify_token_auth(TokenAuth) ->
      case get_token_auth_verification_result_from_cache(TokenAuth) of
          {ok, CachedVerificationResult} ->
              CachedVerificationResult;
          ?ERROR_NOT_FOUND ->
              try
                  VerificationResult = verify_token_auth_and_cache_result(TokenAuth),
                  %% Fetches user doc to trigger user setup if token verification
                  %% succeeded. Otherwise does nothing.
                  %% It must be called after caching verification result as to
  