Indexes.h

#pragma once
 
#include <xrpl/basics/Slice.h>
#include <xrpl/basics/base_uint.h>
#include <xrpl/beast/utility/instrumentation.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/Issue.h>
#include <xrpl/protocol/Keylet.h>
#include <xrpl/protocol/LedgerFormats.h>
#include <xrpl/protocol/Protocol.h>
#include <xrpl/protocol/STXChainBridge.h>
#include <xrpl/protocol/SeqProxy.h>
#include <xrpl/protocol/UintTypes.h>
 
#include <array>
#include <cstdint>
#include <functional>
#include <set>
#include <utility>
 
namespace xrpl {
namespace keylet {

Keylet
account(AccountID const& id) noexcept;

Keylet const&
amendments() noexcept;

Keylet
child(UInt256 const& key) noexcept;

Keylet const&
skip() noexcept;

Keylet
skip(LedgerIndex ledger) noexcept;

Keylet const&
feeSettings() noexcept;

Keylet const&
negativeUNL() noexcept;

Keylet
book(Book const& b);

Keylet
trustLine(AccountID const& id0, AccountID const& id1, Currency const& currency) noexcept;
 
inline Keylet
trustLine(AccountID const& id, Issue const& issue) noexcept
{
    return trustLine(id, issue.account, issue.currency);
}


Keylet
offer(AccountID const& id, SeqProxy const& seq) noexcept;
 
inline Keylet
offer(UInt256 const& key) noexcept
{
    return {ltOFFER, key};
}


Keylet
quality(Keylet const& k, std::uint64_t const q) noexcept;

Keylet
next(Keylet const& k);

Keylet
ticket(AccountID const& id, SeqProxy const& ticketSeq);
 
inline Keylet
ticket(UInt256 const& key)
{
    return {ltTICKET, key};
}


Keylet
signerList(AccountID const& account) noexcept;

Keylet
sponsorship(AccountID const& sponsor, AccountID const& sponsee) noexcept;

Keylet
check(AccountID const& id, SeqProxy const& seq) noexcept;
 
inline Keylet
check(UInt256 const& key) noexcept
{
    return {ltCHECK, key};
}


Keylet
txProposal(AccountID const& target, std::uint32_t ticketSequence) noexcept;
 
inline Keylet
txProposal(UInt256 const& key) noexcept
{
    return {ltTRANSACTION_PROPOSAL, key};
}


Keylet
depositPreauth(AccountID const& owner, AccountID const& preauthorized) noexcept;
 
Keylet
depositPreauth(
    AccountID const& owner,
    std::set<std::pair<AccountID, Slice>> const& authCreds) noexcept;
 
inline Keylet
depositPreauth(UInt256 const& key) noexcept
{
    return {ltDEPOSIT_PREAUTH, key};
}

 
//------------------------------------------------------------------------------

Keylet
unchecked(UInt256 const& key) noexcept;

Keylet
ownerDir(AccountID const& id) noexcept;

Keylet
page(UInt256 const& root, std::uint64_t const index = 0) noexcept;
 
inline Keylet
page(Keylet const& root, std::uint64_t const index = 0) noexcept
{
    XRPL_ASSERT(root.type == ltDIR_NODE, "xrpl::keylet::page : valid root type");
    return page(root.key, index);
}


Keylet
escrow(AccountID const& src, SeqProxy const& seq) noexcept;

Keylet
payChannel(AccountID const& src, AccountID const& dst, SeqProxy const& seq) noexcept;

Keylet
nftokenPageMin(AccountID const& owner);

Keylet
nftokenPageMax(AccountID const& owner);
 
Keylet
nftokenPage(Keylet const& k, UInt256 const& token);

Keylet
nftokenOffer(AccountID const& owner, SeqProxy const& seq);
 
inline Keylet
nftokenOffer(UInt256 const& offer)
{
    return {ltNFTOKEN_OFFER, offer};
}

Keylet
nftBuys(UInt256 const& id) noexcept;

Keylet
nftSells(UInt256 const& id) noexcept;

Keylet
amm(Asset const& issue1, Asset const& issue2) noexcept;
 
Keylet
amm(UInt256 const& amm) noexcept;

Keylet
delegate(AccountID const& account, AccountID const& authorizedAccount) noexcept;
 
Keylet
bridge(STXChainBridge const& bridge, STXChainBridge::ChainType chainType);
 
// `seq` is stored as `sfXChainClaimID` in the object
Keylet
xChainClaimID(STXChainBridge const& bridge, std::uint64_t const seq);
 
// `seq` is stored as `sfXChainAccountCreateCount` in the object
Keylet
xChainCreateAccountClaimID(STXChainBridge const& bridge, std::uint64_t const seq);
 
Keylet
did(AccountID const& account) noexcept;
 
Keylet
oracle(AccountID const& account, std::uint32_t const documentID) noexcept;
 
Keylet
credential(AccountID const& subject, AccountID const& issuer, Slice const& credType) noexcept;
 
inline Keylet
credential(UInt256 const& key) noexcept
{
    return {ltCREDENTIAL, key};
}
 
Keylet
mptokenIssuance(MPTID const& issuanceID) noexcept;
 
inline Keylet
mptokenIssuance(UInt256 const& issuanceKey)
{
    return {ltMPTOKEN_ISSUANCE, issuanceKey};
}
 
Keylet
mptoken(MPTID const& issuanceID, AccountID const& holder) noexcept;
 
inline Keylet
mptoken(UInt256 const& mptokenKey)
{
    return {ltMPTOKEN, mptokenKey};
}
 
Keylet
mptoken(UInt256 const& issuanceKey, AccountID const& holder) noexcept;
 
Keylet
vault(AccountID const& owner, SeqProxy const& seq) noexcept;
 
inline Keylet
vault(UInt256 const& vaultKey)
{
    return {ltVAULT, vaultKey};
}
 
Keylet
loanBroker(AccountID const& owner, SeqProxy const& seq) noexcept;
 
inline Keylet
loanBroker(UInt256 const& key)
{
    return {ltLOAN_BROKER, key};
}
 
Keylet
loan(UInt256 const& loanBrokerID, SeqProxy const& loanSeq) noexcept;
 
inline Keylet
loan(UInt256 const& key)
{
    return {ltLOAN, key};
}
 
Keylet
permissionedDomain(AccountID const& account, SeqProxy const& seq) noexcept;
 
Keylet
permissionedDomain(UInt256 const& domainID) noexcept;
}  // namespace keylet
 
// Everything below is deprecated and should be removed in favor of keylets:
 
UInt256
getBookBase(Book const& book);
 
UInt256
getQualityNext(UInt256 const& uBase);
 
// VFALCO This name could be better
std::uint64_t
getQuality(UInt256 const& uBase);
 
template <class... KeyletParams>
// NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init)
struct KeyletDesc
{
    std::function<Keylet(KeyletParams...)> function;
    json::StaticString expectedLEName;
    bool includeInTests{};
};
 
// This list should include all of the keylet functions that take a single AccountID parameter.
extern std::array<KeyletDesc<AccountID const&>, 6> const kDirectAccountKeylets;
 
MPTID
makeMptID(std::uint32_t const sequence, AccountID const& account);
 
}  // namespace xrpl