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<ripple::AccountID> accounts;
    std::uint32_t ledgerSequence{};
    std::uint32_t transactionIndex{};
    ripple::uint256 txHash;

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

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

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

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

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

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

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

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

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

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

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

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

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

static constexpr std::uint32_t kRIPPLE_EPOCH_START = 946684800;