DBHelpers.hpp

Go to the documentation of this file.

#pragma once
 
#include "util/Assert.hpp"
 
#include <boost/container/flat_set.hpp>
#include <xrpl/basics/Blob.h>
#include <xrpl/basics/Log.h>
#include <xrpl/basics/StringUtilities.h>
#include <xrpl/basics/base_uint.h>
#include <xrpl/protocol/AccountID.h>
#include <xrpl/protocol/SField.h>
#include <xrpl/protocol/STAccount.h>
#include <xrpl/protocol/STLedgerEntry.h>
#include <xrpl/protocol/Serializer.h>
#include <xrpl/protocol/TxMeta.h>
 
#include <cstddef>
#include <cstdint>
#include <optional>
#include <string>

struct AccountTransactionsData {
    boost::container::flat_set<xrpl::AccountID> accounts;
    std::uint32_t ledgerSequence{};
    std::uint32_t transactionIndex{};
    xrpl::uint256 txHash;

    AccountTransactionsData(xrpl::TxMeta const& meta, xrpl::uint256 const& txHash)
        : accounts(meta.getAffectedAccounts())
        , ledgerSequence(meta.getLgrSeq())
        , transactionIndex(meta.getIndex())
        , txHash(txHash)
    {
    }
 
    AccountTransactionsData() = default;
};

struct NFTTransactionsData {
    xrpl::uint256 tokenID;
    std::uint32_t ledgerSequence;
    std::uint32_t transactionIndex;
    xrpl::uint256 txHash;

    NFTTransactionsData(
        xrpl::uint256 const& tokenID,
        xrpl::TxMeta const& meta,
        xrpl::uint256 const& txHash
    )
        : tokenID(tokenID)
        , ledgerSequence(meta.getLgrSeq())
        , transactionIndex(meta.getIndex())
        , txHash(txHash)
    {
    }
};

struct NFTsData {
    xrpl::uint256 tokenID;
    std::uint32_t ledgerSequence;
    std::optional<std::uint32_t> transactionIndex;
    xrpl::AccountID owner;
    std::optional<xrpl::Blob> uri;
    bool isBurned = false;
    bool onlyUriChanged = false;  // Whether only the URI was changed

    NFTsData(
        xrpl::uint256 const& tokenID,
        xrpl::AccountID const& owner,
        xrpl::Blob const& uri,
        xrpl::TxMeta const& meta
    )
        : tokenID(tokenID)
        , ledgerSequence(meta.getLgrSeq())
        , transactionIndex(meta.getIndex())
        , owner(owner)
        , uri(uri)
    {
    }

    NFTsData(
        xrpl::uint256 const& tokenID,
        xrpl::AccountID const& owner,
        xrpl::TxMeta const& meta,
        bool isBurned
    )
        : tokenID(tokenID)
        , ledgerSequence(meta.getLgrSeq())
        , transactionIndex(meta.getIndex())
        , owner(owner)
        , isBurned(isBurned)
    {
    }

    NFTsData(
        xrpl::uint256 const& tokenID,
        std::uint32_t const ledgerSequence,
        xrpl::AccountID const& owner,
        xrpl::Blob const& uri
    )
        : tokenID(tokenID), ledgerSequence(ledgerSequence), owner(owner), uri(uri)
    {
    }

    NFTsData(xrpl::uint256 const& tokenID, xrpl::TxMeta const& meta, xrpl::Blob const& uri)
        : tokenID(tokenID)
        , ledgerSequence(meta.getLgrSeq())
        , transactionIndex(meta.getIndex())
        , uri(uri)
        , onlyUriChanged(true)
    {
    }
};

struct MPTHolderData {
    xrpl::uint192 mptID;
    xrpl::AccountID holder;
};

struct MPTokenIssuanceTransactionsData {
    xrpl::uint192 mptIssuanceID;
    boost::container::flat_set<xrpl::AccountID> accounts;
    std::uint32_t ledgerSequence{};
    std::uint32_t transactionIndex{};
    xrpl::uint256 txHash;
 
    bool
    operator==(MPTokenIssuanceTransactionsData const&) const = default;
};

template <typename T>
inline bool
isDirNode(T const& object)
{
    static constexpr auto kMinSizeRequired = 3;
    if (std::size(object) < kMinSizeRequired)
        return false;
 
    static constexpr short kDirNodeSpaceKey = 0x0064;
    short const spaceKey = (object.data()[1] << 8) | object.data()[2];
    return spaceKey == kDirNodeSpaceKey;
}

template <typename T, typename R>
inline bool
isBookDir(T const& key, R const& object)
{
    if (!isDirNode(object))
        return false;
 
    xrpl::STLedgerEntry const sle{xrpl::SerialIter{object.data(), object.size()}, key};
    return !sle[~xrpl::sfOwner].has_value();
}

template <typename T>
inline xrpl::uint256
getBookBase(T const& key)
{
    static constexpr size_t kEySize = 24;
 
    ASSERT(key.size() == xrpl::uint256::size(), "Invalid key size {}", key.size());
 
    xrpl::uint256 ret;
    for (size_t i = 0; i < kEySize; ++i)
        ret.data()[i] = key.data()[i];
 
    return ret;
}

inline std::string
uint256ToString(xrpl::uint256 const& input)
{
    return {reinterpret_cast<char const*>(input.data()), xrpl::uint256::size()};
}

static constexpr std::uint32_t kRippleEpochStart = 946684800;