mirror of
https://github.com/XRPLF/rippled.git
synced 2026-07-23 15:10:34 +00:00
432 lines
9.0 KiB
C++
432 lines
9.0 KiB
C++
#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/UintTypes.h>
|
|
|
|
#include <array>
|
|
#include <cstdint>
|
|
#include <functional>
|
|
#include <set>
|
|
#include <utility>
|
|
|
|
namespace xrpl {
|
|
|
|
class SeqProxy;
|
|
/**
|
|
* Keylet computation functions.
|
|
*
|
|
* Entries in the ledger are located using 256-bit locators. The locators are
|
|
* calculated using a wide range of parameters specific to the entry whose
|
|
* locator we are calculating (e.g. an account's locator is derived from the
|
|
* account's address, whereas the locator for an offer is derived from the
|
|
* account and the offer sequence.)
|
|
*
|
|
* To enhance type safety during lookup and make the code more robust, we use
|
|
* keylets, which contain not only the locator of the object but also the type
|
|
* of the object being referenced.
|
|
*
|
|
* These functions each return a type-specific keylet.
|
|
*/
|
|
namespace keylet {
|
|
|
|
/**
|
|
* AccountID root
|
|
*/
|
|
Keylet
|
|
account(AccountID const& id) noexcept;
|
|
|
|
/**
|
|
* The index of the amendment table
|
|
*/
|
|
Keylet const&
|
|
amendments() noexcept;
|
|
|
|
/**
|
|
* Any item that can be in an owner dir.
|
|
*/
|
|
Keylet
|
|
child(uint256 const& key) noexcept;
|
|
|
|
/**
|
|
* The index of the "short" skip list
|
|
*
|
|
* The "short" skip list is a node (at a fixed index) that holds the hashes
|
|
* of ledgers since the last flag ledger. It will contain, at most, 256 hashes.
|
|
*/
|
|
Keylet const&
|
|
skip() noexcept;
|
|
|
|
/**
|
|
* The index of the long skip for a particular ledger range.
|
|
*
|
|
* The "long" skip list is a node that holds the hashes of (up to) 256 flag
|
|
* ledgers.
|
|
*
|
|
* It can be used to efficiently skip back to any ledger using only two hops:
|
|
* the first hop gets the "long" skip list for the ledger it wants to retrieve
|
|
* and uses it to get the hash of the flag ledger whose short skip list will
|
|
* contain the hash of the requested ledger.
|
|
*/
|
|
Keylet
|
|
skip(LedgerIndex ledger) noexcept;
|
|
|
|
/**
|
|
* The (fixed) index of the object containing the ledger fees.
|
|
*/
|
|
Keylet const&
|
|
feeSettings() noexcept;
|
|
|
|
/**
|
|
* The (fixed) index of the object containing the ledger negativeUNL.
|
|
*/
|
|
Keylet const&
|
|
negativeUNL() noexcept;
|
|
|
|
/**
|
|
* The beginning of an order book
|
|
*/
|
|
Keylet
|
|
book(Book const& b);
|
|
|
|
/**
|
|
* The index of a trust line for a given currency
|
|
*
|
|
* Note that a trustline is *shared* between two accounts (commonly referred
|
|
* to as the issuer and the holder); if Alice sets up a trust line to Bob for
|
|
* BTC, and Bob trusts Alice for BTC, here is only a single BTC trust line
|
|
* between them.
|
|
*/
|
|
/** @{ */
|
|
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);
|
|
}
|
|
/** @} */
|
|
|
|
/**
|
|
* An offer from an account
|
|
*/
|
|
/** @{ */
|
|
Keylet
|
|
offer(AccountID const& id, std::uint32_t seq) noexcept;
|
|
|
|
inline Keylet
|
|
offer(uint256 const& key) noexcept
|
|
{
|
|
return {ltOFFER, key};
|
|
}
|
|
/** @} */
|
|
|
|
/**
|
|
* The initial directory page for a specific quality
|
|
*/
|
|
Keylet
|
|
quality(Keylet const& k, std::uint64_t q) noexcept;
|
|
|
|
/**
|
|
* The directory for the next lower quality
|
|
*/
|
|
Keylet
|
|
next(Keylet const& k);
|
|
|
|
/**
|
|
* A ticket belonging to an account
|
|
*/
|
|
/** @{ */
|
|
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};
|
|
}
|
|
/** @} */
|
|
|
|
/**
|
|
* A SignerList
|
|
*/
|
|
Keylet
|
|
signerList(AccountID const& account) noexcept;
|
|
|
|
/**
|
|
* A Sponsorship
|
|
*/
|
|
Keylet
|
|
sponsorship(AccountID const& sponsor, AccountID const& sponsee) noexcept;
|
|
|
|
/**
|
|
* A Check
|
|
*/
|
|
/** @{ */
|
|
Keylet
|
|
check(AccountID const& id, std::uint32_t seq) noexcept;
|
|
|
|
inline Keylet
|
|
check(uint256 const& key) noexcept
|
|
{
|
|
return {ltCHECK, key};
|
|
}
|
|
/** @} */
|
|
|
|
/**
|
|
* A DepositPreauth
|
|
*/
|
|
/** @{ */
|
|
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};
|
|
}
|
|
/** @} */
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
/**
|
|
* Any ledger entry
|
|
*/
|
|
Keylet
|
|
unchecked(uint256 const& key) noexcept;
|
|
|
|
/**
|
|
* The root page of an account's directory
|
|
*/
|
|
Keylet
|
|
ownerDir(AccountID const& id) noexcept;
|
|
|
|
/**
|
|
* A page in a directory
|
|
*/
|
|
/** @{ */
|
|
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);
|
|
}
|
|
/** @} */
|
|
|
|
/**
|
|
* An escrow entry
|
|
*/
|
|
Keylet
|
|
escrow(AccountID const& src, std::uint32_t seq) noexcept;
|
|
|
|
/**
|
|
* A PaymentChannel
|
|
*/
|
|
Keylet
|
|
payChannel(AccountID const& src, AccountID const& dst, std::uint32_t seq) noexcept;
|
|
|
|
/**
|
|
* NFT page keylets
|
|
*
|
|
* Unlike objects whose ledger identifiers are produced by hashing data,
|
|
* NFT page identifiers are composite identifiers, consisting of the owner's
|
|
* 160-bit AccountID, followed by a 96-bit value that determines which NFT
|
|
* tokens are candidates for that page.
|
|
*/
|
|
/** @{ */
|
|
/**
|
|
* A keylet for the owner's first possible NFT page.
|
|
*/
|
|
Keylet
|
|
nftokenPageMin(AccountID const& owner);
|
|
|
|
/**
|
|
* A keylet for the owner's last possible NFT page.
|
|
*/
|
|
Keylet
|
|
nftokenPageMax(AccountID const& owner);
|
|
|
|
Keylet
|
|
nftokenPage(Keylet const& k, uint256 const& token);
|
|
/** @} */
|
|
|
|
/**
|
|
* An offer from an account to buy or sell an NFT
|
|
*/
|
|
Keylet
|
|
nftokenOffer(AccountID const& owner, std::uint32_t seq);
|
|
|
|
inline Keylet
|
|
nftokenOffer(uint256 const& offer)
|
|
{
|
|
return {ltNFTOKEN_OFFER, offer};
|
|
}
|
|
|
|
/**
|
|
* The directory of buy offers for the specified NFT
|
|
*/
|
|
Keylet
|
|
nftBuys(uint256 const& id) noexcept;
|
|
|
|
/**
|
|
* The directory of sell offers for the specified NFT
|
|
*/
|
|
Keylet
|
|
nftSells(uint256 const& id) noexcept;
|
|
|
|
/**
|
|
* AMM entry
|
|
*/
|
|
Keylet
|
|
amm(Asset const& issue1, Asset const& issue2) noexcept;
|
|
|
|
Keylet
|
|
amm(uint256 const& amm) noexcept;
|
|
|
|
/**
|
|
* A keylet for Delegate object
|
|
*/
|
|
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.
|
|
extern std::array<KeyletDesc<AccountID const&>, 6> const kDirectAccountKeylets;
|
|
|
|
MPTID
|
|
makeMptID(std::uint32_t sequence, AccountID const& account);
|
|
|
|
} // namespace xrpl
|