Indexes.h

//------------------------------------------------------------------------------
/*
    This file is part of rippled: https://github.com/ripple/rippled
    Copyright (c) 2012, 2013 Ripple Labs Inc.
 
    Permission to use, copy, modify, and/or distribute this software for any
    purpose  with  or without fee is hereby granted, provided that the above
    copyright notice and this permission notice appear in all copies.
 
    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
//==============================================================================
 
#ifndef RIPPLE_PROTOCOL_INDEXES_H_INCLUDED
#define RIPPLE_PROTOCOL_INDEXES_H_INCLUDED
 
#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 ripple {
 
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, "ripple::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
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 ripple
 
#endif