RPCHelpers.hpp File Reference

#include "data/BackendInterface.hpp"
#include "data/Types.hpp"
#include "rpc/Errors.hpp"
#include "rpc/common/Types.hpp"
#include "util/JsonUtils.hpp"
#include "util/log/Logger.hpp"
#include "web/Context.hpp"
#include <boost/asio/spawn.hpp>
#include <boost/json/array.hpp>
#include <boost/json/object.hpp>
#include <boost/json/value.hpp>
#include <boost/regex.hpp>
#include <boost/regex/v5/regex_fwd.hpp>
#include <boost/regex/v5/regex_match.hpp>
#include <fmt/core.h>
#include <xrpl/basics/base_uint.h>
#include <xrpl/json/json_value.h>
#include <xrpl/protocol/AccountID.h>
#include <xrpl/protocol/Book.h>
#include <xrpl/protocol/Fees.h>
#include <xrpl/protocol/Indexes.h>
#include <xrpl/protocol/Issue.h>
#include <xrpl/protocol/Keylet.h>
#include <xrpl/protocol/LedgerHeader.h>
#include <xrpl/protocol/PublicKey.h>
#include <xrpl/protocol/Rate.h>
#include <xrpl/protocol/STAmount.h>
#include <xrpl/protocol/STBase.h>
#include <xrpl/protocol/STLedgerEntry.h>
#include <xrpl/protocol/STObject.h>
#include <xrpl/protocol/STTx.h>
#include <xrpl/protocol/SecretKey.h>
#include <xrpl/protocol/Seed.h>
#include <xrpl/protocol/TxMeta.h>
#include <xrpl/protocol/UintTypes.h>
#include <xrpl/protocol/XRPAmount.h>
#include <chrono>
#include <cstddef>
#include <cstdint>
#include <functional>
#include <memory>
#include <optional>
#include <string>
#include <tuple>
#include <utility>
#include <variant>
#include <vector>

Include dependency graph for RPCHelpers.hpp:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Namespaces
namespace	rpc
	This namespace contains all the RPC logic and handlers.

Typedefs
using	rpc::RippledJson = Json::Value

Enumerations
enum class	rpc::NFTokenjson { ENABLE , DISABLE }
	Enum for NFT json manipulation.

Functions
std::optional< ripple::AccountID >	rpc::accountFromStringStrict (std::string const &account)
	Get a ripple::AccountID from its string representation.
bool	rpc::isOwnedByAccount (ripple::SLE const &sle, ripple::AccountID const &accountID)
	Check whether the SLE is owned by the account.
std::uint64_t	rpc::getStartHint (ripple::SLE const &sle, ripple::AccountID const &accountID)
	Get the start hint for the account.
std::optional< AccountCursor >	rpc::parseAccountCursor (std::optional< std::string > jsonCursor)
	Parse the account cursor from the JSON.
std::pair< std::shared_ptr< ripple::STTx const >, std::shared_ptr< ripple::STObject const > >	rpc::deserializeTxPlusMeta (data::TransactionAndMetadata const &blobs)
	Deserialize a TransactionAndMetadata into a pair of STTx and STObject.
std::pair< std::shared_ptr< ripple::STTx const >, std::shared_ptr< ripple::TxMeta const > >	rpc::deserializeTxPlusMeta (data::TransactionAndMetadata const &blobs, std::uint32_t seq)
	Deserialize a TransactionAndMetadata into a pair of STTx and TxMeta.
std::pair< boost::json::object, boost::json::object >	rpc::toExpandedJson (data::TransactionAndMetadata const &blobs, std::uint32_t apiVersion, NFTokenjson nftEnabled=NFTokenjson::DISABLE, std::optional< uint16_t > networkId=std::nullopt)
	Convert a TransactionAndMetadata to two JSON objects.
boost::json::object	rpc::toJsonWithBinaryTx (data::TransactionAndMetadata const &txnPlusMeta, std::uint32_t apiVersion)
	Convert a TransactionAndMetadata to JSON object containing tx and metadata data in hex format. According to the apiVersion, the key is "tx_blob" and "meta" or "meta_blob".
void	rpc::insertDeliverMaxAlias (boost::json::object &txJson, std::uint32_t apiVersion)
	Add "DeliverMax" which is the alias of "Amount" for "Payment" transaction to transaction json. Remove the "Amount" field when version is greater than 1.
bool	rpc::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.
bool	rpc::insertMPTIssuanceID (boost::json::object &metaJson, std::shared_ptr< ripple::STTx const > const &txn, std::shared_ptr< ripple::TxMeta const > const &meta)
	Add "mpt_issuance_id" into MPTokenIssuanceCreate transaction json.
boost::json::object	rpc::toJson (ripple::STBase const &obj)
	Convert STBase object to JSON.
boost::json::object	rpc::toJson (ripple::SLE const &sle)
	Convert SLE to JSON.
boost::json::object	rpc::toJson (ripple::LedgerHeader const &info, bool binary, std::uint32_t apiVersion)
	Convert a LedgerHeader to JSON object.
boost::json::object	rpc::toJson (ripple::TxMeta const &meta)
	Convert a TxMeta to JSON object.
boost::json::value	rpc::toBoostJson (RippledJson const &value)
	Convert a RippledJson to boost::json::value.
boost::json::object	rpc::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::variant< Status, ripple::LedgerHeader >	rpc::ledgerHeaderFromRequest (std::shared_ptr< data::BackendInterface const > const &backend, web::Context const &ctx)
	Get ledger info from the request.
std::variant< Status, ripple::LedgerHeader >	rpc::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.
std::variant< Status, AccountCursor >	rpc::traverseOwnedNodes (BackendInterface const &backend, ripple::Keylet const &owner, ripple::uint256 const &hexMarker, std::uint32_t startHint, std::uint32_t sequence, std::uint32_t limit, boost::asio::yield_context yield, std::function< void(ripple::SLE)> atOwnedNode)
	Traverse nodes owned by an account.
std::variant< Status, AccountCursor >	rpc::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=false)
	Traverse nodes owned by an account.
std::shared_ptr< ripple::SLE const >	rpc::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.
std::vector< ripple::AccountID >	rpc::getAccountsFromTransaction (boost::json::object const &transaction)
	Get the account associated with a transaction.
std::vector< unsigned char >	rpc::ledgerHeaderToBlob (ripple::LedgerHeader const &info, bool includeHash=false)
	Convert a ledger header to a blob.
bool	rpc::isGlobalFrozen (BackendInterface const &backend, std::uint32_t seq, ripple::AccountID const &issuer, boost::asio::yield_context yield)
	Whether global frozen is set.
bool	rpc::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.
ripple::STAmount	rpc::accountFunds (BackendInterface const &backend, std::uint32_t sequence, ripple::STAmount const &amount, ripple::AccountID const &id, boost::asio::yield_context yield)
	Get the account funds.
ripple::STAmount	rpc::accountHolds (BackendInterface const &backend, std::uint32_t sequence, ripple::AccountID const &account, ripple::Currency const &currency, ripple::AccountID const &issuer, bool zeroIfFrozen, boost::asio::yield_context yield)
	Get the amount that an account holds.
ripple::Rate	rpc::transferRate (BackendInterface const &backend, std::uint32_t sequence, ripple::AccountID const &issuer, boost::asio::yield_context yield)
	Get the transfer rate.
ripple::XRPAmount	rpc::xrpLiquid (BackendInterface const &backend, std::uint32_t sequence, ripple::AccountID const &id, boost::asio::yield_context yield)
	Get the XRP liquidity.
boost::json::array	rpc::postProcessOrderBook (std::vector< data::LedgerObject > const &offers, ripple::Book const &book, ripple::AccountID const &takerID, data::BackendInterface const &backend, std::uint32_t ledgerSequence, boost::asio::yield_context yield)
	Post process an order book.
std::variant< Status, ripple::Book >	rpc::parseBook (ripple::Currency pays, ripple::AccountID payIssuer, ripple::Currency gets, ripple::AccountID getIssuer)
	Parse the book from the request.
std::variant< Status, ripple::Book >	rpc::parseBook (boost::json::object const &request)
	Parse the book from the request.
std::variant< Status, ripple::AccountID >	rpc::parseTaker (boost::json::value const &taker)
	Parse the taker from the request.
ripple::Issue	rpc::parseIssue (boost::json::object const &issue)
	Parse the json object into a ripple::Issue object.
bool	rpc::specifiesCurrentOrClosedLedger (boost::json::object const &request)
	Check whethe the request specifies the current or closed ledger.
bool	rpc::isAdminCmd (std::string const &method, boost::json::object const &request)
	Check whether a request requires administrative privileges on rippled side.
std::variant< ripple::uint256, Status >	rpc::getNFTID (boost::json::object const &request)
	Get the NFTID from the request.
std::optional< std::string >	rpc::encodeCTID (uint32_t ledgerSeq, uint16_t txnIndex, uint16_t networkId) noexcept
	Encode CTID as string.
template<typename T >
std::optional< std::tuple< uint32_t, uint16_t, uint16_t > >	rpc::decodeCTID (T const ctid) noexcept
	Decode the CTID from a string or a uint64_t.
template<typename T >
void	rpc::logDuration (web::Context const &ctx, T const &dur)
	Log the duration of the request processing.
std::optional< ripple::Seed >	rpc::parseRippleLibSeed (boost::json::value const &value)
	Parse a ripple-lib seed.
std::variant< Status, AccountCursor >	rpc::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.
std::optional< std::uint32_t >	rpc::parseStringAsUInt (std::string const &value)
	Parse the string as a uint32_t.
bool	rpc::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.
std::optional< ripple::STAmount >	rpc::getDeliveredAmount (std::shared_ptr< ripple::STTx const > const &txn, std::shared_ptr< ripple::TxMeta const > const &meta, std::uint32_t ledgerSequence, uint32_t date)
	Get the delivered amount.