LedgerEntry.cpp

#include <xrpld/rpc/Context.h>
#include <xrpld/rpc/GRPCHandlers.h>
#include <xrpld/rpc/detail/RPCLedgerHelpers.h>
#include <xrpld/rpc/handlers/ledger/LedgerEntryHelpers.h>
 
#include <xrpl/basics/base_uint.h>
#include <xrpl/basics/strHex.h>
#include <xrpl/json/json_errors.h>
#include <xrpl/json/json_value.h>
#include <xrpl/ledger/ReadView.h>
#include <xrpl/ledger/helpers/CredentialHelpers.h>
#include <xrpl/protocol/AccountID.h>
#include <xrpl/protocol/ErrorCodes.h>
#include <xrpl/protocol/Indexes.h>
#include <xrpl/protocol/Keylet.h>
#include <xrpl/protocol/LedgerFormats.h>
#include <xrpl/protocol/Protocol.h>
#include <xrpl/protocol/SField.h>
#include <xrpl/protocol/STArray.h>
#include <xrpl/protocol/STXChainBridge.h>
#include <xrpl/protocol/SeqProxy.h>
#include <xrpl/protocol/UintTypes.h>
#include <xrpl/protocol/jss.h>
 
#include <grpcpp/support/status.h>
#include <org/xrpl/rpc/v1/get_ledger_entry.pb.h>
 
#include <array>
#include <cstdint>
#include <expected>
#include <functional>
#include <memory>
#include <string>
#include <utility>
 
namespace xrpl {
 
using FunctionType = std::function<std::expected<uint256, json::Value>(
    json::Value const&,
    json::StaticString const,
    unsigned const apiVersion)>;
 
static std::expected<uint256, json::Value>
parseFixed(
    Keylet const& keylet,
    json::Value const& params,
    json::StaticString const& fieldName,
    unsigned const apiVersion);
 
// Helper function to return FunctionType for objects that have a fixed
// location. That is, they don't take parameters to compute the index.
// e.g. amendments, fees, negative UNL, etc.
static FunctionType
fixed(Keylet const& keylet)
{
    return [keylet](
               json::Value const& params,
               json::StaticString const fieldName,
               unsigned const apiVersion) -> std::expected<uint256, json::Value> {
        return parseFixed(keylet, params, fieldName, apiVersion);
    };
}
 
static std::expected<uint256, json::Value>
parseObjectID(
    json::Value const& params,
    json::StaticString const fieldName,
    std::string const& expectedType = "hex string or object")
{
    if (auto const uNodeIndex = ledger_entry_helpers::parse<uint256>(params))
    {
        return *uNodeIndex;
    }
    return ledger_entry_helpers::invalidFieldError("malformedRequest", fieldName, expectedType);
}
 
static std::expected<uint256, json::Value>
parseIndex(json::Value const& params, json::StaticString const fieldName, unsigned const apiVersion)
{
    if (apiVersion > 2u && params.isString())
    {
        std::string const index = params.asString();
        if (index == jss::amendments.cStr())
            return keylet::amendments().key;
        if (index == jss::fee.cStr())
            return keylet::feeSettings().key;
        if (index == jss::nunl)
            return keylet::negativeUNL().key;
        if (index == jss::hashes)
        {
            // Note this only finds the "short" skip list. Use "hashes":index to
            // get the long list.
            return keylet::skip().key;
        }
    }
    return parseObjectID(params, fieldName, "hex string");
}
 
static std::expected<uint256, json::Value>
parseAccountRoot(
    json::Value const& params,
    json::StaticString const fieldName,
    [[maybe_unused]] unsigned const apiVersion)
{
    if (auto const account = ledger_entry_helpers::parse<AccountID>(params))
    {
        return keylet::account(*account).key;
    }
 
    return ledger_entry_helpers::invalidFieldError("malformedAddress", fieldName, "AccountID");
}
 
auto const parseAmendments = fixed(keylet::amendments());
 
static std::expected<uint256, json::Value>
parseAMM(
    json::Value const& params,
    json::StaticString const fieldName,
    [[maybe_unused]] unsigned const apiVersion)
{
    if (!params.isObject())
    {
        return parseObjectID(params, fieldName);
    }
 
    if (auto const value = ledger_entry_helpers::hasRequired(params, {jss::asset, jss::asset2});
        !value)
    {
        return std::unexpected(value.error());
    }
 
    auto const asset = ledger_entry_helpers::requiredAsset(params, jss::asset, "malformedRequest");
    if (!asset)
        return std::unexpected(asset.error());
 
    auto const asset2 =
        ledger_entry_helpers::requiredAsset(params, jss::asset2, "malformedRequest");
    if (!asset2)
        return std::unexpected(asset2.error());
 
    return keylet::amm(*asset, *asset2).key;
}
 
static std::expected<uint256, json::Value>
parseBridge(
    json::Value const& params,
    json::StaticString const fieldName,
    [[maybe_unused]] unsigned const apiVersion)
{
    if (!params.isMember(jss::bridge))
    {
        return std::unexpected(ledger_entry_helpers::missingFieldError(jss::bridge));
    }
 
    if (params[jss::bridge].isString())
    {
        return parseObjectID(params, fieldName);
    }
 
    auto const bridge = ledger_entry_helpers::parseBridgeFields(params[jss::bridge]);
    if (!bridge)
        return std::unexpected(bridge.error());
 
    auto const account = ledger_entry_helpers::requiredAccountID(
        params, jss::bridge_account, "malformedBridgeAccount");
    if (!account)
        return std::unexpected(account.error());
 
    STXChainBridge::ChainType const chainType =
        STXChainBridge::srcChain(account.value() == bridge->lockingChainDoor());
    if (account.value() != bridge->door(chainType))
        return ledger_entry_helpers::malformedError("malformedRequest", "");
 
    return keylet::bridge(*bridge, chainType).key;
}
 
static std::expected<uint256, json::Value>
parseCheck(
    json::Value const& params,
    json::StaticString const fieldName,
    [[maybe_unused]] unsigned const apiVersion)
{
    return parseObjectID(params, fieldName, "hex string");
}
 
static std::expected<uint256, json::Value>
parseCredential(
    json::Value const& cred,
    json::StaticString const fieldName,
    [[maybe_unused]] unsigned const apiVersion)
{
    if (!cred.isObject())
    {
        return parseObjectID(cred, fieldName);
    }
 
    auto const subject =
        ledger_entry_helpers::requiredAccountID(cred, jss::subject, "malformedRequest");
    if (!subject)
        return std::unexpected(subject.error());
 
    auto const issuer =
        ledger_entry_helpers::requiredAccountID(cred, jss::issuer, "malformedRequest");
    if (!issuer)
        return std::unexpected(issuer.error());
 
    auto const credType = ledger_entry_helpers::requiredHexBlob(
        cred, jss::credential_type, kMaxCredentialTypeLength, "malformedRequest");
    if (!credType)
        return std::unexpected(credType.error());
 
    return keylet::credential(*subject, *issuer, Slice(credType->data(), credType->size())).key;
}
 
static std::expected<uint256, json::Value>
parseDelegate(
    json::Value const& params,
    json::StaticString const fieldName,
    [[maybe_unused]] unsigned const apiVersion)
{
    if (!params.isObject())
    {
        return parseObjectID(params, fieldName);
    }
 
    auto const account =
        ledger_entry_helpers::requiredAccountID(params, jss::account, "malformedAddress");
    if (!account)
        return std::unexpected(account.error());
 
    auto const authorize =
        ledger_entry_helpers::requiredAccountID(params, jss::authorize, "malformedAddress");
    if (!authorize)
        return std::unexpected(authorize.error());
 
    return keylet::delegate(*account, *authorize).key;
}
 
static std::expected<STArray, json::Value>
parseAuthorizeCredentials(json::Value const& jv)
{
    if (!jv.isArray())
    {
        return ledger_entry_helpers::invalidFieldError(
            "malformedAuthorizedCredentials", jss::authorized_credentials, "array");
    }
 
    std::uint32_t const n = jv.size();
    if (n > kMaxCredentialsArraySize)
    {
        return std::unexpected(
            ledger_entry_helpers::malformedError(
                "malformedAuthorizedCredentials",
                "Invalid field '" + std::string(jss::authorized_credentials) +
                    "', array too long."));
    }
 
    if (n == 0)
    {
        return std::unexpected(
            ledger_entry_helpers::malformedError(
                "malformedAuthorizedCredentials",
                "Invalid field '" + std::string(jss::authorized_credentials) + "', array empty."));
    }
 
    STArray arr(sfAuthorizeCredentials, n);
    for (auto const& jo : jv)
    {
        if (!jo.isObject())
        {
            return ledger_entry_helpers::invalidFieldError(
                "malformedAuthorizedCredentials", jss::authorized_credentials, "array of objects");
        }
 
        if (auto const value = ledger_entry_helpers::hasRequired(
                jo, {jss::issuer, jss::credential_type}, "malformedAuthorizedCredentials");
            !value)
        {
            return std::unexpected(value.error());
        }
 
        auto const issuer = ledger_entry_helpers::requiredAccountID(
            jo, jss::issuer, "malformedAuthorizedCredentials");
        if (!issuer)
            return std::unexpected(issuer.error());
 
        auto const credentialType = ledger_entry_helpers::requiredHexBlob(
            jo, jss::credential_type, kMaxCredentialTypeLength, "malformedAuthorizedCredentials");
        if (!credentialType)
            return std::unexpected(credentialType.error());
 
        auto credential = STObject::makeInnerObject(sfCredential);
        credential.setAccountID(sfIssuer, *issuer);
        credential.setFieldVL(sfCredentialType, *credentialType);
        arr.pushBack(std::move(credential));
    }
 
    return arr;
}
 
static std::expected<uint256, json::Value>
parseDepositPreauth(
    json::Value const& dp,
    json::StaticString const fieldName,
    [[maybe_unused]] unsigned const apiVersion)
{
    if (!dp.isObject())
    {
        return parseObjectID(dp, fieldName);
    }
 
    if ((dp.isMember(jss::authorized) == dp.isMember(jss::authorized_credentials)))
    {
        return ledger_entry_helpers::malformedError(
            "malformedRequest",
            "Must have exactly one of `authorized` and "
            "`authorized_credentials`.");
    }
 
    auto const owner = ledger_entry_helpers::requiredAccountID(dp, jss::owner, "malformedOwner");
    if (!owner)
    {
        return std::unexpected(owner.error());
    }
 
    if (dp.isMember(jss::authorized))
    {
        if (auto const authorized = ledger_entry_helpers::parse<AccountID>(dp[jss::authorized]))
        {
            return keylet::depositPreauth(*owner, *authorized).key;
        }
        return ledger_entry_helpers::invalidFieldError(
            "malformedAuthorized", jss::authorized, "AccountID");
    }
 
    auto const& ac(dp[jss::authorized_credentials]);
    auto const arr = parseAuthorizeCredentials(ac);
    if (!arr.has_value())
        return std::unexpected(arr.error());
 
    auto const& sorted = credentials::makeSorted(arr.value());
    if (sorted.empty())
    {
        // TODO: this error message is bad/inaccurate
        return ledger_entry_helpers::invalidFieldError(
            "malformedAuthorizedCredentials", jss::authorized_credentials, "array");
    }
 
    return keylet::depositPreauth(*owner, sorted).key;
}
 
static std::expected<uint256, json::Value>
parseDID(
    json::Value const& params,
    json::StaticString const fieldName,
    [[maybe_unused]] unsigned const apiVersion)
{
    auto const account = ledger_entry_helpers::parse<AccountID>(params);
    if (!account)
    {
        return ledger_entry_helpers::invalidFieldError("malformedAddress", fieldName, "AccountID");
    }
 
    return keylet::did(*account).key;
}
 
static std::expected<uint256, json::Value>
parseDirectoryNode(
    json::Value const& params,
    json::StaticString const fieldName,
    [[maybe_unused]] unsigned const apiVersion)
{
    if (!params.isObject())
    {
        return parseObjectID(params, fieldName);
    }
 
    if (params.isMember(jss::sub_index) &&
        (!params[jss::sub_index].isConvertibleTo(json::ValueType::UInt) ||
         params[jss::sub_index].isBool()))
    {
        return ledger_entry_helpers::invalidFieldError(
            "malformedRequest", jss::sub_index, "number");
    }
 
    if (params.isMember(jss::owner) == params.isMember(jss::dir_root))
    {
        return ledger_entry_helpers::malformedError(
            "malformedRequest", "Must have exactly one of `owner` and `dir_root` fields.");
    }
 
    std::uint64_t const uSubIndex = params.get(jss::sub_index, 0).asUInt();
 
    if (params.isMember(jss::dir_root))
    {
        if (auto const uDirRoot = ledger_entry_helpers::parse<uint256>(params[jss::dir_root]))
        {
            return keylet::page(*uDirRoot, uSubIndex).key;
        }
 
        return ledger_entry_helpers::invalidFieldError("malformedDirRoot", jss::dir_root, "hash");
    }
 
    if (params.isMember(jss::owner))
    {
        auto const ownerID = ledger_entry_helpers::parse<AccountID>(params[jss::owner]);
        if (!ownerID)
        {
            return ledger_entry_helpers::invalidFieldError(
                "malformedAddress", jss::owner, "AccountID");
        }
 
        return keylet::page(keylet::ownerDir(*ownerID), uSubIndex).key;
    }
 
    return ledger_entry_helpers::malformedError("malformedRequest", "");
}
 
static std::expected<uint256, json::Value>
parseEscrow(
    json::Value const& params,
    json::StaticString const fieldName,
    [[maybe_unused]] unsigned const apiVersion)
{
    if (!params.isObject())
    {
        return parseObjectID(params, fieldName);
    }
 
    auto const id = ledger_entry_helpers::requiredAccountID(params, jss::owner, "malformedOwner");
    if (!id)
        return std::unexpected(id.error());
    auto const seq = ledger_entry_helpers::requiredUInt32(params, jss::seq, "malformedSeq");
    if (!seq)
        return std::unexpected(seq.error());
 
    auto const seqProxy = SeqProxy::rawSequence(*seq);
    return keylet::escrow(*id, seqProxy).key;
}
 
auto const parseFeeSettings = fixed(keylet::feeSettings());
 
static std::expected<uint256, json::Value>
parseFixed(
    Keylet const& keylet,
    json::Value const& params,
    json::StaticString const& fieldName,
    [[maybe_unused]] unsigned const apiVersion)
{
    if (!params.isBool())
    {
        return parseObjectID(params, fieldName, "hex string");
    }
    if (!params.asBool())
    {
        return ledger_entry_helpers::invalidFieldError("invalidParams", fieldName, "true");
    }
 
    return keylet.key;
}
 
static std::expected<uint256, json::Value>
parseLedgerHashes(
    json::Value const& params,
    json::StaticString const fieldName,
    unsigned const apiVersion)
{
    if (params.isUInt() || params.isInt())
    {
        // If the index doesn't parse as a UInt, throw
        auto const index = params.asUInt();
 
        // Return the "long" skip list for the given ledger index.
        auto const keylet = keylet::skip(index);
        return keylet.key;
    }
    // Return the key in `params` or the "short" skip list, which contains
    // hashes since the last flag ledger.
    return parseFixed(keylet::skip(), params, fieldName, apiVersion);
}
 
static std::expected<uint256, json::Value>
parseLoanBroker(
    json::Value const& params,
    json::StaticString const fieldName,
    [[maybe_unused]] unsigned const apiVersion)
{
    if (!params.isObject())
    {
        return parseObjectID(params, fieldName, "hex string");
    }
 
    auto const id = ledger_entry_helpers::requiredAccountID(params, jss::owner, "malformedOwner");
    if (!id)
        return std::unexpected(id.error());
    auto const seq = ledger_entry_helpers::requiredUInt32(params, jss::seq, "malformedSeq");
    if (!seq)
        return std::unexpected(seq.error());
 
    auto const seqProxy = SeqProxy::rawSequence(*seq);
    return keylet::loanBroker(*id, seqProxy).key;
}
 
static std::expected<uint256, json::Value>
parseLoan(
    json::Value const& params,
    json::StaticString const fieldName,
    [[maybe_unused]] unsigned const apiVersion)
{
    if (!params.isObject())
    {
        return parseObjectID(params, fieldName, "hex string");
    }
 
    auto const id =
        ledger_entry_helpers::requiredUInt256(params, jss::loan_broker_id, "malformedBroker");
    if (!id)
        return std::unexpected(id.error());
    auto const seq = ledger_entry_helpers::requiredUInt32(params, jss::loan_seq, "malformedSeq");
    if (!seq)
        return std::unexpected(seq.error());
 
    auto const seqProxy = SeqProxy::rawSequence(*seq);
    return keylet::loan(*id, seqProxy).key;
}
 
static std::expected<uint256, json::Value>
parseMPToken(
    json::Value const& params,
    json::StaticString const fieldName,
    [[maybe_unused]] unsigned const apiVersion)
{
    if (!params.isObject())
    {
        return parseObjectID(params, fieldName);
    }
 
    auto const mptIssuanceID = ledger_entry_helpers::requiredUInt192(
        params, jss::mpt_issuance_id, "malformedMPTIssuanceID");
    if (!mptIssuanceID)
        return std::unexpected(mptIssuanceID.error());
 
    auto const account =
        ledger_entry_helpers::requiredAccountID(params, jss::account, "malformedAccount");
    if (!account)
        return std::unexpected(account.error());
 
    return keylet::mptoken(*mptIssuanceID, *account).key;
}
 
static std::expected<uint256, json::Value>
parseMPTokenIssuance(
    json::Value const& params,
    json::StaticString const fieldName,
    [[maybe_unused]] unsigned const apiVersion)
{
    auto const mptIssuanceID = ledger_entry_helpers::parse<uint192>(params);
    if (!mptIssuanceID)
    {
        return ledger_entry_helpers::invalidFieldError(
            "malformedMPTokenIssuance", fieldName, "Hash192");
    }
 
    return keylet::mptokenIssuance(*mptIssuanceID).key;
}
 
static std::expected<uint256, json::Value>
parseNFTokenOffer(
    json::Value const& params,
    json::StaticString const fieldName,
    [[maybe_unused]] unsigned const apiVersion)
{
    return parseObjectID(params, fieldName, "hex string");
}
 
static std::expected<uint256, json::Value>
parseNFTokenPage(
    json::Value const& params,
    json::StaticString const fieldName,
    [[maybe_unused]] unsigned const apiVersion)
{
    return parseObjectID(params, fieldName, "hex string");
}
 
auto const parseNegativeUNL = fixed(keylet::negativeUNL());
 
static std::expected<uint256, json::Value>
parseOffer(
    json::Value const& params,
    json::StaticString const fieldName,
    [[maybe_unused]] unsigned const apiVersion)
{
    if (!params.isObject())
    {
        return parseObjectID(params, fieldName);
    }
 
    auto const id =
        ledger_entry_helpers::requiredAccountID(params, jss::account, "malformedAddress");
    if (!id)
        return std::unexpected(id.error());
 
    auto const seq = ledger_entry_helpers::requiredUInt32(params, jss::seq, "malformedRequest");
    if (!seq)
        return std::unexpected(seq.error());
 
    auto const seqProxy = SeqProxy::rawSequence(*seq);
    return keylet::offer(*id, seqProxy).key;
}
 
static std::expected<uint256, json::Value>
parseOracle(
    json::Value const& params,
    json::StaticString const fieldName,
    [[maybe_unused]] unsigned const apiVersion)
{
    if (!params.isObject())
    {
        return parseObjectID(params, fieldName);
    }
 
    auto const id =
        ledger_entry_helpers::requiredAccountID(params, jss::account, "malformedAccount");
    if (!id)
        return std::unexpected(id.error());
 
    auto const seq = ledger_entry_helpers::requiredUInt32(
        params, jss::oracle_document_id, "malformedDocumentID");
    if (!seq)
        return std::unexpected(seq.error());
 
    return keylet::oracle(*id, *seq).key;
}
 
static std::expected<uint256, json::Value>
parsePayChannel(
    json::Value const& params,
    json::StaticString const fieldName,
    [[maybe_unused]] unsigned const apiVersion)
{
    return parseObjectID(params, fieldName, "hex string");
}
 
static std::expected<uint256, json::Value>
parsePermissionedDomain(
    json::Value const& pd,
    json::StaticString const fieldName,
    [[maybe_unused]] unsigned const apiVersion)
{
    if (pd.isString())
    {
        return parseObjectID(pd, fieldName);
    }
 
    if (!pd.isObject())
    {
        return ledger_entry_helpers::invalidFieldError(
            "malformedRequest", fieldName, "hex string or object");
    }
 
    auto const account =
        ledger_entry_helpers::requiredAccountID(pd, jss::account, "malformedAddress");
    if (!account)
        return std::unexpected(account.error());
 
    auto const seq = ledger_entry_helpers::requiredUInt32(pd, jss::seq, "malformedRequest");
    if (!seq)
        return std::unexpected(seq.error());
 
    auto const seqProxy = SeqProxy::rawSequence(pd[jss::seq].asUInt());
    return keylet::permissionedDomain(*account, seqProxy).key;
}
 
static std::expected<uint256, json::Value>
parseRippleState(
    json::Value const& jvRippleState,
    json::StaticString const fieldName,
    [[maybe_unused]] unsigned const apiVersion)
{
    Currency uCurrency;
 
    if (!jvRippleState.isObject())
    {
        return parseObjectID(jvRippleState, fieldName);
    }
 
    if (auto const value =
            ledger_entry_helpers::hasRequired(jvRippleState, {jss::currency, jss::accounts});
        !value)
    {
        return std::unexpected(value.error());
    }
 
    if (!jvRippleState[jss::accounts].isArray() || jvRippleState[jss::accounts].size() != 2)
    {
        return ledger_entry_helpers::invalidFieldError(
            "malformedRequest", jss::accounts, "length-2 array of Accounts");
    }
 
    auto const id1 = ledger_entry_helpers::parse<AccountID>(jvRippleState[jss::accounts][0u]);
    auto const id2 = ledger_entry_helpers::parse<AccountID>(jvRippleState[jss::accounts][1u]);
    if (!id1 || !id2)
    {
        return ledger_entry_helpers::invalidFieldError(
            "malformedAddress", jss::accounts, "array of Accounts");
    }
    if (id1 == id2)
    {
        return ledger_entry_helpers::malformedError(
            "malformedRequest", "Cannot have a trustline to self.");
    }
 
    if (!jvRippleState[jss::currency].isString() || jvRippleState[jss::currency] == "" ||
        !toCurrency(uCurrency, jvRippleState[jss::currency].asString()))
    {
        return ledger_entry_helpers::invalidFieldError(
            "malformedCurrency", jss::currency, "Currency");
    }
 
    return keylet::trustLine(*id1, *id2, uCurrency).key;
}
 
static std::expected<uint256, json::Value>
parseSignerList(
    json::Value const& params,
    json::StaticString const fieldName,
    [[maybe_unused]] unsigned const apiVersion)
{
    return parseObjectID(params, fieldName, "hex string");
}
 
static std::expected<uint256, json::Value>
parseSponsorship(
    json::Value const& params,
    json::StaticString const fieldName,
    [[maybe_unused]] unsigned const apiVersion)
{
    if (!params.isObject())
        return parseObjectID(params, fieldName);
 
    auto const sponsorID =
        ledger_entry_helpers::requiredAccountID(params, jss::sponsor, "malformedSponsor");
    if (!sponsorID)
        return std::unexpected(sponsorID.error());
 
    auto const sponseeID =
        ledger_entry_helpers::requiredAccountID(params, jss::sponsee, "malformedSponsee");
    if (!sponseeID)
        return std::unexpected(sponseeID.error());
 
    return keylet::sponsorship(*sponsorID, *sponseeID).key;
}
 
static std::expected<uint256, json::Value>
parseTicket(
    json::Value const& params,
    json::StaticString const fieldName,
    [[maybe_unused]] unsigned const apiVersion)
{
    if (!params.isObject())
    {
        return parseObjectID(params, fieldName);
    }
 
    auto const id =
        ledger_entry_helpers::requiredAccountID(params, jss::account, "malformedAddress");
    if (!id)
        return std::unexpected(id.error());
 
    auto const seq =
        ledger_entry_helpers::requiredUInt32(params, jss::ticket_seq, "malformedRequest");
    if (!seq)
        return std::unexpected(seq.error());
 
    auto const seqProxy = SeqProxy::rawTicket(*seq);
    return keylet::ticket(*id, seqProxy).key;
}
 
static std::expected<uint256, json::Value>
parseVault(
    json::Value const& params,
    json::StaticString const fieldName,
    [[maybe_unused]] unsigned const apiVersion)
{
    if (!params.isObject())
    {
        return parseObjectID(params, fieldName);
    }
 
    auto const id = ledger_entry_helpers::requiredAccountID(params, jss::owner, "malformedOwner");
    if (!id)
        return std::unexpected(id.error());
 
    auto const seq = ledger_entry_helpers::requiredUInt32(params, jss::seq, "malformedRequest");
    if (!seq)
        return std::unexpected(seq.error());
 
    auto const seqProxy = SeqProxy::rawSequence(*seq);
    return keylet::vault(*id, seqProxy).key;
}
 
static std::expected<uint256, json::Value>
parseXChainOwnedClaimID(
    json::Value const& claimId,
    json::StaticString const fieldName,
    [[maybe_unused]] unsigned const apiVersion)
{
    if (!claimId.isObject())
    {
        return parseObjectID(claimId, fieldName);
    }
 
    auto const bridgeSpec = ledger_entry_helpers::parseBridgeFields(claimId);
    if (!bridgeSpec)
        return std::unexpected(bridgeSpec.error());
 
    auto const seq = ledger_entry_helpers::requiredUInt32(
        claimId, jss::xchain_owned_claim_id, "malformedXChainOwnedClaimID");
    if (!seq)
    {
        return std::unexpected(seq.error());
    }
 
    Keylet const keylet = keylet::xChainClaimID(*bridgeSpec, *seq);
    return keylet.key;
}
 
static std::expected<uint256, json::Value>
parseXChainOwnedCreateAccountClaimID(
    json::Value const& claimId,
    json::StaticString const fieldName,
    [[maybe_unused]] unsigned const apiVersion)
{
    if (!claimId.isObject())
    {
        return parseObjectID(claimId, fieldName);
    }
 
    auto const bridgeSpec = ledger_entry_helpers::parseBridgeFields(claimId);
    if (!bridgeSpec)
        return std::unexpected(bridgeSpec.error());
 
    auto const seq = ledger_entry_helpers::requiredUInt32(
        claimId,
        jss::xchain_owned_create_account_claim_id,
        "malformedXChainOwnedCreateAccountClaimID");
    if (!seq)
    {
        return std::unexpected(seq.error());
    }
 
    Keylet const keylet = keylet::xChainCreateAccountClaimID(*bridgeSpec, *seq);
    return keylet.key;
}
 
struct LedgerEntry
{
    json::StaticString fieldName;
    FunctionType parseFunction;
    LedgerEntryType expectedType;
};
 
// {
//   ledger_hash : <ledger>
//   ledger_index : <ledger_index>
//   ...
// }
json::Value
doLedgerEntry(rpc::JsonContext& context)
{
    static auto kLedgerEntryParsers = std::to_array<LedgerEntry>({
#pragma push_macro("LEDGER_ENTRY")
#undef LEDGER_ENTRY
 
#define LEDGER_ENTRY(tag, value, name, rpcName, fields) {jss::rpcName, parse##name, tag},
 
#include <xrpl/protocol/detail/ledger_entries.macro>
 
#undef LEDGER_ENTRY
#pragma pop_macro("LEDGER_ENTRY")
        {.fieldName = jss::index, .parseFunction = parseIndex, .expectedType = ltANY},
        // aliases
        {.fieldName = jss::account_root,
         .parseFunction = parseAccountRoot,
         .expectedType = ltACCOUNT_ROOT},
        {.fieldName = jss::ripple_state,
         .parseFunction = parseRippleState,
         .expectedType = ltRIPPLE_STATE},
    });
 
    auto const hasMoreThanOneMember = [&]() {
        int count = 0;
 
        for (auto const& ledgerEntry : kLedgerEntryParsers)
        {
            if (context.params.isMember(ledgerEntry.fieldName))
            {
                count++;
                if (count > 1)  // Early exit if more than one is found
                    return true;
            }
        }
        return false;  // Return false if <= 1 is found
    }();
 
    if (hasMoreThanOneMember)
    {
        return rpc::makeParamError("Too many fields provided.");
    }
 
    std::shared_ptr<ReadView const> lpLedger;
    auto jvResult = rpc::lookupLedger(lpLedger, context);
 
    if (!lpLedger)
        return jvResult;
 
    uint256 uNodeIndex;
    LedgerEntryType expectedType = ltANY;
 
    try
    {
        bool found = false;
        for (auto const& ledgerEntry : kLedgerEntryParsers)
        {
            if (context.params.isMember(ledgerEntry.fieldName))
            {
                expectedType = ledgerEntry.expectedType;
                // `Bridge` is the only type that involves two fields at the
                // `ledger_entry` param level.
                // So that parser needs to have the whole `params` field.
                // All other parsers only need the one field name's info.
                json::Value const& params = ledgerEntry.fieldName == jss::bridge
                    ? context.params
                    : context.params[ledgerEntry.fieldName];
                auto const result =
                    ledgerEntry.parseFunction(params, ledgerEntry.fieldName, context.apiVersion);
                if (!result)
                    return result.error();
 
                uNodeIndex = result.value();
                found = true;
                break;
            }
        }
        if (!found)
        {
            if (context.apiVersion < 2u)
            {
                jvResult[jss::error] = "unknownOption";
                return jvResult;
            }
            return rpc::makeParamError("No ledger_entry params provided.");
        }
    }
    catch (json::Error const& e)
    {
        if (context.apiVersion > 1u)
        {
            // For apiVersion 2 onwards, any parsing failures that throw
            // this exception return an invalidParam error.
            return rpc::makeError(RpcInvalidParams);
        }
 
        throw;
    }
 
    // Return the computed index regardless of whether the node exists.
    jvResult[jss::index] = to_string(uNodeIndex);
 
    if (uNodeIndex.isZero())
    {
        rpc::injectError(RpcEntryNotFound, jvResult);
        return jvResult;
    }
 
    auto const sleNode = lpLedger->read(keylet::unchecked(uNodeIndex));
 
    bool bNodeBinary = false;
    if (context.params.isMember(jss::binary))
        bNodeBinary = context.params[jss::binary].asBool();
 
    if (!sleNode)
    {
        // Not found.
        rpc::injectError(RpcEntryNotFound, jvResult);
        return jvResult;
    }
 
    if ((expectedType != ltANY) && (expectedType != sleNode->getType()))
    {
        rpc::injectError(RpcUnexpectedLedgerType, jvResult);
        return jvResult;
    }
 
    if (bNodeBinary)
    {
        Serializer s;
 
        sleNode->add(s);
 
        jvResult[jss::node_binary] = strHex(s.peekData());
    }
    else
    {
        jvResult[jss::node] = sleNode->getJson(JsonOptions::Values::None);
    }
 
    return jvResult;
}
 
std::pair<org::xrpl::rpc::v1::GetLedgerEntryResponse, grpc::Status>
doLedgerEntryGrpc(rpc::GRPCContext<org::xrpl::rpc::v1::GetLedgerEntryRequest>& context)
{
    org::xrpl::rpc::v1::GetLedgerEntryRequest const& request = context.params;
    org::xrpl::rpc::v1::GetLedgerEntryResponse response;
    grpc::Status const status = grpc::Status::OK;
 
    std::shared_ptr<ReadView const> ledger;
    if (auto status = rpc::ledgerFromRequest(ledger, context))
    {
        grpc::Status errorStatus;
        if (status.toErrorCode() == RpcInvalidParams)
        {
            errorStatus = grpc::Status(grpc::StatusCode::INVALID_ARGUMENT, status.message());
        }
        else
        {
            errorStatus = grpc::Status(grpc::StatusCode::NOT_FOUND, status.message());
        }
        return {response, errorStatus};
    }
 
    auto const key = uint256::fromVoidChecked(request.key());
    if (!key)
    {
        grpc::Status const errorStatus{grpc::StatusCode::INVALID_ARGUMENT, "index malformed"};
        return {response, errorStatus};
    }
 
    auto const sleNode = ledger->read(keylet::unchecked(*key));
    if (!sleNode)
    {
        grpc::Status const errorStatus{grpc::StatusCode::NOT_FOUND, "object not found"};
        return {response, errorStatus};
    }
 
    Serializer s;
    sleNode->add(s);
 
    auto& stateObject = *response.mutable_ledger_object();
    stateObject.set_data(s.peekData().data(), s.getLength());
    stateObject.set_key(request.key());
    *(response.mutable_ledger()) = request.ledger();
    return {response, status};
}
}  // namespace xrpl