Clio  develop
The XRP Ledger API server.
Loading...
Searching...
No Matches
RPCHelpers.hpp
Go to the documentation of this file.
1//------------------------------------------------------------------------------
2/*
3 This file is part of clio: https://github.com/XRPLF/clio
4 Copyright (c) 2022, 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
21#pragma once
22
23/*
24 * This file contains a variety of utility functions used when executing the handlers.
25 */
26
27#include "data/AmendmentCenterInterface.hpp"
28#include "data/BackendInterface.hpp"
29#include "data/Types.hpp"
30#include "rpc/Errors.hpp"
31#include "rpc/JS.hpp"
32#include "rpc/common/Types.hpp"
33#include "util/JsonUtils.hpp"
34#include "util/Taggable.hpp"
35#include "util/log/Logger.hpp"
36#include "web/Context.hpp"
37
38#include <boost/asio/spawn.hpp>
39#include <boost/json/array.hpp>
40#include <boost/json/object.hpp>
41#include <boost/json/value.hpp>
42#include <boost/regex.hpp>
43#include <boost/regex/v5/regex_fwd.hpp>
44#include <boost/regex/v5/regex_match.hpp>
45#include <fmt/format.h>
46#include <xrpl/basics/Number.h>
47#include <xrpl/basics/base_uint.h>
48#include <xrpl/json/json_value.h>
49#include <xrpl/protocol/AccountID.h>
50#include <xrpl/protocol/Book.h>
51#include <xrpl/protocol/Fees.h>
52#include <xrpl/protocol/Indexes.h>
53#include <xrpl/protocol/Issue.h>
54#include <xrpl/protocol/Keylet.h>
55#include <xrpl/protocol/LedgerFormats.h>
56#include <xrpl/protocol/LedgerHeader.h>
57#include <xrpl/protocol/MPTIssue.h>
58#include <xrpl/protocol/PublicKey.h>
59#include <xrpl/protocol/Rate.h>
60#include <xrpl/protocol/SField.h>
61#include <xrpl/protocol/STAmount.h>
62#include <xrpl/protocol/STBase.h>
63#include <xrpl/protocol/STLedgerEntry.h>
64#include <xrpl/protocol/STObject.h>
65#include <xrpl/protocol/STTx.h>
66#include <xrpl/protocol/SecretKey.h>
67#include <xrpl/protocol/Seed.h>
68#include <xrpl/protocol/Serializer.h>
69#include <xrpl/protocol/TxMeta.h>
70#include <xrpl/protocol/UintTypes.h>
71#include <xrpl/protocol/XRPAmount.h>
72#include <xrpl/protocol/jss.h>
73
74#include <chrono>
75#include <cstddef>
76#include <cstdint>
77#include <functional>
78#include <memory>
79#include <optional>
80#include <string>
81#include <tuple>
82#include <utility>
83#include <vector>
84
85namespace rpc {
86
88enum class NFTokenjson { ENABLE, DISABLE };
89
96std::optional<ripple::AccountID>
97accountFromStringStrict(std::string const& account);
98
106bool
107isOwnedByAccount(ripple::SLE const& sle, ripple::AccountID const& accountID);
108
116std::uint64_t
117getStartHint(ripple::SLE const& sle, ripple::AccountID const& accountID);
118
125std::optional<AccountCursor>
126parseAccountCursor(std::optional<std::string> jsonCursor);
127
128// TODO this function should probably be in a different file and namespace
135std::pair<std::shared_ptr<ripple::STTx const>, std::shared_ptr<ripple::STObject const>>
137
138// TODO this function should probably be in a different file and namespace
146std::pair<std::shared_ptr<ripple::STTx const>, std::shared_ptr<ripple::TxMeta const>>
147deserializeTxPlusMeta(data::TransactionAndMetadata const& blobs, std::uint32_t seq);
148
158std::pair<boost::json::object, boost::json::object>
160 data::TransactionAndMetadata const& blobs,
161 std::uint32_t apiVersion,
162 NFTokenjson nftEnabled = NFTokenjson::DISABLE,
163 std::optional<uint16_t> networkId = std::nullopt
164);
165
173boost::json::object
174toJsonWithBinaryTx(data::TransactionAndMetadata const& txnPlusMeta, std::uint32_t apiVersion);
175
182void
183insertDeliverMaxAlias(boost::json::object& txJson, std::uint32_t apiVersion);
184
194bool
196 boost::json::object& metaJson,
197 std::shared_ptr<ripple::STTx const> const& txn,
198 std::shared_ptr<ripple::TxMeta const> const& meta,
199 uint32_t date
200);
201
211bool
212insertMPTIssuanceID(boost::json::object& txnJson, std::shared_ptr<ripple::TxMeta const> const& meta);
213
220boost::json::object
221toJson(ripple::STBase const& obj);
222
229boost::json::object
230toJson(ripple::SLE const& sle);
231
240boost::json::object
241toJson(ripple::LedgerHeader const& info, bool binary, std::uint32_t apiVersion);
242
249boost::json::object
250toJson(ripple::TxMeta const& meta);
251
252using RippledJson = Json::Value;
253
260boost::json::value
261toBoostJson(RippledJson const& value);
262
272boost::json::object
274 ripple::LedgerHeader const& lgrInfo,
275 ripple::Fees const& fees,
276 std::string const& ledgerRange,
277 std::uint32_t txnCount
278);
279
287std::expected<ripple::LedgerHeader, Status>
288ledgerHeaderFromRequest(std::shared_ptr<data::BackendInterface const> const& backend, web::Context const& ctx);
289
300std::expected<ripple::LedgerHeader, Status>
302 BackendInterface const& backend,
303 boost::asio::yield_context yield,
304 std::optional<std::string> ledgerHash,
305 std::optional<uint32_t> ledgerIndex,
306 uint32_t maxSeq
307);
308
322std::expected<AccountCursor, Status>
324 BackendInterface const& backend,
325 ripple::Keylet const& owner,
326 ripple::uint256 const& hexMarker,
327 std::uint32_t startHint,
328 std::uint32_t sequence,
329 std::uint32_t limit,
330 boost::asio::yield_context yield,
331 std::function<void(ripple::SLE)> atOwnedNode
332);
333
349std::expected<AccountCursor, Status>
351 BackendInterface const& backend,
352 ripple::AccountID const& accountID,
353 std::uint32_t sequence,
354 std::uint32_t limit,
355 std::optional<std::string> jsonCursor,
356 boost::asio::yield_context yield,
357 std::function<void(ripple::SLE)> atOwnedNode,
358 bool nftIncluded = false
359);
360
370std::shared_ptr<ripple::SLE const>
371read(
372 std::shared_ptr<data::BackendInterface const> const& backend,
373 ripple::Keylet const& keylet,
374 ripple::LedgerHeader const& lgrInfo,
375 web::Context const& context
376);
377
384std::vector<ripple::AccountID>
385getAccountsFromTransaction(boost::json::object const& transaction);
386
394std::vector<unsigned char>
395ledgerHeaderToBlob(ripple::LedgerHeader const& info, bool includeHash = false);
396
406bool
408 BackendInterface const& backend,
409 std::uint32_t seq,
410 ripple::AccountID const& issuer,
411 boost::asio::yield_context yield
412);
413
425bool
427 BackendInterface const& backend,
428 std::uint32_t sequence,
429 ripple::AccountID const& account,
430 ripple::Currency const& currency,
431 ripple::AccountID const& issuer,
432 boost::asio::yield_context yield
433);
434
445bool
447 BackendInterface const& backend,
448 std::uint32_t sequence,
449 ripple::Keylet const& keylet,
450 std::vector<std::uint32_t> const& flags,
451 boost::asio::yield_context yield
452);
453
468bool
470 BackendInterface const& backend,
471 std::uint32_t sequence,
472 ripple::AccountID const& account,
473 ripple::Currency const& currency,
474 ripple::AccountID const& issuer,
475 boost::asio::yield_context yield
476);
477
489bool
491 BackendInterface const& backend,
492 std::uint32_t sequence,
493 ripple::AccountID const& account,
494 ripple::Issue const& asset,
495 ripple::Issue const& asset2,
496 boost::asio::yield_context yield
497);
498
510ripple::STAmount
512 BackendInterface const& backend,
513 data::AmendmentCenterInterface const& amendmentCenter,
514 std::uint32_t sequence,
515 ripple::STAmount const& amount,
516 ripple::AccountID const& id,
517 boost::asio::yield_context yield
518);
519
533ripple::STAmount
535 BackendInterface const& backend,
536 data::AmendmentCenterInterface const& amendmentCenter,
537 std::uint32_t sequence,
538 ripple::AccountID const& account,
539 ripple::Currency const& currency,
540 ripple::AccountID const& issuer,
541 bool zeroIfFrozen,
542 boost::asio::yield_context yield
543);
544
557ripple::STAmount
559 BackendInterface const& backend,
560 std::uint32_t sequence,
561 ripple::AccountID const& account,
562 ripple::Currency const& currency,
563 ripple::AccountID const& issuer,
564 bool const zeroIfFrozen,
565 boost::asio::yield_context yield
566);
567
577ripple::Rate
579 BackendInterface const& backend,
580 std::uint32_t sequence,
581 ripple::AccountID const& issuer,
582 boost::asio::yield_context yield
583);
584
594ripple::XRPAmount
596 BackendInterface const& backend,
597 std::uint32_t sequence,
598 ripple::AccountID const& id,
599 boost::asio::yield_context yield
600);
601
614boost::json::array
616 std::vector<data::LedgerObject> const& offers,
617 ripple::Book const& book,
618 ripple::AccountID const& takerID,
619 data::BackendInterface const& backend,
620 data::AmendmentCenterInterface const& amendmentCenter,
621 std::uint32_t ledgerSequence,
622 boost::asio::yield_context yield
623);
624
635std::expected<ripple::Book, Status>
637 ripple::Currency pays,
638 ripple::AccountID payIssuer,
639 ripple::Currency gets,
640 ripple::AccountID getIssuer,
641 std::optional<std::string> const& domain
642);
643
650std::expected<ripple::Book, Status>
651parseBook(boost::json::object const& request);
652
659std::expected<ripple::AccountID, Status>
660parseTaker(boost::json::value const& taker);
661
669ripple::Issue
670parseIssue(boost::json::object const& issue);
671
677bool
678specifiesCurrentOrClosedLedger(boost::json::object const& request);
679
687bool
688isAdminCmd(std::string const& method, boost::json::object const& request);
689
696std::expected<ripple::uint256, Status>
697getNFTID(boost::json::object const& request);
698
707std::optional<std::string>
708encodeCTID(uint32_t ledgerSeq, uint16_t txnIndex, uint16_t networkId) noexcept;
709
717template <typename T>
718inline std::optional<std::tuple<uint32_t, uint16_t, uint16_t>>
719decodeCTID(T const ctid) noexcept
720{
721 auto const getCTID64 = [](T const ctid) noexcept -> std::optional<uint64_t> {
722 if constexpr (std::is_convertible_v<T, std::string>) {
723 std::string const ctidString(ctid);
724 static constexpr std::size_t kCTID_STRING_LENGTH = 16;
725 if (ctidString.length() != kCTID_STRING_LENGTH)
726 return {};
727
728 if (!boost::regex_match(ctidString, boost::regex("^[0-9A-F]+$")))
729 return {};
730
731 return std::stoull(ctidString, nullptr, 16);
732 }
733
734 if constexpr (std::is_same_v<T, uint64_t>)
735 return ctid;
736
737 return {};
738 };
739
740 auto const ctidValue = getCTID64(ctid).value_or(0);
741
742 static constexpr uint64_t kCTID_PREFIX = 0xC000'0000'0000'0000ULL;
743 static constexpr uint64_t kCTID_PREFIX_MASK = 0xF000'0000'0000'0000ULL;
744
745 if ((ctidValue & kCTID_PREFIX_MASK) != kCTID_PREFIX)
746 return {};
747
748 uint32_t const ledgerSeq = (ctidValue >> 32) & 0xFFFF'FFFUL;
749 uint16_t const txnIndex = (ctidValue >> 16) & 0xFFFFU;
750 uint16_t const networkId = ctidValue & 0xFFFFU;
751 return {{ledgerSeq, txnIndex, networkId}};
752}
753
762template <typename DurationType>
763void
764logDuration(boost::json::object const& request, util::BaseTagDecorator const& tag, DurationType const& dur)
765{
766 using boost::json::serialize;
767
768 static util::Logger const log{"RPC"}; // NOLINT(readability-identifier-naming)
769 static constexpr std::int64_t kDURATION_ERROR_THRESHOLD_SECONDS = 10;
770
771 auto const millis = std::chrono::duration_cast<std::chrono::milliseconds>(dur).count();
772 auto const seconds = std::chrono::duration_cast<std::chrono::seconds>(dur).count();
773 auto const msg = fmt::format(
774 "Request processing duration = {} milliseconds. request = {}", millis, serialize(util::removeSecret(request))
775 );
776
777 if (seconds > kDURATION_ERROR_THRESHOLD_SECONDS) {
778 LOG(log.error()) << tag << msg;
779 } else if (seconds > 1) {
780 LOG(log.warn()) << tag << msg;
781 } else
782 LOG(log.info()) << tag << msg;
783}
784
791std::optional<ripple::Seed>
792parseRippleLibSeed(boost::json::value const& value);
793
806std::expected<AccountCursor, Status>
808 BackendInterface const& backend,
809 std::uint32_t sequence,
810 ripple::AccountID const& accountID,
811 ripple::uint256 nextPage,
812 std::uint32_t limit,
813 boost::asio::yield_context yield,
814 std::function<void(ripple::SLE)> atOwnedNode
815);
816
823std::optional<std::uint32_t>
824parseStringAsUInt(std::string const& value); // TODO: move to string utils or something?
825
833bool
835 std::shared_ptr<ripple::STTx const> const& txn,
836 std::shared_ptr<ripple::TxMeta const> const& meta
837);
838
848std::optional<ripple::STAmount>
850 std::shared_ptr<ripple::STTx const> const& txn,
851 std::shared_ptr<ripple::TxMeta const> const& meta,
852 std::uint32_t ledgerSequence,
853 uint32_t date
854);
855
856} // namespace rpc
The interface of an amendment center.
Definition AmendmentCenterInterface.hpp:36
The interface to the database used by Clio.
Definition BackendInterface.hpp:139
Represents any tag decorator.
Definition Taggable.hpp:74
A simple thread-safe logger for the channel specified in the constructor.
Definition Logger.hpp:94
Pump warn(SourceLocationType const &loc=CURRENT_SRC_LOCATION) const
Interface for logging at Severity::WRN severity.
Definition Logger.cpp:468
Pump error(SourceLocationType const &loc=CURRENT_SRC_LOCATION) const
Interface for logging at Severity::ERR severity.
Definition Logger.cpp:473
Pump info(SourceLocationType const &loc=CURRENT_SRC_LOCATION) const
Interface for logging at Severity::NFO severity.
Definition Logger.cpp:463
This namespace contains all the RPC logic and handlers.
Definition AMMHelpers.cpp:37
std::pair< std::shared_ptr< ripple::STTx const >, std::shared_ptr< ripple::STObject const > > deserializeTxPlusMeta(data::TransactionAndMetadata const &blobs)
Deserialize a TransactionAndMetadata into a pair of STTx and STObject.
Definition RPCHelpers.cpp:203
std::expected< ripple::uint256, Status > getNFTID(boost::json::object const &request)
Get the NFTID from the request.
Definition RPCHelpers.cpp:1541
std::uint64_t getStartHint(ripple::SLE const &sle, ripple::AccountID const &accountID)
Get the start hint for the account.
Definition RPCHelpers.cpp:567
ripple::Issue parseIssue(boost::json::object const &issue)
Parse the json object into a ripple::Issue object.
Definition RPCHelpers.cpp:1491
bool isFrozen(BackendInterface const &backend, std::uint32_t sequence, ripple::AccountID const &account, ripple::Currency const &currency, ripple::AccountID const &issuer, boost::asio::yield_context yield)
Whether the account is frozen.
Definition RPCHelpers.cpp:925
bool insertDeliveredAmount(boost::json::object &metaJson, std::shared_ptr< ripple::STTx const > const &txn, std::shared_ptr< ripple::TxMeta const > const &meta, uint32_t date)
Add "DeliveredAmount" to the transaction json object.
Definition RPCHelpers.cpp:302
boost::json::object toJsonWithBinaryTx(data::TransactionAndMetadata const &txnPlusMeta, std::uint32_t const apiVersion)
Convert a TransactionAndMetadata to JSON object containing tx and metadata data in hex format....
Definition RPCHelpers.cpp:1557
bool isDeepFrozen(BackendInterface const &backend, std::uint32_t sequence, ripple::AccountID const &account, ripple::Currency const &currency, ripple::AccountID const &issuer, boost::asio::yield_context yield)
Whether the trustline is deep frozen.
Definition RPCHelpers.cpp:954
std::optional< AccountCursor > parseAccountCursor(std::optional< std::string > jsonCursor)
Parse the account cursor from the JSON.
Definition RPCHelpers.cpp:109
std::expected< ripple::LedgerHeader, Status > ledgerHeaderFromRequest(std::shared_ptr< data::BackendInterface const > const &backend, web::Context const &ctx)
Get ledger info from the request.
Definition RPCHelpers.cpp:465
std::vector< ripple::AccountID > getAccountsFromTransaction(boost::json::object const &transaction)
Get the account associated with a transaction.
Definition RPCHelpers.cpp:863
void logDuration(boost::json::object const &request, util::BaseTagDecorator const &tag, DurationType const &dur)
Log the duration of the request processing.
Definition RPCHelpers.hpp:764
ripple::STAmount ammAccountHolds(BackendInterface const &backend, std::uint32_t sequence, ripple::AccountID const &account, ripple::Currency const &currency, ripple::AccountID const &issuer, bool const zeroIfFrozen, boost::asio::yield_context yield)
Get the amount that an LPToken owner holds.
Definition RPCHelpers.cpp:1043
std::optional< std::string > encodeCTID(uint32_t ledgerSeq, uint16_t txnIndex, uint16_t networkId) noexcept
Encode CTID as string.
Definition RPCHelpers.cpp:285
boost::json::object generatePubLedgerMessage(ripple::LedgerHeader const &lgrInfo, ripple::Fees const &fees, std::string const &ledgerRange, std::uint32_t txnCount)
Generate a JSON object to publish ledger message.
std::optional< std::tuple< uint32_t, uint16_t, uint16_t > > decodeCTID(T const ctid) noexcept
Decode the CTID from a string or a uint64_t.
Definition RPCHelpers.hpp:719
std::expected< ripple::Book, Status > parseBook(ripple::Currency pays, ripple::AccountID payIssuer, ripple::Currency gets, ripple::AccountID getIssuer, std::optional< std::string > const &domain)
Parse the book from the request.
Definition RPCHelpers.cpp:1311
boost::json::array postProcessOrderBook(std::vector< data::LedgerObject > const &offers, ripple::Book const &book, ripple::AccountID const &takerID, data::BackendInterface const &backend, data::AmendmentCenterInterface const &amendmentCenter, std::uint32_t const ledgerSequence, boost::asio::yield_context yield)
Post process an order book.
Definition RPCHelpers.cpp:1195
bool isOwnedByAccount(ripple::SLE const &sle, ripple::AccountID const &accountID)
Check whether the SLE is owned by the account.
std::pair< boost::json::object, boost::json::object > toExpandedJson(data::TransactionAndMetadata const &blobs, std::uint32_t const apiVersion, NFTokenjson nftEnabled, std::optional< uint16_t > networkId)
Convert a TransactionAndMetadata to two JSON objects.
Definition RPCHelpers.cpp:249
std::optional< ripple::AccountID > accountFromStringStrict(std::string const &account)
Get a ripple::AccountID from its string representation.
Definition RPCHelpers.cpp:181
ripple::STAmount accountHolds(BackendInterface const &backend, data::AmendmentCenterInterface const &amendmentCenter, std::uint32_t sequence, ripple::AccountID const &account, ripple::Currency const &currency, ripple::AccountID const &issuer, bool const zeroIfFrozen, boost::asio::yield_context yield)
Get the amount that an account holds.
Definition RPCHelpers.cpp:1088
std::expected< ripple::LedgerHeader, Status > getLedgerHeaderFromHashOrSeq(BackendInterface const &backend, boost::asio::yield_context yield, std::optional< std::string > ledgerHash, std::optional< uint32_t > ledgerIndex, uint32_t maxSeq)
Get ledger info from hash or sequence.
Definition RPCHelpers.cpp:516
ripple::STAmount accountFunds(BackendInterface const &backend, data::AmendmentCenterInterface const &amendmentCenter, std::uint32_t const sequence, ripple::STAmount const &amount, ripple::AccountID const &id, boost::asio::yield_context yield)
Get the account funds.
Definition RPCHelpers.cpp:1026
boost::json::object toJson(ripple::STBase const &obj)
Convert STBase object to JSON.
Definition RPCHelpers.cpp:241
ripple::XRPAmount xrpLiquid(BackendInterface const &backend, std::uint32_t sequence, ripple::AccountID const &id, boost::asio::yield_context yield)
Get the XRP liquidity.
Definition RPCHelpers.cpp:991
std::expected< ripple::AccountID, Status > parseTaker(boost::json::value const &taker)
Parse the taker from the request.
Definition RPCHelpers.cpp:1477
bool canHaveDeliveredAmount(std::shared_ptr< ripple::STTx const > const &txn, std::shared_ptr< ripple::TxMeta const > const &meta)
Whether the transaction can have a delivered amount.
Definition RPCHelpers.cpp:168
std::shared_ptr< ripple::SLE const > read(std::shared_ptr< data::BackendInterface const > const &backend, ripple::Keylet const &keylet, ripple::LedgerHeader const &lgrInfo, web::Context const &context)
Read SLE from the backend.
Definition RPCHelpers.cpp:828
NFTokenjson
Enum for NFT json manipulation.
Definition RPCHelpers.hpp:88
std::optional< ripple::Seed > parseRippleLibSeed(boost::json::value const &value)
Parse a ripple-lib seed.
Definition RPCHelpers.cpp:843
void insertDeliverMaxAlias(boost::json::object &txJson, std::uint32_t const apiVersion)
Add "DeliverMax" which is the alias of "Amount" for "Payment" transaction to transaction json....
Definition RPCHelpers.cpp:381
bool specifiesCurrentOrClosedLedger(boost::json::object const &request)
Check whether the request specifies the current or closed ledger.
Definition RPCHelpers.cpp:1503
std::optional< ripple::STAmount > getDeliveredAmount(std::shared_ptr< ripple::STTx const > const &txn, std::shared_ptr< ripple::TxMeta const > const &meta, std::uint32_t const ledgerSequence, uint32_t date)
Get the delivered amount.
Definition RPCHelpers.cpp:140
bool insertMPTIssuanceID(boost::json::object &txnJson, std::shared_ptr< ripple::TxMeta const > const &meta)
Add "mpt_issuance_id" into various MPTToken transaction json.
Definition RPCHelpers.cpp:364
ripple::Rate transferRate(BackendInterface const &backend, std::uint32_t sequence, ripple::AccountID const &issuer, boost::asio::yield_context yield)
Get the transfer rate.
Definition RPCHelpers.cpp:1173
bool isGlobalFrozen(BackendInterface const &backend, std::uint32_t sequence, ripple::AccountID const &issuer, boost::asio::yield_context yield)
Whether global frozen is set.
Definition RPCHelpers.cpp:882
boost::json::value toBoostJson(Json::Value const &value)
Convert a RippledJson to boost::json::value.
Definition RPCHelpers.cpp:400
std::expected< AccountCursor, Status > traverseOwnedNodes(BackendInterface const &backend, ripple::AccountID const &accountID, std::uint32_t sequence, std::uint32_t limit, std::optional< std::string > jsonCursor, boost::asio::yield_context yield, std::function< void(ripple::SLE)> atOwnedNode, bool nftIncluded)
Traverse nodes owned by an account.
Definition RPCHelpers.cpp:639
bool isLPTokenFrozen(BackendInterface const &backend, std::uint32_t sequence, ripple::AccountID const &account, ripple::Issue const &asset, ripple::Issue const &asset2, boost::asio::yield_context yield)
Whether the account that owns a LPToken is frozen for the assets in the pool.
Definition RPCHelpers.cpp:977
std::optional< std::uint32_t > parseStringAsUInt(std::string const &value)
Parse the string as a uint32_t.
Definition RPCHelpers.cpp:452
bool isAdminCmd(std::string const &method, boost::json::object const &request)
Check whether a request requires administrative privileges on rippled side.
Definition RPCHelpers.cpp:1516
std::expected< AccountCursor, Status > traverseNFTObjects(BackendInterface const &backend, std::uint32_t sequence, ripple::AccountID const &accountID, ripple::uint256 nextPage, std::uint32_t limit, boost::asio::yield_context yield, std::function< void(ripple::SLE)> atOwnedNode)
Traverse NFT objects and call the callback for each owned node.
Definition RPCHelpers.cpp:587
bool fetchAndCheckAnyFlagsExists(BackendInterface const &backend, std::uint32_t sequence, ripple::Keylet const &keylet, std::vector< std::uint32_t > const &flags, boost::asio::yield_context yield)
Fetches a ledger object and checks if any of the specified flag is set on the account.
Definition RPCHelpers.cpp:905
std::vector< unsigned char > ledgerHeaderToBlob(ripple::LedgerHeader const &info, bool includeHash)
Convert a ledger header to a blob.
Definition RPCHelpers.cpp:549
boost::json::object removeSecret(boost::json::object const &object)
Removes any detected secret information from a response JSON object.
Definition JsonUtils.hpp:69
Represents a transaction and its metadata bundled together.
Definition Types.hpp:68
Context that is used by the Webserver to pass around information about an incoming request.
Definition Context.hpp:40