Errors.hpp

Go to the documentation of this file.

#pragma once
 
#include <boost/json/object.hpp>
#include <xrpl/protocol/ErrorCodes.h>
 
#include <exception>
#include <optional>
#include <string>
#include <string_view>
#include <utility>
#include <variant>
 
namespace rpc {

enum class ClioError {
    // normal clio errors start with 5000
    RpcMalformedCurrency = 5000,
    RpcMalformedRequest = 5001,
    RpcMalformedOwner = 5002,
    RpcMalformedAddress = 5003,
    RpcUnknownOption = 5005,
    RpcFieldNotFoundTransaction = 5006,
    RpcMalformedOracleDocumentId = 5007,
    RpcMalformedAuthorizedCredentials = 5008,
    // NOTE: RpcEntryNotFound is replaced with RippledError::rpcENTRY_NOT_FOUND
    // RpcEntryNotFound = 5009,
 
    // special system errors start with 6000
    RpcInvalidApiVersion = 6000,
    RpcCommandIsMissing = 6001,
    RpcCommandNotString = 6002,
    RpcCommandIsEmpty = 6003,
    RpcParamsUnparsable = 6004,
 
    // TODO: Since it is not only rpc errors here now, we should move it to util
    // etl related errors start with 7000
    // Higher value in this errors means better progress in the forwarding
    EtlConnectionError = 7000,
    EtlRequestError = 7001,
    EtlRequestTimeout = 7002,
    EtlInvalidResponse = 7003,
};

struct ClioErrorInfo {
    ClioError const code;
    std::string_view const error;
    std::string_view const message;
};

using RippledError = ripple::error_code_i;

using CombinedError = std::variant<RippledError, ClioError>;

struct Status {
    CombinedError code = RippledError::rpcSUCCESS;
    std::string error;
    std::string message;
    std::optional<boost::json::object> extraInfo;
 
    Status() = default;

    /* implicit */ Status(CombinedError code) : code(code) {};

    Status(CombinedError code, boost::json::object&& extraInfo)
        : code(code), extraInfo(std::move(extraInfo)) {};

    explicit Status(std::string message) : code(ripple::rpcUNKNOWN), message(std::move(message))
    {
    }

    Status(CombinedError code, std::string message) : code(code), message(std::move(message))
    {
    }

    Status(CombinedError code, std::string error, std::string message)
        : code(code), error(std::move(error)), message(std::move(message))
    {
    }
 
    bool
    operator==(Status const& other) const = default;

    operator bool() const
    {
        if (auto err = std::get_if<RippledError>(&code))
            return *err != RippledError::rpcSUCCESS;
 
        return true;
    }

    bool
    operator==(RippledError other) const
    {
        if (auto err = std::get_if<RippledError>(&code))
            return *err == other;
 
        return false;
    }

    bool
    operator==(ClioError other) const
    {
        if (auto err = std::get_if<ClioError>(&code))
            return *err == other;
 
        return false;
    }

    friend std::ostream&
    operator<<(std::ostream& stream, Status const& status);
};

// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
enum WarningCode {
    WarnUnknown = -1,
    WarnRpcClio = 2001,
    WarnRpcOutdated = 2002,
    WarnRpcRateLimit = 2003,
    WarnRpcDeprecated = 2004
};

struct WarningInfo {
    constexpr WarningInfo() = default;

    constexpr WarningInfo(WarningCode code, char const* message) : code(code), message(message)
    {
    }
 
    WarningCode code = WarningCode::WarnUnknown;
    std::string_view const message = "unknown warning";
};

class InvalidParamsError : public std::exception {
    std::string msg_;
 
public:
    explicit InvalidParamsError(std::string msg) : msg_(std::move(msg))
    {
    }

    [[nodiscard]] char const*
    what() const throw() override
    {
        return msg_.c_str();
    }
};

class AccountNotFoundError : public std::exception {
    std::string account_;
 
public:
    explicit AccountNotFoundError(std::string acct) : account_(std::move(acct))
    {
    }

    [[nodiscard]] char const*
    what() const throw() override
    {
        return account_.c_str();
    }
};

static Status gOk;

WarningInfo const&
getWarningInfo(WarningCode code);

ClioErrorInfo const&
getErrorInfo(ClioError code);

boost::json::object
makeWarning(WarningCode code);

boost::json::object
makeError(Status const& status);

boost::json::object
makeError(
    RippledError err,
    std::optional<std::string_view> customError = std::nullopt,
    std::optional<std::string_view> customMessage = std::nullopt
);

boost::json::object
makeError(
    ClioError err,
    std::optional<std::string_view> customError = std::nullopt,
    std::optional<std::string_view> customMessage = std::nullopt
);
 
}  // namespace rpc