Clio  develop
The XRP Ledger API server.
Loading...
Searching...
No Matches
LedgerEntry.hpp
1//------------------------------------------------------------------------------
2/*
3 This file is part of clio: https://github.com/XRPLF/clio
4 Copyright (c) 2023, the clio developers.
5
6 Permission to use, copy, modify, and distribute this software for any
7 purpose with or without fee is hereby granted, provided that the above
8 copyright notice and this permission notice appear in all copies.
9
10 THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11 WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12 MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13 ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14 WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15 ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16 OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17*/
18//==============================================================================
19
20#pragma once
21
22#include "data/BackendInterface.hpp"
23#include "rpc/Errors.hpp"
24#include "rpc/JS.hpp"
25#include "rpc/common/Checkers.hpp"
26#include "rpc/common/MetaProcessors.hpp"
27#include "rpc/common/Modifiers.hpp"
28#include "rpc/common/Specs.hpp"
29#include "rpc/common/Types.hpp"
30#include "rpc/common/Validators.hpp"
31#include "util/AccountUtils.hpp"
32
33#include <boost/json/array.hpp>
34#include <boost/json/conversion.hpp>
35#include <boost/json/object.hpp>
36#include <boost/json/value.hpp>
37#include <boost/json/value_to.hpp>
38#include <xrpl/basics/base_uint.h>
39#include <xrpl/beast/core/LexicalCast.h>
40#include <xrpl/protocol/AccountID.h>
41#include <xrpl/protocol/ErrorCodes.h>
42#include <xrpl/protocol/Issue.h>
43#include <xrpl/protocol/LedgerFormats.h>
44#include <xrpl/protocol/SField.h>
45#include <xrpl/protocol/jss.h>
46#include <xrpl/protocol/tokens.h>
47
48#include <cstdint>
49#include <memory>
50#include <optional>
51#include <string>
52#include <string_view>
53#include <variant>
54
55namespace rpc {
56
62class LedgerEntryHandler {
63 std::shared_ptr<BackendInterface> sharedPtrBackend_;
64
65public:
69 struct Output {
70 std::string index;
71 uint32_t ledgerIndex;
72 std::string ledgerHash;
73 std::optional<boost::json::object> node;
74 std::optional<std::string> nodeBinary;
75 std::optional<uint32_t> deletedLedgerIndex;
76 bool validated = true;
77 };
78
82 struct Input {
83 std::optional<std::string> ledgerHash;
84 std::optional<uint32_t> ledgerIndex;
85 bool binary = false;
86 // id of this ledger entry: 256 bits hex string
87 std::optional<std::string> index;
88 // index can be extracted from payment_channel, check, escrow, offer
89 // etc, expectedType is used to save the type of index
90 ripple::LedgerEntryType expectedType = ripple::ltANY;
91 // account id to address account root object
92 std::optional<std::string> accountRoot;
93 // account id to address did object
94 std::optional<std::string> did;
95 // mpt issuance id to address mptIssuance object
96 std::optional<std::string> mptIssuance;
97 // TODO: extract into custom objects, remove json from Input
98 std::optional<boost::json::object> directory;
99 std::optional<boost::json::object> offer;
100 std::optional<boost::json::object> rippleStateAccount;
101 std::optional<boost::json::object> escrow;
102 std::optional<boost::json::object> depositPreauth;
103 std::optional<boost::json::object> ticket;
104 std::optional<boost::json::object> amm;
105 std::optional<boost::json::object> mptoken;
106 std::optional<boost::json::object> permissionedDomain;
107 std::optional<boost::json::object> vault;
108 std::optional<ripple::STXChainBridge> bridge;
109 std::optional<std::string> bridgeAccount;
110 std::optional<uint32_t> chainClaimId;
111 std::optional<uint32_t> createAccountClaimId;
112 std::optional<ripple::uint256> oracleNode;
113 std::optional<ripple::uint256> credential;
114 std::optional<boost::json::object> delegate;
115 bool includeDeleted = false;
116 };
117
118 using Result = HandlerReturnType<Output>;
119
125 LedgerEntryHandler(std::shared_ptr<BackendInterface> const& sharedPtrBackend) : sharedPtrBackend_(sharedPtrBackend)
126 {
127 }
128
135 static RpcSpecConstRef
136 spec([[maybe_unused]] uint32_t apiVersion)
137 {
138 // Validator only works in this handler
139 // The accounts array must have two different elements
140 // Each element must be a valid address
141 static auto const kRIPPLE_STATE_ACCOUNTS_CHECK =
142 validation::CustomValidator{[](boost::json::value const& value, std::string_view /* key */) -> MaybeError {
143 if (!value.is_array() || value.as_array().size() != 2 || !value.as_array()[0].is_string() ||
144 !value.as_array()[1].is_string() ||
145 value.as_array()[0].as_string() == value.as_array()[1].as_string()) {
146 return Error{Status{RippledError::rpcINVALID_PARAMS, "malformedAccounts"}};
147 }
148
149 auto const id1 = util::parseBase58Wrapper<ripple::AccountID>(
150 boost::json::value_to<std::string>(value.as_array()[0])
151 );
152 auto const id2 = util::parseBase58Wrapper<ripple::AccountID>(
153 boost::json::value_to<std::string>(value.as_array()[1])
154 );
155
156 if (!id1 || !id2)
157 return Error{Status{ClioError::RpcMalformedAddress, "malformedAddresses"}};
158
159 return MaybeError{};
160 }};
161
162 static auto const kMALFORMED_REQUEST_HEX_STRING_VALIDATOR = meta::WithCustomError{
163 validation::CustomValidators::uint256HexStringValidator, Status(ClioError::RpcMalformedRequest)
164 };
165
166 static auto const kMALFORMED_REQUEST_INT_VALIDATOR =
167 meta::WithCustomError{validation::Type<uint32_t>{}, Status(ClioError::RpcMalformedRequest)};
168
169 static auto const kBRIDGE_JSON_VALIDATOR = meta::WithCustomError{
170 meta::IfType<boost::json::object>{meta::Section{
171 {ripple::sfLockingChainDoor.getJsonName().c_str(),
172 validation::Required{},
173 validation::CustomValidators::accountBase58Validator},
174 {ripple::sfIssuingChainDoor.getJsonName().c_str(),
175 validation::Required{},
176 validation::CustomValidators::accountBase58Validator},
177 {ripple::sfLockingChainIssue.getJsonName().c_str(),
178 validation::Required{},
179 validation::CustomValidators::currencyIssueValidator},
180 {ripple::sfIssuingChainIssue.getJsonName().c_str(),
181 validation::Required{},
182 validation::CustomValidators::currencyIssueValidator},
183 }},
184 Status(ClioError::RpcMalformedRequest)
185 };
186
187 static auto const kRPC_SPEC = RpcSpec{
188 {JS(binary), validation::Type<bool>{}},
189 {JS(ledger_hash), validation::CustomValidators::uint256HexStringValidator},
190 {JS(ledger_index), validation::CustomValidators::ledgerIndexValidator},
191 {JS(index), kMALFORMED_REQUEST_HEX_STRING_VALIDATOR},
192 {JS(account_root), validation::CustomValidators::accountBase58Validator},
193 {JS(did), validation::CustomValidators::accountBase58Validator},
194 {JS(check), kMALFORMED_REQUEST_HEX_STRING_VALIDATOR},
195 {JS(deposit_preauth),
196 validation::Type<std::string, boost::json::object>{},
197 meta::IfType<std::string>{kMALFORMED_REQUEST_HEX_STRING_VALIDATOR},
198 meta::IfType<boost::json::object>{
199 meta::Section{
200 {JS(owner),
201 validation::Required{},
202 meta::WithCustomError{
203 validation::CustomValidators::accountBase58Validator, Status(ClioError::RpcMalformedOwner)
204 }},
205 {JS(authorized), validation::CustomValidators::accountBase58Validator},
206 {JS(authorized_credentials), validation::CustomValidators::authorizeCredentialValidator}
207 },
208 }},
209 {JS(directory),
210 validation::Type<std::string, boost::json::object>{},
211 meta::IfType<std::string>{kMALFORMED_REQUEST_HEX_STRING_VALIDATOR},
212 meta::IfType<boost::json::object>{meta::Section{
213 {JS(owner), validation::CustomValidators::accountBase58Validator},
214 {JS(dir_root), validation::CustomValidators::uint256HexStringValidator},
215 {JS(sub_index), kMALFORMED_REQUEST_INT_VALIDATOR}
216 }}},
217 {JS(escrow),
218 validation::Type<std::string, boost::json::object>{},
219 meta::IfType<std::string>{kMALFORMED_REQUEST_HEX_STRING_VALIDATOR},
220 meta::IfType<boost::json::object>{
221 meta::Section{
222 {JS(owner),
223 validation::Required{},
224 meta::WithCustomError{
225 validation::CustomValidators::accountBase58Validator, Status(ClioError::RpcMalformedOwner)
226 }},
227 {JS(seq), validation::Required{}, kMALFORMED_REQUEST_INT_VALIDATOR},
228 },
229 }},
230 {JS(offer),
231 validation::Type<std::string, boost::json::object>{},
232 meta::IfType<std::string>{kMALFORMED_REQUEST_HEX_STRING_VALIDATOR},
233 meta::IfType<boost::json::object>{
234 meta::Section{
235 {JS(account), validation::Required{}, validation::CustomValidators::accountBase58Validator},
236 {JS(seq), validation::Required{}, kMALFORMED_REQUEST_INT_VALIDATOR},
237 },
238 }},
239 {JS(payment_channel), kMALFORMED_REQUEST_HEX_STRING_VALIDATOR},
240 {JS(ripple_state),
241 validation::Type<boost::json::object>{},
242 meta::Section{
243 {JS(accounts), validation::Required{}, kRIPPLE_STATE_ACCOUNTS_CHECK},
244 {JS(currency), validation::Required{}, validation::CustomValidators::currencyValidator},
245 }},
246 {JS(ticket),
247 validation::Type<std::string, boost::json::object>{},
248 meta::IfType<std::string>{kMALFORMED_REQUEST_HEX_STRING_VALIDATOR},
249 meta::IfType<boost::json::object>{
250 meta::Section{
251 {JS(account), validation::Required{}, validation::CustomValidators::accountBase58Validator},
252 {JS(ticket_seq), validation::Required{}, kMALFORMED_REQUEST_INT_VALIDATOR},
253 },
254 }},
255 {JS(nft_page), kMALFORMED_REQUEST_HEX_STRING_VALIDATOR},
256 {JS(amm),
257 validation::Type<std::string, boost::json::object>{},
258 meta::IfType<std::string>{kMALFORMED_REQUEST_HEX_STRING_VALIDATOR},
259 meta::IfType<boost::json::object>{
260 meta::Section{
261 {JS(asset),
262 meta::WithCustomError{validation::Required{}, Status(ClioError::RpcMalformedRequest)},
263 meta::WithCustomError{
264 validation::Type<boost::json::object>{}, Status(ClioError::RpcMalformedRequest)
265 },
266 validation::CustomValidators::currencyIssueValidator},
267 {JS(asset2),
268 meta::WithCustomError{validation::Required{}, Status(ClioError::RpcMalformedRequest)},
269 meta::WithCustomError{
270 validation::Type<boost::json::object>{}, Status(ClioError::RpcMalformedRequest)
271 },
272 validation::CustomValidators::currencyIssueValidator},
273 },
274 }},
275 {JS(bridge),
276 meta::WithCustomError{validation::Type<boost::json::object>{}, Status(ClioError::RpcMalformedRequest)},
277 kBRIDGE_JSON_VALIDATOR},
278 {JS(bridge_account),
279 meta::WithCustomError{
280 validation::CustomValidators::accountBase58Validator, Status(ClioError::RpcMalformedRequest)
281 }},
282 {JS(xchain_owned_claim_id),
283 meta::WithCustomError{
284 validation::Type<std::string, boost::json::object>{}, Status(ClioError::RpcMalformedRequest)
285 },
286 meta::IfType<std::string>{kMALFORMED_REQUEST_HEX_STRING_VALIDATOR},
287 kBRIDGE_JSON_VALIDATOR,
288 meta::WithCustomError{
289 meta::IfType<boost::json::object>{
290 meta::Section{{JS(xchain_owned_claim_id), validation::Required{}, validation::Type<uint32_t>{}}}
291 },
292 Status(ClioError::RpcMalformedRequest)
293 }},
294 {JS(xchain_owned_create_account_claim_id),
295 meta::WithCustomError{
296 validation::Type<std::string, boost::json::object>{}, Status(ClioError::RpcMalformedRequest)
297 },
298 meta::IfType<std::string>{kMALFORMED_REQUEST_HEX_STRING_VALIDATOR},
299 kBRIDGE_JSON_VALIDATOR,
300 meta::WithCustomError{
301 meta::IfType<boost::json::object>{meta::Section{
302 {JS(xchain_owned_create_account_claim_id), validation::Required{}, validation::Type<uint32_t>{}}
303 }},
304 Status(ClioError::RpcMalformedRequest)
305 }},
306 {JS(oracle),
307 meta::WithCustomError{
308 validation::Type<std::string, boost::json::object>{}, Status(ClioError::RpcMalformedRequest)
309 },
310 meta::IfType<std::string>{
311 meta::WithCustomError{kMALFORMED_REQUEST_HEX_STRING_VALIDATOR, Status(ClioError::RpcMalformedAddress)}
312 },
313 meta::IfType<boost::json::object>{meta::Section{
314 {JS(account),
315 meta::WithCustomError{validation::Required{}, Status(ClioError::RpcMalformedRequest)},
316 meta::WithCustomError{
317 validation::CustomValidators::accountBase58Validator, Status(ClioError::RpcMalformedAddress)
318 }},
319 // note: Unlike `rippled`, Clio only supports UInt as input, no string, no `null`, etc.:
320 {JS(oracle_document_id),
321 meta::WithCustomError{validation::Required{}, Status(ClioError::RpcMalformedRequest)},
322 meta::WithCustomError{
323 validation::Type<uint32_t, std::string>{}, Status(ClioError::RpcMalformedOracleDocumentId)
324 },
325 meta::WithCustomError{modifiers::ToNumber{}, Status(ClioError::RpcMalformedOracleDocumentId)}},
326 }}},
327 {JS(credential),
328 meta::WithCustomError{
329 validation::Type<std::string, boost::json::object>{}, Status(ClioError::RpcMalformedRequest)
330 },
331 meta::IfType<std::string>{
332 meta::WithCustomError{kMALFORMED_REQUEST_HEX_STRING_VALIDATOR, Status(ClioError::RpcMalformedAddress)}
333 },
334 meta::IfType<boost::json::object>{meta::Section{
335 {JS(subject),
336 meta::WithCustomError{validation::Required{}, Status(ClioError::RpcMalformedRequest)},
337 meta::WithCustomError{
338 validation::CustomValidators::accountBase58Validator, Status(ClioError::RpcMalformedAddress)
339 }},
340 {JS(issuer),
341 meta::WithCustomError{validation::Required{}, Status(ClioError::RpcMalformedRequest)},
342 meta::WithCustomError{
343 validation::CustomValidators::accountBase58Validator, Status(ClioError::RpcMalformedAddress)
344 }},
345 {
346 JS(credential_type),
347 meta::WithCustomError{validation::Required{}, Status(ClioError::RpcMalformedRequest)},
348 meta::WithCustomError{validation::Type<std::string>{}, Status(ClioError::RpcMalformedRequest)},
349 },
350 }}},
351 {JS(mpt_issuance),
352 meta::WithCustomError{
353 validation::CustomValidators::uint192HexStringValidator, Status(ClioError::RpcMalformedRequest)
354 }},
355 {JS(mptoken),
356 meta::WithCustomError{
357 validation::Type<std::string, boost::json::object>{}, Status(ClioError::RpcMalformedRequest)
358 },
359 meta::IfType<std::string>{kMALFORMED_REQUEST_HEX_STRING_VALIDATOR},
360 meta::IfType<boost::json::object>{
361 meta::Section{
362 {
363 JS(account),
364 meta::WithCustomError{validation::Required{}, Status(ClioError::RpcMalformedRequest)},
365 meta::WithCustomError{
366 validation::CustomValidators::accountBase58Validator,
367 Status(ClioError::RpcMalformedAddress)
368 },
369 },
370 {
371 JS(mpt_issuance_id),
372 meta::WithCustomError{validation::Required{}, Status(ClioError::RpcMalformedRequest)},
373 meta::WithCustomError{
374 validation::CustomValidators::uint192HexStringValidator,
375 Status(ClioError::RpcMalformedRequest)
376 },
377 },
378 },
379 }},
380 {JS(permissioned_domain),
381 meta::WithCustomError{
382 validation::Type<std::string, boost::json::object>{}, Status(ClioError::RpcMalformedRequest)
383 },
384 meta::IfType<std::string>{kMALFORMED_REQUEST_HEX_STRING_VALIDATOR},
385 meta::IfType<boost::json::object>{meta::Section{
386 {JS(seq),
387 meta::WithCustomError{validation::Required{}, Status(ClioError::RpcMalformedRequest)},
388 meta::WithCustomError{validation::Type<uint32_t>{}, Status(ClioError::RpcMalformedRequest)}},
389 {
390 JS(account),
391 meta::WithCustomError{validation::Required{}, Status(ClioError::RpcMalformedRequest)},
392 meta::WithCustomError{
393 validation::CustomValidators::accountBase58Validator, Status(ClioError::RpcMalformedAddress)
394 },
395 },
396 }}},
397 {JS(vault),
398 meta::WithCustomError{
399 validation::Type<std::string, boost::json::object>{}, Status(ClioError::RpcMalformedRequest)
400 },
401 meta::IfType<std::string>{kMALFORMED_REQUEST_HEX_STRING_VALIDATOR},
402 meta::IfType<boost::json::object>{meta::Section{
403 {JS(seq),
404 meta::WithCustomError{validation::Required{}, Status(ClioError::RpcMalformedRequest)},
405 meta::WithCustomError{validation::Type<uint32_t>{}, Status(ClioError::RpcMalformedRequest)}},
406 {
407 JS(owner),
408 meta::WithCustomError{validation::Required{}, Status(ClioError::RpcMalformedRequest)},
409 meta::WithCustomError{
410 validation::CustomValidators::accountBase58Validator, Status(ClioError::RpcMalformedOwner)
411 },
412 },
413 }}},
414 {JS(delegate),
415 meta::WithCustomError{
416 validation::Type<std::string, boost::json::object>{}, Status(ClioError::RpcMalformedRequest)
417 },
418 meta::IfType<std::string>{kMALFORMED_REQUEST_HEX_STRING_VALIDATOR},
419 meta::IfType<boost::json::object>{meta::Section{
420 {JS(account),
421 meta::WithCustomError{validation::Required{}, Status(ClioError::RpcMalformedRequest)},
422 meta::WithCustomError{
423 validation::CustomValidators::accountBase58Validator, Status(ClioError::RpcMalformedAddress)
424 }},
425 {JS(authorize),
426 meta::WithCustomError{validation::Required{}, Status(ClioError::RpcMalformedRequest)},
427 meta::WithCustomError{
428 validation::CustomValidators::accountBase58Validator, Status(ClioError::RpcMalformedAddress)
429 }}
430 }}},
431 {JS(amendments), kMALFORMED_REQUEST_HEX_STRING_VALIDATOR},
432 {JS(fee), kMALFORMED_REQUEST_HEX_STRING_VALIDATOR},
433 {JS(hashes), kMALFORMED_REQUEST_HEX_STRING_VALIDATOR},
434 {JS(nft_offer), kMALFORMED_REQUEST_HEX_STRING_VALIDATOR},
435 {JS(nunl), kMALFORMED_REQUEST_HEX_STRING_VALIDATOR},
436 {JS(signer_list), kMALFORMED_REQUEST_HEX_STRING_VALIDATOR},
437 {JS(ledger), check::Deprecated{}},
438 {"include_deleted", validation::Type<bool>{}},
439 };
440
441 return kRPC_SPEC;
442 }
443
451 Result
452 process(Input const& input, Context const& ctx) const;
453
454private:
455 // dir_root and owner can not be both empty or filled at the same time
456 // This function will return an error if this is the case
457 static std::expected<ripple::uint256, Status>
458 composeKeyFromDirectory(boost::json::object const& directory) noexcept;
459
466 friend void
467 tag_invoke(boost::json::value_from_tag, boost::json::value& jv, Output const& output);
468
475 friend Input
476 tag_invoke(boost::json::value_to_tag<Input>, boost::json::value const& jv);
477};
478
479} // namespace rpc
rpc::LedgerEntryHandler::spec
static RpcSpecConstRef spec(uint32_t apiVersion)
Returns the API specification for the command.
Definition LedgerEntry.hpp:136
rpc::LedgerEntryHandler::tag_invoke
friend void tag_invoke(boost::json::value_from_tag, boost::json::value &jv, Output const &output)
Convert the Output to a JSON object.
Definition LedgerEntry.cpp:276
rpc::LedgerEntryHandler::process
Result process(Input const &input, Context const &ctx) const
Process the LedgerEntry command.
Definition LedgerEntry.cpp:62
rpc::LedgerEntryHandler::LedgerEntryHandler
LedgerEntryHandler(std::shared_ptr< BackendInterface > const &sharedPtrBackend)
Construct a new LedgerEntryHandler object.
Definition LedgerEntry.hpp:125
rpc::check::Deprecated
Check for a deprecated fields.
Definition Checkers.hpp:62
rpc::meta::IfType
A meta-processor that specifies a list of requirements to run against when the type matches the templ...
Definition MetaProcessors.hpp:101
rpc::meta::Section
A meta-processor that acts as a spec for a sub-object/section.
Definition MetaProcessors.hpp:43
rpc::meta::WithCustomError
A meta-processor that wraps a validator and produces a custom error in case the wrapped validator fai...
Definition MetaProcessors.hpp:166
rpc::validation::CustomValidator
A meta-validator that allows to specify a custom validation function.
Definition Validators.hpp:425
rpc
This namespace contains all the RPC logic and handlers.
Definition AMMHelpers.cpp:37
rpc::RpcSpecConstRef
RpcSpec const & RpcSpecConstRef
An alias for a const reference to RpcSpec.
Definition Specs.hpp:145
rpc::HandlerReturnType
std::expected< OutputType, Status > HandlerReturnType
Return type for each individual handler.
Definition Types.hpp:81
rpc::MaybeError
std::expected< void, Status > MaybeError
Return type used for Validators that can return error but don't have specific value to return.
Definition Types.hpp:55
rpc::Error
std::unexpected< Status > Error
The type that represents just the error part of MaybeError.
Definition Types.hpp:75
util::parseBase58Wrapper
std::optional< T > parseBase58Wrapper(std::string const &str)
A wrapper of parseBase58 function. It adds the check if all characters in the input string are alphan...
Definition AccountUtils.hpp:42
rpc::Context
Context of an RPC call.
Definition Types.hpp:118
rpc::LedgerEntryHandler::Input
A struct to hold the input data for the command.
Definition LedgerEntry.hpp:82
rpc::LedgerEntryHandler::Output
A struct to hold the output data of the command.
Definition LedgerEntry.hpp:69
rpc::Result
Result type used to return responses or error statuses to the Webserver subsystem.
Definition Types.hpp:129
rpc::RpcSpec
Represents a Specification of an entire RPC command.
Definition Specs.hpp:98
rpc::Status
A status returned from any RPC handler.
Definition Errors.hpp:83
rpc::modifiers::ToNumber
Convert input string to integer.
Definition Modifiers.hpp:112
rpc::validation::CustomValidators::currencyValidator
static CustomValidator currencyValidator
Provides a commonly used validator for currency, including standard currency code and token code.
Definition Validators.hpp:556
rpc::validation::CustomValidators::ledgerIndexValidator
static CustomValidator ledgerIndexValidator
Provides a commonly used validator for ledger index.
Definition Validators.hpp:489
rpc::validation::CustomValidators::currencyIssueValidator
static CustomValidator currencyIssueValidator
Validates an asset (ripple::Issue).
Definition Validators.hpp:580
rpc::validation::CustomValidators::authorizeCredentialValidator
static CustomValidator authorizeCredentialValidator
Provides a validator for validating authorized_credentials json array.
Definition Validators.hpp:587
rpc::validation::CustomValidators::uint192HexStringValidator
static CustomValidator uint192HexStringValidator
Provides a commonly used validator for uint192 hex string.
Definition Validators.hpp:543
rpc::validation::CustomValidators::uint256HexStringValidator
static CustomValidator uint256HexStringValidator
Provides a commonly used validator for uint256 hex string.
Definition Validators.hpp:551
rpc::validation::CustomValidators::accountBase58Validator
static CustomValidator accountBase58Validator
Provides a commonly used validator for accounts.
Definition Validators.hpp:511
rpc::validation::Required
A validator that simply requires a field to be present.
Definition Validators.hpp:47
rpc::validation::Type
Validates that the type of the value is one of the given types.
Definition Validators.hpp:142