first partial draft of featureEmail, not finished

2026-04-29 15:37:46 +00:00 · 2024-08-12 14:23:50 +10:00
29 changed files with 598 additions and 1121 deletions
--- a/.github/workflows/clang-format.yml
+++ b/.github/workflows/clang-format.yml
@@ -30,7 +30,7 @@ jobs:
        git diff --exit-code | tee "clang-format.patch"
    - name: Upload patch
      if: failure() && steps.assert.outcome == 'failure'
-      uses: actions/upload-artifact@v3
+      uses: actions/upload-artifact@v2
      continue-on-error: true
      with:
        name: clang-format.patch
--- a/.github/workflows/levelization.yml
+++ b/.github/workflows/levelization.yml
@@ -18,7 +18,7 @@ jobs:
        git diff --exit-code | tee "levelization.patch"
    - name: Upload patch
      if: failure() && steps.assert.outcome == 'failure'
-      uses: actions/upload-artifact@v3
+      uses: actions/upload-artifact@v2
      continue-on-error: true
      with:
        name: levelization.patch
--- a/Builds/CMake/RippledCore.cmake
+++ b/Builds/CMake/RippledCore.cmake
@@ -145,7 +145,6 @@ target_link_libraries (xrpl_core
    OpenSSL::Crypto
    Ripple::boost
    NIH::WasmEdge
-    NIH::MongoCxx
    Ripple::syslibs
    NIH::secp256k1
    NIH::ed25519-donna
--- a/Builds/CMake/deps/Mongo.cmake
+++ b/Builds/CMake/deps/Mongo.cmake
@@ -1,100 +0,0 @@
-#[===================================================================[
- NIH dep: mongo: MongoDB C++ driver (bsoncxx and mongocxx).
-#]===================================================================]
-
-include(FetchContent)
-
-FetchContent_Declare(
-  mongo_c_driver_src
-  GIT_REPOSITORY https://github.com/mongodb/mongo-c-driver.git
-  GIT_TAG        1.17.4
-)
-
-FetchContent_GetProperties(mongo_c_driver_src)
-if(NOT mongo_c_driver_src_POPULATED)
-  message(STATUS "Pausing to download MongoDB C driver...")
-  FetchContent_Populate(mongo_c_driver_src)
-endif()
-
-set(MONGO_C_DRIVER_BUILD_DIR "${mongo_c_driver_src_BINARY_DIR}")
-set(MONGO_C_DRIVER_INCLUDE_DIR "${mongo_c_driver_src_SOURCE_DIR}/src/libbson/src")
-set(MONGO_C_DRIVER_INSTALL_PREFIX "${CMAKE_CURRENT_BINARY_DIR}/mongo_c_install")
-
-set(MONGO_C_DRIVER_CMAKE_ARGS
-  -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}
-  -DENABLE_AUTOMATIC_INIT_AND_CLEANUP=OFF
-  -DENABLE_STATIC=ON
-  -DENABLE_SHARED=OFF
-  -DCMAKE_INSTALL_PREFIX=${MONGO_C_DRIVER_INSTALL_PREFIX}
-)
-
-ExternalProject_Add(mongo_c_driver
-  PREFIX ${CMAKE_CURRENT_BINARY_DIR}/mongo_c
-  SOURCE_DIR ${mongo_c_driver_src_SOURCE_DIR}
-  CMAKE_ARGS ${MONGO_C_DRIVER_CMAKE_ARGS}
-  BUILD_COMMAND ${CMAKE_COMMAND} --build . --config $<CONFIG>
-  INSTALL_COMMAND ${CMAKE_COMMAND} --install .
-)
-
-FetchContent_Declare(
-  mongo_cxx_driver_src
-  GIT_REPOSITORY https://github.com/mongodb/mongo-cxx-driver.git
-  GIT_TAG        r3.10.2
-)
-
-FetchContent_GetProperties(mongo_cxx_driver_src)
-if(NOT mongo_cxx_driver_src_POPULATED)
-  message(STATUS "Pausing to download MongoDB C++ driver...")
-  FetchContent_Populate(mongo_cxx_driver_src)
-endif()
-
-set(MONGO_CXX_DRIVER_BUILD_DIR "${mongo_cxx_driver_src_BINARY_DIR}")
-set(MONGO_CXX_DRIVER_INCLUDE_DIR "${mongo_cxx_driver_src_SOURCE_DIR}/include")
-set(MONGO_CXX_DRIVER_INSTALL_PREFIX "${CMAKE_CURRENT_BINARY_DIR}/mongo_cxx_install")
-
-set(MONGO_CXX_DRIVER_CMAKE_ARGS
-  -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}
-  -DBUILD_SHARED_AND_STATIC_LIBS=ON
-  -DBSONCXX_ENABLE_MONGOC=ON
-  -DCMAKE_INSTALL_PREFIX=${MONGO_CXX_DRIVER_INSTALL_PREFIX}
-  -DCMAKE_PREFIX_PATH=${MONGO_C_DRIVER_INSTALL_PREFIX}
-)
-
-ExternalProject_Add(mongo_cxx_driver
-  PREFIX ${CMAKE_CURRENT_BINARY_DIR}/mongo_cxx
-  SOURCE_DIR ${mongo_cxx_driver_src_SOURCE_DIR}
-  CMAKE_ARGS ${MONGO_CXX_DRIVER_CMAKE_ARGS}
-  BUILD_COMMAND ${CMAKE_COMMAND} --build . --config $<CONFIG>
-  INSTALL_COMMAND ${CMAKE_COMMAND} --install .
-  DEPENDS mongo_c_driver
-)
-
-add_library(bsoncxx STATIC IMPORTED GLOBAL)
-add_library(mongocxx STATIC IMPORTED GLOBAL)
-add_dependencies(bsoncxx mongo_cxx_driver)
-add_dependencies(mongocxx mongo_cxx_driver)
-
-ExternalProject_Get_Property(mongo_cxx_driver BINARY_DIR)
-execute_process(
-    COMMAND
-        mkdir -p "${BINARY_DIR}/include/bsoncxx/v_noabi"
-        mkdir -p "${BINARY_DIR}/include/mongocxx/v_noabi"
-)
-
-set_target_properties(bsoncxx PROPERTIES
-  IMPORTED_LOCATION "${MONGO_CXX_DRIVER_INSTALL_PREFIX}/lib/libbsoncxx-static.a"
-  INTERFACE_INCLUDE_DIRECTORIES "${MONGO_CXX_DRIVER_INSTALL_PREFIX}/include/bsoncxx/v_noabi"
-)
-
-set_target_properties(mongocxx PROPERTIES
-  IMPORTED_LOCATION "${MONGO_CXX_DRIVER_INSTALL_PREFIX}/lib/libmongocxx-static.a"
-  INTERFACE_INCLUDE_DIRECTORIES "${MONGO_CXX_DRIVER_INSTALL_PREFIX}/include/mongocxx/v_noabi"
-)
-
-# Link the C driver libraries
-find_library(BSON_LIB bson-1.0 PATHS ${MONGO_C_DRIVER_INSTALL_PREFIX}/lib)
-find_library(MONGOC_LIB mongoc-1.0 PATHS ${MONGO_C_DRIVER_INSTALL_PREFIX}/lib)
-
-target_link_libraries(ripple_libs INTERFACE bsoncxx mongocxx ${BSON_LIB} ${MONGOC_LIB})
-
-add_library(NIH::MongoCxx ALIAS mongocxx)
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -75,7 +75,6 @@ include(deps/gRPC)
 include(deps/cassandra)
 include(deps/Postgres)
 include(deps/WasmEdge)
-include(deps/Mongo)

 ###

--- a/README.md
+++ b/README.md
@@ -1,4 +1,4 @@
-# Xahau 
+# Xahau

 **Note:** Throughout this README, references to "we" or "our" pertain to the community and contributors involved in the Xahau network. It does not imply a legal entity or a specific collection of individuals.

@@ -68,4 +68,4 @@ git-subtree. See those directories' README files for more details.
 - **Testnet & Faucet**: Test applications and obtain test XAH at [xahau-test.net](https://xahau-test.net) and use the testnet explorer at [explorer.xahau.network](https://explorer.xahau.network).
 - **Supporting Wallets**: A list of wallets that support XAH and Xahau-based assets.
  - [Xumm](https://xumm.app)
-  - [Crossmark](https://crossmark.io)
+  - [Crossmark](https://crossmark.io)
--- a/build-full.sh
+++ b/build-full.sh
@@ -9,15 +9,6 @@ echo "-- GITHUB_RUN_NUMBER: $4"

 umask 0000;

-echo "Fixing CentOS 7 EOL"
-
-sed -i 's/mirrorlist/#mirrorlist/g' /etc/yum.repos.d/CentOS-*
-sed -i 's|#baseurl=http://mirror.centos.org|baseurl=http://vault.centos.org|g' /etc/yum.repos.d/CentOS-*
-yum clean all
-yum-config-manager --disable centos-sclo-sclo
-
-####
-
 cd /io;
 mkdir src/certs;
 curl --silent -k https://raw.githubusercontent.com/RichardAH/rippled-release-builder/main/ca-bundle/certbundle.h -o src/certs/certbundle.h;
--- a/src/ripple/app/consensus/RCLConsensus.cpp
+++ b/src/ripple/app/consensus/RCLConsensus.cpp
@@ -134,12 +134,8 @@ RCLConsensus::Adaptor::acquireLedger(LedgerHash const& hash)
            acquiringLedger_ = hash;

            app_.getJobQueue().addJob(
-                jtADVANCE,
-                "getConsensusLedger1",
-                [id = hash, &app = app_, this]() {
-                    JLOG(j_.debug())
-                        << "JOB advanceLedger getConsensusLedger1 started";
-                    app.getInboundLedgers().acquireAsync(
+                jtADVANCE, "getConsensusLedger", [id = hash, &app = app_]() {
+                    app.getInboundLedgers().acquire(
                        id, 0, InboundLedger::Reason::CONSENSUS);
                });
        }
--- a/src/ripple/app/consensus/RCLValidations.cpp
+++ b/src/ripple/app/consensus/RCLValidations.cpp
@@ -135,10 +135,8 @@ RCLValidationsAdaptor::acquire(LedgerHash const& hash)
        Application* pApp = &app_;

        app_.getJobQueue().addJob(
-            jtADVANCE, "getConsensusLedger2", [pApp, hash, this]() {
-                JLOG(j_.debug())
-                    << "JOB advanceLedger getConsensusLedger2 started";
-                pApp->getInboundLedgers().acquireAsync(
+            jtADVANCE, "getConsensusLedger", [pApp, hash]() {
+                pApp->getInboundLedgers().acquire(
                    hash, 0, InboundLedger::Reason::CONSENSUS);
            });
        return std::nullopt;
@@ -154,9 +152,7 @@ void
 handleNewValidation(
    Application& app,
    std::shared_ptr<STValidation> const& val,
-    std::string const& source,
-    BypassAccept const bypassAccept,
-    std::optional<beast::Journal> j)
+    std::string const& source)
 {
    auto const& signingKey = val->getSignerPublic();
    auto const& hash = val->getLedgerHash();
@@ -181,23 +177,7 @@ handleNewValidation(
    if (outcome == ValStatus::current)
    {
        if (val->isTrusted())
-        {
-            // Was: app.getLedgerMaster().checkAccept(hash, seq);
-            // https://github.com/XRPLF/rippled/commit/fbbea9e6e25795a8a6bd1bf64b780771933a9579
-            if (bypassAccept == BypassAccept::yes)
-            {
-                assert(j.has_value());
-                if (j.has_value())
-                {
-                    JLOG(j->trace()) << "Bypassing checkAccept for validation "
-                                     << val->getLedgerHash();
-                }
-            }
-            else
-            {
-                app.getLedgerMaster().checkAccept(hash, seq);
-            }
-        }
+            app.getLedgerMaster().checkAccept(hash, seq);
        return;
    }

--- a/src/ripple/app/consensus/RCLValidations.h
+++ b/src/ripple/app/consensus/RCLValidations.h
@@ -25,16 +25,12 @@
 #include <ripple/protocol/Protocol.h>
 #include <ripple/protocol/RippleLedgerHash.h>
 #include <ripple/protocol/STValidation.h>
-#include <optional>
-#include <set>
 #include <vector>

 namespace ripple {

 class Application;

-enum class BypassAccept : bool { no = false, yes };
-
 /** Wrapper over STValidation for generic Validation code

    Wraps an STValidation for compatibility with the generic validation code.
@@ -252,9 +248,7 @@ void
 handleNewValidation(
    Application& app,
    std::shared_ptr<STValidation> const& val,
-    std::string const& source,
-    BypassAccept const bypassAccept = BypassAccept::no,
-    std::optional<beast::Journal> j = std::nullopt);
+    std::string const& source);

 }  // namespace ripple

--- a/src/ripple/app/ledger/InboundLedgers.h
+++ b/src/ripple/app/ledger/InboundLedgers.h
@@ -38,21 +38,10 @@ public:
    virtual ~InboundLedgers() = default;

    // VFALCO TODO Should this be called findOrAdd ?
-    // Callers should use this if they possibly need an authoritative
-    // response immediately.
    //
    virtual std::shared_ptr<Ledger const>
    acquire(uint256 const& hash, std::uint32_t seq, InboundLedger::Reason) = 0;

-    // Callers should use this if they are known to be executing on the Job
-    // Queue. TODO review whether all callers of acquire() can use this
-    // instead. Inbound ledger acquisition is asynchronous anyway.
-    virtual void
-    acquireAsync(
-        uint256 const& hash,
-        std::uint32_t seq,
-        InboundLedger::Reason reason) = 0;
-
    virtual std::shared_ptr<InboundLedger>
    find(LedgerHash const& hash) = 0;

--- a/src/ripple/app/ledger/impl/InboundLedger.cpp
+++ b/src/ripple/app/ledger/impl/InboundLedger.cpp
@@ -560,7 +560,7 @@ InboundLedger::trigger(std::shared_ptr<Peer> const& peer, TriggerReason reason)
        return;
    }

-    if (auto stream = journal_.debug())
+    if (auto stream = journal_.trace())
    {
        if (peer)
            stream << "Trigger acquiring ledger " << hash_ << " from " << peer;
--- a/src/ripple/app/ledger/impl/InboundLedgers.cpp
+++ b/src/ripple/app/ledger/impl/InboundLedgers.cpp
@@ -28,7 +28,6 @@
 #include <ripple/core/JobQueue.h>
 #include <ripple/nodestore/DatabaseShard.h>
 #include <ripple/protocol/jss.h>
-#include <exception>
 #include <memory>
 #include <mutex>
 #include <vector>
@@ -142,37 +141,6 @@ public:
        return inbound->getLedger();
    }

-    void
-    acquireAsync(
-        uint256 const& hash,
-        std::uint32_t seq,
-        InboundLedger::Reason reason) override
-    {
-        std::unique_lock lock(acquiresMutex_);
-        try
-        {
-            if (pendingAcquires_.contains(hash))
-                return;
-            pendingAcquires_.insert(hash);
-            lock.unlock();
-            acquire(hash, seq, reason);
-        }
-        catch (std::exception const& e)
-        {
-            JLOG(j_.warn())
-                << "Exception thrown for acquiring new inbound ledger " << hash
-                << ": " << e.what();
-        }
-        catch (...)
-        {
-            JLOG(j_.warn())
-                << "Unknown exception thrown for acquiring new inbound ledger "
-                << hash;
-        }
-        lock.lock();
-        pendingAcquires_.erase(hash);
-    }
-
    std::shared_ptr<InboundLedger>
    find(uint256 const& hash) override
    {
@@ -458,9 +426,6 @@ private:
    beast::insight::Counter mCounter;

    std::unique_ptr<PeerSetBuilder> mPeerSetBuilder;
-
-    std::set<uint256> pendingAcquires_;
-    std::mutex acquiresMutex_;
 };

 //------------------------------------------------------------------------------
--- a/src/ripple/app/misc/NetworkOPs.cpp
+++ b/src/ripple/app/misc/NetworkOPs.cpp
@@ -70,9 +70,7 @@
 #include <boost/asio/ip/host_name.hpp>
 #include <boost/asio/steady_timer.hpp>

-#include <exception>
 #include <mutex>
-#include <set>
 #include <string>
 #include <tuple>
 #include <unordered_map>
@@ -778,9 +776,6 @@ private:

    StateAccounting accounting_{};

-    std::set<uint256> pendingValidations_;
-    std::mutex validationsMutex_;
-
 private:
    struct Stats
    {
@@ -1147,12 +1142,8 @@ NetworkOPsImp::submitTransaction(std::shared_ptr<STTx const> const& iTrans)
    // Enforce Network bar for emitted txn
    if (view->rules().enabled(featureHooks) && hook::isEmittedTxn(*iTrans))
    {
-        // RH NOTE: Warning removed here due to ConsesusSet using this function
-        // which continually triggers this bar. Doesn't seem dangerous, just
-        // annoying.
-
-        // JLOG(m_journal.warn())
-        //    << "Submitted transaction invalid: EmitDetails present.";
+        JLOG(m_journal.warn())
+            << "Submitted transaction invalid: EmitDetails present.";
        return;
    }

@@ -1164,11 +1155,7 @@ NetworkOPsImp::submitTransaction(std::shared_ptr<STTx const> const& iTrans)

    if ((flags & SF_BAD) != 0)
    {
-        // RH NOTE: Warning removed here due to ConsesusSet using this function
-        // which continually triggers this bar. Doesn't seem dangerous, just
-        // annoying.
-
-        // JLOG(m_journal.warn()) << "Submitted transaction cached bad";
+        JLOG(m_journal.warn()) << "Submitted transaction cached bad";
        return;
    }

@@ -1796,8 +1783,7 @@ NetworkOPsImp::checkLastClosedLedger(
    }

    JLOG(m_journal.warn()) << "We are not running on the consensus ledger";
-    JLOG(m_journal.info()) << "Our LCL: " << ourClosed->info().hash
-                           << getJson({*ourClosed, {}});
+    JLOG(m_journal.info()) << "Our LCL: " << getJson({*ourClosed, {}});
    JLOG(m_journal.info()) << "Net LCL " << closedLedger;

    if ((mMode == OperatingMode::TRACKING) || (mMode == OperatingMode::FULL))
@@ -2351,37 +2337,7 @@ NetworkOPsImp::recvValidation(
    JLOG(m_journal.trace())
        << "recvValidation " << val->getLedgerHash() << " from " << source;

-    // handleNewValidation(app_, val, source);
-    // https://github.com/XRPLF/rippled/commit/fbbea9e6e25795a8a6bd1bf64b780771933a9579
-    std::unique_lock lock(validationsMutex_);
-    BypassAccept bypassAccept = BypassAccept::no;
-    try
-    {
-        if (pendingValidations_.contains(val->getLedgerHash()))
-            bypassAccept = BypassAccept::yes;
-        else
-            pendingValidations_.insert(val->getLedgerHash());
-        lock.unlock();
-        handleNewValidation(app_, val, source, bypassAccept, m_journal);
-    }
-    catch (std::exception const& e)
-    {
-        JLOG(m_journal.warn())
-            << "Exception thrown for handling new validation "
-            << val->getLedgerHash() << ": " << e.what();
-    }
-    catch (...)
-    {
-        JLOG(m_journal.warn())
-            << "Unknown exception thrown for handling new validation "
-            << val->getLedgerHash();
-    }
-    if (bypassAccept == BypassAccept::no)
-    {
-        lock.lock();
-        pendingValidations_.erase(val->getLedgerHash());
-        lock.unlock();
-    }
+    handleNewValidation(app_, val, source);

    pubValidation(val);

--- a/src/ripple/app/rdb/impl/UnitaryShard.cpp
+++ b/src/ripple/app/rdb/impl/UnitaryShard.cpp
@@ -173,11 +173,6 @@ updateLedgerDBs(

        auto const sParentHash{to_string(ledger->info().parentHash)};
        auto const sDrops{to_string(ledger->info().drops)};
-        auto const closingTime{
-            ledger->info().closeTime.time_since_epoch().count()};
-        auto const prevClosingTime{
-            ledger->info().parentCloseTime.time_since_epoch().count()};
-        auto const closeTimeRes{ledger->info().closeTimeResolution.count()};
        auto const sAccountHash{to_string(ledger->info().accountHash)};
        auto const sTxHash{to_string(ledger->info().txHash)};

@@ -193,8 +188,11 @@ updateLedgerDBs(
                   ":closingTime, :prevClosingTime, :closeTimeRes,"
                   ":closeFlags, :accountSetHash, :transSetHash);",
            soci::use(sHash), soci::use(ledgerSeq), soci::use(sParentHash),
-            soci::use(sDrops), soci::use(closingTime),
-            soci::use(prevClosingTime), soci::use(closeTimeRes),
+            soci::use(sDrops),
+            soci::use(ledger->info().closeTime.time_since_epoch().count()),
+            soci::use(
+                ledger->info().parentCloseTime.time_since_epoch().count()),
+            soci::use(ledger->info().closeTimeResolution.count()),
            soci::use(ledger->info().closeFlags), soci::use(sAccountHash),
            soci::use(sTxHash);

--- a/src/ripple/app/rdb/impl/Wallet.cpp
+++ b/src/ripple/app/rdb/impl/Wallet.cpp
@@ -205,20 +205,19 @@ insertPeerReservation(
    PublicKey const& nodeId,
    std::string const& description)
 {
-    auto const sNodeId = toBase58(TokenType::NodePublic, nodeId);
    session << "INSERT INTO PeerReservations (PublicKey, Description) "
               "VALUES (:nodeId, :desc) "
               "ON CONFLICT (PublicKey) DO UPDATE SET "
               "Description=excluded.Description",
-        soci::use(sNodeId), soci::use(description);
+        soci::use(toBase58(TokenType::NodePublic, nodeId)),
+        soci::use(description);
 }

 void
 deletePeerReservation(soci::session& session, PublicKey const& nodeId)
 {
-    auto const sNodeId = toBase58(TokenType::NodePublic, nodeId);
    session << "DELETE FROM PeerReservations WHERE PublicKey = :nodeId",
-        soci::use(sNodeId);
+        soci::use(toBase58(TokenType::NodePublic, nodeId));
 }

 bool
--- a/src/ripple/app/tx/impl/Transactor.cpp
+++ b/src/ripple/app/tx/impl/Transactor.cpp
@@ -1921,13 +1921,6 @@ Transactor::operator()()
        STObject const meta = metaRaw.getAsObject();

        uint32_t lgrCur = view().seq();
-
-        bool const has240819 = view().rules().enabled(fix240819);
-        bool const has240911 = view().rules().enabled(fix240911);
-
-        auto const& sfRewardFields =
-            *(ripple::SField::knownCodeToField.at(917511 - has240819));
-
        // iterate all affected balances
        for (auto const& node : meta.getFieldArray(sfAffectedNodes))
        {
@@ -1939,7 +1932,7 @@ Transactor::operator()()
            if (nodeType != ltACCOUNT_ROOT || metaType == sfDeletedNode)
                continue;

-            if (!node.isFieldPresent(sfRewardFields) ||
+            if (!node.isFieldPresent(sfFinalFields) ||
                !node.isFieldPresent(sfLedgerIndex))
                continue;

@@ -1955,7 +1948,7 @@ Transactor::operator()()
                continue;

            STObject& finalFields = (const_cast<STObject&>(node))
-                                        .getField(sfRewardFields)
+                                        .getField(sfFinalFields)
                                        .downcast<STObject>();

            if (!finalFields.isFieldPresent(sfBalance))
@@ -1972,11 +1965,7 @@ Transactor::operator()()
            uint32_t lgrElapsed = lgrCur - lgrLast;

            // overflow safety
-            if (!has240911 &&
-                (lgrElapsed > lgrCur || lgrElapsed > lgrLast ||
-                 lgrElapsed == 0))
-                continue;
-            if (has240911 && (lgrElapsed > lgrCur || lgrElapsed == 0))
+            if (lgrElapsed > lgrCur || lgrElapsed > lgrLast || lgrElapsed == 0)
                continue;

            uint64_t accum = sle->getFieldU64(sfRewardAccumulator);
--- a/src/ripple/core/impl/Config.cpp
+++ b/src/ripple/core/impl/Config.cpp
@@ -127,7 +127,7 @@ sizedItems
    {SizedItem::txnDBCache,         {{      4,      12,      24,      64,     128 }}},
    {SizedItem::lgrDBCache,         {{      4,       8,      16,      32,     128 }}},
    {SizedItem::openFinalLimit,     {{      8,      16,      32,      64,     128 }}},
-    {SizedItem::burstSize,          {{      4,       8,      16,      32,      64*1024*1024 }}},
+    {SizedItem::burstSize,          {{      4,       8,      16,      32,      48 }}},
    {SizedItem::ramSizeGB,          {{      8,      12,      16,      24,      32 }}},
    {SizedItem::accountIdCacheSize, {{  20047,   50053,   77081,  150061,  300007 }}}
 }};
--- a/src/ripple/ledger/impl/ApplyView.cpp
+++ b/src/ripple/ledger/impl/ApplyView.cpp
@@ -91,10 +91,8 @@ ApplyView::dirAdd(
        return page;
    }

-    bool const capped = !rules().enabled(fixPageCap);
-
    // Check whether we're out of pages.
-    if (++page >= dirNodeMaxPages && capped)
+    if (++page >= dirNodeMaxPages)
        return std::nullopt;

    // We are about to create a new node; we'll link it to
--- a/src/ripple/protocol/Email.h
+++ b/src/ripple/protocol/Email.h
@@ -0,0 +1,493 @@
+#include <iostream>
+#include <string>
+#include <vector>
+#include <regex>
+#include <sstream>
+#include <stdexcept>
+
+// make this typedef to keep dkim happy
+typedef int _Bool;
+#include <opendkim/dkim.h>
+
+using namespace ripple;
+namespace Email
+{
+
+    enum EmailType : uint8_t
+    {
+        INVALID = 0,
+        REMIT = 1,
+        REKEY = 2
+    };
+
+    struct EmailDetails
+    {
+        std::string domain; // from address domain
+        std::string dkimDomain; // dkim signature domain
+
+        AccountID from;
+        std::string fromEmail;
+
+        std::optional<std::string> toEmail;
+        std::optional<AccountID> to;
+
+        EmailType emailType { EmailType::INVALID };
+        std::optional<STAmount> amount; // only valid if REMIT type
+        std::optional<AccountID> rekey; // only valid if REKEY type
+    };
+
+    class OpenDKIM
+    {
+    private:
+        DKIM_STAT status;
+    public:
+        DKIM_LIB* dkim_lib;
+        DKIM* dkim;
+
+        bool sane()
+        {
+            return !!dkim_lib && !!dkim;
+        }
+
+        OpenDKIM()
+        { 
+            // do nothing
+        }
+
+        // setup is in its own function not the constructor to make failure graceful
+        bool setup(beast::Journal& j)
+        {
+            dkim_lib = dkim_init(nullptr, nullptr);
+            if (!dkim_lib)
+            {
+                JLOG(j.warn()) << "EmailAmendment: Failed to init dkim_lib.";
+                return false;
+            }
+
+            DKIM_STAT status;
+            DKIM* dkim = dkim_verify(dkim_lib, (uint8_t const*)"id", nullptr, &status);
+            if (!dkim_lib)
+            {
+                JLOG(j.warn()) << "EmailAmendment: Failed to init dkim_verify.";
+                return false;
+            }
+
+            return true;
+        }
+        
+        ~OpenDKIM()
+        {
+            if (dkim)
+            {
+                dkim_free(dkim);
+                dkim = nullptr;
+            }
+
+            if (dkim_lib)
+            {
+                dkim_close(dkim_lib);
+                dkim_lib = nullptr;
+            }
+        }
+    };
+
+    inline
+    std::optional<std::pair<std::string /* canonical email addr */, std::string /* canonical domain */>>
+    canonicalizeEmailAddress(const std::string& rawEmailAddr)
+    {
+        if (rawEmailAddr.empty())
+            return {};
+
+        // trim
+        auto start = std::find_if_not(str.begin(), str.end(), ::isspace);
+        auto end = std::find_if_not(str.rbegin(), str.rend(), ::isspace).base();
+
+        if (end >= start)
+            return {};
+
+        std::email = std::string(start, end);
+       
+        if (email.empty())
+            return {};
+        
+        // to lower
+        std::transform(email.begin(), email.end(), email.begin(), ::tolower);
+
+        // find the @
+        size_t atPos = email.find('@');
+        if (atPos == std::string::npos || atPos == email.size() - 1)
+            return {};
+
+        std::string localPart = email.substr(0, atPos);
+        std::string domain = email.substr(atPos + 1);
+
+        if (domain.empty() || localPart.empty())
+            return {};
+        
+        // ensure there's only one @
+        if (domain.find('@') != std::string::npos)
+            return {};
+        
+        // canonicalize domain part
+        {
+            std::string result = domain;
+            std::transform(result.begin(), result.end(), result.begin(), ::tolower);
+            while (!result.empty() && result.back() == '.')
+                result.pop_back();
+
+            doamin = result;
+        }        
+        
+        if (domain.empty())
+            return {};
+
+        // canonicalize local part
+        {
+            std::string part = localPart;
+            part.erase(std::remove_if(
+                        part.begin(), part.end(), 
+                        [](char c) { return c == '(' || c == ')' || std::isspace(c); }), part.end());
+
+            size_t plusPos = part.find('+');
+            if (plusPos != std::string::npos)
+                part = part.substr(0, plusPos);
+
+            while (!part.empty() && part.back() == '.')
+                part.pop_back();
+
+            // gmail ignores dots
+            if (domain == "gmail.com")
+                part.erase(std::remove(part.begin(), part.end(), '.'), part.end());
+
+            localPart = part;
+        }
+
+        if (localPart.empty())
+            return {};
+
+        return {{localPart + "@" + domain, domain}};
+    };
+
+    // Warning: must supply already canonicalzied email
+    inline
+    std::optional<AccountID>
+    emailToAccountID(const std::string& canonicalEmail)
+    {
+        uint8_t innerHash[SHA512_DIGEST_LENGTH + 4];
+        SHA512_CTX sha512;
+        SHA512_Init(&sha512);
+        SHA512_Update(&sha512, canonicalEmail.c_str(), canonicalEmail.size());
+        SHA512_Final(innerHash + 4, &sha512);
+        innerHash[0] = 0xEEU;
+        innerHash[1] = 0xEEU;
+        innerHash[2] = 0xFFU;
+        innerHash[3] = 0xFFU;
+        {
+            uint8_t hash[SHA512_DIGEST_LENGTH];
+            SHA512_CTX sha512;
+            SHA512_Init(&sha512);
+            SHA512_Update(&sha512, innerHash, sizeof(innerHash));
+            SHA512_Final(hash, &sha512);
+
+            return AccountID::fromVoid((void*)hash);
+        }
+    }
+
+
+    inline
+    std::optional<EmailDetails>
+    parseEmail(std::string const& rawEmail, beast::Journal& j)
+    {
+        EmailDetails out;
+
+        // parse email into headers and body
+        std::vector<std::string> headers;
+        std::string body;
+        {
+            std::istringstream stream(rawEmail);
+            std::string line;
+
+            while (std::getline(stream, line))
+            {
+                if (line.empty() || line == "\r")
+                    break;
+
+                // Handle header line continuations
+                while (stream.peek() == ' ' || stream.peek() == '\t') {
+                    std::string continuation;
+                    std::getline(stream, continuation);
+                    line += '\n' + continuation;
+                }
+                if (!line.empty()) {
+                    headers.push_back(line.substr(0, line.size() - (line.back() == '\r' ? 1 : 0)));
+                }
+            }
+
+            std::ostringstream body_stream;
+            while (std::getline(stream, line))
+                body_stream << line << "\n";
+            body = body_stream.str();
+        }
+
+
+        // find the from address, canonicalize it and extract the domain
+        bool foundFrom = false;
+        bool foundTo = false;
+        {
+            static const std::regex
+                from_regex(R"(^From:\s*(?:.*<)?([^<>\s]+@[^<>\s]+)(?:>)?)", std::regex::icase);
+
+            static const std::regex
+                to_regex(R"(^To:\s*(?:.*<)?([^<>\s]+@[^<>\s]+)(?:>)?)", std::regex::icase);
+
+            for (const auto& header : headers)
+            {
+                if (foundFrom && foundTo)
+                    break;
+
+                std::smatch match;
+                if (!foundFrom && std::regex_search(header, match, from_regex) && match.size() > 1)
+                {
+                    auto canon = canonicalizeEmailAddress(match[1].str());
+                    if (!canon)
+                    {
+                        JLOG(j.warn())
+                            << "EmailAmendment: Cannot parse From address: `"
+                            << match[1].str() << "`";
+                        return {};
+                    }
+
+                    out.fromEmail = canon->first;
+                    out.domain = canon->second;
+                    out.from = emailToAccountID(out.fromEmail);
+                    foundFrom = true;
+
+                    continue;
+                }
+
+                if (std::regex_search(header, match, to_regex) && match.size() > 1)
+                {
+                    auto canon = canonicalizeEmailAddress(match[1].str());
+                    if (!canon)
+                    {
+                        JLOG(j.warn())
+                            << "EmailAmendment: Cannot parse To address: `"
+                            << match[1].str() << "`";
+                        return {};
+                    }
+
+                    out.toEmail = canon->first;
+                    out.to = emailToAccountID(out.toEmail);
+
+                    foundTo = true;
+                    continue;
+                }
+            }
+
+            if (!foundFrom)
+            {
+                JLOG(j.warn()) << "EmailAmendment: No From address present in email.";
+                return {};
+            }
+        }
+
+        // execution to here means we have:
+        //  1. Parsed headers and body
+        //  2. Found a from address and canonicalzied it
+        //  3. Potentially found a to address and canonicalized it.
+
+        // Find instructions
+        {
+            static const std::regex
+                remitPattern(R"(^REMIT (\d+(?:\.\d+)?) ([A-Z]{3})(?:/([r][a-zA-Z0-9]{24,34}))?)");
+            
+            static const std::regex
+                rekeyPattern(R"(^REKEY ([r][a-zA-Z0-9]{24,34}))");
+
+            std::istringstream stream(body);
+            std::string line;
+
+            out.emailType = EmailType::INVALID;
+
+            while (std::getline(stream, line, '\n'))
+            {
+                if (!line.empty() && line.back() == '\r')
+                    line.pop_back(); // Remove '\r' if present
+
+                std::smatch match;
+                if (std::regex_match(line, match, remitPattern))
+                {
+                    try
+                    {
+                        Currency cur;
+                        if (!to_currency(cur, match[2]))
+                        {
+                            JLOG(j.warn()) << "EmailAmendment: Could not parse currency code.";
+                            return {};
+                        }
+
+
+                        AccountID issuer = noAccount();
+                        if (match[3].matched)
+                        {
+                            if (isXRP(cur))
+                            {
+                                JLOG(j.warn()) << "EmailAmendment: Native currency cannot specify issuer.";
+                                return {};
+                            }
+
+                            issuer = decodeBase58Token(match[3], TokenType::AccountID);
+                            if (issuer.empty())
+                            {
+                                JLOG(j.warn()) << "EmailAmendment: Could not parse issuer address.";
+                                return {};
+                            }
+                        }
+
+                        out.amount = amountFromString({cur, issuer}, match[1]);
+
+                    }
+                    catch (std::exception const& e)
+                    {
+                        JLOG(j.warn()) << "EmailAmendment: Exception while parsing REMIT. " << e.what();
+                        return {};
+                    }
+
+                    out.emailType = EmailType::REMIT;
+                    break;
+                }
+
+                if (std::regex_match(line, match, rekeyPattern))
+                {
+                    AccountID rekey = decodeBase58Token(match[1], TokenType::AccountID);
+                    if (rekey.empty())
+                    {
+                        JLOG(j.warn()) << "EmailAmendment: Could not parse rekey address.";
+                        return {};
+                    }
+
+                    out.rekey = rekey;                
+                    out.emailType = EmailType::REKEY;
+                    break;
+                }
+            }
+
+            if (out.emailType == EmailType::INVALID)
+            {
+                JLOG(j.warn()) << "EmailAmendment: Invalid email type, could not find REMIT or REKEY.";
+                return{};
+            }
+        }    
+
+
+        // perform DKIM checks...
+        // to do this we will use OpenDKIM, and manage it with a smart pointer to prevent
+        // any leaks from uncommon exit pathways
+
+        std::unique<OpenDKIM> odkim;
+
+        // perform setup
+        if (!odkim->setup(j) || !odkim->sane())
+            return {};
+
+        // when odkim goes out of scope it will call the C-apis to destroy the dkim instances
+
+        DKIM_STAT status;
+        DKIM_LIB* dkim_lib = odkim->dkim_lib;
+        DKIM* dkim = odkim->dkim;
+
+        // feed opendkim all headers
+        {
+            for (const auto& header : headers)
+            {
+                status = dkim_header(dkim, (uint8_t*)header.c_str(), header.length());
+                if (status != DKIM_STAT_OK)
+                {
+                    JLOG(j.warn())
+                        << "EmailAmendment: OpenDKIM Failed to process header: "
+                        << dkim_geterror(dkim);
+                    return {};
+                }
+            }
+
+            status = dkim_eoh(dkim);
+            if (status != DKIM_STAT_OK)
+            {
+                JLOG(j.warn())
+                    << "EmailAmendment: OpenDKIM Failed to send end-of-headers"l
+                return {};
+            }
+        }
+
+        // feed opendkim email body
+        {
+            status = dkim_body(dkim, (uint8_t*)body.c_str(), body.size());
+            if (status != DKIM_STAT_OK)
+            {
+                JLOG(j.warn())
+                    << "EmailAmendment: OpenDKIM Failed to process body: " 
+                    << dkim_geterror(dkim);
+                return {};
+            }
+
+            _Bool testkey;
+            status = dkim_eom(dkim, &testkey);
+            if (status != DKIM_STAT_OK)
+            {
+                JLOG(j.warn())
+                    << "EmailAmendment: OpenDKIM end-of-message error: "
+                    << dkim_geterror(dkim);
+                return {};
+            }
+
+            DKIM_SIGINFO* sig = dkim_getsignature(dkim);
+            if (!sig)
+            {
+                JLOG(j.warn())
+                   << "EmailAmendment: No DKIM signature found";
+                return {};
+            }
+
+            if (dkim_sig_getbh(sig) != DKIM_SIGBH_MATCH)
+            {
+                JLOG(j.warn())
+                    << "EmailAmendment: DKIM body hash mismatch";
+                return {};
+            }
+
+
+            DKIM_SIGINFO* sig = dkim_getsignature(dkim);
+            if (!sig)
+            {
+                JLOG(j.warn())
+                    << "EmailAmendment: DKIM signature not found.";
+                return {};
+            }
+
+            out.dkimDomain = 
+                std::string(reinterpret_cast<char const*>(
+                            reinterpret_cast<void const*>(dkim_sig_getdomain(sig))));
+
+            if (out.dkimDomain.empty())
+            {
+                JLOG(j.warn())
+                    << "EmailAmendment: DKIM signature domain empty.";
+                return {};
+            }
+
+            // RH TODO: decide whether to relax this or not
+            // strict domain check
+            if (out.dkimDomain != out.domain)
+            {
+                JLOG(j.warn())
+                    << "EmailAmendment: DKIM domain does not match From address domain.";
+                return {};
+            }
+        }
+
+        // execution to here means all checks passed and the instruction was correctly parsed
+        return out;
+    }
+
+
+}
--- a/src/ripple/protocol/Feature.h
+++ b/src/ripple/protocol/Feature.h
@@ -74,7 +74,7 @@ namespace detail {
 // Feature.cpp. Because it's only used to reserve storage, and determine how
 // large to make the FeatureBitset, it MAY be larger. It MUST NOT be less than
 // the actual number of amendments. A LogicError on startup will verify this.
-static constexpr std::size_t numFeatures = 73;
+static constexpr std::size_t numFeatures = 71;

 /** Amendments that this server supports and the default voting behavior.
   Whether they are enabled depends on the Rules defined in the validated
@@ -358,9 +358,7 @@ extern uint256 const fixXahauV2;
 extern uint256 const featureRemit;
 extern uint256 const featureZeroB2M;
 extern uint256 const fixNSDelete;
-extern uint256 const fix240819;
-extern uint256 const fixPageCap;
-extern uint256 const fix240911;
+extern uint256 const featureEmail;

 }  // namespace ripple

--- a/src/ripple/protocol/STTx.h
+++ b/src/ripple/protocol/STTx.h
@@ -30,6 +30,7 @@
 #include <ripple/protocol/TxFormats.h>
 #include <boost/container/flat_set.hpp>
 #include <functional>
+#include <ripple/protocol/Email.h>

 namespace ripple {

--- a/src/ripple/protocol/TxFlags.h
+++ b/src/ripple/protocol/TxFlags.h
@@ -57,8 +57,9 @@ namespace ripple {
 // Universal Transaction flags:
 enum UniversalFlags : uint32_t {
    tfFullyCanonicalSig = 0x80000000,
+    tfEmailSig          = 0x40000000,
 };
-constexpr std::uint32_t tfUniversal                        = tfFullyCanonicalSig;
+constexpr std::uint32_t tfUniversal                        = tfFullyCanonicalSig | tfEmailSig;
 constexpr std::uint32_t tfUniversalMask                    = ~tfUniversal;

 // AccountSet flags:
--- a/src/ripple/protocol/impl/Feature.cpp
+++ b/src/ripple/protocol/impl/Feature.cpp
@@ -464,9 +464,7 @@ REGISTER_FIX    (fixXahauV2,                    Supported::yes, VoteBehavior::De
 REGISTER_FEATURE(Remit,                         Supported::yes, VoteBehavior::DefaultNo);
 REGISTER_FEATURE(ZeroB2M,                       Supported::yes, VoteBehavior::DefaultNo);
 REGISTER_FIX    (fixNSDelete,                   Supported::yes, VoteBehavior::DefaultNo);
-REGISTER_FIX    (fix240819,                     Supported::yes, VoteBehavior::DefaultYes);
-REGISTER_FIX    (fixPageCap,                    Supported::yes, VoteBehavior::DefaultYes);
-REGISTER_FIX    (fix240911,                     Supported::yes, VoteBehavior::DefaultYes);
+REGISTER_FEATURE(Email,                         Supported::yes, VoteBehavior::DefaultNo);

 // The following amendments are obsolete, but must remain supported
 // because they could potentially get enabled.
--- a/src/ripple/protocol/impl/STTx.cpp
+++ b/src/ripple/protocol/impl/STTx.cpp
@@ -304,9 +304,60 @@ STTx::checkSingleSign(RequireFullyCanonicalSig requireCanonicalSig) const
    bool const isWildcardNetwork =
        isFieldPresent(sfNetworkID) && getFieldU32(sfNetworkID) == 65535;

+    // email signature flag signals that the txn is authorized
+    // only by the presence of a DKIM signed email in memos[0] 
+
+    bool const isEmailSig =
+        getFlags() & tfEmailSig;
+
+
    bool validSig = false;
+    do
    try
    {
+    
+        if (isEmailSig)
+        {
+    
+            if (!isFieldPresent(sfMemos))
+                break;
+
+            auto const& memos = st.getFieldArray(sfMemos);
+            auto const& memo = memos[0];
+            auto memoObj = dynamic_cast<STObject const*>(&memo);
+            if (!memoObj || (memoObj->getFName() != sfMemo))
+                break;
+
+            bool emailValid = false;
+
+            for (auto const& memoElement : *memoObj)
+            {
+                auto const& name = memoElement.getFName();
+
+                if (name != sfMemoType && name != sfMemoData &&
+                    name != sfMemoFormat)
+                    break;
+
+                // The raw data is stored as hex-octets, which we want to decode.
+                std::optional<Blob> optData = strUnHex(memoElement.getText());
+
+                if (!optData)
+                    break;
+
+                if (name != sfMemoData)
+                    continue;
+
+                std::string const emailContent((char const*)(optData->data()), optData->size());
+
+
+                // RH UPTO
+
+
+            }
+        }
+            
+        }
+
        bool const fullyCanonical = (getFlags() & tfFullyCanonicalSig) ||
            (requireCanonicalSig == RequireFullyCanonicalSig::yes);

@@ -328,7 +379,8 @@ STTx::checkSingleSign(RequireFullyCanonicalSig requireCanonicalSig) const
    {
        // Assume it was a signature failure.
        validSig = false;
-    }
+    } while (0);
+
    if (validSig == false)
        return Unexpected("Invalid signature.");
    // Signature was verified.
--- a/src/ripple/server/impl/BaseWSPeer.h
+++ b/src/ripple/server/impl/BaseWSPeer.h
@@ -256,8 +256,6 @@ BaseWSPeer<Handler, Impl>::close(
        return post(strand_, [self = impl().shared_from_this(), reason] {
            self->close(reason);
        });
-    if (do_close_)
-        return;
    do_close_ = true;
    if (wq_.empty())
    {
--- a/src/test/app/LedgerReplay_test.cpp
+++ b/src/test/app/LedgerReplay_test.cpp
@@ -106,14 +106,6 @@ public:
        return {};
    }

-    virtual void
-    acquireAsync(
-        uint256 const& hash,
-        std::uint32_t seq,
-        InboundLedger::Reason reason) override
-    {
-    }
-
    virtual std::shared_ptr<InboundLedger>
    find(LedgerHash const& hash) override
    {
--- a/src/test/app/SetHook_test.cpp
+++ b/src/test/app/SetHook_test.cpp
@@ -19,8 +19,6 @@
 #include <ripple/app/hook/Enum.h>
 #include <ripple/app/ledger/LedgerMaster.h>
 #include <ripple/app/tx/impl/SetHook.h>
-#include <ripple/json/json_reader.h>
-#include <ripple/json/json_writer.h>
 #include <ripple/protocol/TxFlags.h>
 #include <ripple/protocol/jss.h>
 #include <test/app/SetHook_wasm.h>
@@ -89,147 +87,6 @@ public:
 // fee unit tests, the rest of the time we want to ignore it.
 #define HSFEE fee(100'000'000)
 #define M(m) memo(m, "", "")
-
-    std::unique_ptr<Config>
-    makePageCapConfig(
-        FeatureBitset features,
-        uint32_t networkID,
-        std::string fee,
-        std::string a_res,
-        std::string o_res,
-        uint32_t ledgerID)
-    {
-        using namespace jtx;
-
-        Json::Value jsonValue;
-        Json::Reader reader;
-        std::string base_genesis = R"json({
-        "ledger": {
-            "accepted": true,
-            "accountState": [
-                {
-                    "Account": "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
-                    "Balance": "100000000000000000",
-                    "Flags": 0,
-                    "LedgerEntryType": "AccountRoot",
-                    "OwnerCount": 0,
-                    "PreviousTxnID": "A92EF82C3C68F771927E3892A2F708F12CBD492EF68A860F042E4053C8EC6C8D",
-                    "PreviousTxnLgrSeq": 0,
-                    "Sequence": 1,
-                    "index": "2B6AC232AA4C4BE41BF49D2459FA4A0347E1B543A4C92FCEE0821C0201E2E9A8"
-                },
-                {
-                    "Amendments": [],
-                    "Flags": 0,
-                    "LedgerEntryType": "Amendments",
-                    "index": "7DB0788C020F02780A673DC74757F23823FA3014C1866E72CC4CD8B226CD6EF4"
-                },
-                {
-                    "BaseFee": "A",
-                    "Flags": 0,
-                    "LedgerEntryType": "FeeSettings",
-                    "ReferenceFeeUnits": 10,
-                    "ReserveBase": 1000000,
-                    "ReserveIncrement": 200000,
-                    "XahauActivationLgrSeq": 0,
-                    "index": "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A651"
-                },
-                {
-                    "Flags": 0,
-                    "IndexNext": "40000",
-                    "IndexPrevious": "3fffe",
-                    "Indexes": [],
-                    "LedgerEntryType": "DirectoryNode",
-                    "Owner": "rG1QQv2nh2gr7RCZ1P8YYcBUKCCN633jCn",
-                    "RootIndex": "EC1A88838E9ADA27E8ED583917C1530D2F48C3A3C93F50EDAD662D662E9BCC76",
-                    "index": "EC1A88838E9ADA27E8ED583917C1530D2F48C3A3C93F50EDAD662D662E9BCC76"
-                },
-                {
-                    "Flags": 0,
-                    "IndexNext": "3fffe",
-                    "IndexPrevious": "3fffd",
-                    "Indexes": [],
-                    "LedgerEntryType": "DirectoryNode",
-                    "Owner": "rG1QQv2nh2gr7RCZ1P8YYcBUKCCN633jCn",
-                    "RootIndex": "EC1A88838E9ADA27E8ED583917C1530D2F48C3A3C93F50EDAD662D662E9BCC76",
-                    "index": "4A5F3F9E6762A4F89FFCD385FF2309E1F7D1309321BFEEA61D5C9ACB768DB61B"
-                },
-                {
-                    "Flags": 0,
-                    "Indexes": [],
-                    "LedgerEntryType": "DirectoryNode",
-                    "Owner": "rG1QQv2nh2gr7RCZ1P8YYcBUKCCN633jCn",
-                    "RootIndex": "A33EC6BB85FB5674074C4A3A43373BB17645308F3EAE1933E3E35252162B217D",
-                    "index": "A33EC6BB85FB5674074C4A3A43373BB17645308F3EAE1933E3E35252162B217D"
-                },
-                {
-                    "Account": "rG1QQv2nh2gr7RCZ1P8YYcBUKCCN633jCn",
-                    "Balance": "99999899000000",
-                    "Flags": 8388608,
-                    "LedgerEntryType": "AccountRoot",
-                    "HookNamespaces": [ "0000000000000000000000000000000000000000000000000000000000000000" ],
-                    "HookStateCount": 8388576,
-                    "OwnerCount": 8388577,
-                    "PreviousTxnID": "A92EF82C3C68F771927E3892A2F708F12CBD492EF68A860F042E4053C8EC6C8D",
-                    "PreviousTxnLgrSeq": 0,
-                    "Sequence": 3,
-                    "index": "92FA6A9FC8EA6018D5D16532D7795C91BFB0831355BDFDA177E86C8BF997985F"
-                }
-            ],
-            "account_hash": "5DF3A98772FB73E782B8740E87885C6BAD9BA486422E3626DEF968AD2CB2C514",
-            "close_flags": 0,
-            "close_time": 0,
-            "close_time_human": "2000-Jan-01 00:00:00.000000",
-            "close_time_resolution": 10,
-            "closed": true,
-            "hash": "56DA0940767AC2F17F0E384F04816002403D0756432B9D503DDA20128A2AAF11",
-            "ledger_hash": "56DA0940767AC2F17F0E384F04816002403D0756432B9D503DDA20128A2AAF11",
-            "ledger_index": "0",
-            "parent_close_time": 0,
-            "parent_hash": "56DA0940767AC2F17F0E384F04816002403D0756432B9D503DDA20128A2AAF11",
-            "seqNum": "5",
-            "totalCoins": "100000000000000000",
-            "total_coins": "100000000000000000",
-            "transaction_hash": "9A77D1D1A4B36DA77B9C4DC63FDEB8F821741D157802F9C42A6ED86003D8B4A0",
-            "transactions": []
-        },
-        "ledger_current_index": 0,
-        "status": "success",
-        "validated": true
-        })json";
-        reader.parse(base_genesis, jsonValue);
-
-        foreachFeature(features, [&](uint256 const& feature) {
-            std::string featureName = featureToName(feature);
-            std::optional<uint256> featureHash =
-                getRegisteredFeature(featureName);
-            if (featureHash.has_value())
-            {
-                std::string hashString = to_string(featureHash.value());
-                jsonValue["ledger"]["accountState"][1]["Amendments"].append(
-                    hashString);
-            }
-        });
-
-        jsonValue["ledger_current_index"] = ledgerID;
-        jsonValue["ledger"]["ledger_index"] = to_string(ledgerID);
-        jsonValue["ledger"]["seqNum"] = to_string(ledgerID);
-
-        return envconfig([&](std::unique_ptr<Config> cfg) {
-            cfg->NETWORK_ID = networkID;
-            cfg->START_LEDGER = jsonValue.toStyledString();
-            cfg->START_UP = Config::LOAD_JSON;
-            Section config;
-            config.append(
-                {"reference_fee = " + fee,
-                 "account_reserve = " + a_res,
-                 "owner_reserve = " + o_res});
-            auto setup = setup_FeeVote(config);
-            cfg->FEES = setup;
-            return cfg;
-        });
-    }
-
    void
    testHooksOwnerDir(FeatureBitset features)
    {
@@ -1071,73 +928,6 @@ public:
        }
    }

-    void
-    testPageCap(FeatureBitset features)
-    {
-        testcase("Test page cap");
-
-        using namespace jtx;
-
-        test::jtx::Env env{
-            *this,
-            makePageCapConfig(features, 21337, "10", "1000000", "200000", 0),
-            features};
-
-        bool const hasFix = env.current()->rules().enabled(fixPageCap);
-
-        auto const alice = Account{"alice"};
-        env.memoize(alice);
-
-        auto const bob = Account{"bob"};
-        env.fund(XRP(10000000), bob);
-
-        auto const preHookCount = (*env.le(alice))[sfHookStateCount];
-        auto const preOwnerCount = (*env.le(alice))[sfOwnerCount];
-
-        std::string hook =
-            "0061736D01000000012A0660057F7F7F7F7F017E60027F7F017E60027F7F017F60"
-            "047F7F7F7F017E60037F7F7E017E60017F017E02520603656E7605747261636500"
-            "0003656E760C686F6F6B5F6163636F756E74000103656E76025F67000203656E76"
-            "057374617465000303656E760973746174655F736574000303656E760661636365"
-            "70740004030201050503010002062B077F0141B088040B7F004180080B7F0041A2"
-            "080B7F004180080B7F0041B088040B7F0041000B7F0041010B07080104686F6F6B"
-            "00060ABF830001BB830002017F017E230041D0006B220124002001200036024C41"
-            "900841114180084110410010001A200141306A2200411410011A4101410110021A"
-            "200141286A41082000411410031A2001200131002F200131002842388620013100"
-            "294230867C200131002A4228867C200131002B4220867C200131002C4218867C20"
-            "0131002D4210867C200131002E4208867C7C3703202001410036021C0340419280"
-            "80807841C90110021A200128021C41C8014E4504402001200134021C2001290320"
-            "42C8017E7C370310200141106A220041082000410810041A2001200128021C4101"
-            "6A36021C0C010B0B2001200129032042017C3703202001200141286A220036020C"
-            "200128020C200129032042388842FF01833C0000200128020C2001290320423088"
-            "42FF01833C0001200128020C200129032042288842FF01833C0002200128020C20"
-            "0129032042208842FF01833C0003200128020C200129032042188842FF01833C00"
-            "04200128020C200129032042108842FF01833C0005200128020C20012903204208"
-            "8842FF01833C0006200128020C200129032042FF01833C00072000410820014130"
-            "6A411410041A4180084110421C1005200141D0006A24000B0B2801004180080B21"
-            "426173652E633A2043616C6C65642E0022426173652E633A2043616C6C65642E2"
-            "2";
-
-        // install the hook on alice
-        env(ripple::test::jtx::hook(alice, {{hso(hook, overrideFlag)}}, 0),
-            M("set fix_page_cap"),
-            HSFEE);
-        env.close();
-
-        env(invoke::invoke(alice),
-            M("test simple"),
-            fee(XRP(1)),
-            ter(tesSUCCESS));
-        env.close();
-
-        BEAST_EXPECT(
-            (*env.le(alice))[sfHookStateCount] == hasFix ? preHookCount + 200
-                                                         : preHookCount + 64);
-        BEAST_EXPECT(
-            (*env.le(alice))[sfOwnerCount] == hasFix ? preHookCount + 202
-                                                     : preHookCount + 66);
-    }
-
    void
    testCreate(FeatureBitset features)
    {
@@ -11971,7 +11761,6 @@ public:

        testNSDelete(features);
        testNSDeletePartial(features);
-        testPageCap(features);

        testWasm(features);
        test_accept(features);
@@ -12073,8 +11862,6 @@ public:
        testWithFeatures(sa - fixXahauV2);
        testWithFeatures(sa - fixXahauV1 - fixXahauV2);
        testWithFeatures(sa - fixXahauV1 - fixXahauV2 - fixNSDelete);
-        testWithFeatures(
-            sa - fixXahauV1 - fixXahauV2 - fixNSDelete - fixPageCap);
    }

 private:
--- a/src/test/app/XahauGenesis_test.cpp
+++ b/src/test/app/XahauGenesis_test.cpp
@@ -3968,8 +3968,8 @@ struct XahauGenesis_test : public beast::unit_test::suite
        using namespace std::chrono_literals;
        testcase("test claim reward valid without unl report");

-        Env env{*this, envconfig(), features - featureXahauGenesis};
-        bool const has240819 = env.current()->rules().enabled(fix240819);
+        Env env{
+            *this, envconfig(), supported_amendments() - featureXahauGenesis};

        double const rateDrops = 0.00333333333 * 1'000'000;
        STAmount const feesXRP = XRP(1);
@@ -4050,12 +4050,7 @@ struct XahauGenesis_test : public beast::unit_test::suite
        // validate account fields
        STAmount const postUser = preUser + netReward;
        BEAST_EXPECT(expectAccountFields(
-            env,
-            user,
-            preLedger,
-            preLedger + 1,
-            has240819 ? (preUser - feesXRP) : postUser,
-            preTime));
+            env, user, preLedger, preLedger + 1, postUser, preTime));

        env(claimReward(user, env.master), fee(feesXRP), ter(tecHOOK_REJECTED));
        env.close();
@@ -4100,12 +4095,7 @@ struct XahauGenesis_test : public beast::unit_test::suite
        // validate account fields
        STAmount const postUser1 = preUser1 + netReward1;
        BEAST_EXPECT(expectAccountFields(
-            env,
-            user,
-            preLedger1,
-            preLedger1 + 1,
-            has240819 ? (preUser1 - feesXRP) : postUser1,
-            preTime1));
+            env, user, preLedger1, preLedger1 + 1, postUser1, preTime1));
    }

    void
@@ -4229,14 +4219,8 @@ struct XahauGenesis_test : public beast::unit_test::suite

        // validate account fields
        STAmount const postUser = preUser + netReward;
-        bool const has240819 = env.current()->rules().enabled(fix240819);
        BEAST_EXPECT(expectAccountFields(
-            env,
-            user,
-            preLedger,
-            preLedger + 1,
-            has240819 ? (preUser - feesXRP) : postUser,
-            preTime));
+            env, user, preLedger, preLedger + 1, postUser, preTime));
    }

    void
@@ -4368,15 +4352,10 @@ struct XahauGenesis_test : public beast::unit_test::suite
            // validate account fields
            STAmount const postAlice = preAlice + netReward + l1Reward;
            bool const boolResult = withXahauV1 ? true : false;
-            bool const has240819 = env.current()->rules().enabled(fix240819);
            BEAST_EXPECT(
                expectAccountFields(
-                    env,
-                    alice,
-                    preLedger,
-                    preLedger + 1,
-                    has240819 ? (preAlice - feesXRP) : postAlice,
-                    preTime) == boolResult);
+                    env, alice, preLedger, preLedger + 1, postAlice, preTime) ==
+                boolResult);
        }
    }

@@ -4388,7 +4367,6 @@ struct XahauGenesis_test : public beast::unit_test::suite
        testcase("test claim reward optin optout");

        Env env{*this, envconfig(), features - featureXahauGenesis};
-        bool const has240819 = env.current()->rules().enabled(fix240819);

        double const rateDrops = 0.00333333333 * 1'000'000;
        STAmount const feesXRP = XRP(1);
@@ -4458,12 +4436,7 @@ struct XahauGenesis_test : public beast::unit_test::suite
        // validate account fields
        STAmount const postUser = preUser + netReward;
        BEAST_EXPECT(expectAccountFields(
-            env,
-            user,
-            preLedger,
-            preLedger + 1,
-            has240819 ? (preUser - feesXRP) : postUser,
-            preTime));
+            env, user, preLedger, preLedger + 1, postUser, preTime));

        // opt out of claim rewards
        env(claimReward(user, std::nullopt, 1), fee(feesXRP), ter(tesSUCCESS));
@@ -4488,7 +4461,7 @@ struct XahauGenesis_test : public beast::unit_test::suite
            user,
            preLedger1,
            preLedger1 + 1,
-            has240819 ? (env.balance(user) + feesXRP) : env.balance(user),
+            env.balance(user),
            preTime1));
    }

@@ -4570,14 +4543,8 @@ struct XahauGenesis_test : public beast::unit_test::suite

        // validate account fields
        STAmount const postUser = preUser + netReward;
-        bool const has240819 = env.current()->rules().enabled(fix240819);
        BEAST_EXPECT(expectAccountFields(
-            env,
-            user,
-            preLedger,
-            has240819 ? preLedger : preLedger + 1,
-            has240819 ? (preUser - feesXRP) : postUser,
-            preTime));
+            env, user, preLedger, preLedger + 1, postUser, preTime));
    }

    void
@@ -4651,14 +4618,8 @@ struct XahauGenesis_test : public beast::unit_test::suite

        // validate account fields
        STAmount const postUser = preUser + netReward;
-        bool const has240819 = env.current()->rules().enabled(fix240819);
        BEAST_EXPECT(expectAccountFields(
-            env,
-            user,
-            preLedger,
-            preLedger + 1,
-            has240819 ? (preUser - feesXRP) : postUser,
-            preTime));
+            env, user, preLedger, preLedger + 1, postUser, preTime));
    }

    void
@@ -4863,13 +4824,13 @@ struct XahauGenesis_test : public beast::unit_test::suite
        Env env{
            *this,
            makeGenesisConfig(
-                features - featureXahauGenesis,
+                supported_amendments() - featureXahauGenesis,
                21337,
                "10",
                "1000000",
                "200000",
                0),
-            features - featureXahauGenesis};
+            supported_amendments() - featureXahauGenesis};

        STAmount const feesXRP = XRP(1);

@@ -4929,7 +4890,8 @@ struct XahauGenesis_test : public beast::unit_test::suite
        using namespace std::chrono_literals;
        testcase("test compound interest over 12 claims");

-        Env env{*this, envconfig(), features - featureXahauGenesis};
+        Env env{
+            *this, envconfig(), supported_amendments() - featureXahauGenesis};

        double const rateDrops = 0.00333333333 * 1'000'000;
        STAmount const feesXRP = XRP(1);
@@ -5003,14 +4965,8 @@ struct XahauGenesis_test : public beast::unit_test::suite

            // validate account fields
            STAmount const postUser = preUser + netReward;
-            bool const has240819 = env.current()->rules().enabled(fix240819);
            BEAST_EXPECT(expectAccountFields(
-                env,
-                user,
-                preLedger,
-                preLedger + 1,
-                has240819 ? (preUser - feesXRP) : postUser,
-                preTime));
+                env, user, preLedger, preLedger + 1, postUser, preTime));
        }

        STAmount const endBal = env.balance(user);
@@ -5020,550 +4976,6 @@ struct XahauGenesis_test : public beast::unit_test::suite
        BEAST_EXPECT(asPercent == 4);
    }

-    void
-    testDeposit(FeatureBitset features)
-    {
-        using namespace jtx;
-        using namespace std::chrono_literals;
-        testcase("test deposit");
-
-        Env env{*this, envconfig(), features - featureXahauGenesis};
-
-        double const rateDrops = 0.00333333333 * 1'000'000;
-        STAmount const feesXRP = XRP(1);
-
-        auto const user = Account("user");
-        env.fund(XRP(1000), user);
-        env.close();
-
-        // setup governance
-        auto const alice = Account("alice");
-        auto const bob = Account("bob");
-        auto const carol = Account("carol");
-        auto const david = Account("david");
-        auto const edward = Account("edward");
-
-        env.fund(XRP(10000), alice, bob, carol, david, edward);
-        env.close();
-
-        std::vector<AccountID> initial_members_ids{
-            alice.id(), bob.id(), carol.id(), david.id(), edward.id()};
-
-        setupGov(env, initial_members_ids);
-
-        // update reward delay
-        {
-            // this will be the new reward delay
-            // 100
-            std::vector<uint8_t> vote_data{
-                0x00U, 0x80U, 0xC6U, 0xA4U, 0x7EU, 0x8DU, 0x03U, 0x55U};
-
-            updateTopic(
-                env, alice, bob, carol, david, edward, 'R', 'D', vote_data);
-        }
-
-        // verify unl report does not exist
-        BEAST_EXPECT(hasUNLReport(env) == false);
-
-        // opt in claim reward
-        env(claimReward(user, env.master), fee(feesXRP), ter(tesSUCCESS));
-        env.close();
-
-        env(pay(alice, user, XRP(1000)));
-        env.close();
-
-        // close ledgers
-        for (int i = 0; i < 10; ++i)
-        {
-            env.close(10s);
-        }
-
-        // close claim ledger & time
-        STAmount const preUser = env.balance(user);
-        NetClock::time_point const preTime = lastClose(env);
-        std::uint32_t const preLedger = env.current()->seq();
-        auto const [acct, acctSle] = accountKeyAndSle(*env.current(), user);
-
-        // claim reward
-        env(claimReward(user, env.master), fee(feesXRP), ter(tesSUCCESS));
-        env.close();
-
-        // trigger emitted txn
-        env.close();
-
-        // calculate rewards
-        bool const has240819 = env.current()->rules().enabled(fix240819);
-        STAmount const netReward =
-            rewardUserAmount(*acctSle, preLedger, rateDrops);
-        BEAST_EXPECT(netReward == (has240819 ? XRP(6.383333) : XRP(6.663333)));
-
-        // validate account fields
-        STAmount const postUser = preUser + netReward;
-        BEAST_EXPECT(expectAccountFields(
-            env,
-            user,
-            preLedger,
-            preLedger + 1,
-            has240819 ? (preUser - feesXRP) : postUser,
-            preTime));
-        BEAST_EXPECT(
-            postUser == (has240819 ? XRP(2005.383333) : XRP(2005.663333)));
-    }
-
-    void
-    testDepositWithdraw(FeatureBitset features)
-    {
-        using namespace jtx;
-        using namespace std::chrono_literals;
-        testcase("test deposit withdraw");
-
-        Env env{*this, envconfig(), features - featureXahauGenesis};
-
-        double const rateDrops = 0.00333333333 * 1'000'000;
-        STAmount const feesXRP = XRP(1);
-
-        auto const user = Account("user");
-        env.fund(XRP(1000), user);
-        env.close();
-
-        // setup governance
-        auto const alice = Account("alice");
-        auto const bob = Account("bob");
-        auto const carol = Account("carol");
-        auto const david = Account("david");
-        auto const edward = Account("edward");
-
-        env.fund(XRP(10000), alice, bob, carol, david, edward);
-        env.close();
-
-        std::vector<AccountID> initial_members_ids{
-            alice.id(), bob.id(), carol.id(), david.id(), edward.id()};
-
-        setupGov(env, initial_members_ids);
-
-        // update reward delay
-        {
-            // this will be the new reward delay
-            // 100
-            std::vector<uint8_t> vote_data{
-                0x00U, 0x80U, 0xC6U, 0xA4U, 0x7EU, 0x8DU, 0x03U, 0x55U};
-
-            updateTopic(
-                env, alice, bob, carol, david, edward, 'R', 'D', vote_data);
-        }
-
-        // verify unl report does not exist
-        BEAST_EXPECT(hasUNLReport(env) == false);
-
-        // opt in claim reward
-        env(claimReward(user, env.master), fee(feesXRP), ter(tesSUCCESS));
-        env.close();
-
-        env(pay(alice, user, XRP(1000)));
-        env.close();
-
-        env(pay(user, alice, XRP(1000)));
-        env.close();
-
-        // close ledgers
-        for (int i = 0; i < 10; ++i)
-        {
-            env.close(10s);
-        }
-
-        // close claim ledger & time
-        STAmount const preUser = env.balance(user);
-        NetClock::time_point const preTime = lastClose(env);
-        std::uint32_t const preLedger = env.current()->seq();
-        auto const [acct, acctSle] = accountKeyAndSle(*env.current(), user);
-
-        // claim reward
-        env(claimReward(user, env.master), fee(feesXRP), ter(tesSUCCESS));
-        env.close();
-
-        // trigger emitted txn
-        env.close();
-
-        // calculate rewards
-        bool const has240819 = env.current()->rules().enabled(fix240819);
-        STAmount const netReward =
-            rewardUserAmount(*acctSle, preLedger, rateDrops);
-        BEAST_EXPECT(netReward == XRP(3.583333));
-
-        // validate account fields
-        STAmount const postUser = preUser + netReward;
-        BEAST_EXPECT(expectAccountFields(
-            env,
-            user,
-            preLedger,
-            preLedger + 1,
-            has240819 ? (preUser - feesXRP) : postUser,
-            preTime));
-        BEAST_EXPECT(postUser == XRP(1002.583323));
-    }
-
-    void
-    testDepositLate(FeatureBitset features)
-    {
-        using namespace jtx;
-        using namespace std::chrono_literals;
-        testcase("test deposit late");
-
-        Env env{*this, envconfig(), features - featureXahauGenesis};
-
-        double const rateDrops = 0.00333333333 * 1'000'000;
-        STAmount const feesXRP = XRP(1);
-
-        auto const user = Account("user");
-        env.fund(XRP(1000), user);
-        env.close();
-
-        // setup governance
-        auto const alice = Account("alice");
-        auto const bob = Account("bob");
-        auto const carol = Account("carol");
-        auto const david = Account("david");
-        auto const edward = Account("edward");
-
-        env.fund(XRP(10000), alice, bob, carol, david, edward);
-        env.close();
-
-        std::vector<AccountID> initial_members_ids{
-            alice.id(), bob.id(), carol.id(), david.id(), edward.id()};
-
-        setupGov(env, initial_members_ids);
-
-        // update reward delay
-        {
-            // this will be the new reward delay
-            // 100
-            std::vector<uint8_t> vote_data{
-                0x00U, 0x80U, 0xC6U, 0xA4U, 0x7EU, 0x8DU, 0x03U, 0x55U};
-
-            updateTopic(
-                env, alice, bob, carol, david, edward, 'R', 'D', vote_data);
-        }
-
-        // verify unl report does not exist
-        BEAST_EXPECT(hasUNLReport(env) == false);
-
-        // opt in claim reward
-        env(claimReward(user, env.master), fee(feesXRP), ter(tesSUCCESS));
-        env.close();
-
-        // close ledgers
-        for (int i = 0; i < 10; ++i)
-        {
-            env.close(10s);
-        }
-
-        env(pay(alice, user, XRP(1000)));
-        env.close();
-
-        // close claim ledger & time
-        STAmount const preUser = env.balance(user);
-        NetClock::time_point const preTime = lastClose(env);
-        std::uint32_t const preLedger = env.current()->seq();
-        auto const [acct, acctSle] = accountKeyAndSle(*env.current(), user);
-
-        // claim reward
-        env(claimReward(user, env.master), fee(feesXRP), ter(tesSUCCESS));
-        env.close();
-
-        // trigger emitted txn
-        env.close();
-
-        // calculate rewards
-        bool const has240819 = env.current()->rules().enabled(fix240819);
-        STAmount const netReward =
-            rewardUserAmount(*acctSle, preLedger, rateDrops);
-        BEAST_EXPECT(netReward == (has240819 ? XRP(3.606666) : XRP(6.663333)));
-
-        // validate account fields
-        STAmount const postUser = preUser + netReward;
-        BEAST_EXPECT(expectAccountFields(
-            env,
-            user,
-            preLedger,
-            preLedger + 1,
-            has240819 ? (preUser - feesXRP) : postUser,
-            preTime));
-        BEAST_EXPECT(
-            postUser == (has240819 ? XRP(2002.606666) : XRP(2005.663333)));
-    }
-
-    void
-    testDepositWithdrawLate(FeatureBitset features)
-    {
-        using namespace jtx;
-        using namespace std::chrono_literals;
-        testcase("test deposit late withdraw");
-
-        Env env{*this, envconfig(), features - featureXahauGenesis};
-
-        double const rateDrops = 0.00333333333 * 1'000'000;
-        STAmount const feesXRP = XRP(1);
-
-        auto const user = Account("user");
-        env.fund(XRP(1000), user);
-        env.close();
-
-        // setup governance
-        auto const alice = Account("alice");
-        auto const bob = Account("bob");
-        auto const carol = Account("carol");
-        auto const david = Account("david");
-        auto const edward = Account("edward");
-
-        env.fund(XRP(10000), alice, bob, carol, david, edward);
-        env.close();
-
-        std::vector<AccountID> initial_members_ids{
-            alice.id(), bob.id(), carol.id(), david.id(), edward.id()};
-
-        setupGov(env, initial_members_ids);
-
-        // update reward delay
-        {
-            // this will be the new reward delay
-            // 100
-            std::vector<uint8_t> vote_data{
-                0x00U, 0x80U, 0xC6U, 0xA4U, 0x7EU, 0x8DU, 0x03U, 0x55U};
-
-            updateTopic(
-                env, alice, bob, carol, david, edward, 'R', 'D', vote_data);
-        }
-
-        // verify unl report does not exist
-        BEAST_EXPECT(hasUNLReport(env) == false);
-
-        // opt in claim reward
-        env(claimReward(user, env.master), fee(feesXRP), ter(tesSUCCESS));
-        env.close();
-
-        // close ledgers
-        for (int i = 0; i < 10; ++i)
-        {
-            env.close(10s);
-        }
-
-        env(pay(alice, user, XRP(1000)));
-        env.close();
-
-        env(pay(user, alice, XRP(1000)));
-        env.close();
-
-        // close claim ledger & time
-        STAmount const preUser = env.balance(user);
-        NetClock::time_point const preTime = lastClose(env);
-        std::uint32_t const preLedger = env.current()->seq();
-        auto const [acct, acctSle] = accountKeyAndSle(*env.current(), user);
-
-        // claim reward
-        env(claimReward(user, env.master), fee(feesXRP), ter(tesSUCCESS));
-        env.close();
-
-        // trigger emitted txn
-        env.close();
-
-        // calculate rewards
-        bool const has240819 = env.current()->rules().enabled(fix240819);
-        STAmount const netReward =
-            rewardUserAmount(*acctSle, preLedger, rateDrops);
-        BEAST_EXPECT(netReward == (has240819 ? XRP(3.583333) : XRP(6.149999)));
-
-        // validate account fields
-        STAmount const postUser = preUser + netReward;
-        BEAST_EXPECT(expectAccountFields(
-            env,
-            user,
-            preLedger,
-            preLedger + 1,
-            has240819 ? (preUser - feesXRP) : postUser,
-            preTime));
-        BEAST_EXPECT(
-            postUser == (has240819 ? XRP(1002.583323) : XRP(1005.149989)));
-    }
-
-    void
-    testNoClaim(FeatureBitset features)
-    {
-        using namespace jtx;
-        using namespace std::chrono_literals;
-        testcase("test no claim");
-
-        Env env{*this, envconfig(), features - featureXahauGenesis};
-
-        double const rateDrops = 0.00333333333 * 1'000'000;
-        STAmount const feesXRP = XRP(1);
-
-        auto const user = Account("user");
-        env.fund(XRP(1000), user);
-        env.close();
-
-        // setup governance
-        auto const alice = Account("alice");
-        auto const bob = Account("bob");
-        auto const carol = Account("carol");
-        auto const david = Account("david");
-        auto const edward = Account("edward");
-
-        env.fund(XRP(10000), alice, bob, carol, david, edward);
-        env.close();
-
-        std::vector<AccountID> initial_members_ids{
-            alice.id(), bob.id(), carol.id(), david.id(), edward.id()};
-
-        setupGov(env, initial_members_ids);
-
-        // update reward delay
-        {
-            // this will be the new reward delay
-            // 100
-            std::vector<uint8_t> vote_data{
-                0x00U, 0x80U, 0xC6U, 0xA4U, 0x7EU, 0x8DU, 0x03U, 0x55U};
-
-            updateTopic(
-                env, alice, bob, carol, david, edward, 'R', 'D', vote_data);
-        }
-
-        // verify unl report does not exist
-        BEAST_EXPECT(hasUNLReport(env) == false);
-
-        // opt in claim reward
-        env(claimReward(user, env.master), fee(feesXRP), ter(tesSUCCESS));
-        env.close();
-
-        // close ledgers (2 cycles)
-        for (int i = 0; i < 20; ++i)
-        {
-            env.close(10s);
-        }
-
-        // close claim ledger & time
-        STAmount const preUser = env.balance(user);
-        NetClock::time_point const preTime = lastClose(env);
-        std::uint32_t const preLedger = env.current()->seq();
-        auto const [acct, acctSle] = accountKeyAndSle(*env.current(), user);
-
-        // claim reward
-        env(claimReward(user, env.master), fee(feesXRP), ter(tesSUCCESS));
-        env.close();
-
-        // trigger emitted txn
-        env.close();
-
-        // calculate rewards
-        bool const hasFix = env.current()->rules().enabled(fix240819) &&
-            env.current()->rules().enabled(fix240911);
-        STAmount const netReward =
-            rewardUserAmount(*acctSle, preLedger, rateDrops);
-        BEAST_EXPECT(netReward == (hasFix ? XRP(3.329999) : XRP(3.329999)));
-
-        // validate account fields
-        STAmount const postUser = preUser + netReward;
-        BEAST_EXPECT(expectAccountFields(
-            env,
-            user,
-            preLedger,
-            preLedger + 1,
-            hasFix ? (preUser - feesXRP) : postUser,
-            preTime));
-        BEAST_EXPECT(
-            postUser == (hasFix ? XRP(1002.329999) : XRP(1002.329999)));
-    }
-
-    void
-    testNoClaimLate(FeatureBitset features)
-    {
-        using namespace jtx;
-        using namespace std::chrono_literals;
-        testcase("test no claim late");
-
-        Env env{*this, envconfig(), features - featureXahauGenesis};
-
-        double const rateDrops = 0.00333333333 * 1'000'000;
-        STAmount const feesXRP = XRP(1);
-
-        auto const user = Account("user");
-        env.fund(XRP(1000), user);
-        env.close();
-
-        // setup governance
-        auto const alice = Account("alice");
-        auto const bob = Account("bob");
-        auto const carol = Account("carol");
-        auto const david = Account("david");
-        auto const edward = Account("edward");
-
-        env.fund(XRP(10000), alice, bob, carol, david, edward);
-        env.close();
-
-        std::vector<AccountID> initial_members_ids{
-            alice.id(), bob.id(), carol.id(), david.id(), edward.id()};
-
-        setupGov(env, initial_members_ids);
-
-        // update reward delay
-        {
-            // this will be the new reward delay
-            // 100
-            std::vector<uint8_t> vote_data{
-                0x00U, 0x80U, 0xC6U, 0xA4U, 0x7EU, 0x8DU, 0x03U, 0x55U};
-
-            updateTopic(
-                env, alice, bob, carol, david, edward, 'R', 'D', vote_data);
-        }
-
-        // verify unl report does not exist
-        BEAST_EXPECT(hasUNLReport(env) == false);
-
-        // opt in claim reward
-        env(claimReward(user, env.master), fee(feesXRP), ter(tesSUCCESS));
-        env.close();
-
-        // close ledgers (2 cycles)
-        for (int i = 0; i < 20; ++i)
-        {
-            env.close(10s);
-        }
-
-        env(pay(alice, user, XRP(1000)));
-        env.close();
-
-        // close claim ledger & time
-        STAmount const preUser = env.balance(user);
-        NetClock::time_point const preTime = lastClose(env);
-        std::uint32_t const preLedger = env.current()->seq();
-        auto const [acct, acctSle] = accountKeyAndSle(*env.current(), user);
-
-        // claim reward
-        env(claimReward(user, env.master), fee(feesXRP), ter(tesSUCCESS));
-        env.close();
-
-        // trigger emitted txn
-        env.close();
-
-        // calculate rewards
-        bool const hasFix = env.current()->rules().enabled(fix240819) &&
-            env.current()->rules().enabled(fix240911);
-        STAmount const netReward =
-            rewardUserAmount(*acctSle, preLedger, rateDrops);
-        BEAST_EXPECT(netReward == (hasFix ? XRP(3.479999) : XRP(6.663333)));
-
-        // validate account fields
-        STAmount const postUser = preUser + netReward;
-        BEAST_EXPECT(expectAccountFields(
-            env,
-            user,
-            preLedger,
-            preLedger + 1,
-            hasFix ? (preUser - feesXRP) : postUser,
-            preTime));
-        BEAST_EXPECT(
-            postUser == (hasFix ? XRP(2002.479999) : XRP(2005.663333)));
-    }
-
    void
    testRewardHookWithFeats(FeatureBitset features)
    {
@@ -5582,12 +4994,6 @@ struct XahauGenesis_test : public beast::unit_test::suite
        testInvalidElapsed0(features);
        testInvalidElapsedNegative(features);
        testCompoundInterest(features);
-        testDeposit(features);
-        testDepositWithdraw(features);
-        testDepositLate(features);
-        testDepositWithdrawLate(features);
-        testNoClaim(features);
-        testNoClaimLate(features);
    }

    void
@@ -5607,8 +5013,6 @@ struct XahauGenesis_test : public beast::unit_test::suite
        auto const sa = supported_amendments();
        testGovernHookWithFeats(sa);
        testRewardHookWithFeats(sa);
-        testRewardHookWithFeats(sa - fix240819);
-        testRewardHookWithFeats(sa - fix240819 - fix240911);
    }
 };