RPCHelpers.hpp

Go to the documentation of this file.

//------------------------------------------------------------------------------
/*
    This file is part of clio: https://github.com/XRPLF/clio
    Copyright (c) 2022, the clio developers.
 
    Permission to use, copy, modify, and distribute this software for any
    purpose with or without fee is hereby granted, provided that the above
    copyright notice and this permission notice appear in all copies.
 
    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
    ANY  SPECIAL,  DIRECT,  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
//==============================================================================
 
#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/JS.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_fwd.hpp>
#include <boost/regex/v5/regex_match.hpp>
#include <fmt/format.h>
#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/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 <tuple>
#include <utility>
#include <vector>
 
namespace rpc {
 
enum class NFTokenjson { ENABLE, DISABLE };
 
std::optional<ripple::AccountID>
accountFromStringStrict(std::string const& account);
 
bool
isOwnedByAccount(ripple::SLE const& sle, ripple::AccountID const& accountID);
 
std::uint64_t
getStartHint(ripple::SLE const& sle, ripple::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<ripple::STTx const>, std::shared_ptr<ripple::STObject const>>
deserializeTxPlusMeta(data::TransactionAndMetadata const& blobs);
 
// TODO this function should probably be in a different file and namespace
std::pair<std::shared_ptr<ripple::STTx const>, std::shared_ptr<ripple::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<uint16_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<ripple::STTx const> const& txn,
    std::shared_ptr<ripple::TxMeta const> const& meta,
    uint32_t date
);
 
bool
insertMPTIssuanceID(
    boost::json::object& metaJson,
    std::shared_ptr<ripple::STTx const> const& txn,
    std::shared_ptr<ripple::TxMeta const> const& meta
);
 
boost::json::object
toJson(ripple::STBase const& obj);
 
boost::json::object
toJson(ripple::SLE const& sle);
 
boost::json::object
toJson(ripple::LedgerHeader const& info, bool binary, std::uint32_t apiVersion);
 
boost::json::object
toJson(ripple::TxMeta const& meta);
 
using RippledJson = Json::Value;
 
boost::json::value
toBoostJson(RippledJson const& value);
 
boost::json::object
generatePubLedgerMessage(
    ripple::LedgerHeader const& lgrInfo,
    ripple::Fees const& fees,
    std::string const& ledgerRange,
    std::uint32_t txnCount
);
 
std::expected<ripple::LedgerHeader, Status>
ledgerHeaderFromRequest(std::shared_ptr<data::BackendInterface const> const& backend, web::Context const& ctx);
 
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
);
 
std::expected<AccountCursor, Status>
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
);
 
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 = false
);
 
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
);
 
std::vector<ripple::AccountID>
getAccountsFromTransaction(boost::json::object const& transaction);
 
std::vector<unsigned char>
ledgerHeaderToBlob(ripple::LedgerHeader const& info, bool includeHash = false);
 
bool
isGlobalFrozen(
    BackendInterface const& backend,
    std::uint32_t seq,
    ripple::AccountID const& issuer,
    boost::asio::yield_context yield
);
 
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
);
 
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
);
 
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
);
 
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
);
 
ripple::STAmount
accountFunds(
    BackendInterface const& backend,
    data::AmendmentCenterInterface const& amendmentCenter,
    std::uint32_t sequence,
    ripple::STAmount const& amount,
    ripple::AccountID const& id,
    boost::asio::yield_context yield
);
 
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 zeroIfFrozen,
    boost::asio::yield_context yield
);
 
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
);
 
ripple::Rate
transferRate(
    BackendInterface const& backend,
    std::uint32_t sequence,
    ripple::AccountID const& issuer,
    boost::asio::yield_context yield
);
 
ripple::XRPAmount
xrpLiquid(
    BackendInterface const& backend,
    std::uint32_t sequence,
    ripple::AccountID const& id,
    boost::asio::yield_context yield
);
 
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 ledgerSequence,
    boost::asio::yield_context yield
);
 
std::expected<ripple::Book, Status>
parseBook(
    ripple::Currency pays,
    ripple::AccountID payIssuer,
    ripple::Currency gets,
    ripple::AccountID getIssuer,
    std::optional<std::string> const& domain
);
 
std::expected<ripple::Book, Status>
parseBook(boost::json::object const& request);
 
std::expected<ripple::AccountID, Status>
parseTaker(boost::json::value const& taker);
 
ripple::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<ripple::uint256, Status>
getNFTID(boost::json::object const& request);
 
std::optional<std::string>
encodeCTID(uint32_t ledgerSeq, uint16_t txnIndex, uint16_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 kCTID_STRING_LENGTH = 16;
            if (ctidString.length() != kCTID_STRING_LENGTH)
                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 kCTID_PREFIX = 0xC000'0000'0000'0000ULL;
    static constexpr uint64_t kCTID_PREFIX_MASK = 0xF000'0000'0000'0000ULL;
 
    if ((ctidValue & kCTID_PREFIX_MASK) != kCTID_PREFIX)
        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 kDURATION_ERROR_THRESHOLD_SECONDS = 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 > kDURATION_ERROR_THRESHOLD_SECONDS) {
        LOG(log.error()) << tag << msg;
    } else if (seconds > 1) {
        LOG(log.warn()) << tag << msg;
    } else
        LOG(log.info()) << tag << msg;
}
 
std::optional<ripple::Seed>
parseRippleLibSeed(boost::json::value const& value);
 
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
);
 
std::optional<std::uint32_t>
parseStringAsUInt(std::string const& value);  // TODO: move to string utils or something?
 
bool
canHaveDeliveredAmount(
    std::shared_ptr<ripple::STTx const> const& txn,
    std::shared_ptr<ripple::TxMeta const> const& meta
);
 
std::optional<ripple::STAmount>
getDeliveredAmount(
    std::shared_ptr<ripple::STTx const> const& txn,
    std::shared_ptr<ripple::TxMeta const> const& meta,
    std::uint32_t ledgerSequence,
    uint32_t date
);
 
}  // namespace rpc