Node.h

#pragma once
 
#include <xrpld/core/Config.h>
 
#include <xrpl/basics/Blob.h>
#include <xrpl/basics/RangeSet.h>
#include <xrpl/basics/base_uint.h>
#include <xrpl/beast/utility/Journal.h>
#include <xrpl/core/PerfLog.h>
#include <xrpl/core/ServiceRegistry.h>
#include <xrpl/ledger/Ledger.h>
#include <xrpl/protocol/ErrorCodes.h>
#include <xrpl/protocol/LedgerHeader.h>
#include <xrpl/protocol/Protocol.h>
#include <xrpl/protocol/TxSearched.h>
#include <xrpl/rdb/DatabaseCon.h>
#include <xrpl/rdb/RelationalDatabase.h>
 
#include <soci/session.h>
 
#include <cstddef>
#include <cstdint>
#include <functional>
#include <map>
#include <memory>
#include <optional>
#include <string>
#include <utility>
#include <variant>
#include <vector>
 
namespace xrpl::detail {
 
/* Need to change TableTypeCount if TableType is modified. */
enum class TableType { Ledgers, Transactions, AccountTransactions };
constexpr int kTableTypeCount = 3;
 
struct DatabasePairValid
{
    std::unique_ptr<DatabaseCon> ledgerDb;
    std::unique_ptr<DatabaseCon> transactionDb;
    bool valid;
};

DatabasePairValid
makeLedgerDBs(
    Config const& config,
    DatabaseCon::Setup const& setup,
    DatabaseCon::CheckpointerSetup const& checkpointerSetup,
    beast::Journal j);

std::optional<LedgerIndex>
getMinLedgerSeq(soci::session& session, TableType type);

std::optional<LedgerIndex>
getMaxLedgerSeq(soci::session& session, TableType type);

void
deleteByLedgerSeq(soci::session& session, TableType type, LedgerIndex ledgerSeq);

void
deleteBeforeLedgerSeq(soci::session& session, TableType type, LedgerIndex ledgerSeq);

std::size_t
getRows(soci::session& session, TableType type);

RelationalDatabase::CountMinMax
getRowsMinMax(soci::session& session, TableType type);

bool
saveValidatedLedger(
    DatabaseCon& ldgDB,
    std::unique_ptr<DatabaseCon> const& txnDB,
    Application& app,
    std::shared_ptr<Ledger const> const& ledger,
    bool current);

std::optional<LedgerHeader>
getLedgerInfoByIndex(soci::session& session, LedgerIndex ledgerSeq, beast::Journal j);

std::optional<LedgerHeader>
getNewestLedgerInfo(soci::session& session, beast::Journal j);

std::optional<LedgerHeader>
getLimitedOldestLedgerInfo(soci::session& session, LedgerIndex ledgerFirstIndex, beast::Journal j);

std::optional<LedgerHeader>
getLimitedNewestLedgerInfo(soci::session& session, LedgerIndex ledgerFirstIndex, beast::Journal j);

std::optional<LedgerHeader>
getLedgerInfoByHash(soci::session& session, uint256 const& ledgerHash, beast::Journal j);

uint256
getHashByIndex(soci::session& session, LedgerIndex ledgerIndex);

std::optional<LedgerHashPair>
getHashesByIndex(soci::session& session, LedgerIndex ledgerIndex, beast::Journal j);

std::map<LedgerIndex, LedgerHashPair>
getHashesByIndex(soci::session& session, LedgerIndex minSeq, LedgerIndex maxSeq, beast::Journal j);

std::pair<std::vector<std::shared_ptr<Transaction>>, int>
getTxHistory(soci::session& session, Application& app, LedgerIndex startIndex, int quantity);

std::pair<RelationalDatabase::AccountTxs, int>
getOldestAccountTxs(
    soci::session& session,
    Application& app,
    LedgerMaster& ledgerMaster,
    RelationalDatabase::AccountTxOptions const& options,
    beast::Journal j);

std::pair<RelationalDatabase::AccountTxs, int>
getNewestAccountTxs(
    soci::session& session,
    Application& app,
    LedgerMaster& ledgerMaster,
    RelationalDatabase::AccountTxOptions const& options,
    beast::Journal j);

std::pair<std::vector<RelationalDatabase::txnMetaLedgerType>, int>
getOldestAccountTxsB(
    soci::session& session,
    Application& app,
    RelationalDatabase::AccountTxOptions const& options,
    beast::Journal j);

std::pair<std::vector<RelationalDatabase::txnMetaLedgerType>, int>
getNewestAccountTxsB(
    soci::session& session,
    Application& app,
    RelationalDatabase::AccountTxOptions const& options,
    beast::Journal j);

std::pair<std::optional<RelationalDatabase::AccountTxMarker>, int>
oldestAccountTxPage(
    soci::session& session,
    std::function<void(std::uint32_t)> const& onUnsavedLedger,
    std::function<void(std::uint32_t, std::string const&, Blob&&, Blob&&)> const& onTransaction,
    RelationalDatabase::AccountTxPageOptions const& options,
    std::uint32_t pageLength);

std::pair<std::optional<RelationalDatabase::AccountTxMarker>, int>
newestAccountTxPage(
    soci::session& session,
    std::function<void(std::uint32_t)> const& onUnsavedLedger,
    std::function<void(std::uint32_t, std::string const&, Blob&&, Blob&&)> const& onTransaction,
    RelationalDatabase::AccountTxPageOptions const& options,
    std::uint32_t pageLength);

std::variant<RelationalDatabase::AccountTx, TxSearched>
getTransaction(
    soci::session& session,
    Application& app,
    uint256 const& id,
    std::optional<ClosedInterval<uint32_t>> const& range,
    ErrorCodeI& ec);

bool
dbHasSpace(soci::session& session, Config const& config, beast::Journal j);
 
}  // namespace xrpl::detail