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&
fees() noexcept;
 
Keylet const&
negativeUNL() noexcept;
 
struct book_t
{
    explicit book_t() = default;
 
    Keylet
    operator()(Book const& b) const;
};
static book_t const book{};
 
Keylet
line(AccountID const& id0, AccountID const& id1, Currency const& currency) noexcept;
 
inline Keylet
line(AccountID const& id, Issue const& issue) noexcept
{
    return line(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;
 
struct next_t
{
    explicit next_t() = default;
 
    Keylet
    operator()(Keylet const& k) const;
};
static next_t const next{};
 
struct ticket_t
{
    explicit ticket_t() = default;
 
    Keylet
    operator()(AccountID const& id, std::uint32_t ticketSeq) const;
 
    Keylet
    operator()(AccountID const& id, SeqProxy ticketSeq) const;
 
    Keylet
    operator()(uint256 const& key) const
    {
        return {ltTICKET, key};
    }
};
static ticket_t const ticket{};
 
Keylet
signers(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
payChan(AccountID const& src, AccountID const& dst, std::uint32_t seq) noexcept;
 
Keylet
nftpage_min(AccountID const& owner);
 
Keylet
nftpage_max(AccountID const& owner);
 
Keylet
nftpage(Keylet const& k, uint256 const& token);
Keylet
nftoffer(AccountID const& owner, std::uint32_t seq);
 
inline Keylet
nftoffer(uint256 const& offer)
{
    return {ltNFTOKEN_OFFER, offer};
}
 
Keylet
nft_buys(uint256 const& id) noexcept;
 
Keylet
nft_sells(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
mptIssuance(std::uint32_t seq, AccountID const& issuer) noexcept;
 
Keylet
mptIssuance(MPTID const& issuanceID) noexcept;
 
inline Keylet
mptIssuance(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>
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 directAccountKeylets{
    {{&keylet::account, jss::AccountRoot, false},
     {&keylet::ownerDir, jss::DirectoryNode, true},
     {&keylet::signers, jss::SignerList, true},
     // It's normally impossible to create an item at nftpage_min, but
     // test it anyway, since the invariant checks for it.
     {&keylet::nftpage_min, jss::NFTokenPage, true},
     {&keylet::nftpage_max, jss::NFTokenPage, true},
     {&keylet::did, jss::DID, true}}};
 
MPTID
makeMptID(std::uint32_t sequence, AccountID const& account);
 
}  // namespace xrpl