Use std::bit_cast

For coverage builds, we try to link against the `gcov` library (specific to the environment). But as macOS doesn't have this library and thus doesn't have the coverage tools to generate reports, the coverage builds on that platform were failing on linking.

We actually don't need to explicitly force this linking, as the `CodeCoverage` file already has correct detection logic (currently on lines 177-193), which is invoked when the `--coverage` flag is provided:
* AppleClang: Uses `xcrun -f llvm-cov` to set `GCOV_TOOL="llvm-cov gcov"`.
* Clang: Finds `llvm-cov` to set `GCOV_TOOL="llvm-cov gcov"`.
* GCC: Finds `gcov` to set `GCOV_TOOL="gcov"`.
The `GCOV_TOOL` is then passed to `gcovr` on line 416, so the correct tool is used for processing coverage data.

This change therefore removes the `gcov` suffix from lines 473 and 475 in the `CodeCoverage.cmake` file.

.github/scripts/levelization/results/loops.txt

@@ -4,14 +4,11 @@ Loop: test.jtx test.toplevel
 Loop: test.jtx test.unit_test
   test.unit_test == test.jtx
 
-Loop: xrpld.app xrpld.core
-  xrpld.app > xrpld.core
-
 Loop: xrpld.app xrpld.overlay
   xrpld.overlay > xrpld.app
 
 Loop: xrpld.app xrpld.peerfinder
-  xrpld.peerfinder ~= xrpld.app
+  xrpld.peerfinder == xrpld.app
 
 Loop: xrpld.app xrpld.rpc
   xrpld.rpc > xrpld.app

.github/scripts/levelization/results/ordering.txt

@@ -17,12 +17,15 @@ libxrpl.nodestore > xrpl.protocol
 libxrpl.protocol > xrpl.basics
 libxrpl.protocol > xrpl.json
 libxrpl.protocol > xrpl.protocol
+libxrpl.rdb > xrpl.basics
+libxrpl.rdb > xrpl.rdb
 libxrpl.resource > xrpl.basics
 libxrpl.resource > xrpl.json
 libxrpl.resource > xrpl.resource
 libxrpl.server > xrpl.basics
 libxrpl.server > xrpl.json
 libxrpl.server > xrpl.protocol
+libxrpl.server > xrpl.rdb
 libxrpl.server > xrpl.server
 libxrpl.shamap > xrpl.basics
 libxrpl.shamap > xrpl.protocol
@@ -41,7 +44,9 @@ test.app > xrpl.json
 test.app > xrpl.ledger
 test.app > xrpl.nodestore
 test.app > xrpl.protocol
+test.app > xrpl.rdb
 test.app > xrpl.resource
+test.app > xrpl.server
 test.basics > test.jtx
 test.basics > test.unit_test
 test.basics > xrpl.basics
@@ -67,6 +72,7 @@ test.core > xrpl.basics
 test.core > xrpl.core
 test.core > xrpld.core
 test.core > xrpl.json
+test.core > xrpl.rdb
 test.core > xrpl.server
 test.csf > xrpl.basics
 test.csf > xrpld.consensus
@@ -95,8 +101,8 @@ test.nodestore > test.jtx
 test.nodestore > test.toplevel
 test.nodestore > test.unit_test
 test.nodestore > xrpl.basics
-test.nodestore > xrpld.core
 test.nodestore > xrpl.nodestore
+test.nodestore > xrpl.rdb
 test.overlay > test.jtx
 test.overlay > test.toplevel
 test.overlay > test.unit_test
@@ -154,6 +160,7 @@ tests.libxrpl > xrpl.net
 xrpl.core > xrpl.basics
 xrpl.core > xrpl.json
 xrpl.core > xrpl.ledger
+xrpl.core > xrpl.protocol
 xrpl.json > xrpl.basics
 xrpl.ledger > xrpl.basics
 xrpl.ledger > xrpl.protocol
@@ -162,12 +169,17 @@ xrpl.nodestore > xrpl.basics
 xrpl.nodestore > xrpl.protocol
 xrpl.protocol > xrpl.basics
 xrpl.protocol > xrpl.json
+xrpl.rdb > xrpl.basics
+xrpl.rdb > xrpl.core
+xrpl.rdb > xrpl.protocol
 xrpl.resource > xrpl.basics
 xrpl.resource > xrpl.json
 xrpl.resource > xrpl.protocol
 xrpl.server > xrpl.basics
+xrpl.server > xrpl.core
 xrpl.server > xrpl.json
 xrpl.server > xrpl.protocol
+xrpl.server > xrpl.rdb
 xrpl.shamap > xrpl.basics
 xrpl.shamap > xrpl.nodestore
 xrpl.shamap > xrpl.protocol
@@ -176,12 +188,15 @@ xrpld.app > xrpl.basics
 xrpld.app > xrpl.core
 xrpld.app > xrpld.conditions
 xrpld.app > xrpld.consensus
+xrpld.app > xrpld.core
 xrpld.app > xrpl.json
 xrpld.app > xrpl.ledger
 xrpld.app > xrpl.net
 xrpld.app > xrpl.nodestore
 xrpld.app > xrpl.protocol
+xrpld.app > xrpl.rdb
 xrpld.app > xrpl.resource
+xrpld.app > xrpl.server
 xrpld.app > xrpl.shamap
 xrpld.conditions > xrpl.basics
 xrpld.conditions > xrpl.protocol
@@ -193,17 +208,20 @@ xrpld.core > xrpl.core
 xrpld.core > xrpl.json
 xrpld.core > xrpl.net
 xrpld.core > xrpl.protocol
+xrpld.core > xrpl.rdb
 xrpld.overlay > xrpl.basics
 xrpld.overlay > xrpl.core
 xrpld.overlay > xrpld.core
 xrpld.overlay > xrpld.peerfinder
 xrpld.overlay > xrpl.json
 xrpld.overlay > xrpl.protocol
+xrpld.overlay > xrpl.rdb
 xrpld.overlay > xrpl.resource
 xrpld.overlay > xrpl.server
 xrpld.peerfinder > xrpl.basics
 xrpld.peerfinder > xrpld.core
 xrpld.peerfinder > xrpl.protocol
+xrpld.peerfinder > xrpl.rdb
 xrpld.perflog > xrpl.basics
 xrpld.perflog > xrpl.core
 xrpld.perflog > xrpld.rpc
@@ -216,6 +234,7 @@ xrpld.rpc > xrpl.ledger
 xrpld.rpc > xrpl.net
 xrpld.rpc > xrpl.nodestore
 xrpld.rpc > xrpl.protocol
+xrpld.rpc > xrpl.rdb
 xrpld.rpc > xrpl.resource
 xrpld.rpc > xrpl.server
 xrpld.shamap > xrpl.shamap

cmake/CodeCoverage.cmake

@@ -466,11 +466,6 @@ function (add_code_coverage_to_target name scope)
     target_compile_options(${name} ${scope} $<$<COMPILE_LANGUAGE:CXX>:${COVERAGE_CXX_COMPILER_FLAGS}>
                            $<$<COMPILE_LANGUAGE:C>:${COVERAGE_C_COMPILER_FLAGS}>)
 
-    target_link_libraries(
-        ${name}
-        ${scope}
-        $<$<LINK_LANGUAGE:CXX>:${COVERAGE_CXX_LINKER_FLAGS}
-        gcov>
-        $<$<LINK_LANGUAGE:C>:${COVERAGE_C_LINKER_FLAGS}
-        gcov>)
+    target_link_libraries(${name} ${scope} $<$<LINK_LANGUAGE:CXX>:${COVERAGE_CXX_LINKER_FLAGS}>
+                          $<$<LINK_LANGUAGE:C>:${COVERAGE_C_LINKER_FLAGS}>)
 endfunction () # add_code_coverage_to_target

cmake/XrplCore.cmake

@@ -84,9 +84,6 @@ add_module(xrpl net)
 target_link_libraries(xrpl.libxrpl.net PUBLIC xrpl.libxrpl.basics xrpl.libxrpl.json xrpl.libxrpl.protocol
                                               xrpl.libxrpl.resource)
 
-add_module(xrpl server)
-target_link_libraries(xrpl.libxrpl.server PUBLIC xrpl.libxrpl.protocol)
-
 add_module(xrpl nodestore)
 target_link_libraries(xrpl.libxrpl.nodestore PUBLIC xrpl.libxrpl.basics xrpl.libxrpl.json xrpl.libxrpl.protocol)
 
@@ -94,8 +91,15 @@ add_module(xrpl shamap)
 target_link_libraries(xrpl.libxrpl.shamap PUBLIC xrpl.libxrpl.basics xrpl.libxrpl.crypto xrpl.libxrpl.protocol
                                                  xrpl.libxrpl.nodestore)
 
+add_module(xrpl rdb)
+target_link_libraries(xrpl.libxrpl.rdb PUBLIC xrpl.libxrpl.basics xrpl.libxrpl.core)
+
+add_module(xrpl server)
+target_link_libraries(xrpl.libxrpl.server PUBLIC xrpl.libxrpl.protocol xrpl.libxrpl.core xrpl.libxrpl.rdb)
+
 add_module(xrpl ledger)
-target_link_libraries(xrpl.libxrpl.ledger PUBLIC xrpl.libxrpl.basics xrpl.libxrpl.json xrpl.libxrpl.protocol)
+target_link_libraries(xrpl.libxrpl.ledger PUBLIC xrpl.libxrpl.basics xrpl.libxrpl.json xrpl.libxrpl.protocol
+                                                 xrpl.libxrpl.rdb)
 
 add_library(xrpl.libxrpl)
 set_target_properties(xrpl.libxrpl PROPERTIES OUTPUT_NAME xrpl)
@@ -113,13 +117,14 @@ target_link_modules(
     core
     crypto
     json
+    ledger
+    net
+    nodestore
     protocol
+    rdb
     resource
     server
-    nodestore
-    shamap
-    net
-    ledger)
+    shamap)
 
 # All headers in libxrpl are in modules.
 # Uncomment this stanza if you have not yet moved new headers into a module.

cmake/XrplInstall.cmake

@@ -23,6 +23,7 @@ install(TARGETS common
                 xrpl.libxrpl.core
                 xrpl.libxrpl.crypto
                 xrpl.libxrpl.json
+                xrpl.libxrpl.rdb
                 xrpl.libxrpl.ledger
                 xrpl.libxrpl.net
                 xrpl.libxrpl.nodestore

include/xrpl/core/ServiceRegistry.h

@@ -5,6 +5,8 @@
 #include <xrpl/basics/TaggedCache.h>
 #include <xrpl/ledger/CachedSLEs.h>
 
+#include <boost/asio.hpp>
+
 namespace xrpl {
 
 // Forward declarations
@@ -18,6 +20,10 @@ namespace perf {
 class PerfLog;
 }
 
+// This is temporary until we migrate all code to use ServiceRegistry.
+class Application;
+
+// Forward declarations
 class AcceptedLedger;
 class AmendmentTable;
 class Cluster;
@@ -194,6 +200,24 @@ public:
 
     virtual perf::PerfLog&
     getPerfLog() = 0;
+
+    // Configuration and state
+    virtual bool
+    isStopping() const = 0;
+
+    virtual beast::Journal
+    journal(std::string const& name) = 0;
+
+    virtual boost::asio::io_context&
+    getIOContext() = 0;
+
+    virtual Logs&
+    logs() = 0;
+
+    // Temporary: Get the underlying Application for functions that haven't
+    // been migrated yet. This should be removed once all code is migrated.
+    virtual Application&
+    app() = 0;
 };
 
 }  // namespace xrpl

include/xrpl/core/StartUpType.h

@@ -0,0 +1,16 @@
+#pragma once
+
+#include <iosfwd>
+#include <type_traits>
+
+namespace xrpl {
+
+enum class StartUpType { FRESH, NORMAL, LOAD, LOAD_FILE, REPLAY, NETWORK };
+
+inline std::ostream&
+operator<<(std::ostream& os, StartUpType const& type)
+{
+    return os << static_cast<std::underlying_type_t<StartUpType>>(type);
+}
+
+}  // namespace xrpl

include/xrpl/nodestore/Backend.h

@@ -76,16 +76,16 @@ public:
         If the object is not found or an error is encountered, the
         result will indicate the condition.
         @note This will be called concurrently.
-        @param key A pointer to the key data.
+        @param hash The hash of the object.
         @param pObject [out] The created object if successful.
         @return The result of the operation.
     */
     virtual Status
-    fetch(void const* key, std::shared_ptr<NodeObject>* pObject) = 0;
+    fetch(uint256 const& hash, std::shared_ptr<NodeObject>* pObject) = 0;
 
     /** Fetch a batch synchronously. */
     virtual std::pair<std::vector<std::shared_ptr<NodeObject>>, Status>
-    fetchBatch(std::vector<uint256 const*> const& hashes) = 0;
+    fetchBatch(std::vector<uint256> const& hashes) = 0;
 
     /** Store a single object.
         Depending on the implementation this may happen immediately

include/xrpl/protocol/LedgerShortcut.h

@@ -0,0 +1,22 @@
+#pragma once
+
+namespace xrpl {
+
+/**
+ * @brief Enumeration of ledger shortcuts for specifying which ledger to use.
+ *
+ * These shortcuts provide a convenient way to reference commonly used ledgers
+ * without needing to specify their exact hash or sequence number.
+ */
+enum class LedgerShortcut {
+    /** The current working ledger (open, not yet closed) */
+    Current,
+
+    /** The most recently closed ledger (may not be validated) */
+    Closed,
+
+    /** The most recently validated ledger */
+    Validated
+};
+
+}  // namespace xrpl

include/xrpl/protocol/TxSearched.h

@@ -0,0 +1,7 @@
+#pragma once
+
+namespace xrpl {
+
+enum class TxSearched { all, some, unknown };
+
+}

include/xrpl/rdb/DatabaseCon.h

@@ -1,10 +1,9 @@
 #pragma once
 
-#include <xrpld/app/main/DBInit.h>
-#include <xrpld/core/Config.h>
-#include <xrpld/core/SociDB.h>
-
 #include <xrpl/core/PerfLog.h>
+#include <xrpl/core/StartUpType.h>
+#include <xrpl/rdb/DBInit.h>
+#include <xrpl/rdb/SociDB.h>
 
 #include <boost/filesystem/path.hpp>
 
@@ -68,7 +67,7 @@ public:
     {
         explicit Setup() = default;
 
-        Config::StartUpType startUp = Config::NORMAL;
+        StartUpType startUp = StartUpType::NORMAL;
         bool standAlone = false;
         boost::filesystem::path dataDir;
         // Indicates whether or not to return the `globalPragma`
@@ -105,8 +104,8 @@ public:
         beast::Journal journal)
         // Use temporary files or regular DB files?
         : DatabaseCon(
-              setup.standAlone && setup.startUp != Config::LOAD && setup.startUp != Config::LOAD_FILE &&
-                      setup.startUp != Config::REPLAY
+              setup.standAlone && setup.startUp != StartUpType::LOAD && setup.startUp != StartUpType::LOAD_FILE &&
+                      setup.startUp != StartUpType::REPLAY
                   ? ""
                   : (setup.dataDir / dbName),
               setup.commonPragma(),
@@ -229,7 +228,4 @@ private:
 std::shared_ptr<Checkpointer>
 checkpointerFromId(std::uintptr_t id);
 
-DatabaseCon::Setup
-setup_DatabaseCon(Config const& c, std::optional<beast::Journal> j = std::nullopt);
-
 }  // namespace xrpl

include/xrpl/rdb/RelationalDatabase.h

@@ -0,0 +1,475 @@
+#pragma once
+
+#include <xrpl/basics/RangeSet.h>
+#include <xrpl/beast/utility/instrumentation.h>
+#include <xrpl/core/ServiceRegistry.h>
+#include <xrpl/protocol/ErrorCodes.h>
+#include <xrpl/protocol/LedgerHeader.h>
+#include <xrpl/protocol/LedgerShortcut.h>
+#include <xrpl/protocol/TxMeta.h>
+#include <xrpl/protocol/TxSearched.h>
+#include <xrpl/rdb/DatabaseCon.h>
+
+#include <boost/filesystem.hpp>
+#include <boost/variant.hpp>
+
+namespace xrpl {
+
+class Transaction;
+class Ledger;
+
+struct LedgerHashPair
+{
+    uint256 ledgerHash;
+    uint256 parentHash;
+};
+
+struct LedgerRange
+{
+    uint32_t min;
+    uint32_t max;
+};
+
+class RelationalDatabase
+{
+public:
+    struct CountMinMax
+    {
+        std::size_t numberOfRows;
+        LedgerIndex minLedgerSequence;
+        LedgerIndex maxLedgerSequence;
+    };
+
+    struct AccountTxMarker
+    {
+        std::uint32_t ledgerSeq = 0;
+        std::uint32_t txnSeq = 0;
+    };
+
+    struct AccountTxOptions
+    {
+        AccountID const& account;
+        std::uint32_t minLedger;
+        std::uint32_t maxLedger;
+        std::uint32_t offset;
+        std::uint32_t limit;
+        bool bUnlimited;
+    };
+
+    struct AccountTxPageOptions
+    {
+        AccountID const& account;
+        std::uint32_t minLedger;
+        std::uint32_t maxLedger;
+        std::optional<AccountTxMarker> marker;
+        std::uint32_t limit;
+        bool bAdmin;
+    };
+
+    using AccountTx = std::pair<std::shared_ptr<Transaction>, std::shared_ptr<TxMeta>>;
+    using AccountTxs = std::vector<AccountTx>;
+    using txnMetaLedgerType = std::tuple<Blob, Blob, std::uint32_t>;
+    using MetaTxsList = std::vector<txnMetaLedgerType>;
+
+    using LedgerSequence = uint32_t;
+    using LedgerHash = uint256;
+    using LedgerSpecifier = std::variant<LedgerRange, LedgerShortcut, LedgerSequence, LedgerHash>;
+
+    struct AccountTxArgs
+    {
+        AccountID account;
+        std::optional<LedgerSpecifier> ledger;
+        bool binary = false;
+        bool forward = false;
+        uint32_t limit = 0;
+        std::optional<AccountTxMarker> marker;
+    };
+
+    struct AccountTxResult
+    {
+        std::variant<AccountTxs, MetaTxsList> transactions;
+        LedgerRange ledgerRange;
+        uint32_t limit;
+        std::optional<AccountTxMarker> marker;
+    };
+
+    virtual ~RelationalDatabase() = default;
+
+    /**
+     * @brief getMinLedgerSeq Returns the minimum ledger sequence in the Ledgers
+     *        table.
+     * @return Ledger sequence or no value if no ledgers exist.
+     */
+    virtual std::optional<LedgerIndex>
+    getMinLedgerSeq() = 0;
+
+    /**
+     * @brief getMaxLedgerSeq Returns the maximum ledger sequence in the Ledgers
+     *        table.
+     * @return Ledger sequence or none if no ledgers exist.
+     */
+    virtual std::optional<LedgerIndex>
+    getMaxLedgerSeq() = 0;
+
+    /**
+     * @brief getLedgerInfoByIndex Returns a ledger by its sequence.
+     * @param ledgerSeq Ledger sequence.
+     * @return The ledger if found, otherwise no value.
+     */
+    virtual std::optional<LedgerHeader>
+    getLedgerInfoByIndex(LedgerIndex ledgerSeq) = 0;
+
+    /**
+     * @brief getNewestLedgerInfo Returns the info of the newest saved ledger.
+     * @return Ledger info if found, otherwise no value.
+     */
+    virtual std::optional<LedgerHeader>
+    getNewestLedgerInfo() = 0;
+
+    /**
+     * @brief getLedgerInfoByHash Returns the info of the ledger with given
+     *        hash.
+     * @param ledgerHash Hash of the ledger.
+     * @return Ledger if found, otherwise no value.
+     */
+    virtual std::optional<LedgerHeader>
+    getLedgerInfoByHash(uint256 const& ledgerHash) = 0;
+
+    /**
+     * @brief getHashByIndex Returns the hash of the ledger with the given
+     *        sequence.
+     * @param ledgerIndex Ledger sequence.
+     * @return Hash of the ledger.
+     */
+    virtual uint256
+    getHashByIndex(LedgerIndex ledgerIndex) = 0;
+
+    /**
+     * @brief getHashesByIndex Returns the hashes of the ledger and its parent
+     *        as specified by the ledgerIndex.
+     * @param ledgerIndex Ledger sequence.
+     * @return Struct LedgerHashPair which contains hashes of the ledger and
+     *         its parent.
+     */
+    virtual std::optional<LedgerHashPair>
+    getHashesByIndex(LedgerIndex ledgerIndex) = 0;
+
+    /**
+     * @brief getHashesByIndex Returns hashes of each ledger and its parent for
+     *        all ledgers within the provided range.
+     * @param minSeq Minimum ledger sequence.
+     * @param maxSeq Maximum ledger sequence.
+     * @return Container that maps the sequence number of a found ledger to the
+     *         struct LedgerHashPair which contains the hashes of the ledger and
+     *         its parent.
+     */
+    virtual std::map<LedgerIndex, LedgerHashPair>
+    getHashesByIndex(LedgerIndex minSeq, LedgerIndex maxSeq) = 0;
+
+    /**
+     * @brief getTxHistory Returns the 20 most recent transactions starting from
+     *        the given number.
+     * @param startIndex First number of returned entry.
+     * @return Vector of shared pointers to transactions sorted in
+     *         descending order by ledger sequence.
+     */
+    virtual std::vector<std::shared_ptr<Transaction>>
+    getTxHistory(LedgerIndex startIndex) = 0;
+
+    /**
+     * @brief getTransactionsMinLedgerSeq Returns the minimum ledger sequence
+     *        stored in the Transactions table.
+     * @return Ledger sequence or no value if no ledgers exist.
+     */
+    virtual std::optional<LedgerIndex>
+    getTransactionsMinLedgerSeq() = 0;
+
+    /**
+     * @brief getAccountTransactionsMinLedgerSeq Returns the minimum ledger
+     *        sequence stored in the AccountTransactions table.
+     * @return Ledger sequence or no value if no ledgers exist.
+     */
+    virtual std::optional<LedgerIndex>
+    getAccountTransactionsMinLedgerSeq() = 0;
+
+    /**
+     * @brief deleteTransactionByLedgerSeq Deletes transactions from the ledger
+     *        with the given sequence.
+     * @param ledgerSeq Ledger sequence.
+     */
+    virtual void
+    deleteTransactionByLedgerSeq(LedgerIndex ledgerSeq) = 0;
+
+    /**
+     * @brief deleteBeforeLedgerSeq Deletes all ledgers with a sequence number
+     *        less than or equal to the given ledger sequence.
+     * @param ledgerSeq Ledger sequence.
+     */
+    virtual void
+    deleteBeforeLedgerSeq(LedgerIndex ledgerSeq) = 0;
+
+    /**
+     * @brief deleteTransactionsBeforeLedgerSeq Deletes all transactions with
+     *        a sequence number less than or equal to the given ledger
+     *        sequence.
+     * @param ledgerSeq Ledger sequence.
+     */
+    virtual void
+    deleteTransactionsBeforeLedgerSeq(LedgerIndex ledgerSeq) = 0;
+
+    /**
+     * @brief deleteAccountTransactionsBeforeLedgerSeq Deletes all account
+     *        transactions with a sequence number less than or equal to the
+     *        given ledger sequence.
+     * @param ledgerSeq Ledger sequence.
+     */
+    virtual void
+    deleteAccountTransactionsBeforeLedgerSeq(LedgerIndex ledgerSeq) = 0;
+
+    /**
+     * @brief getTransactionCount Returns the number of transactions.
+     * @return Number of transactions.
+     */
+    virtual std::size_t
+    getTransactionCount() = 0;
+
+    /**
+     * @brief getAccountTransactionCount Returns the number of account
+     *        transactions.
+     * @return Number of account transactions.
+     */
+    virtual std::size_t
+    getAccountTransactionCount() = 0;
+
+    /**
+     * @brief getLedgerCountMinMax Returns the minimum ledger sequence,
+     *        maximum ledger sequence and total number of saved ledgers.
+     * @return Struct CountMinMax which contains the minimum sequence,
+     *         maximum sequence and number of ledgers.
+     */
+    virtual struct CountMinMax
+    getLedgerCountMinMax() = 0;
+
+    /**
+     * @brief saveValidatedLedger Saves a ledger into the database.
+     * @param ledger The ledger.
+     * @param current True if the ledger is current.
+     * @return True if saving was successful.
+     */
+    virtual bool
+    saveValidatedLedger(std::shared_ptr<Ledger const> const& ledger, bool current) = 0;
+
+    /**
+     * @brief getLimitedOldestLedgerInfo Returns the info of the oldest ledger
+     *        whose sequence number is greater than or equal to the given
+     *        sequence number.
+     * @param ledgerFirstIndex Minimum ledger sequence.
+     * @return Ledger info if found, otherwise no value.
+     */
+    virtual std::optional<LedgerHeader>
+    getLimitedOldestLedgerInfo(LedgerIndex ledgerFirstIndex) = 0;
+
+    /**
+     * @brief getLimitedNewestLedgerInfo Returns the info of the newest ledger
+     *        whose sequence number is greater than or equal to the given
+     *        sequence number.
+     * @param ledgerFirstIndex Minimum ledger sequence.
+     * @return Ledger info if found, otherwise no value.
+     */
+    virtual std::optional<LedgerHeader>
+    getLimitedNewestLedgerInfo(LedgerIndex ledgerFirstIndex) = 0;
+
+    /**
+     * @brief getOldestAccountTxs Returns the oldest transactions for the
+     *        account that matches the given criteria starting from the provided
+     *        offset.
+     * @param options Struct AccountTxOptions which contains the criteria to
+     *        match: the account, ledger search range, the offset of the first
+     *        entry to return, the number of transactions to return, a flag if
+     *        this number is unlimited.
+     * @return Vector of pairs of found transactions and their metadata
+     *         sorted in ascending order by account sequence.
+     */
+    virtual AccountTxs
+    getOldestAccountTxs(AccountTxOptions const& options) = 0;
+
+    /**
+     * @brief getNewestAccountTxs Returns the newest transactions for the
+     *        account that matches the given criteria starting from the provided
+     *        offset.
+     * @param options Struct AccountTxOptions which contains the criteria to
+     *        match: the account, the ledger search range, the offset of  the
+     *        first entry to return, the number of transactions to return, a
+     *        flag if this number unlimited.
+     * @return Vector of pairs of found transactions and their metadata
+     *         sorted in descending order by account sequence.
+     */
+    virtual AccountTxs
+    getNewestAccountTxs(AccountTxOptions const& options) = 0;
+
+    /**
+     * @brief getOldestAccountTxsB Returns the oldest transactions in binary
+     *        form for the account that matches the given criteria starting from
+     *        the provided offset.
+     * @param options Struct AccountTxOptions which contains the criteria to
+     *        match: the account, the ledger search range, the offset of the
+     *        first entry to return, the number of transactions to return, a
+     *        flag if this number unlimited.
+     * @return Vector of tuples of found transactions, their metadata and
+     *         account sequences sorted in ascending order by account sequence.
+     */
+    virtual MetaTxsList
+    getOldestAccountTxsB(AccountTxOptions const& options) = 0;
+
+    /**
+     * @brief getNewestAccountTxsB Returns the newest transactions in binary
+     *        form for the account that matches the given criteria starting from
+     *        the provided offset.
+     * @param options Struct AccountTxOptions which contains the criteria to
+     *        match: the account, the ledger search range, the offset of the
+     *        first entry to return, the number of transactions to return, a
+     *        flag if this number is unlimited.
+     * @return Vector of tuples of found transactions, their metadata and
+     *         account sequences sorted in descending order by account
+     *         sequence.
+     */
+    virtual MetaTxsList
+    getNewestAccountTxsB(AccountTxOptions const& options) = 0;
+
+    /**
+     * @brief oldestAccountTxPage Returns the oldest transactions for the
+     *        account that matches the given criteria starting from the
+     *        provided marker.
+     * @param options Struct AccountTxPageOptions which contains the criteria to
+     *        match: the account, the ledger search range, the marker of first
+     *        returned entry, the number of transactions to return, a flag if
+     *        this number is unlimited.
+     * @return Vector of pairs of found transactions and their metadata
+     *         sorted in ascending order by account sequence and a marker
+     *         for the next search if the search was not finished.
+     */
+    virtual std::pair<AccountTxs, std::optional<AccountTxMarker>>
+    oldestAccountTxPage(AccountTxPageOptions const& options) = 0;
+
+    /**
+     * @brief newestAccountTxPage Returns the newest transactions for the
+     *        account that matches the given criteria starting from the provided
+     *        marker.
+     * @param options Struct AccountTxPageOptions which contains the criteria to
+     *        match: the account, the ledger search range, the marker of the
+     *        first returned entry, the number of transactions to return, a flag
+     *        if this number unlimited.
+     * @return Vector of pairs of found transactions and their metadata
+     *         sorted in descending order by account sequence and a marker
+     *         for the next search if the search was not finished.
+     */
+    virtual std::pair<AccountTxs, std::optional<AccountTxMarker>>
+    newestAccountTxPage(AccountTxPageOptions const& options) = 0;
+
+    /**
+     * @brief oldestAccountTxPageB Returns the oldest transactions in binary
+     *        form for the account that matches the given criteria starting from
+     *        the provided marker.
+     * @param options Struct AccountTxPageOptions which contains criteria to
+     *        match: the account, the ledger search range, the marker of the
+     *        first returned entry, the number of transactions to return, a flag
+     *        if this number unlimited.
+     * @return Vector of tuples of found transactions, their metadata and
+     *         account sequences sorted in ascending order by account
+     *         sequence and a marker for the next search if the search was not
+     *         finished.
+     */
+    virtual std::pair<MetaTxsList, std::optional<AccountTxMarker>>
+    oldestAccountTxPageB(AccountTxPageOptions const& options) = 0;
+
+    /**
+     * @brief newestAccountTxPageB Returns the newest transactions in binary
+     *        form for the account that matches the given criteria starting from
+     *        the provided marker.
+     * @param options Struct AccountTxPageOptions which contains the criteria to
+     *        match: the account, the ledger search range, the marker of the
+     *        first returned entry, the number of transactions to return, a flag
+     *        if this number is unlimited.
+     * @return Vector of tuples of found transactions, their metadata and
+     *         account sequences sorted in descending order by account
+     *         sequence and a marker for the next search if the search was not
+     *         finished.
+     */
+    virtual std::pair<MetaTxsList, std::optional<AccountTxMarker>>
+    newestAccountTxPageB(AccountTxPageOptions const& options) = 0;
+
+    /**
+     * @brief getTransaction Returns the transaction with the given hash. If a
+     *        range is provided but the transaction is not found, then check if
+     *        all ledgers in the range are present in the database.
+     * @param id Hash of the transaction.
+     * @param range Range of ledgers to check, if present.
+     * @param ec Default error code value.
+     * @return Transaction and its metadata if found, otherwise TxSearched::all
+     *         if a range is provided and all ledgers from the range are present
+     *         in the database, TxSearched::some if a range is provided and not
+     *         all ledgers are present, TxSearched::unknown if the range is not
+     *         provided or a deserializing error occurred. In the last case the
+     *         error code is returned via the ec parameter, in other cases the
+     *         default error code is not changed.
+     */
+    virtual std::variant<AccountTx, TxSearched>
+    getTransaction(uint256 const& id, std::optional<ClosedInterval<uint32_t>> const& range, error_code_i& ec) = 0;
+
+    /**
+     * @brief getKBUsedAll Returns the amount of space used by all databases.
+     * @return Space in kilobytes.
+     */
+    virtual uint32_t
+    getKBUsedAll() = 0;
+
+    /**
+     * @brief getKBUsedLedger Returns the amount of space space used by the
+     *        ledger database.
+     * @return Space in kilobytes.
+     */
+    virtual uint32_t
+    getKBUsedLedger() = 0;
+
+    /**
+     * @brief getKBUsedTransaction Returns the amount of space used by the
+     *        transaction database.
+     * @return Space in kilobytes.
+     */
+    virtual uint32_t
+    getKBUsedTransaction() = 0;
+
+    /**
+     * @brief Closes the ledger database
+     */
+    virtual void
+    closeLedgerDB() = 0;
+
+    /**
+     * @brief Closes the transaction database
+     */
+    virtual void
+    closeTransactionDB() = 0;
+};
+
+template <class T, class C>
+T
+rangeCheckedCast(C c)
+{
+    if ((c > std::numeric_limits<T>::max()) || (!std::numeric_limits<T>::is_signed && c < 0) ||
+        (std::numeric_limits<T>::is_signed && std::numeric_limits<C>::is_signed &&
+         c < std::numeric_limits<T>::lowest()))
+    {
+        // This should never happen
+        // LCOV_EXCL_START
+        UNREACHABLE("xrpl::rangeCheckedCast : domain error");
+        JLOG(debugLog().error()) << "rangeCheckedCast domain error:"
+                                 << " value = " << c << " min = " << std::numeric_limits<T>::lowest()
+                                 << " max: " << std::numeric_limits<T>::max();
+        // LCOV_EXCL_STOP
+    }
+
+    return static_cast<T>(c);
+}
+
+}  // namespace xrpl

include/xrpl/server/State.h

@@ -1,10 +1,8 @@
 #pragma once
 
-#include <xrpld/app/ledger/Ledger.h>
-#include <xrpld/app/misc/Manifest.h>
-#include <xrpld/core/Config.h>
-#include <xrpld/core/DatabaseCon.h>
-#include <xrpld/peerfinder/detail/Store.h>
+#include <xrpl/protocol/Protocol.h>
+#include <xrpl/rdb/DatabaseCon.h>
+#include <xrpl/server/Manifest.h>
 
 #include <boost/filesystem.hpp>
 

include/xrpl/server/Vacuum.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#include <xrpld/core/DatabaseCon.h>
+#include <xrpl/rdb/DatabaseCon.h>
 
 namespace xrpl {
 

include/xrpl/server/Wallet.h

@@ -1,9 +1,8 @@
 #pragma once
 
-#include <xrpld/app/misc/Manifest.h>
-#include <xrpld/core/Config.h>
-#include <xrpld/core/DatabaseCon.h>
-#include <xrpld/overlay/PeerReservationTable.h>
+#include <xrpl/core/PeerReservationTable.h>
+#include <xrpl/rdb/DatabaseCon.h>
+#include <xrpl/server/Manifest.h>
 
 namespace xrpl {
 

src/libxrpl/nodestore/DatabaseNodeImp.cpp

@@ -29,7 +29,7 @@ DatabaseNodeImp::fetchNodeObject(uint256 const& hash, std::uint32_t, FetchReport
 
     try
     {
-        status = backend_->fetch(hash.data(), &nodeObject);
+        status = backend_->fetch(hash, &nodeObject);
     }
     catch (std::exception const& e)
     {
@@ -62,18 +62,10 @@ DatabaseNodeImp::fetchBatch(std::vector<uint256> const& hashes)
     using namespace std::chrono;
     auto const before = steady_clock::now();
 
-    std::vector<uint256 const*> batch{};
-    batch.reserve(hashes.size());
-    for (size_t i = 0; i < hashes.size(); ++i)
-    {
-        auto const& hash = hashes[i];
-        batch.push_back(&hash);
-    }
-
     // Get the node objects that match the hashes from the backend. To protect
     // against the backends returning fewer or more results than expected, the
     // container is resized to the number of hashes.
-    auto results = backend_->fetchBatch(batch).first;
+    auto results = backend_->fetchBatch(hashes).first;
     XRPL_ASSERT(
         results.size() == hashes.size() || results.empty(),
         "number of output objects either matches number of input hashes or is empty");

src/libxrpl/nodestore/DatabaseRotatingImp.cpp

@@ -101,7 +101,7 @@ DatabaseRotatingImp::fetchNodeObject(uint256 const& hash, std::uint32_t, FetchRe
         std::shared_ptr<NodeObject> nodeObject;
         try
         {
-            status = backend->fetch(hash.data(), &nodeObject);
+            status = backend->fetch(hash, &nodeObject);
         }
         catch (std::exception const& e)
         {

src/libxrpl/nodestore/backend/MemoryFactory.cpp

@@ -115,10 +115,9 @@ public:
     //--------------------------------------------------------------------------
 
     Status
-    fetch(void const* key, std::shared_ptr<NodeObject>* pObject) override
+    fetch(uint256 const& hash, std::shared_ptr<NodeObject>* pObject) override
     {
         XRPL_ASSERT(db_, "xrpl::NodeStore::MemoryBackend::fetch : non-null database");
-        uint256 const hash(uint256::fromVoid(key));
 
         std::lock_guard _(db_->mutex);
 
@@ -133,14 +132,14 @@ public:
     }
 
     std::pair<std::vector<std::shared_ptr<NodeObject>>, Status>
-    fetchBatch(std::vector<uint256 const*> const& hashes) override
+    fetchBatch(std::vector<uint256> const& hashes) override
     {
         std::vector<std::shared_ptr<NodeObject>> results;
         results.reserve(hashes.size());
         for (auto const& h : hashes)
         {
             std::shared_ptr<NodeObject> nObj;
-            Status status = fetch(h->begin(), &nObj);
+            Status status = fetch(h, &nObj);
             if (status != ok)
                 results.push_back({});
             else

src/libxrpl/nodestore/backend/NuDBFactory.cpp

@@ -177,17 +177,17 @@ public:
     }
 
     Status
-    fetch(void const* key, std::shared_ptr<NodeObject>* pno) override
+    fetch(uint256 const& hash, std::shared_ptr<NodeObject>* pno) override
     {
         Status status;
         pno->reset();
         nudb::error_code ec;
         db_.fetch(
-            key,
-            [key, pno, &status](void const* data, std::size_t size) {
+            hash.data(),
+            [hash, pno, &status](void const* data, std::size_t size) {
                 nudb::detail::buffer bf;
                 auto const result = nodeobject_decompress(data, size, bf);
-                DecodedBlob decoded(key, result.first, result.second);
+                DecodedBlob decoded(hash.data(), result.first, result.second);
                 if (!decoded.wasOk())
                 {
                     status = dataCorrupt;
@@ -205,14 +205,14 @@ public:
     }
 
     std::pair<std::vector<std::shared_ptr<NodeObject>>, Status>
-    fetchBatch(std::vector<uint256 const*> const& hashes) override
+    fetchBatch(std::vector<uint256> const& hashes) override
     {
         std::vector<std::shared_ptr<NodeObject>> results;
         results.reserve(hashes.size());
         for (auto const& h : hashes)
         {
             std::shared_ptr<NodeObject> nObj;
-            Status status = fetch(h->begin(), &nObj);
+            Status status = fetch(h, &nObj);
             if (status != ok)
                 results.push_back({});
             else

src/libxrpl/nodestore/backend/NullFactory.cpp

@@ -36,13 +36,13 @@ public:
     }
 
     Status
-    fetch(void const*, std::shared_ptr<NodeObject>*) override
+    fetch(uint256 const&, std::shared_ptr<NodeObject>*) override
     {
         return notFound;
     }
 
     std::pair<std::vector<std::shared_ptr<NodeObject>>, Status>
-    fetchBatch(std::vector<uint256 const*> const& hashes) override
+    fetchBatch(std::vector<uint256> const& hashes) override
     {
         return {};
     }

src/libxrpl/nodestore/backend/RocksDBFactory.cpp

@@ -237,7 +237,7 @@ public:
     //--------------------------------------------------------------------------
 
     Status
-    fetch(void const* key, std::shared_ptr<NodeObject>* pObject) override
+    fetch(uint256 const& hash, std::shared_ptr<NodeObject>* pObject) override
     {
         XRPL_ASSERT(m_db, "xrpl::NodeStore::RocksDBBackend::fetch : non-null database");
         pObject->reset();
@@ -245,7 +245,7 @@ public:
         Status status(ok);
 
         rocksdb::ReadOptions const options;
-        rocksdb::Slice const slice(static_cast<char const*>(key), m_keyBytes);
+        rocksdb::Slice const slice(std::bit_cast<char const*>(hash.data()), m_keyBytes);
 
         std::string string;
 
@@ -253,7 +253,7 @@ public:
 
         if (getStatus.ok())
         {
-            DecodedBlob decoded(key, string.data(), string.size());
+            DecodedBlob decoded(hash.data(), string.data(), string.size());
 
             if (decoded.wasOk())
             {
@@ -288,14 +288,14 @@ public:
     }
 
     std::pair<std::vector<std::shared_ptr<NodeObject>>, Status>
-    fetchBatch(std::vector<uint256 const*> const& hashes) override
+    fetchBatch(std::vector<uint256> const& hashes) override
     {
         std::vector<std::shared_ptr<NodeObject>> results;
         results.reserve(hashes.size());
         for (auto const& h : hashes)
         {
             std::shared_ptr<NodeObject> nObj;
-            Status status = fetch(h->begin(), &nObj);
+            Status status = fetch(h, &nObj);
             if (status != ok)
                 results.push_back({});
             else

src/libxrpl/rdb/DatabaseCon.cpp

@@ -0,0 +1,92 @@
+#include <xrpl/basics/Log.h>
+#include <xrpl/basics/contract.h>
+#include <xrpl/rdb/DatabaseCon.h>
+#include <xrpl/rdb/SociDB.h>
+
+#include <boost/algorithm/string.hpp>
+#include <boost/format.hpp>
+
+#include <memory>
+#include <unordered_map>
+
+namespace xrpl {
+
+class CheckpointersCollection
+{
+    std::uintptr_t nextId_{0};
+    // Mutex protects the CheckpointersCollection
+    std::mutex mutex_;
+    // Each checkpointer is given a unique id. All the checkpointers that are
+    // part of a DatabaseCon are part of this collection. When the DatabaseCon
+    // is destroyed, its checkpointer is removed from the collection
+    std::unordered_map<std::uintptr_t, std::shared_ptr<Checkpointer>> checkpointers_;
+
+public:
+    std::shared_ptr<Checkpointer>
+    fromId(std::uintptr_t id)
+    {
+        std::lock_guard l{mutex_};
+        auto it = checkpointers_.find(id);
+        if (it != checkpointers_.end())
+            return it->second;
+        return {};
+    }
+
+    void
+    erase(std::uintptr_t id)
+    {
+        std::lock_guard lock{mutex_};
+        checkpointers_.erase(id);
+    }
+
+    std::shared_ptr<Checkpointer>
+    create(std::shared_ptr<soci::session> const& session, JobQueue& jobQueue, Logs& logs)
+    {
+        std::lock_guard lock{mutex_};
+        auto const id = nextId_++;
+        auto const r = makeCheckpointer(id, session, jobQueue, logs);
+        checkpointers_[id] = r;
+        return r;
+    }
+};
+
+CheckpointersCollection checkpointers;
+
+std::shared_ptr<Checkpointer>
+checkpointerFromId(std::uintptr_t id)
+{
+    return checkpointers.fromId(id);
+}
+
+DatabaseCon::~DatabaseCon()
+{
+    if (checkpointer_)
+    {
+        checkpointers.erase(checkpointer_->id());
+
+        std::weak_ptr<Checkpointer> wk(checkpointer_);
+        checkpointer_.reset();
+
+        // The references to our Checkpointer held by 'checkpointer_' and
+        // 'checkpointers' have been removed, so if the use count is nonzero, a
+        // checkpoint is currently in progress. Wait for it to end, otherwise
+        // creating a new DatabaseCon to the same database may fail due to the
+        // database being locked by our (now old) Checkpointer.
+        while (wk.use_count())
+        {
+            std::this_thread::sleep_for(std::chrono::milliseconds(100));
+        }
+    }
+}
+
+std::unique_ptr<std::vector<std::string> const> DatabaseCon::Setup::globalPragma;
+
+void
+DatabaseCon::setupCheckpointing(JobQueue* q, Logs& l)
+{
+    if (!q)
+        Throw<std::logic_error>("No JobQueue");
+    checkpointer_ = checkpointers.create(session_, *q, l);
+}
+
+}  // namespace xrpl

src/libxrpl/rdb/SociDB.cpp

@@ -3,12 +3,10 @@
 #pragma clang diagnostic ignored "-Wdeprecated"
 #endif
 
-#include <xrpld/core/Config.h>
-#include <xrpld/core/DatabaseCon.h>
-#include <xrpld/core/SociDB.h>
-
 #include <xrpl/basics/ByteUtilities.h>
 #include <xrpl/basics/contract.h>
+#include <xrpl/rdb/DatabaseCon.h>
+#include <xrpl/rdb/SociDB.h>
 
 #include <boost/filesystem.hpp>
 

src/libxrpl/server/State.cpp

@@ -1,4 +1,4 @@
-#include <xrpld/app/rdb/State.h>
+#include <xrpl/server/State.h>
 
 namespace xrpl {
 

src/libxrpl/server/Vacuum.cpp

@@ -1,7 +1,9 @@
-#include <xrpld/app/rdb/Vacuum.h>
+#include <xrpl/server/Vacuum.h>
 
 #include <boost/format.hpp>
 
+#include <iostream>
+
 namespace xrpl {
 
 bool

src/libxrpl/server/Wallet.cpp

@@ -1,4 +1,5 @@
-#include <xrpld/app/rdb/Wallet.h>
+#include <xrpl/rdb/DBInit.h>
+#include <xrpl/server/Wallet.h>
 
 #include <boost/format.hpp>
 

src/test/app/LedgerLoad_test.cpp

@@ -21,7 +21,7 @@ class LedgerLoad_test : public beast::unit_test::suite
         std::unique_ptr<Config> cfg,
         std::string const& dbPath,
         std::string const& ledger,
-        Config::StartUpType type,
+        StartUpType type,
         std::optional<uint256> trapTxHash)
     {
         cfg->START_LEDGER = ledger;
@@ -105,7 +105,7 @@ class LedgerLoad_test : public beast::unit_test::suite
         // create a new env with the ledger file specified for startup
         Env env(
             *this,
-            envconfig(ledgerConfig, sd.dbPath, sd.ledgerFile, Config::LOAD_FILE, std::nullopt),
+            envconfig(ledgerConfig, sd.dbPath, sd.ledgerFile, StartUpType::LOAD_FILE, std::nullopt),
             nullptr,
             beast::severities::kDisabled);
         auto jrb = env.rpc("ledger", "current", "full")[jss::result];
@@ -123,7 +123,7 @@ class LedgerLoad_test : public beast::unit_test::suite
         except([&] {
             Env env(
                 *this,
-                envconfig(ledgerConfig, sd.dbPath, "", Config::LOAD_FILE, std::nullopt),
+                envconfig(ledgerConfig, sd.dbPath, "", StartUpType::LOAD_FILE, std::nullopt),
                 nullptr,
                 beast::severities::kDisabled);
         });
@@ -132,7 +132,7 @@ class LedgerLoad_test : public beast::unit_test::suite
         except([&] {
             Env env(
                 *this,
-                envconfig(ledgerConfig, sd.dbPath, "badfile.json", Config::LOAD_FILE, std::nullopt),
+                envconfig(ledgerConfig, sd.dbPath, "badfile.json", StartUpType::LOAD_FILE, std::nullopt),
                 nullptr,
                 beast::severities::kDisabled);
         });
@@ -153,7 +153,7 @@ class LedgerLoad_test : public beast::unit_test::suite
         except([&] {
             Env env(
                 *this,
-                envconfig(ledgerConfig, sd.dbPath, ledgerFileCorrupt.string(), Config::LOAD_FILE, std::nullopt),
+                envconfig(ledgerConfig, sd.dbPath, ledgerFileCorrupt.string(), StartUpType::LOAD_FILE, std::nullopt),
                 nullptr,
                 beast::severities::kDisabled);
         });
@@ -170,7 +170,7 @@ class LedgerLoad_test : public beast::unit_test::suite
         boost::erase_all(ledgerHash, "\"");
         Env env(
             *this,
-            envconfig(ledgerConfig, sd.dbPath, ledgerHash, Config::LOAD, std::nullopt),
+            envconfig(ledgerConfig, sd.dbPath, ledgerHash, StartUpType::LOAD, std::nullopt),
             nullptr,
             beast::severities::kDisabled);
         auto jrb = env.rpc("ledger", "current", "full")[jss::result];
@@ -189,7 +189,7 @@ class LedgerLoad_test : public beast::unit_test::suite
         boost::erase_all(ledgerHash, "\"");
         Env env(
             *this,
-            envconfig(ledgerConfig, sd.dbPath, ledgerHash, Config::REPLAY, std::nullopt),
+            envconfig(ledgerConfig, sd.dbPath, ledgerHash, StartUpType::REPLAY, std::nullopt),
             nullptr,
             beast::severities::kDisabled);
         auto const jrb = env.rpc("ledger", "current", "full")[jss::result];
@@ -213,7 +213,7 @@ class LedgerLoad_test : public beast::unit_test::suite
         boost::erase_all(ledgerHash, "\"");
         Env env(
             *this,
-            envconfig(ledgerConfig, sd.dbPath, ledgerHash, Config::REPLAY, sd.trapTxHash),
+            envconfig(ledgerConfig, sd.dbPath, ledgerHash, StartUpType::REPLAY, sd.trapTxHash),
             nullptr,
             beast::severities::kDisabled);
         auto const jrb = env.rpc("ledger", "current", "full")[jss::result];
@@ -241,7 +241,7 @@ class LedgerLoad_test : public beast::unit_test::suite
             // replay when trapTxHash is set to an invalid transaction
             Env env(
                 *this,
-                envconfig(ledgerConfig, sd.dbPath, ledgerHash, Config::REPLAY, ~sd.trapTxHash),
+                envconfig(ledgerConfig, sd.dbPath, ledgerHash, StartUpType::REPLAY, ~sd.trapTxHash),
                 nullptr,
                 beast::severities::kDisabled);
             BEAST_EXPECT(false);
@@ -265,7 +265,7 @@ class LedgerLoad_test : public beast::unit_test::suite
         // create a new env with the ledger "latest" specified for startup
         Env env(
             *this,
-            envconfig(ledgerConfig, sd.dbPath, "latest", Config::LOAD, std::nullopt),
+            envconfig(ledgerConfig, sd.dbPath, "latest", StartUpType::LOAD, std::nullopt),
             nullptr,
             beast::severities::kDisabled);
         auto jrb = env.rpc("ledger", "current", "full")[jss::result];
@@ -281,7 +281,7 @@ class LedgerLoad_test : public beast::unit_test::suite
         // create a new env with specific ledger index at startup
         Env env(
             *this,
-            envconfig(ledgerConfig, sd.dbPath, "43", Config::LOAD, std::nullopt),
+            envconfig(ledgerConfig, sd.dbPath, "43", StartUpType::LOAD, std::nullopt),
             nullptr,
             beast::severities::kDisabled);
         auto jrb = env.rpc("ledger", "current", "full")[jss::result];

src/test/app/Manifest_test.cpp

@@ -1,15 +1,15 @@
 #include <test/jtx.h>
 
-#include <xrpld/app/main/DBInit.h>
-#include <xrpld/app/misc/Manifest.h>
 #include <xrpld/app/misc/ValidatorList.h>
-#include <xrpld/app/rdb/Wallet.h>
 
 #include <xrpl/basics/base64.h>
 #include <xrpl/basics/contract.h>
 #include <xrpl/protocol/STExchange.h>
 #include <xrpl/protocol/SecretKey.h>
 #include <xrpl/protocol/Sign.h>
+#include <xrpl/rdb/DBInit.h>
+#include <xrpl/server/Manifest.h>
+#include <xrpl/server/Wallet.h>
 
 #include <boost/algorithm/string.hpp>
 #include <boost/filesystem.hpp>

src/test/app/SHAMapStore_test.cpp

@@ -91,8 +91,7 @@ class SHAMapStore_test : public beast::unit_test::suite
     void
     ledgerCheck(jtx::Env& env, int const rows, int const first)
     {
-        auto const [actualRows, actualFirst, actualLast] =
-            dynamic_cast<SQLiteDatabase*>(&env.app().getRelationalDatabase())->getLedgerCountMinMax();
+        auto const [actualRows, actualFirst, actualLast] = env.app().getRelationalDatabase().getLedgerCountMinMax();
 
         BEAST_EXPECT(actualRows == rows);
         BEAST_EXPECT(actualFirst == first);
@@ -102,14 +101,13 @@ class SHAMapStore_test : public beast::unit_test::suite
     void
     transactionCheck(jtx::Env& env, int const rows)
     {
-        BEAST_EXPECT(dynamic_cast<SQLiteDatabase*>(&env.app().getRelationalDatabase())->getTransactionCount() == rows);
+        BEAST_EXPECT(env.app().getRelationalDatabase().getTransactionCount() == rows);
     }
 
     void
     accountTransactionCheck(jtx::Env& env, int const rows)
     {
-        BEAST_EXPECT(
-            dynamic_cast<SQLiteDatabase*>(&env.app().getRelationalDatabase())->getAccountTransactionCount() == rows);
+        BEAST_EXPECT(env.app().getRelationalDatabase().getAccountTransactionCount() == rows);
     }
 
     int

src/test/app/ValidatorKeys_test.cpp

@@ -1,12 +1,12 @@
 #include <test/jtx/Env.h>
 
-#include <xrpld/app/misc/Manifest.h>
 #include <xrpld/app/misc/ValidatorKeys.h>
 #include <xrpld/core/Config.h>
 #include <xrpld/core/ConfigSections.h>
 
 #include <xrpl/basics/base64.h>
 #include <xrpl/beast/unit_test.h>
+#include <xrpl/server/Manifest.h>
 
 #include <string>
 

src/test/core/SociDB_test.cpp

@@ -1,9 +1,8 @@
 #include <test/jtx/TestSuite.h>
 
-#include <xrpld/core/SociDB.h>
-
 #include <xrpl/basics/BasicConfig.h>
 #include <xrpl/basics/contract.h>
+#include <xrpl/rdb/SociDB.h>
 
 #include <boost/algorithm/string.hpp>
 #include <boost/filesystem.hpp>

src/test/nodestore/Database_test.cpp

@@ -4,11 +4,10 @@
 #include <test/nodestore/TestBase.h>
 #include <test/unit_test/SuiteJournal.h>
 
-#include <xrpld/core/DatabaseCon.h>
-
 #include <xrpl/beast/utility/temp_dir.h>
 #include <xrpl/nodestore/DummyScheduler.h>
 #include <xrpl/nodestore/Manager.h>
+#include <xrpl/rdb/DatabaseCon.h>
 
 namespace xrpl {
 

src/test/nodestore/TestBase.h

@@ -137,7 +137,7 @@ public:
         {
             std::shared_ptr<NodeObject> object;
 
-            Status const status = backend.fetch(batch[i]->getHash().cbegin(), &object);
+            Status const status = backend.fetch(batch[i]->getHash(), &object);
 
             BEAST_EXPECT(status == ok);
 
@@ -157,7 +157,7 @@ public:
         {
             std::shared_ptr<NodeObject> object;
 
-            Status const status = backend.fetch(batch[i]->getHash().cbegin(), &object);
+            Status const status = backend.fetch(batch[i]->getHash(), &object);
 
             BEAST_EXPECT(status == notFound);
         }

src/test/nodestore/Timing_test.cpp

@@ -313,7 +313,7 @@ public:
                     std::shared_ptr<NodeObject> obj;
                     std::shared_ptr<NodeObject> result;
                     obj = seq1_.obj(dist_(gen_));
-                    backend_.fetch(obj->getHash().data(), &result);
+                    backend_.fetch(obj->getHash(), &result);
                     suite_.expect(result && isSame(result, obj));
                 }
                 catch (std::exception const& e)
@@ -371,9 +371,9 @@ public:
             {
                 try
                 {
-                    auto const key = seq2_.key(i);
+                    auto const hash = seq2_.key(i);
                     std::shared_ptr<NodeObject> result;
-                    backend_.fetch(key.data(), &result);
+                    backend_.fetch(hash, &result);
                     suite_.expect(!result);
                 }
                 catch (std::exception const& e)
@@ -438,9 +438,9 @@ public:
                 {
                     if (rand_(gen_) < missingNodePercent)
                     {
-                        auto const key = seq2_.key(dist_(gen_));
+                        auto const hash = seq2_.key(dist_(gen_));
                         std::shared_ptr<NodeObject> result;
-                        backend_.fetch(key.data(), &result);
+                        backend_.fetch(hash, &result);
                         suite_.expect(!result);
                     }
                     else
@@ -448,7 +448,7 @@ public:
                         std::shared_ptr<NodeObject> obj;
                         std::shared_ptr<NodeObject> result;
                         obj = seq1_.obj(dist_(gen_));
-                        backend_.fetch(obj->getHash().data(), &result);
+                        backend_.fetch(obj->getHash(), &result);
                         suite_.expect(result && isSame(result, obj));
                     }
                 }
@@ -524,8 +524,7 @@ public:
                         std::shared_ptr<NodeObject> result;
                         auto const j = older_(gen_);
                         obj = seq1_.obj(j);
-                        std::shared_ptr<NodeObject> result1;
-                        backend_.fetch(obj->getHash().data(), &result);
+                        backend_.fetch(obj->getHash(), &result);
                         suite_.expect(result != nullptr);
                         suite_.expect(isSame(result, obj));
                     }
@@ -543,7 +542,7 @@ public:
                                 std::shared_ptr<NodeObject> result;
                                 auto const j = recent_(gen_);
                                 obj = seq1_.obj(j);
-                                backend_.fetch(obj->getHash().data(), &result);
+                                backend_.fetch(obj->getHash(), &result);
                                 suite_.expect(!result || isSame(result, obj));
                                 break;
                             }

src/test/rpc/LedgerEntry_test.cpp

@@ -2050,7 +2050,7 @@ class LedgerEntry_test : public beast::unit_test::suite
         Account const bob{"bob"};
 
         Env env{*this, envconfig([](auto cfg) {
-                    cfg->START_UP = Config::FRESH;
+                    cfg->START_UP = StartUpType::FRESH;
                     return cfg;
                 })};
 
@@ -2241,7 +2241,7 @@ class LedgerEntry_test : public beast::unit_test::suite
         Account const bob{"bob"};
 
         Env env{*this, envconfig([](auto cfg) {
-                    cfg->START_UP = Config::FRESH;
+                    cfg->START_UP = StartUpType::FRESH;
                     return cfg;
                 })};
 

src/test/rpc/Transaction_test.cpp

@@ -108,8 +108,7 @@ class Transaction_test : public beast::unit_test::suite
         auto const deletedLedger = (startLegSeq + endLegSeq) / 2;
         {
             // Remove one of the ledgers from the database directly
-            dynamic_cast<SQLiteDatabase*>(&env.app().getRelationalDatabase())
-                ->deleteTransactionByLedgerSeq(deletedLedger);
+            env.app().getRelationalDatabase().deleteTransactionByLedgerSeq(deletedLedger);
         }
 
         for (int deltaEndSeq = 0; deltaEndSeq < 2; ++deltaEndSeq)
@@ -320,8 +319,7 @@ class Transaction_test : public beast::unit_test::suite
         auto const deletedLedger = (startLegSeq + endLegSeq) / 2;
         {
             // Remove one of the ledgers from the database directly
-            dynamic_cast<SQLiteDatabase*>(&env.app().getRelationalDatabase())
-                ->deleteTransactionByLedgerSeq(deletedLedger);
+            env.app().getRelationalDatabase().deleteTransactionByLedgerSeq(deletedLedger);
         }
 
         for (int deltaEndSeq = 0; deltaEndSeq < 2; ++deltaEndSeq)

src/xrpld/app/ledger/Ledger.cpp

@@ -4,10 +4,8 @@
 #include <xrpld/app/ledger/PendingSaves.h>
 #include <xrpld/app/main/Application.h>
 #include <xrpld/app/misc/HashRouter.h>
-#include <xrpld/app/rdb/backend/SQLiteDatabase.h>
 #include <xrpld/consensus/LedgerTiming.h>
 #include <xrpld/core/Config.h>
-#include <xrpld/core/SociDB.h>
 
 #include <xrpl/basics/Log.h>
 #include <xrpl/basics/contract.h>
@@ -23,6 +21,7 @@
 #include <xrpl/protocol/SecretKey.h>
 #include <xrpl/protocol/digest.h>
 #include <xrpl/protocol/jss.h>
+#include <xrpl/rdb/RelationalDatabase.h>
 
 #include <utility>
 #include <vector>
@@ -905,11 +904,9 @@ saveValidatedLedger(Application& app, std::shared_ptr<Ledger const> const& ledge
         return true;
     }
 
-    auto const db = dynamic_cast<SQLiteDatabase*>(&app.getRelationalDatabase());
-    if (!db)
-        Throw<std::runtime_error>("Failed to get relational database");
+    auto& db = app.getRelationalDatabase();
 
-    auto const res = db->saveValidatedLedger(ledger, current);
+    auto const res = db.saveValidatedLedger(ledger, current);
 
     // Clients can now trust the database for
     // information about this ledger sequence.

src/xrpld/app/ledger/detail/LedgerMaster.cpp

@@ -14,7 +14,6 @@
 #include <xrpld/app/misc/TxQ.h>
 #include <xrpld/app/misc/ValidatorList.h>
 #include <xrpld/app/paths/PathRequests.h>
-#include <xrpld/app/rdb/RelationalDatabase.h>
 #include <xrpld/core/TimeKeeper.h>
 #include <xrpld/overlay/Overlay.h>
 #include <xrpld/overlay/Peer.h>
@@ -29,6 +28,7 @@
 #include <xrpl/protocol/BuildInfo.h>
 #include <xrpl/protocol/HashPrefix.h>
 #include <xrpl/protocol/digest.h>
+#include <xrpl/rdb/RelationalDatabase.h>
 #include <xrpl/resource/Fees.h>
 
 #include <algorithm>

src/xrpld/app/main/Application.cpp

@@ -11,7 +11,6 @@
 #include <xrpld/app/ledger/TransactionMaster.h>
 #include <xrpld/app/main/Application.h>
 #include <xrpld/app/main/BasicApp.h>
-#include <xrpld/app/main/DBInit.h>
 #include <xrpld/app/main/GRPCServer.h>
 #include <xrpld/app/main/LoadManager.h>
 #include <xrpld/app/main/NodeIdentity.h>
@@ -25,12 +24,9 @@
 #include <xrpld/app/misc/ValidatorKeys.h>
 #include <xrpld/app/misc/ValidatorSite.h>
 #include <xrpld/app/paths/PathRequests.h>
-#include <xrpld/app/rdb/RelationalDatabase.h>
-#include <xrpld/app/rdb/Wallet.h>
+#include <xrpld/app/rdb/backend/SQLiteDatabase.h>
 #include <xrpld/app/tx/apply.h>
-#include <xrpld/core/DatabaseCon.h>
 #include <xrpld/overlay/Cluster.h>
-#include <xrpld/overlay/PeerReservationTable.h>
 #include <xrpld/overlay/PeerSet.h>
 #include <xrpld/overlay/make_Overlay.h>
 #include <xrpld/shamap/NodeFamily.h>
@@ -40,6 +36,7 @@
 #include <xrpl/basics/random.h>
 #include <xrpl/beast/asio/io_latency_probe.h>
 #include <xrpl/beast/core/LexicalCast.h>
+#include <xrpl/core/PeerReservationTable.h>
 #include <xrpl/core/PerfLog.h>
 #include <xrpl/crypto/csprng.h>
 #include <xrpl/json/json_reader.h>
@@ -49,7 +46,9 @@
 #include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/Protocol.h>
 #include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/rdb/DatabaseCon.h>
 #include <xrpl/resource/Fees.h>
+#include <xrpl/server/Wallet.h>
 
 #include <boost/algorithm/string/predicate.hpp>
 #include <boost/asio/steady_timer.hpp>
@@ -192,7 +191,7 @@ public:
     boost::asio::steady_timer sweepTimer_;
     boost::asio::steady_timer entropyTimer_;
 
-    std::unique_ptr<RelationalDatabase> mRelationalDatabase;
+    std::optional<SQLiteDatabase> relationalDatabase_;
     std::unique_ptr<DatabaseCon> mWalletDB;
     std::unique_ptr<Overlay> overlay_;
     std::optional<uint256> trapTxID_;
@@ -731,10 +730,10 @@ public:
     getRelationalDatabase() override
     {
         XRPL_ASSERT(
-            mRelationalDatabase,
+            relationalDatabase_,
             "xrpl::ApplicationImp::getRelationalDatabase : non-null "
             "relational database");
-        return *mRelationalDatabase;
+        return *relationalDatabase_;
     }
 
     DatabaseCon&
@@ -762,7 +761,7 @@ public:
 
         try
         {
-            mRelationalDatabase = RelationalDatabase::init(*this, *config_, *m_jobQueue);
+            relationalDatabase_.emplace(setup_RelationalDatabase(*this, *config_, *m_jobQueue));
 
             // wallet database
             auto setup = setup_DatabaseCon(*config_, m_journal);
@@ -873,7 +872,8 @@ public:
     void
     doSweep()
     {
-        if (!config_->standalone() && !getRelationalDatabase().transactionDbHasSpace(*config_))
+        XRPL_ASSERT(relationalDatabase_, "xrpl::ApplicationImp::doSweep : non-null relational database");
+        if (!config_->standalone() && !relationalDatabase_->transactionDbHasSpace(*config_))
         {
             signalStop("Out of transaction DB space");
         }
@@ -1021,6 +1021,12 @@ private:
 
     void
     setMaxDisallowedLedger();
+
+    Application&
+    app() override
+    {
+        return *this;
+    }
 };
 
 //------------------------------------------------------------------------------
@@ -1116,18 +1122,21 @@ ApplicationImp::setup(boost::program_options::variables_map const& cmdline)
 
     auto const startUp = config_->START_UP;
     JLOG(m_journal.debug()) << "startUp: " << startUp;
-    if (startUp == Config::FRESH)
+    if (startUp == StartUpType::FRESH)
     {
         JLOG(m_journal.info()) << "Starting new Ledger";
 
         startGenesisLedger();
     }
-    else if (startUp == Config::LOAD || startUp == Config::LOAD_FILE || startUp == Config::REPLAY)
+    else if (startUp == StartUpType::LOAD || startUp == StartUpType::LOAD_FILE || startUp == StartUpType::REPLAY)
     {
         JLOG(m_journal.info()) << "Loading specified Ledger";
 
         if (!loadOldLedger(
-                config_->START_LEDGER, startUp == Config::REPLAY, startUp == Config::LOAD_FILE, config_->TRAP_TX_HASH))
+                config_->START_LEDGER,
+                startUp == StartUpType::REPLAY,
+                startUp == StartUpType::LOAD_FILE,
+                config_->TRAP_TX_HASH))
         {
             JLOG(m_journal.error()) << "The specified ledger could not be loaded.";
             if (config_->FAST_LOAD)
@@ -1142,7 +1151,7 @@ ApplicationImp::setup(boost::program_options::variables_map const& cmdline)
             }
         }
     }
-    else if (startUp == Config::NETWORK)
+    else if (startUp == StartUpType::NETWORK)
     {
         // This should probably become the default once we have a stable
         // network.
@@ -1529,7 +1538,7 @@ void
 ApplicationImp::startGenesisLedger()
 {
     std::vector<uint256> const initialAmendments =
-        (config_->START_UP == Config::FRESH) ? m_amendmentTable->getDesired() : std::vector<uint256>{};
+        (config_->START_UP == StartUpType::FRESH) ? m_amendmentTable->getDesired() : std::vector<uint256>{};
 
     std::shared_ptr<Ledger> const genesis =
         std::make_shared<Ledger>(create_genesis, *config_, initialAmendments, nodeFamily_);

src/xrpld/app/main/Application.h

@@ -1,10 +1,10 @@
 #pragma once
 
 #include <xrpld/core/Config.h>
-#include <xrpld/overlay/PeerReservationTable.h>
 
 #include <xrpl/basics/TaggedCache.h>
 #include <xrpl/beast/utility/PropertyStream.h>
+#include <xrpl/core/PeerReservationTable.h>
 #include <xrpl/core/ServiceRegistry.h>
 #include <xrpl/protocol/Protocol.h>
 #include <xrpl/shamap/TreeNodeCache.h>
@@ -112,8 +112,6 @@ public:
 public:
     Application();
 
-    virtual ~Application() = default;
-
     virtual bool
     setup(boost::program_options::variables_map const& options) = 0;
 
@@ -127,8 +125,6 @@ public:
     checkSigs() const = 0;
     virtual void
     checkSigs(bool) = 0;
-    virtual bool
-    isStopping() const = 0;
 
     //
     // ---
@@ -138,14 +134,9 @@ public:
     virtual std::uint64_t
     instanceID() const = 0;
 
-    virtual Logs&
-    logs() = 0;
     virtual Config&
     config() = 0;
 
-    virtual boost::asio::io_context&
-    getIOContext() = 0;
-
     virtual std::pair<PublicKey, SecretKey> const&
     nodeIdentity() = 0;
 
@@ -158,9 +149,6 @@ public:
     virtual bool
     serverOkay(std::string& reason) = 0;
 
-    virtual beast::Journal
-    journal(std::string const& name) = 0;
-
     /* Returns the number of file descriptors the application needs */
     virtual int
     fdRequired() const = 0;

src/xrpld/app/main/Main.cpp

@@ -1,5 +1,4 @@
 #include <xrpld/app/main/Application.h>
-#include <xrpld/app/rdb/Vacuum.h>
 #include <xrpld/core/Config.h>
 #include <xrpld/core/ConfigSections.h>
 #include <xrpld/core/TimeKeeper.h>
@@ -8,6 +7,7 @@
 #include <xrpl/basics/Log.h>
 #include <xrpl/beast/core/CurrentThreadName.h>
 #include <xrpl/protocol/BuildInfo.h>
+#include <xrpl/server/Vacuum.h>
 
 #include <boost/asio/io_context.hpp>
 #include <boost/process/v1/args.hpp>
@@ -601,7 +601,7 @@ run(int argc, char** argv)
 
     if (vm.count("start"))
     {
-        config->START_UP = Config::FRESH;
+        config->START_UP = StartUpType::FRESH;
     }
 
     if (vm.count("import"))
@@ -612,7 +612,7 @@ run(int argc, char** argv)
         config->START_LEDGER = vm["ledger"].as<std::string>();
         if (vm.count("replay"))
         {
-            config->START_UP = Config::REPLAY;
+            config->START_UP = StartUpType::REPLAY;
             if (vm.count("trap_tx_hash"))
             {
                 uint256 tmp = {};
@@ -631,16 +631,16 @@ run(int argc, char** argv)
             }
         }
         else
-            config->START_UP = Config::LOAD;
+            config->START_UP = StartUpType::LOAD;
     }
     else if (vm.count("ledgerfile"))
     {
         config->START_LEDGER = vm["ledgerfile"].as<std::string>();
-        config->START_UP = Config::LOAD_FILE;
+        config->START_UP = StartUpType::LOAD_FILE;
     }
     else if (vm.count("load") || config->FAST_LOAD)
     {
-        config->START_UP = Config::LOAD;
+        config->START_UP = StartUpType::LOAD;
     }
 
     if (vm.count("trap_tx_hash") && vm.count("replay") == 0)
@@ -651,13 +651,13 @@ run(int argc, char** argv)
 
     if (vm.count("net") && !config->FAST_LOAD)
     {
-        if ((config->START_UP == Config::LOAD) || (config->START_UP == Config::REPLAY))
+        if ((config->START_UP == StartUpType::LOAD) || (config->START_UP == StartUpType::REPLAY))
         {
             std::cerr << "Net and load/replay options are incompatible" << std::endl;
             return -1;
         }
 
-        config->START_UP = Config::NETWORK;
+        config->START_UP = StartUpType::NETWORK;
     }
 
     if (vm.count("valid"))

src/xrpld/app/main/NodeIdentity.cpp

@@ -1,9 +1,10 @@
 #include <xrpld/app/main/Application.h>
 #include <xrpld/app/main/NodeIdentity.h>
-#include <xrpld/app/rdb/Wallet.h>
 #include <xrpld/core/Config.h>
 #include <xrpld/core/ConfigSections.h>
 
+#include <xrpl/server/Wallet.h>
+
 namespace xrpl {
 
 std::pair<PublicKey, SecretKey>

src/xrpld/app/misc/SHAMapStoreImp.cpp

@@ -1,13 +1,13 @@
 #include <xrpld/app/ledger/TransactionMaster.h>
 #include <xrpld/app/misc/NetworkOPs.h>
 #include <xrpld/app/misc/SHAMapStoreImp.h>
-#include <xrpld/app/rdb/State.h>
 #include <xrpld/app/rdb/backend/SQLiteDatabase.h>
 #include <xrpld/core/ConfigSections.h>
 
 #include <xrpl/beast/core/CurrentThreadName.h>
 #include <xrpl/nodestore/Scheduler.h>
 #include <xrpl/nodestore/detail/DatabaseRotatingImp.h>
+#include <xrpl/server/State.h>
 #include <xrpl/shamap/SHAMapMissingNode.h>
 
 #include <boost/algorithm/string/predicate.hpp>
@@ -507,16 +507,13 @@ SHAMapStoreImp::clearPrior(LedgerIndex lastRotated)
     if (healthWait() == stopping)
         return;
 
-    SQLiteDatabase* const db = dynamic_cast<SQLiteDatabase*>(&app_.getRelationalDatabase());
-
-    if (!db)
-        Throw<std::runtime_error>("Failed to get relational database");
+    auto& db = app_.getRelationalDatabase();
 
     clearSql(
         lastRotated,
         "Ledgers",
-        [db]() -> std::optional<LedgerIndex> { return db->getMinLedgerSeq(); },
-        [db](LedgerIndex min) -> void { db->deleteBeforeLedgerSeq(min); });
+        [&db]() -> std::optional<LedgerIndex> { return db.getMinLedgerSeq(); },
+        [&db](LedgerIndex min) -> void { db.deleteBeforeLedgerSeq(min); });
     if (healthWait() == stopping)
         return;
 
@@ -526,16 +523,16 @@ SHAMapStoreImp::clearPrior(LedgerIndex lastRotated)
     clearSql(
         lastRotated,
         "Transactions",
-        [&db]() -> std::optional<LedgerIndex> { return db->getTransactionsMinLedgerSeq(); },
-        [&db](LedgerIndex min) -> void { db->deleteTransactionsBeforeLedgerSeq(min); });
+        [&db]() -> std::optional<LedgerIndex> { return db.getTransactionsMinLedgerSeq(); },
+        [&db](LedgerIndex min) -> void { db.deleteTransactionsBeforeLedgerSeq(min); });
     if (healthWait() == stopping)
         return;
 
     clearSql(
         lastRotated,
         "AccountTransactions",
-        [&db]() -> std::optional<LedgerIndex> { return db->getAccountTransactionsMinLedgerSeq(); },
-        [&db](LedgerIndex min) -> void { db->deleteAccountTransactionsBeforeLedgerSeq(min); });
+        [&db]() -> std::optional<LedgerIndex> { return db.getAccountTransactionsMinLedgerSeq(); },
+        [&db](LedgerIndex min) -> void { db.deleteAccountTransactionsBeforeLedgerSeq(min); });
     if (healthWait() == stopping)
         return;
 }

src/xrpld/app/misc/SHAMapStoreImp.h

@@ -2,11 +2,11 @@
 
 #include <xrpld/app/ledger/LedgerMaster.h>
 #include <xrpld/app/misc/SHAMapStore.h>
-#include <xrpld/app/rdb/State.h>
-#include <xrpld/core/DatabaseCon.h>
 
 #include <xrpl/nodestore/DatabaseRotating.h>
 #include <xrpl/nodestore/Scheduler.h>
+#include <xrpl/rdb/DatabaseCon.h>
+#include <xrpl/server/State.h>
 
 #include <atomic>
 #include <chrono>

src/xrpld/app/misc/Transaction.h

@@ -8,6 +8,7 @@
 #include <xrpl/protocol/STTx.h>
 #include <xrpl/protocol/TER.h>
 #include <xrpl/protocol/TxMeta.h>
+#include <xrpl/protocol/TxSearched.h>
 
 #include <optional>
 #include <variant>
@@ -35,8 +36,6 @@ enum TransStatus {
     INCOMPLETE = 8   // needs more signatures
 };
 
-enum class TxSearched { all, some, unknown };
-
 // This class is for constructing and examining transactions.
 // Transactions are static so manipulation functions are unnecessary.
 class Transaction : public std::enable_shared_from_this<Transaction>, public CountedObject<Transaction>

src/xrpld/app/misc/ValidatorList.h

@@ -1,6 +1,5 @@
 #pragma once
 
-#include <xrpld/app/misc/Manifest.h>
 #include <xrpld/core/TimeKeeper.h>
 #include <xrpld/overlay/Message.h>
 
@@ -9,6 +8,7 @@
 #include <xrpl/crypto/csprng.h>
 #include <xrpl/json/json_value.h>
 #include <xrpl/protocol/PublicKey.h>
+#include <xrpl/server/Manifest.h>
 
 #include <boost/thread/shared_mutex.hpp>
 

src/xrpld/app/misc/detail/AccountTxPaging.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#include <xrpld/app/rdb/RelationalDatabase.h>
+#include <xrpl/rdb/RelationalDatabase.h>
 
 #include <cstdint>
 

src/xrpld/app/misc/detail/AmendmentTable.cpp

@@ -1,12 +1,12 @@
 #include <xrpld/app/main/Application.h>
 #include <xrpld/app/misc/AmendmentTable.h>
-#include <xrpld/app/rdb/Wallet.h>
 #include <xrpld/core/ConfigSections.h>
 
 #include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/STValidation.h>
 #include <xrpl/protocol/TxFlags.h>
 #include <xrpl/protocol/jss.h>
+#include <xrpl/server/Wallet.h>
 
 #include <boost/algorithm/string.hpp>
 #include <boost/format.hpp>

src/xrpld/app/misc/detail/Manifest.cpp

@@ -1,13 +1,12 @@
-#include <xrpld/app/misc/Manifest.h>
-#include <xrpld/app/rdb/Wallet.h>
-#include <xrpld/core/DatabaseCon.h>
-
 #include <xrpl/basics/Log.h>
 #include <xrpl/basics/StringUtilities.h>
 #include <xrpl/basics/base64.h>
 #include <xrpl/json/json_reader.h>
 #include <xrpl/protocol/PublicKey.h>
 #include <xrpl/protocol/Sign.h>
+#include <xrpl/rdb/DatabaseCon.h>
+#include <xrpl/server/Manifest.h>
+#include <xrpl/server/Wallet.h>
 
 #include <boost/algorithm/string/trim.hpp>
 

src/xrpld/app/misc/detail/Transaction.cpp

@@ -2,13 +2,13 @@
 #include <xrpld/app/main/Application.h>
 #include <xrpld/app/misc/HashRouter.h>
 #include <xrpld/app/misc/Transaction.h>
-#include <xrpld/app/rdb/backend/SQLiteDatabase.h>
 #include <xrpld/app/tx/apply.h>
 #include <xrpld/rpc/CTID.h>
 
 #include <xrpl/basics/safe_cast.h>
 #include <xrpl/protocol/ErrorCodes.h>
 #include <xrpl/protocol/jss.h>
+#include <xrpl/rdb/RelationalDatabase.h>
 
 namespace xrpl {
 
@@ -113,14 +113,9 @@ Transaction::load(
     std::optional<ClosedInterval<uint32_t>> const& range,
     error_code_i& ec)
 {
-    auto const db = dynamic_cast<SQLiteDatabase*>(&app.getRelationalDatabase());
+    auto& db = app.getRelationalDatabase();
 
-    if (!db)
-    {
-        Throw<std::runtime_error>("Failed to get relational database");
-    }
-
-    return db->getTransaction(id, range, ec);
+    return db.getTransaction(id, range, ec);
 }
 
 // options 1 to include the date of the transaction

src/xrpld/app/misc/detail/ValidatorKeys.cpp

@@ -1,10 +1,10 @@
-#include <xrpld/app/misc/Manifest.h>
 #include <xrpld/app/misc/ValidatorKeys.h>
 #include <xrpld/core/Config.h>
 #include <xrpld/core/ConfigSections.h>
 
 #include <xrpl/basics/Log.h>
 #include <xrpl/basics/base64.h>
+#include <xrpl/server/Manifest.h>
 
 namespace xrpl {
 ValidatorKeys::ValidatorKeys(Config const& config, beast::Journal j)

src/xrpld/app/rdb/PeerFinder.h

@@ -1,9 +1,10 @@
 #pragma once
 
 #include <xrpld/core/Config.h>
-#include <xrpld/core/DatabaseCon.h>
 #include <xrpld/peerfinder/detail/Store.h>
 
+#include <xrpl/rdb/DatabaseCon.h>
+
 namespace xrpl {
 
 /**

src/xrpld/app/rdb/RelationalDatabase.h

@@ -1,226 +0,0 @@
-#pragma once
-
-#include <xrpld/app/ledger/Ledger.h>
-#include <xrpld/app/main/Application.h>
-#include <xrpld/app/misc/Transaction.h>
-#include <xrpld/core/Config.h>
-#include <xrpld/core/DatabaseCon.h>
-#include <xrpld/rpc/detail/RPCLedgerHelpers.h>
-
-#include <xrpl/beast/utility/instrumentation.h>
-
-#include <boost/filesystem.hpp>
-#include <boost/variant.hpp>
-
-namespace xrpl {
-
-struct LedgerHashPair
-{
-    uint256 ledgerHash;
-    uint256 parentHash;
-};
-
-struct LedgerRange
-{
-    uint32_t min;
-    uint32_t max;
-};
-
-class RelationalDatabase
-{
-public:
-    struct CountMinMax
-    {
-        std::size_t numberOfRows;
-        LedgerIndex minLedgerSequence;
-        LedgerIndex maxLedgerSequence;
-    };
-
-    struct AccountTxMarker
-    {
-        std::uint32_t ledgerSeq = 0;
-        std::uint32_t txnSeq = 0;
-    };
-
-    struct AccountTxOptions
-    {
-        AccountID const& account;
-        std::uint32_t minLedger;
-        std::uint32_t maxLedger;
-        std::uint32_t offset;
-        std::uint32_t limit;
-        bool bUnlimited;
-    };
-
-    struct AccountTxPageOptions
-    {
-        AccountID const& account;
-        std::uint32_t minLedger;
-        std::uint32_t maxLedger;
-        std::optional<AccountTxMarker> marker;
-        std::uint32_t limit;
-        bool bAdmin;
-    };
-
-    using AccountTx = std::pair<std::shared_ptr<Transaction>, std::shared_ptr<TxMeta>>;
-    using AccountTxs = std::vector<AccountTx>;
-    using txnMetaLedgerType = std::tuple<Blob, Blob, std::uint32_t>;
-    using MetaTxsList = std::vector<txnMetaLedgerType>;
-
-    using LedgerSequence = uint32_t;
-    using LedgerHash = uint256;
-    using LedgerShortcut = RPC::LedgerShortcut;
-    using LedgerSpecifier = std::variant<LedgerRange, LedgerShortcut, LedgerSequence, LedgerHash>;
-
-    struct AccountTxArgs
-    {
-        AccountID account;
-        std::optional<LedgerSpecifier> ledger;
-        bool binary = false;
-        bool forward = false;
-        uint32_t limit = 0;
-        std::optional<AccountTxMarker> marker;
-    };
-
-    struct AccountTxResult
-    {
-        std::variant<AccountTxs, MetaTxsList> transactions;
-        LedgerRange ledgerRange;
-        uint32_t limit;
-        std::optional<AccountTxMarker> marker;
-    };
-
-    /**
-     * @brief init Creates and returns an appropriate RelationalDatabase
-     *        instance based on configuration.
-     * @param app Application object.
-     * @param config Config object.
-     * @param jobQueue JobQueue object.
-     * @return Unique pointer to the interface.
-     */
-    static std::unique_ptr<RelationalDatabase>
-    init(Application& app, Config const& config, JobQueue& jobQueue);
-
-    virtual ~RelationalDatabase() = default;
-
-    /**
-     * @brief getMinLedgerSeq Returns the minimum ledger sequence in the Ledgers
-     *        table.
-     * @return Ledger sequence or no value if no ledgers exist.
-     */
-    virtual std::optional<LedgerIndex>
-    getMinLedgerSeq() = 0;
-
-    /**
-     * @brief getMaxLedgerSeq Returns the maximum ledger sequence in the Ledgers
-     *        table.
-     * @return Ledger sequence or none if no ledgers exist.
-     */
-    virtual std::optional<LedgerIndex>
-    getMaxLedgerSeq() = 0;
-
-    /**
-     * @brief getLedgerInfoByIndex Returns a ledger by its sequence.
-     * @param ledgerSeq Ledger sequence.
-     * @return The ledger if found, otherwise no value.
-     */
-    virtual std::optional<LedgerHeader>
-    getLedgerInfoByIndex(LedgerIndex ledgerSeq) = 0;
-
-    /**
-     * @brief getNewestLedgerInfo Returns the info of the newest saved ledger.
-     * @return Ledger info if found, otherwise no value.
-     */
-    virtual std::optional<LedgerHeader>
-    getNewestLedgerInfo() = 0;
-
-    /**
-     * @brief getLedgerInfoByHash Returns the info of the ledger with given
-     *        hash.
-     * @param ledgerHash Hash of the ledger.
-     * @return Ledger if found, otherwise no value.
-     */
-    virtual std::optional<LedgerHeader>
-    getLedgerInfoByHash(uint256 const& ledgerHash) = 0;
-
-    /**
-     * @brief getHashByIndex Returns the hash of the ledger with the given
-     *        sequence.
-     * @param ledgerIndex Ledger sequence.
-     * @return Hash of the ledger.
-     */
-    virtual uint256
-    getHashByIndex(LedgerIndex ledgerIndex) = 0;
-
-    /**
-     * @brief getHashesByIndex Returns the hashes of the ledger and its parent
-     *        as specified by the ledgerIndex.
-     * @param ledgerIndex Ledger sequence.
-     * @return Struct LedgerHashPair which contains hashes of the ledger and
-     *         its parent.
-     */
-    virtual std::optional<LedgerHashPair>
-    getHashesByIndex(LedgerIndex ledgerIndex) = 0;
-
-    /**
-     * @brief getHashesByIndex Returns hashes of each ledger and its parent for
-     *        all ledgers within the provided range.
-     * @param minSeq Minimum ledger sequence.
-     * @param maxSeq Maximum ledger sequence.
-     * @return Container that maps the sequence number of a found ledger to the
-     *         struct LedgerHashPair which contains the hashes of the ledger and
-     *         its parent.
-     */
-    virtual std::map<LedgerIndex, LedgerHashPair>
-    getHashesByIndex(LedgerIndex minSeq, LedgerIndex maxSeq) = 0;
-
-    /**
-     * @brief getTxHistory Returns the 20 most recent transactions starting from
-     *        the given number.
-     * @param startIndex First number of returned entry.
-     * @return Vector of shared pointers to transactions sorted in
-     *         descending order by ledger sequence.
-     */
-    virtual std::vector<std::shared_ptr<Transaction>>
-    getTxHistory(LedgerIndex startIndex) = 0;
-
-    /**
-     * @brief ledgerDbHasSpace Checks if the ledger database has available
-     *        space.
-     * @param config Config object.
-     * @return True if space is available.
-     */
-    virtual bool
-    ledgerDbHasSpace(Config const& config) = 0;
-
-    /**
-     * @brief transactionDbHasSpace Checks if the transaction database has
-     *        available space.
-     * @param config Config object.
-     * @return True if space is available.
-     */
-    virtual bool
-    transactionDbHasSpace(Config const& config) = 0;
-};
-
-template <class T, class C>
-T
-rangeCheckedCast(C c)
-{
-    if ((c > std::numeric_limits<T>::max()) || (!std::numeric_limits<T>::is_signed && c < 0) ||
-        (std::numeric_limits<T>::is_signed && std::numeric_limits<C>::is_signed &&
-         c < std::numeric_limits<T>::lowest()))
-    {
-        // This should never happen
-        // LCOV_EXCL_START
-        UNREACHABLE("xrpl::rangeCheckedCast : domain error");
-        JLOG(debugLog().error()) << "rangeCheckedCast domain error:"
-                                 << " value = " << c << " min = " << std::numeric_limits<T>::lowest()
-                                 << " max: " << std::numeric_limits<T>::max();
-        // LCOV_EXCL_STOP
-    }
-
-    return static_cast<T>(c);
-}
-
-}  // namespace xrpl

src/xrpld/app/rdb/backend/SQLiteDatabase.h

@@ -1,43 +1,130 @@
 #pragma once
 
-#include <xrpld/app/rdb/RelationalDatabase.h>
+#include <xrpl/rdb/RelationalDatabase.h>
+
+#include <memory>
 
 namespace xrpl {
 
-class SQLiteDatabase : public RelationalDatabase
+class Config;
+class JobQueue;
+class ServiceRegistry;
+
+class SQLiteDatabase final : public RelationalDatabase
 {
 public:
+    /**
+     * @brief getMinLedgerSeq Returns the minimum ledger sequence in the Ledgers
+     *        table.
+     * @return Ledger sequence or no value if no ledgers exist.
+     */
+    std::optional<LedgerIndex>
+    getMinLedgerSeq() override;
+
+    /**
+     * @brief getMaxLedgerSeq Returns the maximum ledger sequence in the Ledgers
+     *        table.
+     * @return Ledger sequence or none if no ledgers exist.
+     */
+    std::optional<LedgerIndex>
+    getMaxLedgerSeq() override;
+
+    /**
+     * @brief getLedgerInfoByIndex Returns a ledger by its sequence.
+     * @param ledgerSeq Ledger sequence.
+     * @return The ledger if found, otherwise no value.
+     */
+    std::optional<LedgerHeader>
+    getLedgerInfoByIndex(LedgerIndex ledgerSeq) override;
+
+    /**
+     * @brief getNewestLedgerInfo Returns the info of the newest saved ledger.
+     * @return Ledger info if found, otherwise no value.
+     */
+    std::optional<LedgerHeader>
+    getNewestLedgerInfo() override;
+
+    /**
+     * @brief getLedgerInfoByHash Returns the info of the ledger with given
+     *        hash.
+     * @param ledgerHash Hash of the ledger.
+     * @return Ledger if found, otherwise no value.
+     */
+    std::optional<LedgerHeader>
+    getLedgerInfoByHash(uint256 const& ledgerHash) override;
+
+    /**
+     * @brief getHashByIndex Returns the hash of the ledger with the given
+     *        sequence.
+     * @param ledgerIndex Ledger sequence.
+     * @return Hash of the ledger.
+     */
+    uint256
+    getHashByIndex(LedgerIndex ledgerIndex) override;
+
+    /**
+     * @brief getHashesByIndex Returns the hashes of the ledger and its parent
+     *        as specified by the ledgerIndex.
+     * @param ledgerIndex Ledger sequence.
+     * @return Struct LedgerHashPair which contains hashes of the ledger and
+     *         its parent.
+     */
+    std::optional<LedgerHashPair>
+    getHashesByIndex(LedgerIndex ledgerIndex) override;
+
+    /**
+     * @brief getHashesByIndex Returns hashes of each ledger and its parent for
+     *        all ledgers within the provided range.
+     * @param minSeq Minimum ledger sequence.
+     * @param maxSeq Maximum ledger sequence.
+     * @return Container that maps the sequence number of a found ledger to the
+     *         struct LedgerHashPair which contains the hashes of the ledger and
+     *         its parent.
+     */
+    std::map<LedgerIndex, LedgerHashPair>
+    getHashesByIndex(LedgerIndex minSeq, LedgerIndex maxSeq) override;
+
+    /**
+     * @brief getTxHistory Returns the 20 most recent transactions starting from
+     *        the given number.
+     * @param startIndex First number of returned entry.
+     * @return Vector of shared pointers to transactions sorted in
+     *         descending order by ledger sequence.
+     */
+    std::vector<std::shared_ptr<Transaction>>
+    getTxHistory(LedgerIndex startIndex) override;
+
     /**
      * @brief getTransactionsMinLedgerSeq Returns the minimum ledger sequence
      *        stored in the Transactions table.
      * @return Ledger sequence or no value if no ledgers exist.
      */
-    virtual std::optional<LedgerIndex>
-    getTransactionsMinLedgerSeq() = 0;
+    std::optional<LedgerIndex>
+    getTransactionsMinLedgerSeq() override;
 
     /**
      * @brief getAccountTransactionsMinLedgerSeq Returns the minimum ledger
      *        sequence stored in the AccountTransactions table.
      * @return Ledger sequence or no value if no ledgers exist.
      */
-    virtual std::optional<LedgerIndex>
-    getAccountTransactionsMinLedgerSeq() = 0;
+    std::optional<LedgerIndex>
+    getAccountTransactionsMinLedgerSeq() override;
 
     /**
      * @brief deleteTransactionByLedgerSeq Deletes transactions from the ledger
      *        with the given sequence.
      * @param ledgerSeq Ledger sequence.
      */
-    virtual void
-    deleteTransactionByLedgerSeq(LedgerIndex ledgerSeq) = 0;
+    void
+    deleteTransactionByLedgerSeq(LedgerIndex ledgerSeq) override;
 
     /**
      * @brief deleteBeforeLedgerSeq Deletes all ledgers with a sequence number
      *        less than or equal to the given ledger sequence.
      * @param ledgerSeq Ledger sequence.
      */
-    virtual void
-    deleteBeforeLedgerSeq(LedgerIndex ledgerSeq) = 0;
+    void
+    deleteBeforeLedgerSeq(LedgerIndex ledgerSeq) override;
 
     /**
      * @brief deleteTransactionsBeforeLedgerSeq Deletes all transactions with
@@ -45,8 +132,8 @@ public:
      *        sequence.
      * @param ledgerSeq Ledger sequence.
      */
-    virtual void
-    deleteTransactionsBeforeLedgerSeq(LedgerIndex ledgerSeq) = 0;
+    void
+    deleteTransactionsBeforeLedgerSeq(LedgerIndex ledgerSeq) override;
 
     /**
      * @brief deleteAccountTransactionsBeforeLedgerSeq Deletes all account
@@ -54,23 +141,23 @@ public:
      *        given ledger sequence.
      * @param ledgerSeq Ledger sequence.
      */
-    virtual void
-    deleteAccountTransactionsBeforeLedgerSeq(LedgerIndex ledgerSeq) = 0;
+    void
+    deleteAccountTransactionsBeforeLedgerSeq(LedgerIndex ledgerSeq) override;
 
     /**
      * @brief getTransactionCount Returns the number of transactions.
      * @return Number of transactions.
      */
-    virtual std::size_t
-    getTransactionCount() = 0;
+    std::size_t
+    getTransactionCount() override;
 
     /**
      * @brief getAccountTransactionCount Returns the number of account
      *        transactions.
      * @return Number of account transactions.
      */
-    virtual std::size_t
-    getAccountTransactionCount() = 0;
+    std::size_t
+    getAccountTransactionCount() override;
 
     /**
      * @brief getLedgerCountMinMax Returns the minimum ledger sequence,
@@ -78,8 +165,8 @@ public:
      * @return Struct CountMinMax which contains the minimum sequence,
      *         maximum sequence and number of ledgers.
      */
-    virtual struct CountMinMax
-    getLedgerCountMinMax() = 0;
+    CountMinMax
+    getLedgerCountMinMax() override;
 
     /**
      * @brief saveValidatedLedger Saves a ledger into the database.
@@ -87,8 +174,8 @@ public:
      * @param current True if the ledger is current.
      * @return True if saving was successful.
      */
-    virtual bool
-    saveValidatedLedger(std::shared_ptr<Ledger const> const& ledger, bool current) = 0;
+    bool
+    saveValidatedLedger(std::shared_ptr<Ledger const> const& ledger, bool current) override;
 
     /**
      * @brief getLimitedOldestLedgerInfo Returns the info of the oldest ledger
@@ -97,8 +184,8 @@ public:
      * @param ledgerFirstIndex Minimum ledger sequence.
      * @return Ledger info if found, otherwise no value.
      */
-    virtual std::optional<LedgerHeader>
-    getLimitedOldestLedgerInfo(LedgerIndex ledgerFirstIndex) = 0;
+    std::optional<LedgerHeader>
+    getLimitedOldestLedgerInfo(LedgerIndex ledgerFirstIndex) override;
 
     /**
      * @brief getLimitedNewestLedgerInfo Returns the info of the newest ledger
@@ -107,8 +194,8 @@ public:
      * @param ledgerFirstIndex Minimum ledger sequence.
      * @return Ledger info if found, otherwise no value.
      */
-    virtual std::optional<LedgerHeader>
-    getLimitedNewestLedgerInfo(LedgerIndex ledgerFirstIndex) = 0;
+    std::optional<LedgerHeader>
+    getLimitedNewestLedgerInfo(LedgerIndex ledgerFirstIndex) override;
 
     /**
      * @brief getOldestAccountTxs Returns the oldest transactions for the
@@ -121,8 +208,8 @@ public:
      * @return Vector of pairs of found transactions and their metadata
      *         sorted in ascending order by account sequence.
      */
-    virtual AccountTxs
-    getOldestAccountTxs(AccountTxOptions const& options) = 0;
+    AccountTxs
+    getOldestAccountTxs(AccountTxOptions const& options) override;
 
     /**
      * @brief getNewestAccountTxs Returns the newest transactions for the
@@ -135,8 +222,8 @@ public:
      * @return Vector of pairs of found transactions and their metadata
      *         sorted in descending order by account sequence.
      */
-    virtual AccountTxs
-    getNewestAccountTxs(AccountTxOptions const& options) = 0;
+    AccountTxs
+    getNewestAccountTxs(AccountTxOptions const& options) override;
 
     /**
      * @brief getOldestAccountTxsB Returns the oldest transactions in binary
@@ -149,8 +236,8 @@ public:
      * @return Vector of tuples of found transactions, their metadata and
      *         account sequences sorted in ascending order by account sequence.
      */
-    virtual MetaTxsList
-    getOldestAccountTxsB(AccountTxOptions const& options) = 0;
+    MetaTxsList
+    getOldestAccountTxsB(AccountTxOptions const& options) override;
 
     /**
      * @brief getNewestAccountTxsB Returns the newest transactions in binary
@@ -164,8 +251,8 @@ public:
      *         account sequences sorted in descending order by account
      *         sequence.
      */
-    virtual MetaTxsList
-    getNewestAccountTxsB(AccountTxOptions const& options) = 0;
+    MetaTxsList
+    getNewestAccountTxsB(AccountTxOptions const& options) override;
 
     /**
      * @brief oldestAccountTxPage Returns the oldest transactions for the
@@ -179,8 +266,8 @@ public:
      *         sorted in ascending order by account sequence and a marker
      *         for the next search if the search was not finished.
      */
-    virtual std::pair<AccountTxs, std::optional<AccountTxMarker>>
-    oldestAccountTxPage(AccountTxPageOptions const& options) = 0;
+    std::pair<AccountTxs, std::optional<AccountTxMarker>>
+    oldestAccountTxPage(AccountTxPageOptions const& options) override;
 
     /**
      * @brief newestAccountTxPage Returns the newest transactions for the
@@ -194,8 +281,8 @@ public:
      *         sorted in descending order by account sequence and a marker
      *         for the next search if the search was not finished.
      */
-    virtual std::pair<AccountTxs, std::optional<AccountTxMarker>>
-    newestAccountTxPage(AccountTxPageOptions const& options) = 0;
+    std::pair<AccountTxs, std::optional<AccountTxMarker>>
+    newestAccountTxPage(AccountTxPageOptions const& options) override;
 
     /**
      * @brief oldestAccountTxPageB Returns the oldest transactions in binary
@@ -210,8 +297,8 @@ public:
      *         sequence and a marker for the next search if the search was not
      *         finished.
      */
-    virtual std::pair<MetaTxsList, std::optional<AccountTxMarker>>
-    oldestAccountTxPageB(AccountTxPageOptions const& options) = 0;
+    std::pair<MetaTxsList, std::optional<AccountTxMarker>>
+    oldestAccountTxPageB(AccountTxPageOptions const& options) override;
 
     /**
      * @brief newestAccountTxPageB Returns the newest transactions in binary
@@ -226,8 +313,8 @@ public:
      *         sequence and a marker for the next search if the search was not
      *         finished.
      */
-    virtual std::pair<MetaTxsList, std::optional<AccountTxMarker>>
-    newestAccountTxPageB(AccountTxPageOptions const& options) = 0;
+    std::pair<MetaTxsList, std::optional<AccountTxMarker>>
+    newestAccountTxPageB(AccountTxPageOptions const& options) override;
 
     /**
      * @brief getTransaction Returns the transaction with the given hash. If a
@@ -244,43 +331,146 @@ public:
      *         error code is returned via the ec parameter, in other cases the
      *         default error code is not changed.
      */
-    virtual std::variant<AccountTx, TxSearched>
-    getTransaction(uint256 const& id, std::optional<ClosedInterval<uint32_t>> const& range, error_code_i& ec) = 0;
+    std::variant<AccountTx, TxSearched>
+    getTransaction(uint256 const& id, std::optional<ClosedInterval<std::uint32_t>> const& range, error_code_i& ec)
+        override;
 
     /**
      * @brief getKBUsedAll Returns the amount of space used by all databases.
      * @return Space in kilobytes.
      */
-    virtual uint32_t
-    getKBUsedAll() = 0;
+    std::uint32_t
+    getKBUsedAll() override;
 
     /**
      * @brief getKBUsedLedger Returns the amount of space space used by the
      *        ledger database.
      * @return Space in kilobytes.
      */
-    virtual uint32_t
-    getKBUsedLedger() = 0;
+    std::uint32_t
+    getKBUsedLedger() override;
 
     /**
      * @brief getKBUsedTransaction Returns the amount of space used by the
      *        transaction database.
      * @return Space in kilobytes.
      */
-    virtual uint32_t
-    getKBUsedTransaction() = 0;
+    std::uint32_t
+    getKBUsedTransaction() override;
 
     /**
      * @brief Closes the ledger database
      */
-    virtual void
-    closeLedgerDB() = 0;
+    void
+    closeLedgerDB() override;
 
     /**
      * @brief Closes the transaction database
      */
-    virtual void
-    closeTransactionDB() = 0;
+    void
+    closeTransactionDB() override;
+
+    SQLiteDatabase(ServiceRegistry& registry, Config const& config, JobQueue& jobQueue);
+
+    SQLiteDatabase(SQLiteDatabase const&) = delete;
+    SQLiteDatabase(SQLiteDatabase&& rhs) noexcept;
+
+    SQLiteDatabase&
+    operator=(SQLiteDatabase const&) = delete;
+    SQLiteDatabase&
+    operator=(SQLiteDatabase&& rhs) = delete;
+
+    /**
+     * @brief ledgerDbHasSpace Checks if the ledger database has available
+     *        space.
+     * @param config Config object.
+     * @return True if space is available.
+     */
+    bool
+    ledgerDbHasSpace(Config const& config);
+
+    /**
+     * @brief transactionDbHasSpace Checks if the transaction database has
+     *        available space.
+     * @param config Config object.
+     * @return True if space is available.
+     */
+    bool
+    transactionDbHasSpace(Config const& config);
+
+private:
+    ServiceRegistry& registry_;
+    bool const useTxTables_;
+    beast::Journal j_;
+    std::unique_ptr<DatabaseCon> ledgerDb_, txdb_;
+
+    /**
+     * @brief makeLedgerDBs Opens ledger and transaction databases for the node
+     *        store, and stores their descriptors in private member variables.
+     * @param config Config object.
+     * @param setup Path to the databases and other opening parameters.
+     * @param checkpointerSetup Checkpointer parameters.
+     * @return True if node databases opened successfully.
+     */
+    bool
+    makeLedgerDBs(
+        Config const& config,
+        DatabaseCon::Setup const& setup,
+        DatabaseCon::CheckpointerSetup const& checkpointerSetup);
+
+    /**
+     * @brief existsLedger Checks if the node store ledger database exists.
+     * @return True if the node store ledger database exists.
+     */
+    bool
+    existsLedger()
+    {
+        return static_cast<bool>(ledgerDb_);
+    }
+
+    /**
+     * @brief existsTransaction Checks if the node store transaction database
+     *        exists.
+     * @return True if the node store transaction database exists.
+     */
+    bool
+    existsTransaction()
+    {
+        return static_cast<bool>(txdb_);
+    }
+
+    /**
+     * @brief checkoutTransaction Checks out and returns node store ledger
+     *        database.
+     * @return Session to the node store ledger database.
+     */
+    auto
+    checkoutLedger()
+    {
+        return ledgerDb_->checkoutDb();
+    }
+
+    /**
+     * @brief checkoutTransaction Checks out and returns the node store
+     *        transaction database.
+     * @return Session to the node store transaction database.
+     */
+    auto
+    checkoutTransaction()
+    {
+        return txdb_->checkoutDb();
+    }
 };
 
+/**
+ * @brief setup_RelationalDatabase Creates and returns a SQLiteDatabase
+ *        instance based on configuration.
+ * @param registry The service registry.
+ * @param config Config object.
+ * @param jobQueue JobQueue object.
+ * @return SQLiteDatabase instance.
+ */
+SQLiteDatabase
+setup_RelationalDatabase(ServiceRegistry& registry, Config const& config, JobQueue& jobQueue);
+
 }  // namespace xrpl

src/xrpld/app/rdb/backend/detail/Node.cpp

@@ -3,14 +3,14 @@
 #include <xrpld/app/ledger/LedgerToJson.h>
 #include <xrpld/app/ledger/PendingSaves.h>
 #include <xrpld/app/ledger/TransactionMaster.h>
-#include <xrpld/app/rdb/RelationalDatabase.h>
 #include <xrpld/app/rdb/backend/detail/Node.h>
-#include <xrpld/core/DatabaseCon.h>
-#include <xrpld/core/SociDB.h>
 
 #include <xrpl/basics/BasicConfig.h>
 #include <xrpl/basics/StringUtilities.h>
 #include <xrpl/json/to_string.h>
+#include <xrpl/rdb/DatabaseCon.h>
+#include <xrpl/rdb/RelationalDatabase.h>
+#include <xrpl/rdb/SociDB.h>
 
 #include <boost/range/adaptor/transformed.hpp>
 
@@ -64,8 +64,8 @@ makeLedgerDBs(
         tx->getSession() << boost::str(
             boost::format("PRAGMA cache_size=-%d;") % kilobytes(config.getValueFor(SizedItem::txnDBCache)));
 
-        if (!setup.standAlone || setup.startUp == Config::LOAD || setup.startUp == Config::LOAD_FILE ||
-            setup.startUp == Config::REPLAY)
+        if (!setup.standAlone || setup.startUp == StartUpType::LOAD || setup.startUp == StartUpType::LOAD_FILE ||
+            setup.startUp == StartUpType::REPLAY)
         {
             // Check if AccountTransactions has primary key
             std::string cid, name, type;

src/xrpld/app/rdb/backend/detail/Node.h

@@ -1,9 +1,10 @@
 #pragma once
 
 #include <xrpld/app/ledger/Ledger.h>
-#include <xrpld/app/rdb/RelationalDatabase.h>
 #include <xrpld/core/Config.h>
 
+#include <xrpl/rdb/RelationalDatabase.h>
+
 namespace xrpl {
 namespace detail {
 

src/xrpld/app/rdb/backend/detail/SQLiteDatabase.cpp

@@ -3,207 +3,15 @@
 #include <xrpld/app/misc/detail/AccountTxPaging.h>
 #include <xrpld/app/rdb/backend/SQLiteDatabase.h>
 #include <xrpld/app/rdb/backend/detail/Node.h>
-#include <xrpld/core/DatabaseCon.h>
-#include <xrpld/core/SociDB.h>
 
 #include <xrpl/basics/StringUtilities.h>
+#include <xrpl/rdb/DatabaseCon.h>
+#include <xrpl/rdb/SociDB.h>
 
 namespace xrpl {
 
-class SQLiteDatabaseImp final : public SQLiteDatabase
-{
-public:
-    SQLiteDatabaseImp(Application& app, Config const& config, JobQueue& jobQueue)
-        : app_(app), useTxTables_(config.useTxTables()), j_(app_.journal("SQLiteDatabaseImp"))
-    {
-        DatabaseCon::Setup const setup = setup_DatabaseCon(config, j_);
-        if (!makeLedgerDBs(config, setup, DatabaseCon::CheckpointerSetup{&jobQueue, &app_.logs()}))
-        {
-            std::string_view constexpr error = "Failed to create ledger databases";
-
-            JLOG(j_.fatal()) << error;
-            Throw<std::runtime_error>(error.data());
-        }
-    }
-
-    std::optional<LedgerIndex>
-    getMinLedgerSeq() override;
-
-    std::optional<LedgerIndex>
-    getTransactionsMinLedgerSeq() override;
-
-    std::optional<LedgerIndex>
-    getAccountTransactionsMinLedgerSeq() override;
-
-    std::optional<LedgerIndex>
-    getMaxLedgerSeq() override;
-
-    void
-    deleteTransactionByLedgerSeq(LedgerIndex ledgerSeq) override;
-
-    void
-    deleteBeforeLedgerSeq(LedgerIndex ledgerSeq) override;
-
-    void
-    deleteTransactionsBeforeLedgerSeq(LedgerIndex ledgerSeq) override;
-
-    void
-    deleteAccountTransactionsBeforeLedgerSeq(LedgerIndex ledgerSeq) override;
-
-    std::size_t
-    getTransactionCount() override;
-
-    std::size_t
-    getAccountTransactionCount() override;
-
-    RelationalDatabase::CountMinMax
-    getLedgerCountMinMax() override;
-
-    bool
-    saveValidatedLedger(std::shared_ptr<Ledger const> const& ledger, bool current) override;
-
-    std::optional<LedgerHeader>
-    getLedgerInfoByIndex(LedgerIndex ledgerSeq) override;
-
-    std::optional<LedgerHeader>
-    getNewestLedgerInfo() override;
-
-    std::optional<LedgerHeader>
-    getLimitedOldestLedgerInfo(LedgerIndex ledgerFirstIndex) override;
-
-    std::optional<LedgerHeader>
-    getLimitedNewestLedgerInfo(LedgerIndex ledgerFirstIndex) override;
-
-    std::optional<LedgerHeader>
-    getLedgerInfoByHash(uint256 const& ledgerHash) override;
-
-    uint256
-    getHashByIndex(LedgerIndex ledgerIndex) override;
-
-    std::optional<LedgerHashPair>
-    getHashesByIndex(LedgerIndex ledgerIndex) override;
-
-    std::map<LedgerIndex, LedgerHashPair>
-    getHashesByIndex(LedgerIndex minSeq, LedgerIndex maxSeq) override;
-
-    std::vector<std::shared_ptr<Transaction>>
-    getTxHistory(LedgerIndex startIndex) override;
-
-    AccountTxs
-    getOldestAccountTxs(AccountTxOptions const& options) override;
-
-    AccountTxs
-    getNewestAccountTxs(AccountTxOptions const& options) override;
-
-    MetaTxsList
-    getOldestAccountTxsB(AccountTxOptions const& options) override;
-
-    MetaTxsList
-    getNewestAccountTxsB(AccountTxOptions const& options) override;
-
-    std::pair<AccountTxs, std::optional<AccountTxMarker>>
-    oldestAccountTxPage(AccountTxPageOptions const& options) override;
-
-    std::pair<AccountTxs, std::optional<AccountTxMarker>>
-    newestAccountTxPage(AccountTxPageOptions const& options) override;
-
-    std::pair<MetaTxsList, std::optional<AccountTxMarker>>
-    oldestAccountTxPageB(AccountTxPageOptions const& options) override;
-
-    std::pair<MetaTxsList, std::optional<AccountTxMarker>>
-    newestAccountTxPageB(AccountTxPageOptions const& options) override;
-
-    std::variant<AccountTx, TxSearched>
-    getTransaction(uint256 const& id, std::optional<ClosedInterval<std::uint32_t>> const& range, error_code_i& ec)
-        override;
-
-    bool
-    ledgerDbHasSpace(Config const& config) override;
-
-    bool
-    transactionDbHasSpace(Config const& config) override;
-
-    std::uint32_t
-    getKBUsedAll() override;
-
-    std::uint32_t
-    getKBUsedLedger() override;
-
-    std::uint32_t
-    getKBUsedTransaction() override;
-
-    void
-    closeLedgerDB() override;
-
-    void
-    closeTransactionDB() override;
-
-private:
-    Application& app_;
-    bool const useTxTables_;
-    beast::Journal j_;
-    std::unique_ptr<DatabaseCon> ledgerDb_, txdb_;
-
-    /**
-     * @brief makeLedgerDBs Opens ledger and transaction databases for the node
-     *        store, and stores their descriptors in private member variables.
-     * @param config Config object.
-     * @param setup Path to the databases and other opening parameters.
-     * @param checkpointerSetup Checkpointer parameters.
-     * @return True if node databases opened successfully.
-     */
-    bool
-    makeLedgerDBs(
-        Config const& config,
-        DatabaseCon::Setup const& setup,
-        DatabaseCon::CheckpointerSetup const& checkpointerSetup);
-
-    /**
-     * @brief existsLedger Checks if the node store ledger database exists.
-     * @return True if the node store ledger database exists.
-     */
-    bool
-    existsLedger()
-    {
-        return static_cast<bool>(ledgerDb_);
-    }
-
-    /**
-     * @brief existsTransaction Checks if the node store transaction database
-     *        exists.
-     * @return True if the node store transaction database exists.
-     */
-    bool
-    existsTransaction()
-    {
-        return static_cast<bool>(txdb_);
-    }
-
-    /**
-     * @brief checkoutTransaction Checks out and returns node store ledger
-     *        database.
-     * @return Session to the node store ledger database.
-     */
-    auto
-    checkoutLedger()
-    {
-        return ledgerDb_->checkoutDb();
-    }
-
-    /**
-     * @brief checkoutTransaction Checks out and returns the node store
-     *        transaction database.
-     * @return Session to the node store transaction database.
-     */
-    auto
-    checkoutTransaction()
-    {
-        return txdb_->checkoutDb();
-    }
-};
-
 bool
-SQLiteDatabaseImp::makeLedgerDBs(
+SQLiteDatabase::makeLedgerDBs(
     Config const& config,
     DatabaseCon::Setup const& setup,
     DatabaseCon::CheckpointerSetup const& checkpointerSetup)
@@ -215,7 +23,7 @@ SQLiteDatabaseImp::makeLedgerDBs(
 }
 
 std::optional<LedgerIndex>
-SQLiteDatabaseImp::getMinLedgerSeq()
+SQLiteDatabase::getMinLedgerSeq()
 {
     /* if databases exists, use it */
     if (existsLedger())
@@ -229,7 +37,7 @@ SQLiteDatabaseImp::getMinLedgerSeq()
 }
 
 std::optional<LedgerIndex>
-SQLiteDatabaseImp::getTransactionsMinLedgerSeq()
+SQLiteDatabase::getTransactionsMinLedgerSeq()
 {
     if (!useTxTables_)
         return {};
@@ -244,7 +52,7 @@ SQLiteDatabaseImp::getTransactionsMinLedgerSeq()
 }
 
 std::optional<LedgerIndex>
-SQLiteDatabaseImp::getAccountTransactionsMinLedgerSeq()
+SQLiteDatabase::getAccountTransactionsMinLedgerSeq()
 {
     if (!useTxTables_)
         return {};
@@ -259,7 +67,7 @@ SQLiteDatabaseImp::getAccountTransactionsMinLedgerSeq()
 }
 
 std::optional<LedgerIndex>
-SQLiteDatabaseImp::getMaxLedgerSeq()
+SQLiteDatabase::getMaxLedgerSeq()
 {
     if (existsLedger())
     {
@@ -271,7 +79,7 @@ SQLiteDatabaseImp::getMaxLedgerSeq()
 }
 
 void
-SQLiteDatabaseImp::deleteTransactionByLedgerSeq(LedgerIndex ledgerSeq)
+SQLiteDatabase::deleteTransactionByLedgerSeq(LedgerIndex ledgerSeq)
 {
     if (!useTxTables_)
         return;
@@ -285,7 +93,7 @@ SQLiteDatabaseImp::deleteTransactionByLedgerSeq(LedgerIndex ledgerSeq)
 }
 
 void
-SQLiteDatabaseImp::deleteBeforeLedgerSeq(LedgerIndex ledgerSeq)
+SQLiteDatabase::deleteBeforeLedgerSeq(LedgerIndex ledgerSeq)
 {
     if (existsLedger())
     {
@@ -296,7 +104,7 @@ SQLiteDatabaseImp::deleteBeforeLedgerSeq(LedgerIndex ledgerSeq)
 }
 
 void
-SQLiteDatabaseImp::deleteTransactionsBeforeLedgerSeq(LedgerIndex ledgerSeq)
+SQLiteDatabase::deleteTransactionsBeforeLedgerSeq(LedgerIndex ledgerSeq)
 {
     if (!useTxTables_)
         return;
@@ -310,7 +118,7 @@ SQLiteDatabaseImp::deleteTransactionsBeforeLedgerSeq(LedgerIndex ledgerSeq)
 }
 
 void
-SQLiteDatabaseImp::deleteAccountTransactionsBeforeLedgerSeq(LedgerIndex ledgerSeq)
+SQLiteDatabase::deleteAccountTransactionsBeforeLedgerSeq(LedgerIndex ledgerSeq)
 {
     if (!useTxTables_)
         return;
@@ -324,7 +132,7 @@ SQLiteDatabaseImp::deleteAccountTransactionsBeforeLedgerSeq(LedgerIndex ledgerSe
 }
 
 std::size_t
-SQLiteDatabaseImp::getTransactionCount()
+SQLiteDatabase::getTransactionCount()
 {
     if (!useTxTables_)
         return 0;
@@ -339,7 +147,7 @@ SQLiteDatabaseImp::getTransactionCount()
 }
 
 std::size_t
-SQLiteDatabaseImp::getAccountTransactionCount()
+SQLiteDatabase::getAccountTransactionCount()
 {
     if (!useTxTables_)
         return 0;
@@ -354,7 +162,7 @@ SQLiteDatabaseImp::getAccountTransactionCount()
 }
 
 RelationalDatabase::CountMinMax
-SQLiteDatabaseImp::getLedgerCountMinMax()
+SQLiteDatabase::getLedgerCountMinMax()
 {
     if (existsLedger())
     {
@@ -366,11 +174,11 @@ SQLiteDatabaseImp::getLedgerCountMinMax()
 }
 
 bool
-SQLiteDatabaseImp::saveValidatedLedger(std::shared_ptr<Ledger const> const& ledger, bool current)
+SQLiteDatabase::saveValidatedLedger(std::shared_ptr<Ledger const> const& ledger, bool current)
 {
     if (existsLedger())
     {
-        if (!detail::saveValidatedLedger(*ledgerDb_, txdb_, app_, ledger, current))
+        if (!detail::saveValidatedLedger(*ledgerDb_, txdb_, registry_.app(), ledger, current))
             return false;
     }
 
@@ -378,7 +186,7 @@ SQLiteDatabaseImp::saveValidatedLedger(std::shared_ptr<Ledger const> const& ledg
 }
 
 std::optional<LedgerHeader>
-SQLiteDatabaseImp::getLedgerInfoByIndex(LedgerIndex ledgerSeq)
+SQLiteDatabase::getLedgerInfoByIndex(LedgerIndex ledgerSeq)
 {
     if (existsLedger())
     {
@@ -393,7 +201,7 @@ SQLiteDatabaseImp::getLedgerInfoByIndex(LedgerIndex ledgerSeq)
 }
 
 std::optional<LedgerHeader>
-SQLiteDatabaseImp::getNewestLedgerInfo()
+SQLiteDatabase::getNewestLedgerInfo()
 {
     if (existsLedger())
     {
@@ -408,7 +216,7 @@ SQLiteDatabaseImp::getNewestLedgerInfo()
 }
 
 std::optional<LedgerHeader>
-SQLiteDatabaseImp::getLimitedOldestLedgerInfo(LedgerIndex ledgerFirstIndex)
+SQLiteDatabase::getLimitedOldestLedgerInfo(LedgerIndex ledgerFirstIndex)
 {
     if (existsLedger())
     {
@@ -423,7 +231,7 @@ SQLiteDatabaseImp::getLimitedOldestLedgerInfo(LedgerIndex ledgerFirstIndex)
 }
 
 std::optional<LedgerHeader>
-SQLiteDatabaseImp::getLimitedNewestLedgerInfo(LedgerIndex ledgerFirstIndex)
+SQLiteDatabase::getLimitedNewestLedgerInfo(LedgerIndex ledgerFirstIndex)
 {
     if (existsLedger())
     {
@@ -438,7 +246,7 @@ SQLiteDatabaseImp::getLimitedNewestLedgerInfo(LedgerIndex ledgerFirstIndex)
 }
 
 std::optional<LedgerHeader>
-SQLiteDatabaseImp::getLedgerInfoByHash(uint256 const& ledgerHash)
+SQLiteDatabase::getLedgerInfoByHash(uint256 const& ledgerHash)
 {
     if (existsLedger())
     {
@@ -453,7 +261,7 @@ SQLiteDatabaseImp::getLedgerInfoByHash(uint256 const& ledgerHash)
 }
 
 uint256
-SQLiteDatabaseImp::getHashByIndex(LedgerIndex ledgerIndex)
+SQLiteDatabase::getHashByIndex(LedgerIndex ledgerIndex)
 {
     if (existsLedger())
     {
@@ -468,7 +276,7 @@ SQLiteDatabaseImp::getHashByIndex(LedgerIndex ledgerIndex)
 }
 
 std::optional<LedgerHashPair>
-SQLiteDatabaseImp::getHashesByIndex(LedgerIndex ledgerIndex)
+SQLiteDatabase::getHashesByIndex(LedgerIndex ledgerIndex)
 {
     if (existsLedger())
     {
@@ -483,7 +291,7 @@ SQLiteDatabaseImp::getHashesByIndex(LedgerIndex ledgerIndex)
 }
 
 std::map<LedgerIndex, LedgerHashPair>
-SQLiteDatabaseImp::getHashesByIndex(LedgerIndex minSeq, LedgerIndex maxSeq)
+SQLiteDatabase::getHashesByIndex(LedgerIndex minSeq, LedgerIndex maxSeq)
 {
     if (existsLedger())
     {
@@ -498,7 +306,7 @@ SQLiteDatabaseImp::getHashesByIndex(LedgerIndex minSeq, LedgerIndex maxSeq)
 }
 
 std::vector<std::shared_ptr<Transaction>>
-SQLiteDatabaseImp::getTxHistory(LedgerIndex startIndex)
+SQLiteDatabase::getTxHistory(LedgerIndex startIndex)
 {
     if (!useTxTables_)
         return {};
@@ -506,7 +314,7 @@ SQLiteDatabaseImp::getTxHistory(LedgerIndex startIndex)
     if (existsTransaction())
     {
         auto db = checkoutTransaction();
-        auto const res = detail::getTxHistory(*db, app_, startIndex, 20).first;
+        auto const res = detail::getTxHistory(*db, registry_.app(), startIndex, 20).first;
 
         if (!res.empty())
             return res;
@@ -516,41 +324,41 @@ SQLiteDatabaseImp::getTxHistory(LedgerIndex startIndex)
 }
 
 RelationalDatabase::AccountTxs
-SQLiteDatabaseImp::getOldestAccountTxs(AccountTxOptions const& options)
+SQLiteDatabase::getOldestAccountTxs(AccountTxOptions const& options)
 {
     if (!useTxTables_)
         return {};
 
-    LedgerMaster& ledgerMaster = app_.getLedgerMaster();
+    LedgerMaster& ledgerMaster = registry_.getLedgerMaster();
 
     if (existsTransaction())
     {
         auto db = checkoutTransaction();
-        return detail::getOldestAccountTxs(*db, app_, ledgerMaster, options, j_).first;
+        return detail::getOldestAccountTxs(*db, registry_.app(), ledgerMaster, options, j_).first;
     }
 
     return {};
 }
 
 RelationalDatabase::AccountTxs
-SQLiteDatabaseImp::getNewestAccountTxs(AccountTxOptions const& options)
+SQLiteDatabase::getNewestAccountTxs(AccountTxOptions const& options)
 {
     if (!useTxTables_)
         return {};
 
-    LedgerMaster& ledgerMaster = app_.getLedgerMaster();
+    LedgerMaster& ledgerMaster = registry_.getLedgerMaster();
 
     if (existsTransaction())
     {
         auto db = checkoutTransaction();
-        return detail::getNewestAccountTxs(*db, app_, ledgerMaster, options, j_).first;
+        return detail::getNewestAccountTxs(*db, registry_.app(), ledgerMaster, options, j_).first;
     }
 
     return {};
 }
 
 RelationalDatabase::MetaTxsList
-SQLiteDatabaseImp::getOldestAccountTxsB(AccountTxOptions const& options)
+SQLiteDatabase::getOldestAccountTxsB(AccountTxOptions const& options)
 {
     if (!useTxTables_)
         return {};
@@ -558,14 +366,14 @@ SQLiteDatabaseImp::getOldestAccountTxsB(AccountTxOptions const& options)
     if (existsTransaction())
     {
         auto db = checkoutTransaction();
-        return detail::getOldestAccountTxsB(*db, app_, options, j_).first;
+        return detail::getOldestAccountTxsB(*db, registry_.app(), options, j_).first;
     }
 
     return {};
 }
 
 RelationalDatabase::MetaTxsList
-SQLiteDatabaseImp::getNewestAccountTxsB(AccountTxOptions const& options)
+SQLiteDatabase::getNewestAccountTxsB(AccountTxOptions const& options)
 {
     if (!useTxTables_)
         return {};
@@ -573,23 +381,22 @@ SQLiteDatabaseImp::getNewestAccountTxsB(AccountTxOptions const& options)
     if (existsTransaction())
     {
         auto db = checkoutTransaction();
-        return detail::getNewestAccountTxsB(*db, app_, options, j_).first;
+        return detail::getNewestAccountTxsB(*db, registry_.app(), options, j_).first;
     }
 
     return {};
 }
 
 std::pair<RelationalDatabase::AccountTxs, std::optional<RelationalDatabase::AccountTxMarker>>
-SQLiteDatabaseImp::oldestAccountTxPage(AccountTxPageOptions const& options)
+SQLiteDatabase::oldestAccountTxPage(AccountTxPageOptions const& options)
 {
     if (!useTxTables_)
         return {};
 
     static std::uint32_t const page_length(200);
-    auto onUnsavedLedger = std::bind(saveLedgerAsync, std::ref(app_), std::placeholders::_1);
+    auto onUnsavedLedger = std::bind(saveLedgerAsync, std::ref(registry_.app()), std::placeholders::_1);
     AccountTxs ret;
-    Application& app = app_;
-    auto onTransaction = [&ret, &app](
+    auto onTransaction = [&ret, &app = registry_.app()](
                              std::uint32_t ledger_index, std::string const& status, Blob&& rawTxn, Blob&& rawMeta) {
         convertBlobsToTxResult(ret, ledger_index, status, rawTxn, rawMeta, app);
     };
@@ -605,16 +412,15 @@ SQLiteDatabaseImp::oldestAccountTxPage(AccountTxPageOptions const& options)
 }
 
 std::pair<RelationalDatabase::AccountTxs, std::optional<RelationalDatabase::AccountTxMarker>>
-SQLiteDatabaseImp::newestAccountTxPage(AccountTxPageOptions const& options)
+SQLiteDatabase::newestAccountTxPage(AccountTxPageOptions const& options)
 {
     if (!useTxTables_)
         return {};
 
     static std::uint32_t const page_length(200);
-    auto onUnsavedLedger = std::bind(saveLedgerAsync, std::ref(app_), std::placeholders::_1);
+    auto onUnsavedLedger = std::bind(saveLedgerAsync, std::ref(registry_.app()), std::placeholders::_1);
     AccountTxs ret;
-    Application& app = app_;
-    auto onTransaction = [&ret, &app](
+    auto onTransaction = [&ret, &app = registry_.app()](
                              std::uint32_t ledger_index, std::string const& status, Blob&& rawTxn, Blob&& rawMeta) {
         convertBlobsToTxResult(ret, ledger_index, status, rawTxn, rawMeta, app);
     };
@@ -630,13 +436,13 @@ SQLiteDatabaseImp::newestAccountTxPage(AccountTxPageOptions const& options)
 }
 
 std::pair<RelationalDatabase::MetaTxsList, std::optional<RelationalDatabase::AccountTxMarker>>
-SQLiteDatabaseImp::oldestAccountTxPageB(AccountTxPageOptions const& options)
+SQLiteDatabase::oldestAccountTxPageB(AccountTxPageOptions const& options)
 {
     if (!useTxTables_)
         return {};
 
     static std::uint32_t const page_length(500);
-    auto onUnsavedLedger = std::bind(saveLedgerAsync, std::ref(app_), std::placeholders::_1);
+    auto onUnsavedLedger = std::bind(saveLedgerAsync, std::ref(registry_.app()), std::placeholders::_1);
     MetaTxsList ret;
     auto onTransaction = [&ret](std::uint32_t ledgerIndex, std::string const& status, Blob&& rawTxn, Blob&& rawMeta) {
         ret.emplace_back(std::move(rawTxn), std::move(rawMeta), ledgerIndex);
@@ -653,13 +459,13 @@ SQLiteDatabaseImp::oldestAccountTxPageB(AccountTxPageOptions const& options)
 }
 
 std::pair<RelationalDatabase::MetaTxsList, std::optional<RelationalDatabase::AccountTxMarker>>
-SQLiteDatabaseImp::newestAccountTxPageB(AccountTxPageOptions const& options)
+SQLiteDatabase::newestAccountTxPageB(AccountTxPageOptions const& options)
 {
     if (!useTxTables_)
         return {};
 
     static std::uint32_t const page_length(500);
-    auto onUnsavedLedger = std::bind(saveLedgerAsync, std::ref(app_), std::placeholders::_1);
+    auto onUnsavedLedger = std::bind(saveLedgerAsync, std::ref(registry_.app()), std::placeholders::_1);
     MetaTxsList ret;
     auto onTransaction = [&ret](std::uint32_t ledgerIndex, std::string const& status, Blob&& rawTxn, Blob&& rawMeta) {
         ret.emplace_back(std::move(rawTxn), std::move(rawMeta), ledgerIndex);
@@ -676,7 +482,7 @@ SQLiteDatabaseImp::newestAccountTxPageB(AccountTxPageOptions const& options)
 }
 
 std::variant<RelationalDatabase::AccountTx, TxSearched>
-SQLiteDatabaseImp::getTransaction(
+SQLiteDatabase::getTransaction(
     uint256 const& id,
     std::optional<ClosedInterval<std::uint32_t>> const& range,
     error_code_i& ec)
@@ -687,14 +493,14 @@ SQLiteDatabaseImp::getTransaction(
     if (existsTransaction())
     {
         auto db = checkoutTransaction();
-        return detail::getTransaction(*db, app_, id, range, ec);
+        return detail::getTransaction(*db, registry_.app(), id, range, ec);
     }
 
     return TxSearched::unknown;
 }
 
 bool
-SQLiteDatabaseImp::ledgerDbHasSpace(Config const& config)
+SQLiteDatabase::ledgerDbHasSpace(Config const& config)
 {
     if (existsLedger())
     {
@@ -706,7 +512,7 @@ SQLiteDatabaseImp::ledgerDbHasSpace(Config const& config)
 }
 
 bool
-SQLiteDatabaseImp::transactionDbHasSpace(Config const& config)
+SQLiteDatabase::transactionDbHasSpace(Config const& config)
 {
     if (!useTxTables_)
         return true;
@@ -721,7 +527,7 @@ SQLiteDatabaseImp::transactionDbHasSpace(Config const& config)
 }
 
 std::uint32_t
-SQLiteDatabaseImp::getKBUsedAll()
+SQLiteDatabase::getKBUsedAll()
 {
     if (existsLedger())
     {
@@ -732,7 +538,7 @@ SQLiteDatabaseImp::getKBUsedAll()
 }
 
 std::uint32_t
-SQLiteDatabaseImp::getKBUsedLedger()
+SQLiteDatabase::getKBUsedLedger()
 {
     if (existsLedger())
     {
@@ -743,7 +549,7 @@ SQLiteDatabaseImp::getKBUsedLedger()
 }
 
 std::uint32_t
-SQLiteDatabaseImp::getKBUsedTransaction()
+SQLiteDatabase::getKBUsedTransaction()
 {
     if (!useTxTables_)
         return 0;
@@ -757,21 +563,43 @@ SQLiteDatabaseImp::getKBUsedTransaction()
 }
 
 void
-SQLiteDatabaseImp::closeLedgerDB()
+SQLiteDatabase::closeLedgerDB()
 {
     ledgerDb_.reset();
 }
 
 void
-SQLiteDatabaseImp::closeTransactionDB()
+SQLiteDatabase::closeTransactionDB()
 {
     txdb_.reset();
 }
 
-std::unique_ptr<RelationalDatabase>
-getSQLiteDatabase(Application& app, Config const& config, JobQueue& jobQueue)
+SQLiteDatabase::SQLiteDatabase(ServiceRegistry& registry, Config const& config, JobQueue& jobQueue)
+    : registry_(registry), useTxTables_(config.useTxTables()), j_(registry.journal("SQLiteDatabase"))
 {
-    return std::make_unique<SQLiteDatabaseImp>(app, config, jobQueue);
+    DatabaseCon::Setup const setup = setup_DatabaseCon(config, j_);
+    if (!makeLedgerDBs(config, setup, DatabaseCon::CheckpointerSetup{&jobQueue, &registry_.logs()}))
+    {
+        std::string_view constexpr error = "Failed to create ledger databases";
+
+        JLOG(j_.fatal()) << error;
+        Throw<std::runtime_error>(error.data());
+    }
+}
+
+SQLiteDatabase::SQLiteDatabase(SQLiteDatabase&& rhs) noexcept
+    : registry_(rhs.registry_)
+    , useTxTables_(rhs.useTxTables_)
+    , j_(rhs.j_)
+    , ledgerDb_(std::move(rhs.ledgerDb_))
+    , txdb_(std::move(rhs.txdb_))
+{
+}
+
+SQLiteDatabase
+setup_RelationalDatabase(ServiceRegistry& registry, Config const& config, JobQueue& jobQueue)
+{
+    return {registry, config, jobQueue};
 }
 
 }  // namespace xrpl

src/xrpld/app/rdb/detail/RelationalDatabase.cpp

@@ -1,40 +0,0 @@
-#include <xrpld/app/main/Application.h>
-#include <xrpld/app/rdb/RelationalDatabase.h>
-#include <xrpld/core/ConfigSections.h>
-
-namespace xrpl {
-
-extern std::unique_ptr<RelationalDatabase>
-getSQLiteDatabase(Application& app, Config const& config, JobQueue& jobQueue);
-
-std::unique_ptr<RelationalDatabase>
-RelationalDatabase::init(Application& app, Config const& config, JobQueue& jobQueue)
-{
-    bool use_sqlite = false;
-
-    Section const& rdb_section{config.section(SECTION_RELATIONAL_DB)};
-    if (!rdb_section.empty())
-    {
-        if (boost::iequals(get(rdb_section, "backend"), "sqlite"))
-        {
-            use_sqlite = true;
-        }
-        else
-        {
-            Throw<std::runtime_error>("Invalid rdb_section backend value: " + get(rdb_section, "backend"));
-        }
-    }
-    else
-    {
-        use_sqlite = true;
-    }
-
-    if (use_sqlite)
-    {
-        return getSQLiteDatabase(app, config, jobQueue);
-    }
-
-    return std::unique_ptr<RelationalDatabase>();
-}
-
-}  // namespace xrpl

src/xrpld/core/Config.h

@@ -4,7 +4,9 @@
 #include <xrpl/basics/base_uint.h>
 #include <xrpl/beast/net/IPEndpoint.h>
 #include <xrpl/beast/utility/Journal.h>
+#include <xrpl/core/StartUpType.h>
 #include <xrpl/protocol/SystemParameters.h>  // VFALCO Breaks levelization
+#include <xrpl/rdb/DatabaseCon.h>
 
 #include <boost/filesystem.hpp>  // VFALCO FIX: This include should not be here
 
@@ -124,8 +126,7 @@ public:
     // Entries from [ips_fixed] config stanza
     std::vector<std::string> IPS_FIXED;
 
-    enum StartUpType { FRESH, NORMAL, LOAD, LOAD_FILE, REPLAY, NETWORK };
-    StartUpType START_UP = NORMAL;
+    StartUpType START_UP = StartUpType::NORMAL;
 
     bool START_VALID = false;
 
@@ -355,4 +356,7 @@ public:
 FeeSetup
 setup_FeeVote(Section const& section);
 
+DatabaseCon::Setup
+setup_DatabaseCon(Config const& c, std::optional<beast::Journal> j = std::nullopt);
+
 }  // namespace xrpl

src/xrpld/core/detail/Config.cpp

@@ -1039,4 +1039,150 @@ setup_FeeVote(Section const& section)
     return setup;
 }
 
+DatabaseCon::Setup
+setup_DatabaseCon(Config const& c, std::optional<beast::Journal> j)
+{
+    DatabaseCon::Setup setup;
+
+    setup.startUp = c.START_UP;
+    setup.standAlone = c.standalone();
+    setup.dataDir = c.legacy("database_path");
+    if (!setup.standAlone && setup.dataDir.empty())
+    {
+        Throw<std::runtime_error>("database_path must be set.");
+    }
+
+    if (!setup.globalPragma)
+    {
+        auto const& sqlite = c.section("sqlite");
+        auto result = std::make_unique<std::vector<std::string>>();
+        result->reserve(3);
+
+        // defaults
+        std::string safety_level;
+        std::string journal_mode = "wal";
+        std::string synchronous = "normal";
+        std::string temp_store = "file";
+        bool showRiskWarning = false;
+
+        if (set(safety_level, "safety_level", sqlite))
+        {
+            if (boost::iequals(safety_level, "low"))
+            {
+                // low safety defaults
+                journal_mode = "memory";
+                synchronous = "off";
+                temp_store = "memory";
+                showRiskWarning = true;
+            }
+            else if (!boost::iequals(safety_level, "high"))
+            {
+                Throw<std::runtime_error>("Invalid safety_level value: " + safety_level);
+            }
+        }
+
+        {
+            // #journal_mode Valid values : delete, truncate, persist,
+            // memory, wal, off
+            if (set(journal_mode, "journal_mode", sqlite) && !safety_level.empty())
+            {
+                Throw<std::runtime_error>(
+                    "Configuration file may not define both "
+                    "\"safety_level\" and \"journal_mode\"");
+            }
+            bool higherRisk = boost::iequals(journal_mode, "memory") || boost::iequals(journal_mode, "off");
+            showRiskWarning = showRiskWarning || higherRisk;
+            if (higherRisk || boost::iequals(journal_mode, "delete") || boost::iequals(journal_mode, "truncate") ||
+                boost::iequals(journal_mode, "persist") || boost::iequals(journal_mode, "wal"))
+            {
+                result->emplace_back(boost::str(boost::format(CommonDBPragmaJournal) % journal_mode));
+            }
+            else
+            {
+                Throw<std::runtime_error>("Invalid journal_mode value: " + journal_mode);
+            }
+        }
+
+        {
+            // #synchronous Valid values : off, normal, full, extra
+            if (set(synchronous, "synchronous", sqlite) && !safety_level.empty())
+            {
+                Throw<std::runtime_error>(
+                    "Configuration file may not define both "
+                    "\"safety_level\" and \"synchronous\"");
+            }
+            bool higherRisk = boost::iequals(synchronous, "off");
+            showRiskWarning = showRiskWarning || higherRisk;
+            if (higherRisk || boost::iequals(synchronous, "normal") || boost::iequals(synchronous, "full") ||
+                boost::iequals(synchronous, "extra"))
+            {
+                result->emplace_back(boost::str(boost::format(CommonDBPragmaSync) % synchronous));
+            }
+            else
+            {
+                Throw<std::runtime_error>("Invalid synchronous value: " + synchronous);
+            }
+        }
+
+        {
+            // #temp_store Valid values : default, file, memory
+            if (set(temp_store, "temp_store", sqlite) && !safety_level.empty())
+            {
+                Throw<std::runtime_error>(
+                    "Configuration file may not define both "
+                    "\"safety_level\" and \"temp_store\"");
+            }
+            bool higherRisk = boost::iequals(temp_store, "memory");
+            showRiskWarning = showRiskWarning || higherRisk;
+            if (higherRisk || boost::iequals(temp_store, "default") || boost::iequals(temp_store, "file"))
+            {
+                result->emplace_back(boost::str(boost::format(CommonDBPragmaTemp) % temp_store));
+            }
+            else
+            {
+                Throw<std::runtime_error>("Invalid temp_store value: " + temp_store);
+            }
+        }
+
+        if (showRiskWarning && j && c.LEDGER_HISTORY > SQLITE_TUNING_CUTOFF)
+        {
+            JLOG(j->warn()) << "reducing the data integrity guarantees from the "
+                               "default [sqlite] behavior is not recommended for "
+                               "nodes storing large amounts of history, because of the "
+                               "difficulty inherent in rebuilding corrupted data.";
+        }
+        XRPL_ASSERT(result->size() == 3, "xrpl::setup_DatabaseCon::globalPragma : result size is 3");
+        setup.globalPragma = std::move(result);
+    }
+    setup.useGlobalPragma = true;
+
+    auto setPragma = [](std::string& pragma, std::string const& key, int64_t value) {
+        pragma = "PRAGMA " + key + "=" + std::to_string(value) + ";";
+    };
+
+    // Lgr Pragma
+    setPragma(setup.lgrPragma[0], "journal_size_limit", 1582080);
+
+    // TX Pragma
+    int64_t page_size = 4096;
+    int64_t journal_size_limit = 1582080;
+    if (c.exists("sqlite"))
+    {
+        auto& s = c.section("sqlite");
+        set(journal_size_limit, "journal_size_limit", s);
+        set(page_size, "page_size", s);
+        if (page_size < 512 || page_size > 65536)
+            Throw<std::runtime_error>("Invalid page_size. Must be between 512 and 65536.");
+
+        if (page_size & (page_size - 1))
+            Throw<std::runtime_error>("Invalid page_size. Must be a power of 2.");
+    }
+
+    setPragma(setup.txPragma[0], "page_size", page_size);
+    setPragma(setup.txPragma[1], "journal_size_limit", journal_size_limit);
+    setPragma(setup.txPragma[2], "max_page_count", 4294967294);
+    setPragma(setup.txPragma[3], "mmap_size", 17179869184);
+
+    return setup;
+}
 }  // namespace xrpl

src/xrpld/core/detail/DatabaseCon.cpp

@@ -1,242 +0,0 @@
-#include <xrpld/core/DatabaseCon.h>
-#include <xrpld/core/SociDB.h>
-
-#include <xrpl/basics/Log.h>
-#include <xrpl/basics/contract.h>
-
-#include <boost/algorithm/string.hpp>
-#include <boost/format.hpp>
-
-#include <memory>
-#include <unordered_map>
-
-namespace xrpl {
-
-class CheckpointersCollection
-{
-    std::uintptr_t nextId_{0};
-    // Mutex protects the CheckpointersCollection
-    std::mutex mutex_;
-    // Each checkpointer is given a unique id. All the checkpointers that are
-    // part of a DatabaseCon are part of this collection. When the DatabaseCon
-    // is destroyed, its checkpointer is removed from the collection
-    std::unordered_map<std::uintptr_t, std::shared_ptr<Checkpointer>> checkpointers_;
-
-public:
-    std::shared_ptr<Checkpointer>
-    fromId(std::uintptr_t id)
-    {
-        std::lock_guard l{mutex_};
-        auto it = checkpointers_.find(id);
-        if (it != checkpointers_.end())
-            return it->second;
-        return {};
-    }
-
-    void
-    erase(std::uintptr_t id)
-    {
-        std::lock_guard lock{mutex_};
-        checkpointers_.erase(id);
-    }
-
-    std::shared_ptr<Checkpointer>
-    create(std::shared_ptr<soci::session> const& session, JobQueue& jobQueue, Logs& logs)
-    {
-        std::lock_guard lock{mutex_};
-        auto const id = nextId_++;
-        auto const r = makeCheckpointer(id, session, jobQueue, logs);
-        checkpointers_[id] = r;
-        return r;
-    }
-};
-
-CheckpointersCollection checkpointers;
-
-std::shared_ptr<Checkpointer>
-checkpointerFromId(std::uintptr_t id)
-{
-    return checkpointers.fromId(id);
-}
-
-DatabaseCon::~DatabaseCon()
-{
-    if (checkpointer_)
-    {
-        checkpointers.erase(checkpointer_->id());
-
-        std::weak_ptr<Checkpointer> wk(checkpointer_);
-        checkpointer_.reset();
-
-        // The references to our Checkpointer held by 'checkpointer_' and
-        // 'checkpointers' have been removed, so if the use count is nonzero, a
-        // checkpoint is currently in progress. Wait for it to end, otherwise
-        // creating a new DatabaseCon to the same database may fail due to the
-        // database being locked by our (now old) Checkpointer.
-        while (wk.use_count())
-        {
-            std::this_thread::sleep_for(std::chrono::milliseconds(100));
-        }
-    }
-}
-
-DatabaseCon::Setup
-setup_DatabaseCon(Config const& c, std::optional<beast::Journal> j)
-{
-    DatabaseCon::Setup setup;
-
-    setup.startUp = c.START_UP;
-    setup.standAlone = c.standalone();
-    setup.dataDir = c.legacy("database_path");
-    if (!setup.standAlone && setup.dataDir.empty())
-    {
-        Throw<std::runtime_error>("database_path must be set.");
-    }
-
-    if (!setup.globalPragma)
-    {
-        setup.globalPragma = [&c, &j]() {
-            auto const& sqlite = c.section("sqlite");
-            auto result = std::make_unique<std::vector<std::string>>();
-            result->reserve(3);
-
-            // defaults
-            std::string safety_level;
-            std::string journal_mode = "wal";
-            std::string synchronous = "normal";
-            std::string temp_store = "file";
-            bool showRiskWarning = false;
-
-            if (set(safety_level, "safety_level", sqlite))
-            {
-                if (boost::iequals(safety_level, "low"))
-                {
-                    // low safety defaults
-                    journal_mode = "memory";
-                    synchronous = "off";
-                    temp_store = "memory";
-                    showRiskWarning = true;
-                }
-                else if (!boost::iequals(safety_level, "high"))
-                {
-                    Throw<std::runtime_error>("Invalid safety_level value: " + safety_level);
-                }
-            }
-
-            {
-                // #journal_mode Valid values : delete, truncate, persist,
-                // memory, wal, off
-                if (set(journal_mode, "journal_mode", sqlite) && !safety_level.empty())
-                {
-                    Throw<std::runtime_error>(
-                        "Configuration file may not define both "
-                        "\"safety_level\" and \"journal_mode\"");
-                }
-                bool higherRisk = boost::iequals(journal_mode, "memory") || boost::iequals(journal_mode, "off");
-                showRiskWarning = showRiskWarning || higherRisk;
-                if (higherRisk || boost::iequals(journal_mode, "delete") || boost::iequals(journal_mode, "truncate") ||
-                    boost::iequals(journal_mode, "persist") || boost::iequals(journal_mode, "wal"))
-                {
-                    result->emplace_back(boost::str(boost::format(CommonDBPragmaJournal) % journal_mode));
-                }
-                else
-                {
-                    Throw<std::runtime_error>("Invalid journal_mode value: " + journal_mode);
-                }
-            }
-
-            {
-                // #synchronous Valid values : off, normal, full, extra
-                if (set(synchronous, "synchronous", sqlite) && !safety_level.empty())
-                {
-                    Throw<std::runtime_error>(
-                        "Configuration file may not define both "
-                        "\"safety_level\" and \"synchronous\"");
-                }
-                bool higherRisk = boost::iequals(synchronous, "off");
-                showRiskWarning = showRiskWarning || higherRisk;
-                if (higherRisk || boost::iequals(synchronous, "normal") || boost::iequals(synchronous, "full") ||
-                    boost::iequals(synchronous, "extra"))
-                {
-                    result->emplace_back(boost::str(boost::format(CommonDBPragmaSync) % synchronous));
-                }
-                else
-                {
-                    Throw<std::runtime_error>("Invalid synchronous value: " + synchronous);
-                }
-            }
-
-            {
-                // #temp_store Valid values : default, file, memory
-                if (set(temp_store, "temp_store", sqlite) && !safety_level.empty())
-                {
-                    Throw<std::runtime_error>(
-                        "Configuration file may not define both "
-                        "\"safety_level\" and \"temp_store\"");
-                }
-                bool higherRisk = boost::iequals(temp_store, "memory");
-                showRiskWarning = showRiskWarning || higherRisk;
-                if (higherRisk || boost::iequals(temp_store, "default") || boost::iequals(temp_store, "file"))
-                {
-                    result->emplace_back(boost::str(boost::format(CommonDBPragmaTemp) % temp_store));
-                }
-                else
-                {
-                    Throw<std::runtime_error>("Invalid temp_store value: " + temp_store);
-                }
-            }
-
-            if (showRiskWarning && j && c.LEDGER_HISTORY > SQLITE_TUNING_CUTOFF)
-            {
-                JLOG(j->warn()) << "reducing the data integrity guarantees from the "
-                                   "default [sqlite] behavior is not recommended for "
-                                   "nodes storing large amounts of history, because of the "
-                                   "difficulty inherent in rebuilding corrupted data.";
-            }
-            XRPL_ASSERT(result->size() == 3, "xrpl::setup_DatabaseCon::globalPragma : result size is 3");
-            return result;
-        }();
-    }
-    setup.useGlobalPragma = true;
-
-    auto setPragma = [](std::string& pragma, std::string const& key, int64_t value) {
-        pragma = "PRAGMA " + key + "=" + std::to_string(value) + ";";
-    };
-
-    // Lgr Pragma
-    setPragma(setup.lgrPragma[0], "journal_size_limit", 1582080);
-
-    // TX Pragma
-    int64_t page_size = 4096;
-    int64_t journal_size_limit = 1582080;
-    if (c.exists("sqlite"))
-    {
-        auto& s = c.section("sqlite");
-        set(journal_size_limit, "journal_size_limit", s);
-        set(page_size, "page_size", s);
-        if (page_size < 512 || page_size > 65536)
-            Throw<std::runtime_error>("Invalid page_size. Must be between 512 and 65536.");
-
-        if (page_size & (page_size - 1))
-            Throw<std::runtime_error>("Invalid page_size. Must be a power of 2.");
-    }
-
-    setPragma(setup.txPragma[0], "page_size", page_size);
-    setPragma(setup.txPragma[1], "journal_size_limit", journal_size_limit);
-    setPragma(setup.txPragma[2], "max_page_count", 4294967294);
-    setPragma(setup.txPragma[3], "mmap_size", 17179869184);
-
-    return setup;
-}
-
-std::unique_ptr<std::vector<std::string> const> DatabaseCon::Setup::globalPragma;
-
-void
-DatabaseCon::setupCheckpointing(JobQueue* q, Logs& l)
-{
-    if (!q)
-        Throw<std::logic_error>("No JobQueue");
-    checkpointer_ = checkpointers.create(session_, *q, l);
-}
-
-}  // namespace xrpl

src/xrpld/overlay/detail/OverlayImpl.cpp

@@ -2,8 +2,6 @@
 #include <xrpld/app/misc/NetworkOPs.h>
 #include <xrpld/app/misc/ValidatorList.h>
 #include <xrpld/app/misc/ValidatorSite.h>
-#include <xrpld/app/rdb/RelationalDatabase.h>
-#include <xrpld/app/rdb/Wallet.h>
 #include <xrpld/overlay/Cluster.h>
 #include <xrpld/overlay/detail/ConnectAttempt.h>
 #include <xrpld/overlay/detail/PeerImp.h>
@@ -19,7 +17,9 @@
 #include <xrpl/basics/random.h>
 #include <xrpl/beast/core/LexicalCast.h>
 #include <xrpl/protocol/STTx.h>
+#include <xrpl/rdb/RelationalDatabase.h>
 #include <xrpl/server/SimpleWriter.h>
+#include <xrpl/server/Wallet.h>
 
 #include <boost/algorithm/string/predicate.hpp>
 #include <boost/asio/executor_work_guard.hpp>

src/xrpld/overlay/detail/PeerReservationTable.cpp

@@ -1,10 +1,9 @@
-#include <xrpld/app/rdb/RelationalDatabase.h>
-#include <xrpld/app/rdb/Wallet.h>
-#include <xrpld/overlay/PeerReservationTable.h>
-
+#include <xrpl/core/PeerReservationTable.h>
 #include <xrpl/json/json_value.h>
 #include <xrpl/protocol/PublicKey.h>
 #include <xrpl/protocol/jss.h>
+#include <xrpl/rdb/RelationalDatabase.h>
+#include <xrpl/server/Wallet.h>
 
 #include <algorithm>
 #include <iterator>

src/xrpld/peerfinder/detail/StoreSqdb.h

@@ -1,9 +1,10 @@
 #pragma once
 
 #include <xrpld/app/rdb/PeerFinder.h>
-#include <xrpld/core/SociDB.h>
 #include <xrpld/peerfinder/detail/Store.h>
 
+#include <xrpl/rdb/SociDB.h>
+
 namespace xrpl {
 namespace PeerFinder {
 

src/xrpld/rpc/InfoSub.h

@@ -1,12 +1,11 @@
 #pragma once
 
-#include <xrpld/app/misc/Manifest.h>
-
 #include <xrpl/basics/CountedObject.h>
 #include <xrpl/json/json_value.h>
 #include <xrpl/protocol/Book.h>
 #include <xrpl/protocol/ErrorCodes.h>
 #include <xrpl/resource/Consumer.h>
+#include <xrpl/server/Manifest.h>
 
 namespace xrpl {
 

src/xrpld/rpc/detail/RPCHelpers.cpp

@@ -1,6 +1,5 @@
 #include <xrpld/app/misc/Transaction.h>
 #include <xrpld/app/paths/TrustLine.h>
-#include <xrpld/app/rdb/RelationalDatabase.h>
 #include <xrpld/app/tx/detail/NFTokenUtils.h>
 #include <xrpld/rpc/Context.h>
 #include <xrpld/rpc/DeliveredAmount.h>
@@ -10,6 +9,7 @@
 #include <xrpl/protocol/AccountID.h>
 #include <xrpl/protocol/RPCErr.h>
 #include <xrpl/protocol/nftPageMask.h>
+#include <xrpl/rdb/RelationalDatabase.h>
 #include <xrpl/resource/Fees.h>
 
 #include <boost/algorithm/string/case_conv.hpp>

src/xrpld/rpc/detail/RPCLedgerHelpers.h

@@ -7,6 +7,7 @@
 #include <xrpld/rpc/detail/Tuning.h>
 
 #include <xrpl/proto/org/xrpl/rpc/v1/xrp_ledger.pb.h>
+#include <xrpl/protocol/LedgerShortcut.h>
 
 #include <optional>
 
@@ -19,8 +20,6 @@ namespace RPC {
 
 struct JsonContext;
 
-enum class LedgerShortcut { Current, Closed, Validated };
-
 /**
  * @brief Retrieves a ledger by its hash.
  *

src/xrpld/rpc/handlers/AccountTx.cpp

@@ -8,6 +8,7 @@
 #include <xrpld/rpc/MPTokenIssuanceID.h>
 #include <xrpld/rpc/Role.h>
 #include <xrpld/rpc/detail/RPCHelpers.h>
+#include <xrpld/rpc/detail/RPCLedgerHelpers.h>
 #include <xrpld/rpc/detail/Tuning.h>
 
 #include <xrpl/json/json_value.h>
@@ -26,8 +27,6 @@ using TxnsDataBinary = RelationalDatabase::MetaTxsList;
 using TxnDataBinary = RelationalDatabase::txnMetaLedgerType;
 using AccountTxArgs = RelationalDatabase::AccountTxArgs;
 using AccountTxResult = RelationalDatabase::AccountTxResult;
-
-using LedgerShortcut = RelationalDatabase::LedgerShortcut;
 using LedgerSpecifier = RelationalDatabase::LedgerSpecifier;
 
 // parses args into a ledger specifier, or returns a Json object on error
@@ -208,22 +207,19 @@ doAccountTxHelp(RPC::Context& context, AccountTxArgs const& args)
         args.limit,
         isUnlimited(context.role)};
 
-    auto const db = dynamic_cast<SQLiteDatabase*>(&context.app.getRelationalDatabase());
-
-    if (!db)
-        Throw<std::runtime_error>("Failed to get relational database");
+    auto& db = context.app.getRelationalDatabase();
 
     if (args.binary)
     {
         if (args.forward)
         {
-            auto [tx, marker] = db->oldestAccountTxPageB(options);
+            auto [tx, marker] = db.oldestAccountTxPageB(options);
             result.transactions = tx;
             result.marker = marker;
         }
         else
         {
-            auto [tx, marker] = db->newestAccountTxPageB(options);
+            auto [tx, marker] = db.newestAccountTxPageB(options);
             result.transactions = tx;
             result.marker = marker;
         }
@@ -232,13 +228,13 @@ doAccountTxHelp(RPC::Context& context, AccountTxArgs const& args)
     {
         if (args.forward)
         {
-            auto [tx, marker] = db->oldestAccountTxPage(options);
+            auto [tx, marker] = db.oldestAccountTxPage(options);
             result.transactions = tx;
             result.marker = marker;
         }
         else
         {
-            auto [tx, marker] = db->newestAccountTxPage(options);
+            auto [tx, marker] = db.newestAccountTxPage(options);
             result.transactions = tx;
             result.marker = marker;
         }

src/xrpld/rpc/handlers/GetCounts.cpp

@@ -49,22 +49,19 @@ getCountsJson(Application& app, int minObjectCount)
 
     if (app.config().useTxTables())
     {
-        auto const db = dynamic_cast<SQLiteDatabase*>(&app.getRelationalDatabase());
+        auto& db = app.getRelationalDatabase();
 
-        if (!db)
-            Throw<std::runtime_error>("Failed to get relational database");
-
-        auto dbKB = db->getKBUsedAll();
+        auto dbKB = db.getKBUsedAll();
 
         if (dbKB > 0)
             ret[jss::dbKBTotal] = dbKB;
 
-        dbKB = db->getKBUsedLedger();
+        dbKB = db.getKBUsedLedger();
 
         if (dbKB > 0)
             ret[jss::dbKBLedger] = dbKB;
 
-        dbKB = db->getKBUsedTransaction();
+        dbKB = db.getKBUsedTransaction();
 
         if (dbKB > 0)
             ret[jss::dbKBTransaction] = dbKB;

src/xrpld/rpc/handlers/Tx.cpp

@@ -3,18 +3,19 @@
 #include <xrpld/app/misc/DeliverMax.h>
 #include <xrpld/app/misc/NetworkOPs.h>
 #include <xrpld/app/misc/Transaction.h>
-#include <xrpld/app/rdb/RelationalDatabase.h>
 #include <xrpld/rpc/CTID.h>
 #include <xrpld/rpc/Context.h>
 #include <xrpld/rpc/DeliveredAmount.h>
 #include <xrpld/rpc/GRPCHandlers.h>
 #include <xrpld/rpc/MPTokenIssuanceID.h>
+#include <xrpld/rpc/Status.h>
 
 #include <xrpl/basics/ToString.h>
 #include <xrpl/protocol/ErrorCodes.h>
 #include <xrpl/protocol/NFTSyntheticSerializer.h>
 #include <xrpl/protocol/RPCErr.h>
 #include <xrpl/protocol/jss.h>
+#include <xrpl/rdb/RelationalDatabase.h>
 
 #include <regex>
 

src/xrpld/rpc/handlers/TxHistory.cpp

@@ -2,13 +2,13 @@
 #include <xrpld/app/main/Application.h>
 #include <xrpld/app/misc/DeliverMax.h>
 #include <xrpld/app/misc/Transaction.h>
-#include <xrpld/app/rdb/RelationalDatabase.h>
 #include <xrpld/rpc/Context.h>
 #include <xrpld/rpc/Role.h>
 
 #include <xrpl/protocol/ErrorCodes.h>
 #include <xrpl/protocol/RPCErr.h>
 #include <xrpl/protocol/jss.h>
+#include <xrpl/rdb/RelationalDatabase.h>
 #include <xrpl/resource/Fees.h>
 
 namespace xrpl {