RPCHelpers.hpp

Go to the documentation of this file.

#pragma once
 
/*
 * This file contains a variety of utility functions used when executing the handlers.
 */
 
#include "data/AmendmentCenterInterface.hpp"
#include "data/BackendInterface.hpp"
#include "data/Types.hpp"
#include "rpc/Errors.hpp"
#include "rpc/common/Types.hpp"
#include "util/JsonUtils.hpp"
#include "util/Taggable.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_match.hpp>
#include <fmt/format.h>
#include <rpcspec/Ledger.hpp>
#include <xrpl/basics/Number.h>
#include <xrpl/basics/base_uint.h>
#include <xrpl/json/json_value.h>
#include <xrpl/protocol/AccountID.h>
#include <xrpl/protocol/Asset.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/LedgerFormats.h>
#include <xrpl/protocol/LedgerHeader.h>
#include <xrpl/protocol/MPTIssue.h>
#include <xrpl/protocol/PublicKey.h>
#include <xrpl/protocol/Rate.h>
#include <xrpl/protocol/SField.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/Serializer.h>
#include <xrpl/protocol/TxMeta.h>
#include <xrpl/protocol/UintTypes.h>
#include <xrpl/protocol/XRPAmount.h>
#include <xrpl/protocol/jss.h>
 
#include <chrono>
#include <cstddef>
#include <cstdint>
#include <functional>
#include <memory>
#include <optional>
#include <string>
#include <string_view>
#include <tuple>
#include <utility>
#include <vector>
 
namespace rpc {

enum class NFTokenjson { ENABLE, DISABLE };

std::optional<xrpl::AccountID>
accountFromStringStrict(std::string const& account);

bool
isOwnedByAccount(xrpl::SLE const& sle, xrpl::AccountID const& accountID);

std::uint64_t
getStartHint(xrpl::SLE const& sle, xrpl::AccountID const& accountID);

std::optional<AccountCursor>
parseAccountCursor(std::optional<std::string> jsonCursor);
 
// TODO this function should probably be in a different file and namespace
std::pair<std::shared_ptr<xrpl::STTx const>, std::shared_ptr<xrpl::STObject const>>
deserializeTxPlusMeta(data::TransactionAndMetadata const& blobs);
 
// TODO this function should probably be in a different file and namespace
std::pair<std::shared_ptr<xrpl::STTx const>, std::shared_ptr<xrpl::TxMeta const>>
deserializeTxPlusMeta(data::TransactionAndMetadata const& blobs, std::uint32_t seq);

std::pair<boost::json::object, boost::json::object>
toExpandedJson(
    data::TransactionAndMetadata const& blobs,
    std::uint32_t apiVersion,
    NFTokenjson nftEnabled = NFTokenjson::DISABLE,
    std::optional<uint32_t> networkId = std::nullopt
);

boost::json::object
toJsonWithBinaryTx(data::TransactionAndMetadata const& txnPlusMeta, std::uint32_t apiVersion);

void
insertDeliverMaxAlias(boost::json::object& txJson, std::uint32_t apiVersion);

bool
insertDeliveredAmount(
    boost::json::object& metaJson,
    std::shared_ptr<xrpl::STTx const> const& txn,
    std::shared_ptr<xrpl::TxMeta const> const& meta,
    uint32_t date
);

bool
insertMPTIssuanceID(
    boost::json::object& txnJson,
    std::shared_ptr<xrpl::STTx const> const& txn,
    boost::json::object& metaJson,
    std::shared_ptr<xrpl::TxMeta const> const& meta
);

boost::json::object
toJson(xrpl::STBase const& obj);

boost::json::object
toJson(xrpl::SLE const& sle);

boost::json::object
toJson(xrpl::LedgerHeader const& info, bool binary, std::uint32_t apiVersion);

boost::json::object
toJson(xrpl::TxMeta const& meta);
 
using RippledJson = json::Value;

boost::json::value
toBoostJson(RippledJson const& value);

boost::json::object
generatePubLedgerMessage(
    xrpl::LedgerHeader const& lgrInfo,
    xrpl::Fees const& fees,
    std::string const& ledgerRange,
    std::uint32_t txnCount
);

std::expected<xrpl::LedgerHeader, Status>
ledgerHeaderFromRequest(
    std::shared_ptr<data::BackendInterface const> const& backend,
    web::Context const& ctx
);

std::expected<xrpl::LedgerHeader, Status>
getLedgerHeaderFromHashOrSeq(
    BackendInterface const& backend,
    boost::asio::yield_context yield,
    std::optional<std::string> ledgerHash,
    std::optional<uint32_t> ledgerIndex,
    uint32_t maxSeq
);

std::expected<xrpl::LedgerHeader, Status>
getLedgerHeaderFromLedgerSpecifier(
    BackendInterface const& backend,
    boost::asio::yield_context yield,
    rpc::spec::LedgerSpecifier const& ledger,
    uint32_t maxSeq
);

std::expected<AccountCursor, Status>
traverseOwnedNodes(
    BackendInterface const& backend,
    xrpl::Keylet const& owner,
    xrpl::uint256 const& hexMarker,
    std::uint32_t startHint,
    std::uint32_t sequence,
    std::uint32_t limit,
    boost::asio::yield_context yield,
    std::function<void(xrpl::SLE)> atOwnedNode
);

std::expected<AccountCursor, Status>
traverseOwnedNodes(
    BackendInterface const& backend,
    xrpl::AccountID const& accountID,
    std::uint32_t sequence,
    std::uint32_t limit,
    std::optional<std::string> jsonCursor,
    boost::asio::yield_context yield,
    std::function<void(xrpl::SLE)> atOwnedNode,
    bool nftIncluded = false
);

std::shared_ptr<xrpl::SLE const>
read(
    std::shared_ptr<data::BackendInterface const> const& backend,
    xrpl::Keylet const& keylet,
    xrpl::LedgerHeader const& lgrInfo,
    web::Context const& context
);

std::vector<xrpl::AccountID>
getAccountsFromTransaction(boost::json::object const& transaction);

std::vector<unsigned char>
ledgerHeaderToBlob(xrpl::LedgerHeader const& info, bool includeHash = false);

bool
isGlobalFrozen(
    BackendInterface const& backend,
    std::uint32_t seq,
    xrpl::AccountID const& issuer,
    boost::asio::yield_context yield
);

bool
isFrozen(
    BackendInterface const& backend,
    std::uint32_t sequence,
    xrpl::AccountID const& account,
    xrpl::Currency const& currency,
    xrpl::AccountID const& issuer,
    boost::asio::yield_context yield
);

bool
fetchAndCheckAnyFlagsExists(
    BackendInterface const& backend,
    std::uint32_t sequence,
    xrpl::Keylet const& keylet,
    std::vector<std::uint32_t> const& flags,
    boost::asio::yield_context yield
);

bool
isDeepFrozen(
    BackendInterface const& backend,
    std::uint32_t sequence,
    xrpl::AccountID const& account,
    xrpl::Currency const& currency,
    xrpl::AccountID const& issuer,
    boost::asio::yield_context yield
);

bool
isLPTokenFrozen(
    BackendInterface const& backend,
    std::uint32_t sequence,
    xrpl::AccountID const& account,
    xrpl::Issue const& asset,
    xrpl::Issue const& asset2,
    boost::asio::yield_context yield
);

xrpl::STAmount
accountFunds(
    BackendInterface const& backend,
    data::AmendmentCenterInterface const& amendmentCenter,
    std::uint32_t sequence,
    xrpl::STAmount const& amount,
    xrpl::AccountID const& id,
    boost::asio::yield_context yield
);

xrpl::STAmount
accountHolds(
    BackendInterface const& backend,
    data::AmendmentCenterInterface const& amendmentCenter,
    std::uint32_t sequence,
    xrpl::AccountID const& account,
    xrpl::Currency const& currency,
    xrpl::AccountID const& issuer,
    bool zeroIfFrozen,
    boost::asio::yield_context yield
);

xrpl::STAmount
ammAccountHolds(
    BackendInterface const& backend,
    std::uint32_t sequence,
    xrpl::AccountID const& account,
    xrpl::Currency const& currency,
    xrpl::AccountID const& issuer,
    bool const zeroIfFrozen,
    boost::asio::yield_context yield
);

xrpl::Rate
transferRate(
    BackendInterface const& backend,
    std::uint32_t sequence,
    xrpl::AccountID const& issuer,
    boost::asio::yield_context yield
);

xrpl::STAmount
accountHoldsMPT(
    BackendInterface const& backend,
    std::uint32_t sequence,
    xrpl::AccountID const& account,
    xrpl::MPTIssue const& mptIssue,
    bool zeroIfFrozen,
    boost::asio::yield_context yield
);

xrpl::XRPAmount
xrpLiquid(
    BackendInterface const& backend,
    std::uint32_t sequence,
    xrpl::AccountID const& id,
    boost::asio::yield_context yield
);

boost::json::array
postProcessOrderBook(
    std::vector<data::LedgerObject> const& offers,
    xrpl::Book const& book,
    xrpl::AccountID const& takerID,
    data::BackendInterface const& backend,
    data::AmendmentCenterInterface const& amendmentCenter,
    std::uint32_t ledgerSequence,
    boost::asio::yield_context yield
);

std::expected<xrpl::Book, Status>
parseBook(
    xrpl::Currency pays,
    xrpl::AccountID payIssuer,
    xrpl::Currency gets,
    xrpl::AccountID getIssuer,
    std::optional<std::string> const& domain
);

std::expected<xrpl::Book, Status>
parseBook(
    xrpl::Asset const& pays,
    xrpl::Asset const& gets,
    std::optional<std::string> const& domain
);

std::expected<xrpl::Book, Status>
parseBook(boost::json::object const& request);

std::expected<xrpl::AccountID, Status>
parseTaker(boost::json::value const& taker);

xrpl::Issue
parseIssue(boost::json::object const& issue);

bool
specifiesCurrentOrClosedLedger(boost::json::object const& request);

bool
isAdminCmd(std::string const& method, boost::json::object const& request);

std::expected<xrpl::uint256, Status>
getNFTID(boost::json::object const& request);

std::optional<std::string>
encodeCTID(uint32_t ledgerSeq, uint16_t txnIndex, uint32_t networkId) noexcept;

template <typename T>
inline std::optional<std::tuple<uint32_t, uint16_t, uint16_t>>
decodeCTID(T const ctid) noexcept
{
    auto const getCTID64 = [](T const ctid) noexcept -> std::optional<uint64_t> {
        if constexpr (std::is_convertible_v<T, std::string>) {
            std::string const ctidString(ctid);
            static constexpr std::size_t kCtidStringLength = 16;
            if (ctidString.length() != kCtidStringLength)
                return {};
 
            if (!boost::regex_match(ctidString, boost::regex("^[0-9A-F]+$")))
                return {};
 
            return std::stoull(ctidString, nullptr, 16);
        }
 
        if constexpr (std::is_same_v<T, uint64_t>)
            return ctid;
 
        return {};
    };
 
    auto const ctidValue = getCTID64(ctid).value_or(0);
 
    static constexpr uint64_t kCtidPrefix = 0xC000'0000'0000'0000ULL;
    static constexpr uint64_t kCtidPrefixMask = 0xF000'0000'0000'0000ULL;
 
    if ((ctidValue & kCtidPrefixMask) != kCtidPrefix)
        return {};
 
    uint32_t const ledgerSeq = (ctidValue >> 32) & 0xFFFF'FFFUL;
    uint16_t const txnIndex = (ctidValue >> 16) & 0xFFFFU;
    uint16_t const networkId = ctidValue & 0xFFFFU;
    return {{ledgerSeq, txnIndex, networkId}};
}

template <typename DurationType>
void
logDuration(
    boost::json::object const& request,
    util::BaseTagDecorator const& tag,
    DurationType const& dur
)
{
    using boost::json::serialize;
 
    static util::Logger const log{"RPC"};  // NOLINT(readability-identifier-naming)
    static constexpr std::int64_t kDurationErrorThresholdSeconds = 10;
 
    auto const millis = std::chrono::duration_cast<std::chrono::milliseconds>(dur).count();
    auto const seconds = std::chrono::duration_cast<std::chrono::seconds>(dur).count();
    auto const msg = fmt::format(
        "Request processing duration = {} milliseconds. request = {}",
        millis,
        serialize(util::removeSecret(request))
    );
 
    if (seconds > kDurationErrorThresholdSeconds) {
        LOG(log.error()) << tag << msg;
    } else if (seconds > 1) {
        LOG(log.warn()) << tag << msg;
    } else {
        LOG(log.info()) << tag << msg;
    }
}

std::optional<xrpl::Seed>
parseRippleLibSeed(boost::json::value const& value);

std::expected<AccountCursor, Status>
traverseNFTObjects(
    BackendInterface const& backend,
    std::uint32_t sequence,
    xrpl::AccountID const& accountID,
    xrpl::uint256 nextPage,
    std::uint32_t limit,
    boost::asio::yield_context yield,
    std::function<void(xrpl::SLE)> atOwnedNode
);

std::optional<std::uint32_t>
parseStringAsUInt(std::string const& value);  // TODO: move to string utils or something?

bool
canHaveDeliveredAmount(
    std::shared_ptr<xrpl::STTx const> const& txn,
    std::shared_ptr<xrpl::TxMeta const> const& meta
);

std::optional<xrpl::STAmount>
getDeliveredAmount(
    std::shared_ptr<xrpl::STTx const> const& txn,
    std::shared_ptr<xrpl::TxMeta const> const& meta,
    std::uint32_t ledgerSequence,
    uint32_t date
);
 
}  // namespace rpc