Tx.cpp

#include <xrpld/app/ledger/LedgerMaster.h>
#include <xrpld/app/ledger/TransactionMaster.h>
#include <xrpld/app/misc/DeliverMax.h>
#include <xrpld/app/misc/Transaction.h>
#include <xrpld/rpc/CTID.h>
#include <xrpld/rpc/Context.h>
#include <xrpld/rpc/DeliveredAmount.h>
#include <xrpld/rpc/MPTokenIssuanceID.h>
#include <xrpld/rpc/Status.h>
 
#include <xrpl/basics/Blob.h>
#include <xrpl/basics/RangeSet.h>
#include <xrpl/basics/Slice.h>
#include <xrpl/basics/base_uint.h>
#include <xrpl/basics/chrono.h>
#include <xrpl/basics/strHex.h>
#include <xrpl/beast/utility/instrumentation.h>
#include <xrpl/core/NetworkIDService.h>
#include <xrpl/json/json_value.h>
#include <xrpl/protocol/ErrorCodes.h>
#include <xrpl/protocol/NFTSyntheticSerializer.h>
#include <xrpl/protocol/RPCErr.h>
#include <xrpl/protocol/SField.h>
#include <xrpl/protocol/STBase.h>
#include <xrpl/protocol/TxSearched.h>
#include <xrpl/protocol/jss.h>
#include <xrpl/rdb/RelationalDatabase.h>
#include <xrpl/server/NetworkOPs.h>
 
#include <cstdint>
#include <memory>
#include <optional>
#include <sstream>
#include <string>
#include <utility>
#include <variant>
 
namespace xrpl {
 
static bool
isValidated(LedgerMaster& ledgerMaster, std::uint32_t seq, uint256 const& hash)
{
    if (!ledgerMaster.haveLedger(seq))
        return false;
 
    if (seq > ledgerMaster.getValidatedLedger()->header().seq)
        return false;
 
    return ledgerMaster.getHashBySeq(seq) == hash;
}
 
struct TxResult
{
    Transaction::pointer txn;
    std::variant<std::shared_ptr<TxMeta>, Blob> meta;
    bool validated = false;
    std::optional<std::string> ctid;
    std::optional<NetClock::time_point> closeTime;
    std::optional<uint256> ledgerHash;
    TxSearched searchedAll = TxSearched::Unknown;
};
 
struct TxArgs
{
    std::optional<uint256> hash;
    std::optional<std::pair<uint32_t, uint16_t>> ctid;
    bool binary = false;
    std::optional<std::pair<uint32_t, uint32_t>> ledgerRange;
};
 
std::pair<TxResult, RPC::Status>
doTxHelp(RPC::Context& context, TxArgs args)
{
    TxResult result;
 
    ClosedInterval<uint32_t> range;
 
    if (args.ledgerRange)
    {
        static constexpr uint16_t kMaxRange = 1000;
 
        if (args.ledgerRange->second < args.ledgerRange->first)
            return {result, RpcInvalidLgrRange};
 
        if (args.ledgerRange->second - args.ledgerRange->first > kMaxRange)
            return {result, RpcExcessiveLgrRange};
 
        range = ClosedInterval<uint32_t>(args.ledgerRange->first, args.ledgerRange->second);
    }
 
    auto ec{RpcSuccess};
 
    using TxPair = std::pair<std::shared_ptr<Transaction>, std::shared_ptr<TxMeta>>;
 
    result.searchedAll = TxSearched::Unknown;
    std::variant<TxPair, TxSearched> v;
 
    if (args.ctid)
    {
        args.hash =
            context.app.getLedgerMaster().txnIdFromIndex(args.ctid->first, args.ctid->second);
 
        if (args.hash)
            range = ClosedInterval<uint32_t>(args.ctid->first, args.ctid->second);
    }
 
    if (!args.hash)
        return {result, RpcTxnNotFound};
 
    if (args.ledgerRange)
    {
        v = context.app.getMasterTransaction().fetch(*(args.hash), range, ec);
    }
    else
    {
        v = context.app.getMasterTransaction().fetch(*(args.hash), ec);
    }
 
    if (auto e = std::get_if<TxSearched>(&v))
    {
        result.searchedAll = *e;
        return {result, RpcTxnNotFound};
    }
 
    auto [txn, meta] = std::get<TxPair>(v);
 
    if (ec == RpcDbDeserialization)
    {
        return {result, ec};
    }
    if (!txn)
    {
        return {result, RpcTxnNotFound};
    }
 
    // populate transaction data
    result.txn = txn;
    if (txn->getLedger() == 0)
    {
        return {result, RpcSuccess};
    }
 
    std::shared_ptr<Ledger const> const ledger =
        context.ledgerMaster.getLedgerBySeq(txn->getLedger());
 
    if (ledger && !ledger->open())
        result.ledgerHash = ledger->header().hash;
 
    if (ledger && meta)
    {
        if (args.binary)
        {
            result.meta = meta->getAsObject().getSerializer().getData();
        }
        else
        {
            result.meta = meta;
        }
        result.validated =
            isValidated(context.ledgerMaster, ledger->header().seq, ledger->header().hash);
        if (result.validated)
            result.closeTime = context.ledgerMaster.getCloseTimeBySeq(txn->getLedger());
 
        // compute outgoing CTID
        if (meta->getAsObject().isFieldPresent(sfTransactionIndex))
        {
            uint32_t const lgrSeq = ledger->header().seq;
            uint32_t const txnIdx = meta->getAsObject().getFieldU32(sfTransactionIndex);
            uint32_t const netID = context.app.getNetworkIDService().getNetworkID();
 
            if (txnIdx <= 0xFFFFU && netID < 0xFFFFU && lgrSeq < 0x0FFF'FFFFUL)
                result.ctid = RPC::encodeCTID(lgrSeq, txnIdx, netID);
        }
    }
 
    return {result, RpcSuccess};
}
 
json::Value
populateJsonResponse(
    std::pair<TxResult, RPC::Status> const& res,
    TxArgs const& args,
    RPC::JsonContext const& context)
{
    json::Value response;
    RPC::Status const& error = res.second;
    TxResult const& result = res.first;
    // handle errors
    if (error.toErrorCode() != RpcSuccess)
    {
        if (error.toErrorCode() == RpcTxnNotFound && result.searchedAll != TxSearched::Unknown)
        {
            response = json::Value(json::ValueType::Object);
            response[jss::searched_all] = (result.searchedAll == TxSearched::All);
            error.inject(response);
        }
        else
        {
            error.inject(response);
        }
    }
    // no errors
    else if (result.txn)
    {
        auto const& sttx = result.txn->getSTransaction();
        if (context.apiVersion > 1)
        {
            static constexpr auto kOptionsJson =
                static_cast<JsonOptions::underlying_t>(JsonOptions::Values::IncludeDate) |
                static_cast<JsonOptions::underlying_t>(JsonOptions::Values::DisableApiPriorV2);
            if (args.binary)
            {
                response[jss::tx_blob] = result.txn->getJson(kOptionsJson, true);
            }
            else
            {
                response[jss::tx_json] = result.txn->getJson(kOptionsJson);
                RPC::insertDeliverMax(
                    response[jss::tx_json], sttx->getTxnType(), context.apiVersion);
            }
 
            // Note, result.ledgerHash is only set in a closed or validated
            // ledger - as seen in `doTxHelp`
            if (result.ledgerHash)
                response[jss::ledger_hash] = to_string(*result.ledgerHash);
 
            response[jss::hash] = to_string(result.txn->getID());
            if (result.validated)
            {
                response[jss::ledger_index] = result.txn->getLedger();
                if (result.closeTime)
                    response[jss::close_time_iso] = toStringIso(*result.closeTime);
            }
        }
        else
        {
            response = result.txn->getJson(JsonOptions::Values::IncludeDate, args.binary);
            if (!args.binary)
                RPC::insertDeliverMax(response, sttx->getTxnType(), context.apiVersion);
        }
 
        // populate binary metadata
        if (auto blob = std::get_if<Blob>(&result.meta))
        {
            XRPL_ASSERT(args.binary, "xrpl::populateJsonResponse : binary is set");
            auto jsonMeta = (context.apiVersion > 1 ? jss::meta_blob : jss::meta);
            response[jsonMeta] = strHex(makeSlice(*blob));
        }
        // populate meta data
        else if (auto m = std::get_if<std::shared_ptr<TxMeta>>(&result.meta))
        {
            auto& meta = *m;
            if (meta)
            {
                response[jss::meta] = meta->getJson(JsonOptions::Values::None);
                insertDeliveredAmount(response[jss::meta], context, result.txn, *meta);
                RPC::insertNFTSyntheticInJson(response, sttx, *meta);
                RPC::insertMPTokenIssuanceID(response[jss::meta], sttx, *meta);
            }
        }
        response[jss::validated] = result.validated;
 
        if (result.ctid)
            response[jss::ctid] = *(result.ctid);
    }
    return response;
}
 
json::Value
doTxJson(RPC::JsonContext& context)
{
    if (!context.app.config().useTxTables())
        return rpcError(RpcNotEnabled);
 
    // Deserialize and validate JSON arguments
 
    TxArgs args;
 
    if (context.params.isMember(jss::transaction) && context.params.isMember(jss::ctid))
    {
        // specifying both is ambiguous
        return rpcError(RpcInvalidParams);
    }
 
    if (context.params.isMember(jss::transaction))
    {
        uint256 hash;
        if (!hash.parseHex(context.params[jss::transaction].asString()))
            return rpcError(RpcNotImpl);
        args.hash = hash;
    }
    else if (context.params.isMember(jss::ctid))
    {
        auto ctid = RPC::decodeCTID(context.params[jss::ctid].asString());
        if (!ctid)
            return rpcError(RpcInvalidParams);
 
        auto const [lgr_seq, txn_idx, net_id] = *ctid;
        if (net_id != context.app.getNetworkIDService().getNetworkID())
        {
            std::stringstream out;
            out << "Wrong network. You should submit this request to a node "
                   "running on NetworkID: "
                << net_id;
            return RPC::makeError(RpcWrongNetwork, out.str());
        }
        args.ctid = {lgr_seq, txn_idx};
    }
    else
    {
        return rpcError(RpcInvalidParams);
    }
 
    args.binary = context.params.isMember(jss::binary) && context.params[jss::binary].asBool();
 
    if (context.params.isMember(jss::min_ledger) && context.params.isMember(jss::max_ledger))
    {
        try
        {
            args.ledgerRange = std::make_pair(
                context.params[jss::min_ledger].asUInt(), context.params[jss::max_ledger].asUInt());
        }
        catch (...)
        {
            // One of the calls to `asUInt ()` failed.
            return rpcError(RpcInvalidLgrRange);
        }
    }
 
    std::pair<TxResult, RPC::Status> const res = doTxHelp(context, args);
    return populateJsonResponse(res, args, context);
}
 
}  // namespace xrpl