mirror of
https://github.com/XRPLF/rippled.git
synced 2025-11-19 18:45:52 +00:00
1d42c4f6de
Per XLS-0095, we are taking steps to rename ripple(d) to xrpl(d). This change specifically removes all copyright notices referencing Ripple, XRPLF, and certain affiliated contributors upon mutual agreement, so the notice in the LICENSE.md file applies throughout. Copyright notices referencing external contributions remain as-is. Duplicate verbiage is also removed.
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
|