Indexes.h

#pragma once
 
#include <xrpl/basics/base_uint.h>
#include <xrpl/protocol/Book.h>
#include <xrpl/protocol/Keylet.h>
#include <xrpl/protocol/LedgerFormats.h>
#include <xrpl/protocol/Protocol.h>
#include <xrpl/protocol/PublicKey.h>
#include <xrpl/protocol/STXChainBridge.h>
#include <xrpl/protocol/Serializer.h>
#include <xrpl/protocol/UintTypes.h>
#include <xrpl/protocol/jss.h>
 
#include <cstdint>
#include <set>
 
namespace xrpl {
 
class SeqProxy;
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, std::uint32_t seq) noexcept;
 
inline Keylet
offer(uint256 const& key) noexcept
{
    return {ltOFFER, key};
}


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

Keylet
next(Keylet const& k);

Keylet
ticket(AccountID const& id, std::uint32_t ticketSeq);
 
Keylet
ticket(AccountID const& id, SeqProxy ticketSeq);
 
inline Keylet
ticket(uint256 const& key)
{
    return {ltTICKET, key};
}


Keylet
signerList(AccountID const& account) noexcept;

Keylet
check(AccountID const& id, std::uint32_t seq) noexcept;
 
inline Keylet
check(uint256 const& key) noexcept
{
    return {ltCHECK, 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 index = 0) noexcept;
 
inline Keylet
page(Keylet const& root, std::uint64_t 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, std::uint32_t seq) noexcept;

Keylet
payChannel(AccountID const& src, AccountID const& dst, std::uint32_t 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, std::uint32_t 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 seq);
 
// `seq` is stored as `sfXChainAccountCreateCount` in the object
Keylet
xChainCreateAccountClaimID(STXChainBridge const& bridge, std::uint64_t 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(std::uint32_t seq, AccountID const& issuer) noexcept;
 
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, std::uint32_t seq) noexcept;
 
inline Keylet
vault(uint256 const& vaultKey)
{
    return {ltVAULT, vaultKey};
}
 
Keylet
loanBroker(AccountID const& owner, std::uint32_t seq) noexcept;
 
inline Keylet
loanBroker(uint256 const& key)
{
    return {ltLOAN_BROKER, key};
}
 
Keylet
loan(uint256 const& loanBrokerID, std::uint32_t loanSeq) noexcept;
 
inline Keylet
loan(uint256 const& key)
{
    return {ltLOAN, key};
}
 
Keylet
permissionedDomain(AccountID const& account, std::uint32_t 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);
 
uint256
getTicketIndex(AccountID const& account, std::uint32_t uSequence);
 
uint256
getTicketIndex(AccountID const& account, SeqProxy ticketSeq);
 
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.
std::array<KeyletDesc<AccountID const&>, 6> const kDirectAccountKeylets{
    {{.function = &keylet::account, .expectedLEName = jss::AccountRoot, .includeInTests = false},
     {.function = &keylet::ownerDir, .expectedLEName = jss::DirectoryNode, .includeInTests = true},
     {.function = &keylet::signerList, .expectedLEName = jss::SignerList, .includeInTests = true},
     // It's normally impossible to create an item at nftpage_min, but
     // test it anyway, since the invariant checks for it.
     {.function = &keylet::nftokenPageMin,
      .expectedLEName = jss::NFTokenPage,
      .includeInTests = true},
     {.function = &keylet::nftokenPageMax,
      .expectedLEName = jss::NFTokenPage,
      .includeInTests = true},
     {.function = &keylet::did, .expectedLEName = jss::DID, .includeInTests = true}}};
 
MPTID
makeMptID(std::uint32_t sequence, AccountID const& account);
 
}  // namespace xrpl