xrpld
Loading...
Searching...
No Matches
LedgerEntryHelpers.h
1#pragma once
2
3#include <xrpld/rpc/detail/RPCHelpers.h>
4
5#include <xrpl/basics/Blob.h>
6#include <xrpl/basics/StringUtilities.h>
7#include <xrpl/basics/base_uint.h>
8#include <xrpl/beast/core/LexicalCast.h>
9#include <xrpl/json/json_value.h>
10#include <xrpl/protocol/AccountID.h>
11#include <xrpl/protocol/Asset.h>
12#include <xrpl/protocol/ErrorCodes.h>
13#include <xrpl/protocol/jss.h>
14
15#include <cstddef>
16#include <cstdint>
17#include <expected>
18#include <initializer_list>
19#include <optional>
20#include <stdexcept>
21#include <string>
22
24
27{
29 json[jss::error] = err.value_or("malformedRequest");
30 json[jss::error_code] = RpcInvalidParams;
31 json[jss::error_message] = rpc::missingFieldMessage(std::string(field.cStr()));
32 return std::unexpected(json);
33}
34
36invalidFieldError(std::string const& err, json::StaticString const field, std::string const& type)
37{
39 json[jss::error] = err;
40 json[jss::error_code] = RpcInvalidParams;
41 json[jss::error_message] = rpc::expectedFieldMessage(field, type);
42 return std::unexpected(json);
43}
44
46malformedError(std::string const& err, std::string const& message)
47{
49 json[jss::error] = err;
50 json[jss::error_code] = RpcInvalidParams;
51 json[jss::error_message] = message;
52 return std::unexpected(json);
53}
54
55inline std::expected<bool, json::Value>
57 json::Value const& params,
59 std::optional<std::string> err = std::nullopt)
60{
61 for (auto const field : fields)
62 {
63 if (!params.isMember(field) || params[field].isNull())
64 {
65 return missingFieldError(field, err);
66 }
67 }
68 return true;
69}
70
71template <class T>
73parse(json::Value const& param);
74
75template <class T>
76std::expected<T, json::Value>
78 json::Value const& params,
79 json::StaticString const fieldName,
80 std::string const& err,
81 std::string const& expectedType)
82{
83 if (!params.isMember(fieldName) || params[fieldName].isNull())
84 {
85 return missingFieldError(fieldName);
86 }
87 if (auto obj = parse<T>(params[fieldName]))
88 {
89 return *obj;
90 }
91 return invalidFieldError(err, fieldName, expectedType);
92}
93
94template <>
96parse(json::Value const& param)
97{
98 if (!param.isString())
99 return std::nullopt;
100
101 auto const account = parseBase58<AccountID>(param.asString());
102 if (!account || account->isZero())
103 {
104 return std::nullopt;
105 }
106
107 return account;
108}
109
110inline std::expected<AccountID, json::Value>
112 json::Value const& params,
113 json::StaticString const fieldName,
114 std::string const& err)
115{
116 return required<AccountID>(params, fieldName, err, "AccountID");
117}
118
120parseHexBlob(json::Value const& param, std::size_t maxLength)
121{
122 if (!param.isString())
123 return std::nullopt;
124
125 auto blob = strUnHex(param.asString());
126 if (!blob || blob->empty() || blob->size() > maxLength)
127 return std::nullopt;
128
129 return blob;
130}
131
132inline std::expected<Blob, json::Value>
134 json::Value const& params,
135 json::StaticString const fieldName,
136 std::size_t maxLength,
137 std::string const& err)
138{
139 if (!params.isMember(fieldName) || params[fieldName].isNull())
140 {
141 return missingFieldError(fieldName);
142 }
143 if (auto blob = parseHexBlob(params[fieldName], maxLength))
144 {
145 return *blob;
146 }
147 return invalidFieldError(err, fieldName, "hex string");
148}
149
150template <>
152parse(json::Value const& param)
153{
154 if (param.isUInt() || (param.isInt() && param.asInt() >= 0))
155 return param.asUInt();
156
157 if (param.isString())
158 {
159 std::uint32_t v = 0;
160 if (beast::lexicalCastChecked(v, param.asString()))
161 return v;
162 }
163
164 return std::nullopt;
165}
166
167inline std::expected<std::uint32_t, json::Value>
169 json::Value const& params,
170 json::StaticString const fieldName,
171 std::string const& err)
172{
173 return required<std::uint32_t>(params, fieldName, err, "number");
174}
175
176template <>
178parse(json::Value const& param)
179{
180 UInt256 uNodeIndex;
181 if (!param.isString() || !uNodeIndex.parseHex(param.asString()))
182 {
183 return std::nullopt;
184 }
185
186 return uNodeIndex;
187}
188
189inline std::expected<UInt256, json::Value>
191 json::Value const& params,
192 json::StaticString const fieldName,
193 std::string const& err)
194{
195 return required<UInt256>(params, fieldName, err, "Hash256");
196}
197
198template <>
200parse(json::Value const& param)
201{
202 UInt192 field;
203 if (!param.isString() || !field.parseHex(param.asString()))
204 {
205 return std::nullopt;
206 }
207
208 return field;
209}
210
211inline std::expected<UInt192, json::Value>
213 json::Value const& params,
214 json::StaticString const fieldName,
215 std::string const& err)
216{
217 return required<UInt192>(params, fieldName, err, "Hash192");
218}
219
220template <>
222parse(json::Value const& param)
223{
224 try
225 {
226 return assetFromJson(param);
227 }
228 catch (std::runtime_error const&)
229 {
230 return std::nullopt;
231 }
232}
233
234inline std::expected<Asset, json::Value>
235requiredAsset(json::Value const& params, json::StaticString const fieldName, std::string const& err)
236{
237 return required<Asset>(params, fieldName, err, "Asset");
238}
239
240} // namespace xrpl::ledger_entry_helpers
Lightweight wrapper to tag static string.
Definition json_value.h:52
constexpr char const * cStr() const
Definition json_value.h:65
Represents a JSON value.
Definition json_value.h:121
bool isNull() const
isNull() tests to see if this field is null.
bool isString() const
bool isUInt() const
bool isInt() const
UInt asUInt() const
std::string asString() const
Returns the unquoted string value.
bool isMember(char const *key) const
Return true if the object has a member named key.
Int asInt() const
constexpr bool parseHex(std::string_view sv)
Parse a hex string into a base_uint.
Definition base_uint.h:526
constexpr bool lexicalCastChecked(Out &out, In in)
Intelligently convert from one type to another.
JSON (JavaScript Object Notation).
Definition json_errors.h:5
@ Object
object value (collection of name/value pairs).
Definition json_value.h:33
std::optional< T > parse(json::Value const &param)
std::expected< AccountID, json::Value > requiredAccountID(json::Value const &params, json::StaticString const fieldName, std::string const &err)
std::expected< UInt192, json::Value > requiredUInt192(json::Value const &params, json::StaticString const fieldName, std::string const &err)
std::expected< Asset, json::Value > requiredAsset(json::Value const &params, json::StaticString const fieldName, std::string const &err)
std::expected< Blob, json::Value > requiredHexBlob(json::Value const &params, json::StaticString const fieldName, std::size_t maxLength, std::string const &err)
std::expected< T, json::Value > required(json::Value const &params, json::StaticString const fieldName, std::string const &err, std::string const &expectedType)
std::unexpected< json::Value > malformedError(std::string const &err, std::string const &message)
std::expected< std::uint32_t, json::Value > requiredUInt32(json::Value const &params, json::StaticString const fieldName, std::string const &err)
std::expected< UInt256, json::Value > requiredUInt256(json::Value const &params, json::StaticString const fieldName, std::string const &err)
std::optional< Blob > parseHexBlob(json::Value const &param, std::size_t maxLength)
std::unexpected< json::Value > missingFieldError(json::StaticString const field, std::optional< std::string > err=std::nullopt)
std::unexpected< json::Value > invalidFieldError(std::string const &err, json::StaticString const field, std::string const &type)
std::expected< bool, json::Value > hasRequired(json::Value const &params, std::initializer_list< json::StaticString > fields, std::optional< std::string > err=std::nullopt)
std::string expectedFieldMessage(std::string const &name, std::string const &type)
Definition ErrorCodes.h:297
std::string missingFieldMessage(std::string const &name)
Definition ErrorCodes.h:237
@ RpcInvalidParams
Definition ErrorCodes.h:67
std::optional< AccountID > parseBase58(std::string const &s)
Parse AccountID from checked, base58 string.
BaseUInt< 192 > UInt192
Definition base_uint.h:582
BaseUInt< 256 > UInt256
Definition base_uint.h:581
std::optional< Blob > strUnHex(std::size_t strSize, Iterator begin, Iterator end)
Asset assetFromJson(json::Value const &jv)
Definition Asset.cpp:59
T unexpected(T... args)