mirror of
https://github.com/XRPLF/rippled.git
synced 2025-12-06 17:27:55 +00:00
366 lines
8.8 KiB
C++
366 lines
8.8 KiB
C++
#ifndef XRPL_PROTOCOL_ERRORCODES_H_INCLUDED
|
|
#define XRPL_PROTOCOL_ERRORCODES_H_INCLUDED
|
|
|
|
#include <xrpl/json/json_value.h>
|
|
#include <xrpl/protocol/jss.h>
|
|
|
|
namespace ripple {
|
|
|
|
// VFALCO NOTE These are outside the RPC namespace
|
|
|
|
// NOTE: Although the precise numeric values of these codes were never
|
|
// intended to be stable, several API endpoints include the numeric values.
|
|
// Some users came to rely on the values, meaning that renumbering would be
|
|
// a breaking change for those users.
|
|
//
|
|
// We therefore treat the range of values as stable although they are not
|
|
// and are subject to change.
|
|
//
|
|
// Please only append to this table. Do not "fill-in" gaps and do not re-use
|
|
// or repurpose error code values.
|
|
enum error_code_i {
|
|
// -1 represents codes not listed in this enumeration
|
|
rpcUNKNOWN = -1,
|
|
|
|
rpcSUCCESS = 0,
|
|
|
|
rpcBAD_SYNTAX = 1,
|
|
rpcJSON_RPC = 2,
|
|
rpcFORBIDDEN = 3,
|
|
|
|
rpcWRONG_NETWORK = 4,
|
|
// Misc failure
|
|
// unused 5,
|
|
rpcNO_PERMISSION = 6,
|
|
rpcNO_EVENTS = 7,
|
|
// unused 8,
|
|
rpcTOO_BUSY = 9,
|
|
rpcSLOW_DOWN = 10,
|
|
rpcHIGH_FEE = 11,
|
|
rpcNOT_ENABLED = 12,
|
|
rpcNOT_READY = 13,
|
|
rpcAMENDMENT_BLOCKED = 14,
|
|
|
|
// Networking
|
|
rpcNO_CLOSED = 15,
|
|
rpcNO_CURRENT = 16,
|
|
rpcNO_NETWORK = 17,
|
|
rpcNOT_SYNCED = 18,
|
|
|
|
// Ledger state
|
|
rpcACT_NOT_FOUND = 19,
|
|
// unused 20,
|
|
rpcLGR_NOT_FOUND = 21,
|
|
rpcLGR_NOT_VALIDATED = 22,
|
|
rpcMASTER_DISABLED = 23,
|
|
// unused 24,
|
|
// unused 25,
|
|
// unused 26,
|
|
// unused 27,
|
|
// unused 28,
|
|
rpcTXN_NOT_FOUND = 29,
|
|
rpcINVALID_HOTWALLET = 30,
|
|
|
|
// Malformed command
|
|
rpcINVALID_PARAMS = 31,
|
|
rpcUNKNOWN_COMMAND = 32,
|
|
rpcNO_PF_REQUEST = 33,
|
|
|
|
// Bad parameter
|
|
// NOT USED DO NOT USE AGAIN rpcACT_BITCOIN = 34,
|
|
rpcACT_MALFORMED = 35,
|
|
rpcALREADY_MULTISIG = 36,
|
|
rpcALREADY_SINGLE_SIG = 37,
|
|
// unused 38,
|
|
// unused 39,
|
|
rpcBAD_FEATURE = 40,
|
|
rpcBAD_ISSUER = 41,
|
|
rpcBAD_MARKET = 42,
|
|
rpcBAD_SECRET = 43,
|
|
rpcBAD_SEED = 44,
|
|
rpcCHANNEL_MALFORMED = 45,
|
|
rpcCHANNEL_AMT_MALFORMED = 46,
|
|
rpcCOMMAND_MISSING = 47,
|
|
rpcDST_ACT_MALFORMED = 48,
|
|
rpcDST_ACT_MISSING = 49,
|
|
rpcDST_ACT_NOT_FOUND = 50,
|
|
rpcDST_AMT_MALFORMED = 51,
|
|
rpcDST_AMT_MISSING = 52,
|
|
rpcDST_ISR_MALFORMED = 53,
|
|
// unused 54,
|
|
// unused 55,
|
|
// unused 56,
|
|
rpcLGR_IDXS_INVALID = 57,
|
|
rpcLGR_IDX_MALFORMED = 58,
|
|
// unused 59,
|
|
// unused 60,
|
|
// unused 61,
|
|
rpcPUBLIC_MALFORMED = 62,
|
|
rpcSIGNING_MALFORMED = 63,
|
|
rpcSENDMAX_MALFORMED = 64,
|
|
rpcSRC_ACT_MALFORMED = 65,
|
|
rpcSRC_ACT_MISSING = 66,
|
|
rpcSRC_ACT_NOT_FOUND = 67,
|
|
rpcDELEGATE_ACT_NOT_FOUND = 68,
|
|
rpcSRC_CUR_MALFORMED = 69,
|
|
rpcSRC_ISR_MALFORMED = 70,
|
|
rpcSTREAM_MALFORMED = 71,
|
|
rpcATX_DEPRECATED = 72,
|
|
|
|
// Internal error (should never happen)
|
|
rpcINTERNAL = 73, // Generic internal error.
|
|
rpcNOT_IMPL = 74,
|
|
rpcNOT_SUPPORTED = 75,
|
|
rpcBAD_KEY_TYPE = 76,
|
|
rpcDB_DESERIALIZATION = 77,
|
|
rpcEXCESSIVE_LGR_RANGE = 78,
|
|
rpcINVALID_LGR_RANGE = 79,
|
|
rpcEXPIRED_VALIDATOR_LIST = 80,
|
|
|
|
// unused = 90,
|
|
// DEPRECATED. New code must not use this value.
|
|
rpcREPORTING_UNSUPPORTED = 91,
|
|
|
|
rpcOBJECT_NOT_FOUND = 92,
|
|
|
|
// AMM
|
|
rpcISSUE_MALFORMED = 93,
|
|
|
|
// Oracle
|
|
rpcORACLE_MALFORMED = 94,
|
|
|
|
// deposit_authorized + credentials
|
|
rpcBAD_CREDENTIALS = 95,
|
|
|
|
// Simulate
|
|
rpcTX_SIGNED = 96,
|
|
|
|
// Pathfinding
|
|
rpcDOMAIN_MALFORMED = 97,
|
|
|
|
// ledger_entry
|
|
rpcENTRY_NOT_FOUND = 98,
|
|
rpcUNEXPECTED_LEDGER_TYPE = 99,
|
|
|
|
rpcLAST =
|
|
rpcUNEXPECTED_LEDGER_TYPE // rpcLAST should always equal the last code.
|
|
};
|
|
|
|
/** Codes returned in the `warnings` array of certain RPC commands.
|
|
|
|
These values need to remain stable.
|
|
*/
|
|
enum warning_code_i {
|
|
warnRPC_UNSUPPORTED_MAJORITY = 1001,
|
|
warnRPC_AMENDMENT_BLOCKED = 1002,
|
|
warnRPC_EXPIRED_VALIDATOR_LIST = 1003,
|
|
// unused = 1004
|
|
warnRPC_FIELDS_DEPRECATED = 2004, // rippled needs to maintain
|
|
// compatibility with Clio on this code.
|
|
};
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
// VFALCO NOTE these should probably not be in the RPC namespace.
|
|
|
|
namespace RPC {
|
|
|
|
/** Maps an rpc error code to its token, default message, and HTTP status. */
|
|
struct ErrorInfo
|
|
{
|
|
// Default ctor needed to produce an empty std::array during constexpr eval.
|
|
constexpr ErrorInfo()
|
|
: code(rpcUNKNOWN)
|
|
, token("unknown")
|
|
, message("An unknown error code.")
|
|
, http_status(200)
|
|
{
|
|
}
|
|
|
|
constexpr ErrorInfo(
|
|
error_code_i code_,
|
|
char const* token_,
|
|
char const* message_)
|
|
: code(code_), token(token_), message(message_), http_status(200)
|
|
{
|
|
}
|
|
|
|
constexpr ErrorInfo(
|
|
error_code_i code_,
|
|
char const* token_,
|
|
char const* message_,
|
|
int http_status_)
|
|
: code(code_)
|
|
, token(token_)
|
|
, message(message_)
|
|
, http_status(http_status_)
|
|
{
|
|
}
|
|
|
|
error_code_i code;
|
|
Json::StaticString token;
|
|
Json::StaticString message;
|
|
int http_status;
|
|
};
|
|
|
|
/** Returns an ErrorInfo that reflects the error code. */
|
|
ErrorInfo const&
|
|
get_error_info(error_code_i code);
|
|
|
|
/** Add or update the json update to reflect the error code. */
|
|
/** @{ */
|
|
template <class JsonValue>
|
|
void
|
|
inject_error(error_code_i code, JsonValue& json)
|
|
{
|
|
ErrorInfo const& info(get_error_info(code));
|
|
json[jss::error] = info.token;
|
|
json[jss::error_code] = info.code;
|
|
json[jss::error_message] = info.message;
|
|
}
|
|
|
|
template <class JsonValue>
|
|
void
|
|
inject_error(int code, JsonValue& json)
|
|
{
|
|
inject_error(error_code_i(code), json);
|
|
}
|
|
|
|
template <class JsonValue>
|
|
void
|
|
inject_error(error_code_i code, std::string const& message, JsonValue& json)
|
|
{
|
|
ErrorInfo const& info(get_error_info(code));
|
|
json[jss::error] = info.token;
|
|
json[jss::error_code] = info.code;
|
|
json[jss::error_message] = message;
|
|
}
|
|
|
|
/** @} */
|
|
|
|
/** Returns a new json object that reflects the error code. */
|
|
/** @{ */
|
|
Json::Value
|
|
make_error(error_code_i code);
|
|
Json::Value
|
|
make_error(error_code_i code, std::string const& message);
|
|
/** @} */
|
|
|
|
/** Returns a new json object that indicates invalid parameters. */
|
|
/** @{ */
|
|
inline Json::Value
|
|
make_param_error(std::string const& message)
|
|
{
|
|
return make_error(rpcINVALID_PARAMS, message);
|
|
}
|
|
|
|
inline std::string
|
|
missing_field_message(std::string const& name)
|
|
{
|
|
return "Missing field '" + name + "'.";
|
|
}
|
|
|
|
inline Json::Value
|
|
missing_field_error(std::string const& name)
|
|
{
|
|
return make_param_error(missing_field_message(name));
|
|
}
|
|
|
|
inline Json::Value
|
|
missing_field_error(Json::StaticString name)
|
|
{
|
|
return missing_field_error(std::string(name));
|
|
}
|
|
|
|
inline std::string
|
|
object_field_message(std::string const& name)
|
|
{
|
|
return "Invalid field '" + name + "', not object.";
|
|
}
|
|
|
|
inline Json::Value
|
|
object_field_error(std::string const& name)
|
|
{
|
|
return make_param_error(object_field_message(name));
|
|
}
|
|
|
|
inline Json::Value
|
|
object_field_error(Json::StaticString name)
|
|
{
|
|
return object_field_error(std::string(name));
|
|
}
|
|
|
|
inline std::string
|
|
invalid_field_message(std::string const& name)
|
|
{
|
|
return "Invalid field '" + name + "'.";
|
|
}
|
|
|
|
inline std::string
|
|
invalid_field_message(Json::StaticString name)
|
|
{
|
|
return invalid_field_message(std::string(name));
|
|
}
|
|
|
|
inline Json::Value
|
|
invalid_field_error(std::string const& name)
|
|
{
|
|
return make_param_error(invalid_field_message(name));
|
|
}
|
|
|
|
inline Json::Value
|
|
invalid_field_error(Json::StaticString name)
|
|
{
|
|
return invalid_field_error(std::string(name));
|
|
}
|
|
|
|
inline std::string
|
|
expected_field_message(std::string const& name, std::string const& type)
|
|
{
|
|
return "Invalid field '" + name + "', not " + type + ".";
|
|
}
|
|
|
|
inline std::string
|
|
expected_field_message(Json::StaticString name, std::string const& type)
|
|
{
|
|
return expected_field_message(std::string(name), type);
|
|
}
|
|
|
|
inline Json::Value
|
|
expected_field_error(std::string const& name, std::string const& type)
|
|
{
|
|
return make_param_error(expected_field_message(name, type));
|
|
}
|
|
|
|
inline Json::Value
|
|
expected_field_error(Json::StaticString name, std::string const& type)
|
|
{
|
|
return expected_field_error(std::string(name), type);
|
|
}
|
|
|
|
inline Json::Value
|
|
not_validator_error()
|
|
{
|
|
return make_param_error("not a validator");
|
|
}
|
|
|
|
/** @} */
|
|
|
|
/** Returns `true` if the json contains an rpc error specification. */
|
|
bool
|
|
contains_error(Json::Value const& json);
|
|
|
|
/** Returns http status that corresponds to the error code. */
|
|
int
|
|
error_code_http_status(error_code_i code);
|
|
|
|
} // namespace RPC
|
|
|
|
/** Returns a single string with the contents of an RPC error. */
|
|
std::string
|
|
rpcErrorString(Json::Value const& jv);
|
|
|
|
} // namespace ripple
|
|
|
|
#endif
|