Types.hpp

#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>;

struct LedgerObject {
    ripple::uint256 key;
    Blob blob;
 
    bool
    operator==(LedgerObject const& other) const = default;
};

struct LedgerPage {
    std::vector<LedgerObject> objects;
    std::optional<ripple::uint256> cursor;
};

struct BookOffersPage {
    std::vector<LedgerObject> offers;
    std::optional<ripple::uint256> cursor;
};

struct TransactionAndMetadata {
    Blob transaction;
    Blob metadata;
    std::uint32_t ledgerSequence = 0;
    std::uint32_t date = 0;
 
    TransactionAndMetadata() = default;

    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}
    {
    }

    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)}
    {
    }

    bool
    operator==(TransactionAndMetadata const& other) const
    {
        return transaction == other.transaction && metadata == other.metadata &&
            ledgerSequence == other.ledgerSequence && date == other.date;
    }
};

struct TransactionsCursor {
    std::uint32_t ledgerSequence = 0;
    std::uint32_t transactionIndex = 0;
 
    TransactionsCursor() = default;

    TransactionsCursor(std::uint32_t ledgerSequence, std::uint32_t transactionIndex)
        : ledgerSequence{ledgerSequence}, transactionIndex{transactionIndex}
    {
    }

    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;

    [[nodiscard]] std::tuple<std::uint32_t, std::uint32_t>
    asTuple() const
    {
        return std::make_tuple(ledgerSequence, transactionIndex);
    }
};

struct TransactionsAndCursor {
    std::vector<TransactionAndMetadata> txns;
    std::optional<TransactionsCursor> cursor;
};

struct NFT {
    ripple::uint256 tokenID;
    std::uint32_t ledgerSequence{};
    ripple::AccountID owner;
    Blob uri;
    bool isBurned{};
 
    NFT() = default;

    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}
    {
    }

    NFT(ripple::uint256 const& tokenID,
        std::uint32_t ledgerSequence,
        ripple::AccountID const& owner,
        bool isBurned)
        : NFT(tokenID, ledgerSequence, owner, {}, isBurned)
    {
    }

    bool
    operator==(NFT const& other) const
    {
        return tokenID == other.tokenID && ledgerSequence == other.ledgerSequence;
    }
};

struct NFTsAndCursor {
    std::vector<NFT> nfts;
    std::optional<ripple::uint256> cursor;
};

struct MPTHoldersAndCursor {
    std::vector<Blob> mptokens;
    std::optional<ripple::AccountID> cursor;
};

struct LedgerRange {
    std::uint32_t minSequence = 0;
    std::uint32_t maxSequence = 0;
 
    bool
    operator==(LedgerRange const&) const = default;
};

struct Amendment {
    std::string name;
    ripple::uint256 feature;
    bool isSupportedByXRPL = false;
    bool isSupportedByClio = false;
    bool isRetired = false;

    static ripple::uint256
    getAmendmentId(std::string_view const name);

    bool
    operator==(Amendment const& other) const
    {
        return name == other.name;
    }
};

struct AmendmentKey {
    std::string name;

    AmendmentKey(std::convertible_to<std::string> auto&& val)
        : name{std::forward<decltype(val)>(val)}
    {
    }

    operator std::string const&() const;

    operator std::string_view() const;

    operator ripple::uint256() const;

    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