mirror of
https://github.com/XRPLF/clio.git
synced 2026-04-29 15:37:53 +00:00
320 lines
8.7 KiB
C++
320 lines
8.7 KiB
C++
//------------------------------------------------------------------------------
|
|
/*
|
|
This file is part of clio: https://github.com/XRPLF/clio
|
|
Copyright (c) 2022, the clio developers.
|
|
|
|
Permission to use, copy, modify, and 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.
|
|
*/
|
|
//==============================================================================
|
|
|
|
#pragma once
|
|
|
|
#include <xrpl/basics/base_uint.h>
|
|
#include <xrpl/protocol/AccountID.h>
|
|
|
|
#include <concepts>
|
|
#include <cstdint>
|
|
#include <optional>
|
|
#include <string>
|
|
#include <string_view>
|
|
#include <tuple>
|
|
#include <utility>
|
|
#include <vector>
|
|
|
|
namespace data {
|
|
|
|
using Blob = std::vector<unsigned char>;
|
|
|
|
/**
|
|
* @brief Represents an object in the ledger.
|
|
*/
|
|
struct LedgerObject {
|
|
ripple::uint256 key;
|
|
Blob blob;
|
|
|
|
bool
|
|
operator==(LedgerObject const& other) const = default;
|
|
};
|
|
|
|
/**
|
|
* @brief Represents a page of LedgerObjects.
|
|
*/
|
|
struct LedgerPage {
|
|
std::vector<LedgerObject> objects;
|
|
std::optional<ripple::uint256> cursor;
|
|
};
|
|
|
|
/**
|
|
* @brief Represents a page of book offer objects.
|
|
*/
|
|
struct BookOffersPage {
|
|
std::vector<LedgerObject> offers;
|
|
std::optional<ripple::uint256> cursor;
|
|
};
|
|
|
|
/**
|
|
* @brief Represents a transaction and its metadata bundled together.
|
|
*/
|
|
struct TransactionAndMetadata {
|
|
Blob transaction;
|
|
Blob metadata;
|
|
std::uint32_t ledgerSequence = 0;
|
|
std::uint32_t date = 0;
|
|
|
|
TransactionAndMetadata() = default;
|
|
|
|
/**
|
|
* @brief Construct a new Transaction And Metadata object
|
|
*
|
|
* @param transaction The transaction
|
|
* @param metadata The metadata
|
|
* @param ledgerSequence The ledger sequence
|
|
* @param date The date
|
|
*/
|
|
TransactionAndMetadata(Blob transaction, Blob metadata, std::uint32_t ledgerSequence, std::uint32_t date)
|
|
: transaction{std::move(transaction)}, metadata{std::move(metadata)}, ledgerSequence{ledgerSequence}, date{date}
|
|
{
|
|
}
|
|
|
|
/**
|
|
* @brief Construct a new Transaction And Metadata object
|
|
*
|
|
* @param data The data to construct from
|
|
*/
|
|
TransactionAndMetadata(std::tuple<Blob, Blob, std::uint32_t, std::uint32_t> data)
|
|
: transaction{std::get<0>(data)}
|
|
, metadata{std::get<1>(data)}
|
|
, ledgerSequence{std::get<2>(data)}
|
|
, date{std::get<3>(data)}
|
|
{
|
|
}
|
|
|
|
/**
|
|
* @brief Check if the transaction and metadata are the same as another
|
|
*
|
|
* @param other The other transaction and metadata
|
|
* @return true if they are the same; false otherwise
|
|
*/
|
|
bool
|
|
operator==(TransactionAndMetadata const& other) const
|
|
{
|
|
return transaction == other.transaction && metadata == other.metadata &&
|
|
ledgerSequence == other.ledgerSequence && date == other.date;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* @brief Represents a cursor into the transactions table.
|
|
*/
|
|
struct TransactionsCursor {
|
|
std::uint32_t ledgerSequence = 0;
|
|
std::uint32_t transactionIndex = 0;
|
|
|
|
TransactionsCursor() = default;
|
|
|
|
/**
|
|
* @brief Construct a new Transactions Cursor object
|
|
*
|
|
* @param ledgerSequence The ledger sequence
|
|
* @param transactionIndex The transaction index
|
|
*/
|
|
TransactionsCursor(std::uint32_t ledgerSequence, std::uint32_t transactionIndex)
|
|
: ledgerSequence{ledgerSequence}, transactionIndex{transactionIndex}
|
|
{
|
|
}
|
|
|
|
/**
|
|
* @brief Construct a new Transactions Cursor object
|
|
*
|
|
* @param data The data to construct from
|
|
*/
|
|
TransactionsCursor(std::tuple<std::uint32_t, std::uint32_t> data)
|
|
: ledgerSequence{std::get<0>(data)}, transactionIndex{std::get<1>(data)}
|
|
{
|
|
}
|
|
|
|
bool
|
|
operator==(TransactionsCursor const& other) const = default;
|
|
|
|
/**
|
|
* @brief Convert the cursor to a tuple of seq and index
|
|
*
|
|
* @return The cursor as a tuple
|
|
*/
|
|
[[nodiscard]] std::tuple<std::uint32_t, std::uint32_t>
|
|
asTuple() const
|
|
{
|
|
return std::make_tuple(ledgerSequence, transactionIndex);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* @brief Represests a bundle of transactions with metadata and a cursor to the next page.
|
|
*/
|
|
struct TransactionsAndCursor {
|
|
std::vector<TransactionAndMetadata> txns;
|
|
std::optional<TransactionsCursor> cursor;
|
|
};
|
|
|
|
/**
|
|
* @brief Represents a NFToken.
|
|
*/
|
|
struct NFT {
|
|
ripple::uint256 tokenID;
|
|
std::uint32_t ledgerSequence{};
|
|
ripple::AccountID owner;
|
|
Blob uri;
|
|
bool isBurned{};
|
|
|
|
NFT() = default;
|
|
|
|
/**
|
|
* @brief Construct a new NFT object
|
|
*
|
|
* @param tokenID The token ID
|
|
* @param ledgerSequence The ledger sequence
|
|
* @param owner The owner
|
|
* @param uri The URI
|
|
* @param isBurned Whether the token is burned
|
|
*/
|
|
NFT(ripple::uint256 const& tokenID,
|
|
std::uint32_t ledgerSequence,
|
|
ripple::AccountID const& owner,
|
|
Blob uri,
|
|
bool isBurned)
|
|
: tokenID{tokenID}, ledgerSequence{ledgerSequence}, owner{owner}, uri{std::move(uri)}, isBurned{isBurned}
|
|
{
|
|
}
|
|
|
|
/**
|
|
* @brief Construct a new NFT object
|
|
*
|
|
* @param tokenID The token ID
|
|
* @param ledgerSequence The ledger sequence
|
|
* @param owner The owner
|
|
* @param isBurned Whether the token is burned
|
|
*/
|
|
NFT(ripple::uint256 const& tokenID, std::uint32_t ledgerSequence, ripple::AccountID const& owner, bool isBurned)
|
|
: NFT(tokenID, ledgerSequence, owner, {}, isBurned)
|
|
{
|
|
}
|
|
|
|
/**
|
|
* @brief Check if the NFT is the same as another
|
|
*
|
|
* Clearly two tokens are the same if they have the same ID, but this struct stores the state of a given
|
|
* token at a given ledger sequence, so we also need to compare with ledgerSequence.
|
|
*
|
|
* @param other The other NFT
|
|
* @return true if they are the same; false otherwise
|
|
*/
|
|
bool
|
|
operator==(NFT const& other) const
|
|
{
|
|
return tokenID == other.tokenID && ledgerSequence == other.ledgerSequence;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* @brief Represents a bundle of NFTs with a cursor to the next page
|
|
*/
|
|
struct NFTsAndCursor {
|
|
std::vector<NFT> nfts;
|
|
std::optional<ripple::uint256> cursor;
|
|
};
|
|
|
|
/**
|
|
* @brief Represents an array of MPTokens
|
|
*/
|
|
struct MPTHoldersAndCursor {
|
|
std::vector<Blob> mptokens;
|
|
std::optional<ripple::AccountID> cursor;
|
|
};
|
|
|
|
/**
|
|
* @brief Stores a range of sequences as a min and max pair.
|
|
*/
|
|
struct LedgerRange {
|
|
std::uint32_t minSequence = 0;
|
|
std::uint32_t maxSequence = 0;
|
|
};
|
|
|
|
/**
|
|
* @brief Represents an amendment in the XRPL
|
|
*/
|
|
struct Amendment {
|
|
std::string name;
|
|
ripple::uint256 feature;
|
|
bool isSupportedByXRPL = false;
|
|
bool isSupportedByClio = false;
|
|
bool isRetired = false;
|
|
|
|
/**
|
|
* @brief Get the amendment Id from its name
|
|
*
|
|
* @param name The name of the amendment
|
|
* @return The amendment Id as uint256
|
|
*/
|
|
static ripple::uint256
|
|
getAmendmentId(std::string_view const name);
|
|
|
|
/**
|
|
* @brief Equality comparison operator
|
|
* @param other The object to compare to
|
|
* @return Whether the objects are equal
|
|
*/
|
|
bool
|
|
operator==(Amendment const& other) const
|
|
{
|
|
return name == other.name;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* @brief A helper for amendment name to feature conversions
|
|
*/
|
|
struct AmendmentKey {
|
|
std::string name;
|
|
|
|
/**
|
|
* @brief Construct a new AmendmentKey
|
|
* @param val Anything convertible to a string
|
|
*/
|
|
AmendmentKey(std::convertible_to<std::string> auto&& val) : name{std::forward<decltype(val)>(val)}
|
|
{
|
|
}
|
|
|
|
/** @brief Conversion to string */
|
|
operator std::string const&() const;
|
|
|
|
/** @brief Conversion to string_view */
|
|
operator std::string_view() const;
|
|
|
|
/** @brief Conversion to uint256 */
|
|
operator ripple::uint256() const;
|
|
|
|
/**
|
|
* @brief Comparison operators
|
|
* @param other The object to compare to
|
|
* @return Whether the objects are equal, greater or less
|
|
*/
|
|
auto
|
|
operator<=>(AmendmentKey const& other) const = default;
|
|
};
|
|
|
|
constexpr ripple::uint256 kFIRST_KEY{"0000000000000000000000000000000000000000000000000000000000000000"};
|
|
constexpr ripple::uint256 kLAST_KEY{"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"};
|
|
constexpr ripple::uint256 kHI192{"0000000000000000000000000000000000000000000000001111111111111111"};
|
|
|
|
} // namespace data
|