Merge branch 'develop' into mvadari/fix-defs

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

@@ -188,16 +188,10 @@ test.toplevel > xrpl.json
 test.unit_test > xrpl.basics
 test.unit_test > xrpl.protocol
 tests.libxrpl > xrpl.basics
-tests.libxrpl > xrpl.core
 tests.libxrpl > xrpl.json
-tests.libxrpl > xrpl.ledger
 tests.libxrpl > xrpl.net
-tests.libxrpl > xrpl.nodestore
 tests.libxrpl > xrpl.protocol
 tests.libxrpl > xrpl.protocol_autogen
-tests.libxrpl > xrpl.server
-tests.libxrpl > xrpl.shamap
-tests.libxrpl > xrpl.tx
 xrpl.conditions > xrpl.basics
 xrpl.conditions > xrpl.protocol
 xrpl.core > xrpl.basics

.github/scripts/strategy-matrix/generate.py

@@ -51,21 +51,20 @@ def generate_strategy_matrix(all: bool, config: Config) -> list:
         # Only generate a subset of configurations in PRs.
         if not all:
             # Debian:
-            # - Bookworm using GCC 13: Debug on linux/amd64, set the reference
-            #   fee to 500 and enable code coverage (which will be done below).
-            # - Bookworm using GCC 15: Debug on linux/amd64, enable Address and
-            #   UB sanitizers (which will be done below).
+            # - Bookworm using GCC 13: Release on linux/amd64, set the reference
+            #   fee to 500.
+            # - Bookworm using GCC 15: Debug on linux/amd64, enable code
+            #   coverage (which will be done below).
             # - Bookworm using Clang 16: Debug on linux/amd64, enable voidstar.
             # - Bookworm using Clang 17: Release on linux/amd64, set the
             #   reference fee to 1000.
-            # - Bookworm using Clang 20: Debug on linux/amd64, enable Address
-            #   and UB sanitizers (which will be done below).
+            # - Bookworm using Clang 20: Debug on linux/amd64.
             if os["distro_name"] == "debian":
                 skip = True
                 if os["distro_version"] == "bookworm":
                     if (
                         f"{os['compiler_name']}-{os['compiler_version']}" == "gcc-13"
-                        and build_type == "Debug"
+                        and build_type == "Release"
                         and architecture["platform"] == "linux/amd64"
                     ):
                         cmake_args = f"-DUNIT_TEST_REFERENCE_FEE=500 {cmake_args}"
@@ -194,11 +193,11 @@ def generate_strategy_matrix(all: bool, config: Config) -> list:
         ):
             continue
 
-        # Enable code coverage for Debian Bookworm using GCC 13 in Debug on
-        # linux/amd64.
+        # Enable code coverage for Debian Bookworm using GCC 15 in Debug on
+        # linux/amd64
         if (
             f"{os['distro_name']}-{os['distro_version']}" == "debian-bookworm"
-            and f"{os['compiler_name']}-{os['compiler_version']}" == "gcc-13"
+            and f"{os['compiler_name']}-{os['compiler_version']}" == "gcc-15"
             and build_type == "Debug"
             and architecture["platform"] == "linux/amd64"
         ):
@@ -235,39 +234,23 @@ def generate_strategy_matrix(all: bool, config: Config) -> list:
         # Add the configuration to the list, with the most unique fields first,
         # so that they are easier to identify in the GitHub Actions UI, as long
         # names get truncated.
-        # Add Address and UB sanitizers as separate configurations for specific
-        # bookworm distros. Thread sanitizer is currently disabled (see below).
+        # Add Address and Thread (both coupled with UB) sanitizers for specific bookworm distros.
         # GCC-Asan xrpld-embedded tests are failing because of https://github.com/google/sanitizers/issues/856
-        if os[
-            "distro_version"
-        ] == "bookworm" and f"{os['compiler_name']}-{os['compiler_version']}" in [
-            "gcc-15",
-            "clang-20",
-        ]:
-            # Add ASAN configuration.
+        if (
+            os["distro_version"] == "bookworm"
+            and f"{os['compiler_name']}-{os['compiler_version']}" == "clang-20"
+        ):
+            # Add ASAN + UBSAN configuration.
             configurations.append(
                 {
-                    "config_name": config_name + "-asan",
+                    "config_name": config_name + "-asan-ubsan",
                     "cmake_args": cmake_args,
                     "cmake_target": cmake_target,
                     "build_only": build_only,
                     "build_type": build_type,
                     "os": os,
                     "architecture": architecture,
-                    "sanitizers": "address",
-                }
-            )
-            # Add UBSAN configuration.
-            configurations.append(
-                {
-                    "config_name": config_name + "-ubsan",
-                    "cmake_args": cmake_args,
-                    "cmake_target": cmake_target,
-                    "build_only": build_only,
-                    "build_type": build_type,
-                    "os": os,
-                    "architecture": architecture,
-                    "sanitizers": "undefinedbehavior",
+                    "sanitizers": "address,undefinedbehavior",
                 }
             )
             # TSAN is deactivated due to seg faults with latest compilers.

include/xrpl/basics/CanProcess.h

@@ -1,139 +0,0 @@
-//------------------------------------------------------------------------------
-/*
-    This file is part of rippled: https://github.com/ripple/rippled
-    Copyright (c) 2024 Ripple Labs Inc.
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose  with  or without fee is hereby granted, provided that the above
-    copyright notice and this permission notice appear in all copies.
-
-    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
-    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
-    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-*/
-//==============================================================================
-
-#ifndef RIPPLE_BASICS_CANPROCESS_H_INCLUDED
-#define RIPPLE_BASICS_CANPROCESS_H_INCLUDED
-
-#include <functional>
-#include <mutex>
-#include <set>
-
-/** RAII class to check if an Item is already being processed on another thread,
- * as indicated by it's presence in a Collection.
- *
- * If the Item is not in the Collection, it will be added under lock in the
- * ctor, and removed under lock in the dtor. The object will be considered
- * "usable" and evaluate to `true`.
- *
- * If the Item is in the Collection, no changes will be made to the collection,
- * and the CanProcess object will be considered "unusable".
- *
- * It's up to the caller to decide what "usable" and "unusable" mean. (e.g.
- * Process or skip a block of code, or set a flag.)
- *
- * The current use is to avoid lock contention that would be involved in
- * processing something associated with the Item.
- *
- * Examples:
- *
- * void IncomingLedgers::acquireAsync(LedgerHash const& hash, ...)
- * {
- *    if (CanProcess check{acquiresMutex_, pendingAcquires_, hash})
- *    {
- *      acquire(hash, ...);
- *    }
- * }
- *
- * bool
- * NetworkOPsImp::recvValidation(
- *   std::shared_ptr<STValidation> const& val,
- *   std::string const& source)
- *   {
- *       CanProcess check(
- *           validationsMutex_, pendingValidations_, val->getLedgerHash());
- *       BypassAccept bypassAccept =
- *           check ? BypassAccept::no : BypassAccept::yes;
- *       handleNewValidation(app_, val, source, bypassAccept, m_journal);
- *   }
- *
- */
-class CanProcess
-{
-public:
-    template <class Mutex, class Collection, class Item>
-    CanProcess(Mutex& mtx, Collection& collection, Item const& item)
-        : cleanup_(insert(mtx, collection, item))
-    {
-    }
-
-    ~CanProcess()
-    {
-        if (cleanup_)
-            cleanup_();
-    }
-
-    CanProcess(CanProcess const&) = delete;
-
-    CanProcess&
-    operator=(CanProcess const&) = delete;
-
-    explicit
-    operator bool() const
-    {
-        return static_cast<bool>(cleanup_);
-    }
-
-private:
-    template <bool useIterator, class Mutex, class Collection, class Item>
-    std::function<void()>
-    doInsert(Mutex& mtx, Collection& collection, Item const& item)
-    {
-        std::unique_lock<Mutex> lock(mtx);
-        // TODO: Use structured binding once LLVM 16 is the minimum supported
-        // version. See also: https://github.com/llvm/llvm-project/issues/48582
-        // https://github.com/llvm/llvm-project/commit/127bf44385424891eb04cff8e52d3f157fc2cb7c
-        auto const insertResult = collection.insert(item);
-        auto const it = insertResult.first;
-        if (!insertResult.second)
-            return {};
-        if constexpr (useIterator)
-            return [&, it]() {
-                std::unique_lock<Mutex> lock(mtx);
-                collection.erase(it);
-            };
-        else
-            return [&]() {
-                std::unique_lock<Mutex> lock(mtx);
-                collection.erase(item);
-            };
-    }
-
-    // Generic insert() function doesn't use iterators because they may get
-    // invalidated
-    template <class Mutex, class Collection, class Item>
-    std::function<void()>
-    insert(Mutex& mtx, Collection& collection, Item const& item)
-    {
-        return doInsert<false>(mtx, collection, item);
-    }
-
-    // Specialize insert() for std::set, which does not invalidate iterators for
-    // insert and erase
-    template <class Mutex, class Item>
-    std::function<void()>
-    insert(Mutex& mtx, std::set<Item>& collection, Item const& item)
-    {
-        return doInsert<true>(mtx, collection, item);
-    }
-
-    // If set, then the item is "usable"
-    std::function<void()> cleanup_;
-};
-
-#endif

include/xrpl/basics/DecayingSample.h

@@ -67,10 +67,8 @@ private:
             }
             else
             {
-                for (; elapsed > 0; --elapsed)
-                {
+                while ((elapsed--) != 0u)
                     m_value -= (m_value + Window - 1) / Window;
-                }
             }
         }
 

include/xrpl/beast/test/yield_to.h

@@ -43,10 +43,8 @@ public:
         : work_(boost::asio::make_work_guard(ios_))
     {
         threads_.reserve(concurrency);
-        for (std::size_t i = 0; i < concurrency; ++i)
-        {
+        while ((concurrency--) != 0u)
             threads_.emplace_back([&] { ios_.run(); });
-        }
     }
 
     ~enable_yield_to()

include/xrpl/core/HashRouter.h

@@ -197,7 +197,7 @@ public:
 
     /** Add a suppression peer and get message's relay status.
      * Return pair:
-     * element 1: true if the key is added.
+     * element 1: true if the peer is added.
      * element 2: optional is seated to the relay time point or
      * is unseated if has not relayed yet. */
     std::pair<bool, std::optional<Stopwatch::time_point>>

include/xrpl/nodestore/detail/varint.h

@@ -54,9 +54,8 @@ read_varint(void const* buf, std::size_t buflen, std::size_t& t)
         return 1;
     }
     auto const used = n;
-    while (n > 0)
+    while (n--)
     {
-        --n;
         auto const d = p[n];
         auto const t0 = t;
         t *= 127;

include/xrpl/protocol/LedgerHeader.h

@@ -35,8 +35,6 @@ struct LedgerHeader
 
     // If validated is false, it means "not yet validated."
     // Once validated is true, it will never be set false at a later time.
-    // NOTE: If you are accessing this directly, you are probably doing it
-    //   wrong. Use LedgerMaster::isValidated().
     // VFALCO TODO Make this not mutable
     bool mutable validated = false;
     bool accepted = false;

include/xrpl/protocol/detail/features.macro

@@ -15,7 +15,6 @@
 // Add new amendments to the top of this list.
 // Keep it sorted in reverse chronological order.
 
-XRPL_FIX    (Cleanup3_2_0,                Supported::no, VoteBehavior::DefaultNo)
 XRPL_FEATURE(MPTokensV2,                  Supported::no, VoteBehavior::DefaultNo)
 XRPL_FIX    (Security3_1_3,               Supported::no, VoteBehavior::DefaultNo)
 XRPL_FIX    (PermissionedDomainInvariant, Supported::yes, VoteBehavior::DefaultNo)

include/xrpl/protocol_autogen/LedgerEntryBase.h

@@ -130,19 +130,6 @@ public:
         return sle_->at(sfFlags);
     }
 
-    /**
-     * @brief Check if a specific flag is set.
-     *
-     * @param f The flag bitmask to check
-     * @return true if all bits in f are set in the flags field
-     */
-    [[nodiscard]]
-    bool
-    isFlag(std::uint32_t f) const
-    {
-        return sle_->isFlag(f);
-    }
-
     /**
      * @brief Get the underlying SLE object.
      *

include/xrpl/server/NetworkOPs.h

@@ -185,7 +185,7 @@ public:
     virtual bool
     isFull() = 0;
     virtual void
-    setMode(OperatingMode om, char const* reason) = 0;
+    setMode(OperatingMode om) = 0;
     virtual bool
     isBlocked() = 0;
     virtual bool

sanitizers/suppressions/ubsan.supp

@@ -11,6 +11,7 @@ float-cast-overflow:external
 float-divide-by-zero:external
 function:external
 implicit-integer-sign-change:external
+implicit-signed-integer-truncation::external
 implicit-signed-integer-truncation:external
 implicit-unsigned-integer-truncation:external
 integer-divide-by-zero:external
@@ -70,15 +71,145 @@ vla-bound:boost
 vptr_check:boost
 vptr:boost
 
-# Google protobuf - intentional overflows in hash functions
+# Google protobuf
 undefined:protobuf
+
+# Suppress UBSan errors in xrpld code by source file path
+undefined:src/libxrpl/basics/base64.cpp
+undefined:src/libxrpl/basics/Number.cpp
+undefined:src/libxrpl/beast/utility/beast_Journal.cpp
+undefined:src/libxrpl/crypto/RFC1751.cpp
+undefined:src/libxrpl/ledger/ApplyView.cpp
+undefined:src/libxrpl/ledger/View.cpp
+undefined:src/libxrpl/protocol/Permissions.cpp
+undefined:src/libxrpl/protocol/STAmount.cpp
+undefined:src/libxrpl/protocol/STPathSet.cpp
+undefined:src/libxrpl/protocol/tokens.cpp
+undefined:src/libxrpl/shamap/SHAMap.cpp
+undefined:src/test/app/Batch_test.cpp
+undefined:src/test/app/Invariants_test.cpp
+undefined:src/test/app/NFToken_test.cpp
+undefined:src/test/app/Offer_test.cpp
+undefined:src/test/app/Path_test.cpp
+undefined:src/test/basics/XRPAmount_test.cpp
+undefined:src/test/beast/LexicalCast_test.cpp
+undefined:src/test/jtx/impl/acctdelete.cpp
+undefined:src/test/ledger/SkipList_test.cpp
+undefined:src/test/rpc/Subscribe_test.cpp
+undefined:src/tests/libxrpl/basics/RangeSet.cpp
+undefined:src/xrpld/app/main/BasicApp.cpp
+undefined:src/xrpld/app/main/BasicApp.cpp
+undefined:src/xrpld/app/misc/detail/AmendmentTable.cpp
+undefined:src/xrpld/app/misc/NetworkOPs.cpp
+undefined:src/libxrpl/json/json_value.cpp
+undefined:src/xrpld/app/paths/detail/StrandFlow.h
+undefined:src/xrpld/app/tx/detail/NFTokenMint.cpp
+undefined:src/xrpld/app/tx/detail/OracleSet.cpp
+undefined:src/xrpld/core/detail/JobQueue.cpp
+undefined:src/xrpld/core/detail/Workers.cpp
+undefined:src/xrpld/rpc/detail/Role.cpp
+undefined:src/xrpld/rpc/handlers/GetAggregatePrice.cpp
+undefined:xrpl/basics/base_uint.h
+undefined:xrpl/basics/DecayingSample.h
+undefined:xrpl/beast/test/yield_to.h
+undefined:xrpl/beast/xor_shift_engine.h
+undefined:xrpl/nodestore/detail/varint.h
+undefined:xrpl/peerfinder/detail/Counts.h
+undefined:xrpl/protocol/nft.h
+
+# basic_string.h:483:51: runtime error: unsigned integer overflow
+unsigned-integer-overflow:basic_string.h
+unsigned-integer-overflow:bits/chrono.h
+unsigned-integer-overflow:bits/random.h
+unsigned-integer-overflow:bits/random.tcc
+unsigned-integer-overflow:bits/stl_algobase.h
+unsigned-integer-overflow:bits/uniform_int_dist.h
+unsigned-integer-overflow:string_view
+
+# runtime error: unsigned integer overflow: 0 - 1 cannot be represented in type 'std::size_t' (aka 'unsigned long')
+unsigned-integer-overflow:src/libxrpl/basics/base64.cpp
+unsigned-integer-overflow:src/libxrpl/basics/Number.cpp
+unsigned-integer-overflow:src/libxrpl/crypto/RFC1751.cpp
+unsigned-integer-overflow:rc/libxrpl/json/json_value.cpp
+unsigned-integer-overflow:src/libxrpl/ledger/ApplyView.cpp
+unsigned-integer-overflow:src/libxrpl/ledger/View.cpp
+unsigned-integer-overflow:src/libxrpl/protocol/Permissions.cpp
+unsigned-integer-overflow:src/libxrpl/protocol/STAmount.cpp
+unsigned-integer-overflow:src/libxrpl/protocol/STPathSet.cpp
+unsigned-integer-overflow:src/libxrpl/protocol/tokens.cpp
+unsigned-integer-overflow:src/libxrpl/shamap/SHAMap.cpp
+unsigned-integer-overflow:src/test/app/Batch_test.cpp
+unsigned-integer-overflow:src/test/app/Invariants_test.cpp
+unsigned-integer-overflow:src/test/app/NFToken_test.cpp
+unsigned-integer-overflow:src/test/app/Offer_test.cpp
+unsigned-integer-overflow:src/test/app/Path_test.cpp
+unsigned-integer-overflow:src/test/basics/XRPAmount_test.cpp
+unsigned-integer-overflow:src/test/beast/LexicalCast_test.cpp
+unsigned-integer-overflow:src/test/jtx/impl/acctdelete.cpp
+unsigned-integer-overflow:src/test/ledger/SkipList_test.cpp
+unsigned-integer-overflow:src/test/rpc/Subscribe_test.cpp
+unsigned-integer-overflow:src/tests/libxrpl/basics/RangeSet.cpp
+unsigned-integer-overflow:src/xrpld/app/main/BasicApp.cpp
+unsigned-integer-overflow:src/xrpld/app/misc/detail/AmendmentTable.cpp
+unsigned-integer-overflow:src/xrpld/app/misc/NetworkOPs.cpp
+unsigned-integer-overflow:src/xrpld/app/paths/detail/StrandFlow.h
+unsigned-integer-overflow:src/xrpld/app/tx/detail/NFTokenMint.cpp
+unsigned-integer-overflow:src/xrpld/app/tx/detail/OracleSet.cpp
+unsigned-integer-overflow:src/xrpld/rpc/detail/Role.cpp
+unsigned-integer-overflow:src/xrpld/rpc/handlers/GetAggregatePrice.cpp
+unsigned-integer-overflow:xrpl/basics/base_uint.h
+unsigned-integer-overflow:xrpl/basics/DecayingSample.h
+unsigned-integer-overflow:xrpl/beast/test/yield_to.h
+unsigned-integer-overflow:xrpl/beast/xor_shift_engine.h
+unsigned-integer-overflow:xrpl/nodestore/detail/varint.h
+unsigned-integer-overflow:xrpl/peerfinder/detail/Counts.h
+unsigned-integer-overflow:xrpl/protocol/nft.h
+
+# Xrpld intentional overflows and operations
+# STAmount uses intentional negation of INT64_MIN and overflow in arithmetic
+signed-integer-overflow:src/libxrpl/protocol/STAmount.cpp
+unsigned-integer-overflow:src/libxrpl/protocol/STAmount.cpp
+
+# XRPAmount test intentional overflows
+signed-integer-overflow:src/test/basics/XRPAmount_test.cpp
+
+# Peerfinder intentional overflow in counter arithmetic
+unsigned-integer-overflow:src/xrpld/peerfinder/detail/Counts.h
+
+# Signed integer overflow suppressions
+signed-integer-overflow:src/test/beast/LexicalCast_test.cpp
+
+# External library suppressions
+unsigned-integer-overflow:nudb/detail/xxhash.hpp
+
+# Loan_test.cpp intentional underflow in test arithmetic
+unsigned-integer-overflow:src/test/app/Loan_test.cpp
+undefined:src/test/app/Loan_test.cpp
+
+# Source tree restructured paths (libxrpl/tx/transactors/)
+# These duplicate the xrpld/app/tx/detail entries above for the new layout
+unsigned-integer-overflow:src/libxrpl/tx/transactors/oracle/OracleSet.cpp
+undefined:src/libxrpl/tx/transactors/oracle/OracleSet.cpp
+unsigned-integer-overflow:src/libxrpl/tx/transactors/nft/NFTokenMint.cpp
+undefined:src/libxrpl/tx/transactors/nft/NFTokenMint.cpp
+
+# Protobuf intentional overflows in hash functions
+# Protobuf uses intentional unsigned overflow for hash computation (stringpiece.h:393)
 unsigned-integer-overflow:google/protobuf/stubs/stringpiece.h
 
-# gRPC intentional overflows in timer calculations
+# gRPC intentional overflows
+# gRPC uses intentional overflow in timer calculations
 unsigned-integer-overflow:grpc
 unsigned-integer-overflow:timer_manager.cc
 
-# RocksDB intentional unsigned integer overflows in hash functions and CRC calculations
+# Standard library intentional overflows
+# These are intentional overflows in random number generation and character conversion
+unsigned-integer-overflow:__random/seed_seq.h
+unsigned-integer-overflow:__charconv/traits.h
+
+
+# Suppress errors in RocksDB
+# RocksDB uses intentional unsigned integer overflows in hash functions and CRC calculations
 unsigned-integer-overflow:rocks*/*/util/xxhash.h
 unsigned-integer-overflow:rocks*/*/util/xxph3.h
 unsigned-integer-overflow:rocks*/*/util/hash.cc
@@ -90,14 +221,13 @@ unsigned-integer-overflow:rocks*/*/table/format.cc
 unsigned-integer-overflow:rocks*/*/table/block_based/block_based_table_builder.cc
 unsigned-integer-overflow:rocks*/*/table/block_based/reader_common.cc
 unsigned-integer-overflow:rocks*/*/db/version_set.cc
+
+# RocksDB misaligned loads (intentional for performance on ARM64)
 alignment:rocks*/*/util/crc32c_arm64.cc
-undefined:rocks*/*/util/crc32c_arm64.cc
-undefined:rocks*/*/util/xxhash.h
 
 # nudb intentional overflows in hash functions
 unsigned-integer-overflow:nudb/detail/xxhash.hpp
 alignment:nudb/detail/xxhash.hpp
-undefined:nudb
 
 # Snappy compression library intentional overflows
 unsigned-integer-overflow:snappy.cc
@@ -109,40 +239,10 @@ unsigned-integer-overflow:absl/base/internal/low_level_alloc.cc
 unsigned-integer-overflow:absl/hash/internal/hash.h
 unsigned-integer-overflow:absl/container/internal/raw_hash_set.h
 
-# Standard library intentional overflows
-unsigned-integer-overflow:basic_string.h
-unsigned-integer-overflow:bits/chrono.h
-unsigned-integer-overflow:bits/random.h
-unsigned-integer-overflow:bits/random.tcc
-unsigned-integer-overflow:bits/stl_algobase.h
-unsigned-integer-overflow:bits/uniform_int_dist.h
-unsigned-integer-overflow:string_view
-unsigned-integer-overflow:__random/seed_seq.h
-unsigned-integer-overflow:__charconv/traits.h
+# Standard library intentional overflows in chrono duration arithmetic
 unsigned-integer-overflow:__chrono/duration.h
 
-# =============================================================================
-# Rippled code suppressions
-# =============================================================================
-
-# Signed integer negation (-value) in amount types.
-# INT64_MIN cannot occur in practice due to domain invariants (mantissa ranges
-# are well within int64_t bounds), but UBSan flags the pattern as potential
-# signed overflow. Narrowed to operator- to avoid suppressing unrelated
-# overflows anywhere in a stack trace containing these type names.
-signed-integer-overflow:operator-*IOUAmount*
-signed-integer-overflow:operator-*XRPAmount*
-signed-integer-overflow:operator-*MPTAmount*
-signed-integer-overflow:operator-*STAmount*
-
-# STAmount::operator+ signed addition — operands are bounded by total supply
-# (~10^17 for XRP, ~10^18 for MPT) so overflow cannot occur in practice.
-signed-integer-overflow:operator+*STAmount*
-
-# STAmount::getRate uses unsigned shift and addition
-unsigned-integer-overflow:*STAmount*getRate*
-# STAmount::serialize uses unsigned bitwise operations
-unsigned-integer-overflow:*STAmount*serialize*
-
-# nft::cipheredTaxon uses intentional uint32 wraparound (LCG permutation)
-unsigned-integer-overflow:cipheredTaxon
+# Suppress undefined errors in RocksDB and nudb
+undefined:rocks.*/*/util/crc32c_arm64.cc
+undefined:rocks.*/*/util/xxhash.h
+undefined:nudb

src/libxrpl/basics/base64.cpp

@@ -107,7 +107,7 @@ encode(void* dest, void const* src, std::size_t len)
     char const* in = static_cast<char const*>(src);
     auto const tab = base64::get_alphabet();
 
-    for (auto n = len / 3; n > 0; --n)
+    for (auto n = len / 3; n != 0u; --n)
     {
         *out++ = tab[(in[0] & 0xfc) >> 2];
         *out++ = tab[((in[0] & 0x03) << 4) + ((in[1] & 0xf0) >> 4)];

src/libxrpl/protocol/SField.cpp

@@ -100,7 +100,7 @@ SField::SField(private_access_tag_t, int fc, char const* fn)
     , fieldName(fn)
     , fieldMeta(sMD_Never)
     , fieldNum(++num)
-    , signingField(IsSigning::yes)
+    , signingField(IsSigning::no)
     , jsonName(fieldName.c_str())
 {
     XRPL_ASSERT(

src/test/app/LedgerReplay_test.cpp

@@ -130,12 +130,7 @@ public:
     }
 
     void
-    acquireAsync(
-        JobType type,
-        std::string const& name,
-        uint256 const& hash,
-        std::uint32_t seq,
-        InboundLedger::Reason reason) override
+    acquireAsync(uint256 const& hash, std::uint32_t seq, InboundLedger::Reason reason) override
     {
     }
 

src/test/basics/CanProcess_test.cpp

@@ -1,165 +0,0 @@
-//------------------------------------------------------------------------------
-/*
-    This file is part of rippled: https://github.com/ripple/rippled
-    Copyright (c) 2012-2016 Ripple Labs Inc.
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose  with  or without fee is hereby granted, provided that the above
-    copyright notice and this permission notice appear in all copies.
-
-    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
-    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
-    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-*/
-//==============================================================================
-
-#include <xrpl/basics/CanProcess.h>
-#include <xrpl/beast/unit_test.h>
-
-#include <memory>
-
-namespace ripple {
-namespace test {
-
-struct CanProcess_test : beast::unit_test::suite
-{
-    template <class Mutex, class Collection, class Item>
-    void
-    test(
-        std::string const& name,
-        Mutex& mtx,
-        Collection& collection,
-        std::vector<Item> const& items)
-    {
-        testcase(name);
-
-        if (!BEAST_EXPECT(!items.empty()))
-            return;
-        if (!BEAST_EXPECT(collection.empty()))
-            return;
-
-        // CanProcess objects can't be copied or moved. To make that easier,
-        // store shared_ptrs
-        std::vector<std::shared_ptr<CanProcess>> trackers;
-        // Fill up the vector with two CanProcess for each Item. The first
-        // inserts the item into the collection and is "good". The second does
-        // not and is "bad".
-        for (int i = 0; i < items.size(); ++i)
-        {
-            {
-                auto const& good =
-                    trackers.emplace_back(std::make_shared<CanProcess>(mtx, collection, items[i]));
-                BEAST_EXPECT(*good);
-            }
-            BEAST_EXPECT(trackers.size() == (2 * i) + 1);
-            BEAST_EXPECT(collection.size() == i + 1);
-            {
-                auto const& bad =
-                    trackers.emplace_back(std::make_shared<CanProcess>(mtx, collection, items[i]));
-                BEAST_EXPECT(!*bad);
-            }
-            BEAST_EXPECT(trackers.size() == 2 * (i + 1));
-            BEAST_EXPECT(collection.size() == i + 1);
-        }
-        BEAST_EXPECT(collection.size() == items.size());
-        // Now remove the items from the vector<CanProcess> two at a time, and
-        // try to get another CanProcess for that item.
-        for (int i = 0; i < items.size(); ++i)
-        {
-            // Remove the "bad" one in the second position
-            // This will have no effect on the collection
-            {
-                auto const iter = trackers.begin() + 1;
-                BEAST_EXPECT(!**iter);
-                trackers.erase(iter);
-            }
-            BEAST_EXPECT(trackers.size() == (2 * items.size()) - 1);
-            BEAST_EXPECT(collection.size() == items.size());
-            {
-                // Append a new "bad" one
-                auto const& bad =
-                    trackers.emplace_back(std::make_shared<CanProcess>(mtx, collection, items[i]));
-                BEAST_EXPECT(!*bad);
-            }
-            BEAST_EXPECT(trackers.size() == 2 * items.size());
-            BEAST_EXPECT(collection.size() == items.size());
-
-            // Remove the "good" one from the front
-            {
-                auto const iter = trackers.begin();
-                BEAST_EXPECT(**iter);
-                trackers.erase(iter);
-            }
-            BEAST_EXPECT(trackers.size() == (2 * items.size()) - 1);
-            BEAST_EXPECT(collection.size() == items.size() - 1);
-            {
-                // Append a new "good" one
-                auto const& good =
-                    trackers.emplace_back(std::make_shared<CanProcess>(mtx, collection, items[i]));
-                BEAST_EXPECT(*good);
-            }
-            BEAST_EXPECT(trackers.size() == 2 * items.size());
-            BEAST_EXPECT(collection.size() == items.size());
-        }
-        // Now remove them all two at a time
-        for (int i = items.size() - 1; i >= 0; --i)
-        {
-            // Remove the "bad" one from the front
-            {
-                auto const iter = trackers.begin();
-                BEAST_EXPECT(!**iter);
-                trackers.erase(iter);
-            }
-            BEAST_EXPECT(trackers.size() == (2 * i) + 1);
-            BEAST_EXPECT(collection.size() == i + 1);
-            // Remove the "good" one now in front
-            {
-                auto const iter = trackers.begin();
-                BEAST_EXPECT(**iter);
-                trackers.erase(iter);
-            }
-            BEAST_EXPECT(trackers.size() == 2 * i);
-            BEAST_EXPECT(collection.size() == i);
-        }
-        BEAST_EXPECT(trackers.empty());
-        BEAST_EXPECT(collection.empty());
-    }
-
-    void
-    run() override
-    {
-        {
-            std::mutex m;
-            std::set<int> collection;
-            std::vector<int> const items{1, 2, 3, 4, 5};
-            test("set of int", m, collection, items);
-        }
-        {
-            std::mutex m;
-            std::set<std::string> collection;
-            std::vector<std::string> const items{"one", "two", "three", "four", "five"};
-            test("set of string", m, collection, items);
-        }
-        {
-            std::mutex m;
-            std::unordered_set<char> collection;
-            std::vector<char> const items{'1', '2', '3', '4', '5'};
-            test("unorderd_set of char", m, collection, items);
-        }
-        {
-            std::mutex m;
-            std::unordered_set<std::uint64_t> collection;
-            std::vector<std::uint64_t> const items{100u, 1000u, 150u, 4u, 0u};
-            test("unordered_set of uint64_t", m, collection, items);
-        }
-    }
-};
-
-BEAST_DEFINE_TESTSUITE(CanProcess, ripple_basics, ripple);
-
-}  // namespace test
-}  // namespace ripple

src/test/beast/LexicalCast_test.cpp

@@ -24,7 +24,7 @@ public:
     testInteger(IntType in)
     {
         std::string s;
-        IntType out = static_cast<IntType>(~in);  // Ensure out != in
+        IntType out(in + 1);
 
         expect(lexicalCastChecked(s, in));
         expect(lexicalCastChecked(out, s));

src/test/rpc/ServerDefinitions_test.cpp

@@ -8,6 +8,9 @@
 #include <xrpl/protocol/TxFlags.h>
 #include <xrpl/protocol/jss.h>
 
+#include <set>
+#include <string>
+
 namespace xrpl::test {
 
 class ServerDefinitions_test : public beast::unit_test::suite
@@ -37,20 +40,23 @@ public:
 
             {
                 auto const firstField = result[jss::result][jss::FIELDS][0u];
-                BEAST_EXPECT(firstField[0u].asString() == "Generic");
+                BEAST_EXPECT(firstField[0u].asString() == "Invalid");
                 BEAST_EXPECT(firstField[1][jss::isSerialized].asBool() == false);
                 BEAST_EXPECT(firstField[1][jss::isSigningField].asBool() == false);
                 BEAST_EXPECT(firstField[1][jss::isVLEncoded].asBool() == false);
-                BEAST_EXPECT(firstField[1][jss::nth].asUInt() == 0);
+                BEAST_EXPECT(firstField[1][jss::nth].asInt() == -1);
                 BEAST_EXPECT(firstField[1][jss::type].asString() == "Unknown");
             }
 
-            BEAST_EXPECT(
-                result[jss::result][jss::LEDGER_ENTRY_TYPES]["AccountRoot"].asUInt() == 97);
-            BEAST_EXPECT(
-                result[jss::result][jss::TRANSACTION_RESULTS]["tecDIR_FULL"].asUInt() == 121);
-            BEAST_EXPECT(result[jss::result][jss::TRANSACTION_TYPES]["Payment"].asUInt() == 0);
-            BEAST_EXPECT(result[jss::result][jss::TYPES]["AccountID"].asUInt() == 8);
+            {
+                auto const field = result[jss::result][jss::FIELDS][6u];
+                BEAST_EXPECT(field[0u].asString() == "LedgerEntryType");
+                BEAST_EXPECT(field[1][jss::isSerialized].asBool() == true);
+                BEAST_EXPECT(field[1][jss::isSigningField].asBool() == true);
+                BEAST_EXPECT(field[1][jss::isVLEncoded].asBool() == false);
+                BEAST_EXPECT(field[1][jss::nth].asUInt() == 1);
+                BEAST_EXPECT(field[1][jss::type].asString() == "UInt16");
+            }
 
             // check exception SFields
             {
@@ -74,17 +80,34 @@ public:
                 BEAST_EXPECT(fieldExists("index"));
             }
 
+            // verify no duplicate field names in FIELDS array
+            {
+                std::set<std::string> fieldNames;
+                for (auto const& field : result[jss::result][jss::FIELDS])
+                {
+                    auto const name = field[0u].asString();
+                    BEAST_EXPECT(fieldNames.insert(name).second);
+                }
+            }
+
             // test that base_uint types are replaced with "Hash" prefix
             {
                 auto const types = result[jss::result][jss::TYPES];
-                BEAST_EXPECT(types["Hash128"].asUInt() == 4);
-                BEAST_EXPECT(types["Hash160"].asUInt() == 17);
-                BEAST_EXPECT(types["Hash192"].asUInt() == 21);
-                BEAST_EXPECT(types["Hash256"].asUInt() == 5);
-                BEAST_EXPECT(types["Hash384"].asUInt() == 22);
-                BEAST_EXPECT(types["Hash512"].asUInt() == 23);
+                BEAST_EXPECT(types.isMember("Hash128") && types["Hash128"].asUInt() == 4);
+                BEAST_EXPECT(types.isMember("Hash160") && types["Hash160"].asUInt() == 17);
+                BEAST_EXPECT(types.isMember("Hash192") && types["Hash192"].asUInt() == 21);
+                BEAST_EXPECT(types.isMember("Hash256") && types["Hash256"].asUInt() == 5);
+                BEAST_EXPECT(types.isMember("Hash384") && types["Hash384"].asUInt() == 22);
+                BEAST_EXPECT(types.isMember("Hash512") && types["Hash512"].asUInt() == 23);
             }
 
+            BEAST_EXPECT(
+                result[jss::result][jss::LEDGER_ENTRY_TYPES]["AccountRoot"].asUInt() == 97);
+            BEAST_EXPECT(
+                result[jss::result][jss::TRANSACTION_RESULTS]["tecDIR_FULL"].asUInt() == 121);
+            BEAST_EXPECT(result[jss::result][jss::TRANSACTION_TYPES]["Payment"].asUInt() == 0);
+            BEAST_EXPECT(result[jss::result][jss::TYPES]["AccountID"].asUInt() == 8);
+
             // test the properties of the LEDGER_ENTRY_FLAGS section
             {
                 BEAST_EXPECT(result[jss::result].isMember(jss::LEDGER_ENTRY_FLAGS));

src/tests/libxrpl/CMakeLists.txt

@@ -8,12 +8,9 @@ add_custom_target(xrpl.tests)
 
 # Test helpers
 add_library(xrpl.helpers.test STATIC)
-target_sources(
-    xrpl.helpers.test
-    PRIVATE helpers/Account.cpp helpers/TestSink.cpp helpers/TxTest.cpp
-)
+target_sources(xrpl.helpers.test PRIVATE helpers/TestSink.cpp)
 target_include_directories(xrpl.helpers.test PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
-target_link_libraries(xrpl.helpers.test PUBLIC xrpl.libxrpl gtest::gtest)
+target_link_libraries(xrpl.helpers.test PRIVATE xrpl.libxrpl)
 
 # Common library dependencies for the rest of the tests.
 add_library(xrpl.imports.test INTERFACE)
@@ -35,10 +32,6 @@ xrpl_add_test(json)
 target_link_libraries(xrpl.test.json PRIVATE xrpl.imports.test)
 add_dependencies(xrpl.tests xrpl.test.json)
 
-xrpl_add_test(tx)
-target_link_libraries(xrpl.test.tx PRIVATE xrpl.imports.test)
-add_dependencies(xrpl.tests xrpl.test.tx)
-
 xrpl_add_test(protocol_autogen)
 target_link_libraries(xrpl.test.protocol_autogen PRIVATE xrpl.imports.test)
 add_dependencies(xrpl.tests xrpl.test.protocol_autogen)

src/tests/libxrpl/helpers/Account.cpp

@@ -1,19 +0,0 @@
-#include <helpers/Account.h>
-
-#include <xrpl/protocol/KeyType.h>
-#include <xrpl/protocol/PublicKey.h>
-#include <xrpl/protocol/SecretKey.h>
-#include <xrpl/protocol/Seed.h>
-
-namespace xrpl::test {
-
-Account const Account::master{"masterpassphrase"};
-
-Account::Account(std::string_view name, KeyType type)
-    : name_(name)
-    , keyPair_(generateKeyPair(type, generateSeed(name_)))
-    , id_(calcAccountID(keyPair_.first))
-{
-}
-
-}  // namespace xrpl::test

src/tests/libxrpl/helpers/Account.h

@@ -1,81 +0,0 @@
-#pragma once
-
-#include <xrpl/protocol/AccountID.h>
-#include <xrpl/protocol/KeyType.h>
-#include <xrpl/protocol/PublicKey.h>
-#include <xrpl/protocol/SecretKey.h>
-
-#include <string>
-#include <string_view>
-#include <utility>
-
-namespace xrpl::test {
-
-/**
- * @brief A test account with cryptographic keys.
- *
- * Generates keys deterministically from a name, making tests reproducible.
- * The same name always produces the same AccountID and keys.
- */
-class Account
-{
-public:
-    /**
-     * @brief The master account that holds all XRP in genesis.
-     *
-     * This account is created in the genesis ledger with all 100 billion XRP.
-     * It uses the well-known seed "masterpassphrase".
-     */
-    static Account const master;
-
-    /**
-     * @brief Create an account from a name.
-     *
-     * Keys are derived deterministically from the name.
-     *
-     * @param name Human-readable name for the account.
-     * @param type Key type to use (defaults to secp256k1).
-     */
-    explicit Account(std::string_view name, KeyType type = KeyType::secp256k1);
-
-    /** @brief Return the human-readable name. */
-    std::string const&
-    name() const noexcept
-    {
-        return name_;
-    }
-
-    /** @brief Return the AccountID. */
-    AccountID const&
-    id() const noexcept
-    {
-        return id_;
-    }
-
-    /** @brief Return the public key. */
-    PublicKey const&
-    pk() const noexcept
-    {
-        return keyPair_.first;
-    }
-
-    /** @brief Return the secret key. */
-    SecretKey const&
-    sk() const noexcept
-    {
-        return keyPair_.second;
-    }
-
-    /** @brief Implicit conversion to AccountID. */
-    operator AccountID const&() const noexcept
-    {
-        return id_;
-    }
-
-private:
-    std::string name_;
-    std::pair<PublicKey, SecretKey> keyPair_;
-    AccountID id_;
-};
-
-}  // namespace xrpl::test

src/tests/libxrpl/helpers/IOU.h

@@ -1,132 +0,0 @@
-#pragma once
-
-#include <xrpl/basics/Number.h>
-#include <xrpl/protocol/Asset.h>
-#include <xrpl/protocol/Issue.h>
-#include <xrpl/protocol/STAmount.h>
-#include <xrpl/protocol/UintTypes.h>
-
-#include <helpers/Account.h>
-
-#include <concepts>
-#include <string>
-#include <string_view>
-#include <type_traits>
-
-namespace xrpl::test {
-
-/**
- * @brief Represents an IOU (issued currency) for testing.
- *
- * Provides a clear, explicit API for creating currencies issued by an account.
- * This replaces the cryptic `Account::operator[]` from the jtx framework.
- *
- * @code
- *     Account gw("gateway");
- *     IOU USD("USD", gw);
- *
- *     auto issue = USD.issue();      // Get the Issue
- *     auto asset = USD.asset();      // Get the Asset
- *     auto amt = USD.amount(100);    // Get STAmount of 100 USD
- * @endcode
- */
-class IOU
-{
-public:
-    /**
-     * @brief Construct an IOU from a currency code and issuing account.
-     * @param currencyCode A 3-character ISO currency code (e.g., "USD").
-     * @param issuer The account that issues this currency.
-     */
-    IOU(std::string_view currencyCode, Account const& issuer)
-        : currency_(to_currency(std::string(currencyCode))), issuer_(issuer.id())
-    {
-        XRPL_ASSERT(!isXRP(currency_), "IOU: currency code must not resolve to XRP");
-    }
-
-    /**
-     * @brief Construct an IOU from a Currency and issuing account.
-     * @param currency The Currency object.
-     * @param issuer The account that issues this currency.
-     */
-    IOU(Currency currency, Account const& issuer)
-        : currency_(std::move(currency)), issuer_(issuer.id())
-    {
-        XRPL_ASSERT(!isXRP(currency_), "IOU: currency code must not resolve to XRP");
-    }
-
-    /**
-     * @brief Get the Issue (currency + issuer pair).
-     * @return An Issue object representing this IOU.
-     */
-    [[nodiscard]] Issue
-    issue() const
-    {
-        return Issue{currency_, issuer_};
-    }
-
-    /**
-     * @brief Get the Asset.
-     * @return An Asset object representing this IOU.
-     */
-    [[nodiscard]] Asset
-    asset() const
-    {
-        return Asset{issue()};
-    }
-
-    /**
-     * @brief Create an STAmount of this IOU.
-     *
-     * Works with any arithmetic type (int, double, etc.) by converting
-     * to string and parsing. This matches the jtx IOU behaviour.
-     *
-     * @tparam T An arithmetic type.
-     * @param value The amount as any arithmetic type.
-     * @return An STAmount representing value units of this IOU.
-     */
-    template <typename T>
-        requires std::is_arithmetic_v<T>
-    [[nodiscard]] STAmount
-    amount(T value) const
-    {
-        return amountFromString(issue(), to_string(value));
-    }
-
-    /**
-     * @brief Create an STAmount of this IOU from a Number.
-     * @param value The amount as a Number.
-     * @return An STAmount representing value units of this IOU.
-     */
-    [[nodiscard]] STAmount
-    amount(Number const& value) const
-    {
-        return STAmount{issue(), value};
-    }
-
-    /**
-     * @brief Get the currency.
-     * @return The currency.
-     */
-    [[nodiscard]] Currency const&
-    currency() const
-    {
-        return currency_;
-    }
-
-    /**
-     * @brief Get the issuer account ID.
-     * @return The issuer's AccountID.
-     */
-    [[nodiscard]] AccountID const&
-    issuer() const
-    {
-        return issuer_;
-    }
-
-private:
-    Currency currency_;
-    AccountID issuer_;
-};
-
-}  // namespace xrpl::test

src/tests/libxrpl/helpers/TestFamily.h

@@ -1,111 +0,0 @@
-#pragma once
-
-#include <xrpl/basics/chrono.h>
-#include <xrpl/nodestore/DummyScheduler.h>
-#include <xrpl/nodestore/Manager.h>
-#include <xrpl/shamap/Family.h>
-
-#include <memory>
-
-namespace xrpl {
-namespace test {
-
-/** Test implementation of Family for unit tests.
-
-    Uses an in-memory NodeStore database and simple caches.
-    The missingNode methods throw since tests shouldn't encounter missing nodes.
-*/
-class TestFamily : public Family
-{
-private:
-    std::unique_ptr<NodeStore::Database> db_;
-    TestStopwatch clock_;
-    std::shared_ptr<FullBelowCache> fbCache_;
-    std::shared_ptr<TreeNodeCache> tnCache_;
-    NodeStore::DummyScheduler scheduler_;
-    beast::Journal j_;
-
-public:
-    explicit TestFamily(beast::Journal j)
-        : fbCache_(std::make_shared<FullBelowCache>("TestFamily full below cache", clock_, j))
-        , tnCache_(
-              std::make_shared<TreeNodeCache>(
-                  "TestFamily tree node cache",
-                  65536,
-                  std::chrono::minutes{1},
-                  clock_,
-                  j))
-        , j_(j)
-    {
-        Section config;
-        config.set("type", "memory");
-        config.set("path", "TestFamily");
-        db_ = NodeStore::Manager::instance().make_Database(megabytes(4), scheduler_, 1, config, j);
-    }
-
-    NodeStore::Database&
-    db() override
-    {
-        return *db_;
-    }
-
-    NodeStore::Database const&
-    db() const override
-    {
-        return *db_;
-    }
-
-    beast::Journal const&
-    journal() override
-    {
-        return j_;
-    }
-
-    std::shared_ptr<FullBelowCache>
-    getFullBelowCache() override
-    {
-        return fbCache_;
-    }
-
-    std::shared_ptr<TreeNodeCache>
-    getTreeNodeCache() override
-    {
-        return tnCache_;
-    }
-
-    void
-    sweep() override
-    {
-        fbCache_->sweep();
-        tnCache_->sweep();
-    }
-
-    void
-    missingNodeAcquireBySeq(std::uint32_t refNum, uint256 const& nodeHash) override
-    {
-        Throw<std::runtime_error>("TestFamily: missing node (by seq)");
-    }
-
-    void
-    missingNodeAcquireByHash(uint256 const& refHash, std::uint32_t refNum) override
-    {
-        Throw<std::runtime_error>("TestFamily: missing node (by hash)");
-    }
-
-    void
-    reset() override
-    {
-        fbCache_->reset();
-        tnCache_->reset();
-    }
-
-    /** Access the test clock for time manipulation in tests. */
-    TestStopwatch&
-    clock()
-    {
-        return clock_;
-    }
-};
-
-}  // namespace test
-}  // namespace xrpl

src/tests/libxrpl/helpers/TestServiceRegistry.h

@@ -1,378 +0,0 @@
-#pragma once
-
-#include <xrpl/basics/Log.h>
-#include <xrpl/basics/chrono.h>
-#include <xrpl/core/HashRouter.h>
-#include <xrpl/core/NetworkIDService.h>
-#include <xrpl/core/ServiceRegistry.h>
-#include <xrpl/ledger/PendingSaves.h>
-#include <xrpl/server/LoadFeeTrack.h>
-
-#include <boost/asio/io_context.hpp>
-
-#include <helpers/TestFamily.h>
-#include <helpers/TestSink.h>
-
-#include <optional>
-#include <stdexcept>
-
-namespace xrpl {
-namespace test {
-
-/** Logs implementation that creates TestSink instances. */
-class TestLogs : public Logs
-{
-public:
-    explicit TestLogs(beast::severities::Severity level = beast::severities::kWarning) : Logs(level)
-    {
-    }
-
-    std::unique_ptr<beast::Journal::Sink>
-    makeSink(std::string const&, beast::severities::Severity threshold) override
-    {
-        return std::make_unique<TestSink>(threshold);
-    }
-};
-
-/** Simple NetworkIDService implementation for tests. */
-class TestNetworkIDService final : public NetworkIDService
-{
-public:
-    explicit TestNetworkIDService(std::uint32_t networkID = 0) : networkID_(networkID)
-    {
-    }
-
-    [[nodiscard]] std::uint32_t
-    getNetworkID() const noexcept override
-    {
-        return networkID_;
-    }
-
-private:
-    std::uint32_t networkID_;
-};
-
-/** Test implementation of ServiceRegistry for unit tests.
-
-    This class provides real implementations for services that can be
-    instantiated from libxrpl (such as Logs, io_context, caches), and
-    throws std::logic_error for services that require the full Application.
-
-    Tests can subclass this to provide additional services they need.
-*/
-class TestServiceRegistry : public ServiceRegistry
-{
-    TestLogs logs_{beast::severities::kWarning};
-    boost::asio::io_context io_context_;
-    TestFamily family_{logs_.journal("TestFamily")};
-    LoadFeeTrack feeTrack_{logs_.journal("LoadFeeTrack")};
-    TestNetworkIDService networkIDService_;
-    HashRouter hashRouter_{HashRouter::Setup{}, stopwatch()};
-    NodeCache tempNodeCache_{
-        "TempNodeCache",
-        16384,
-        std::chrono::minutes{1},
-        stopwatch(),
-        logs_.journal("TaggedCache")};
-    CachedSLEs cachedSLEs_{
-        "CachedSLEs",
-        16384,
-        std::chrono::minutes{1},
-        stopwatch(),
-        logs_.journal("TaggedCache")};
-    PendingSaves pendingSaves_;
-    std::optional<uint256> trapTxID_;
-
-public:
-    TestServiceRegistry() = default;
-    ~TestServiceRegistry() override = default;
-
-    // Core infrastructure services
-    CollectorManager&
-    getCollectorManager() override
-    {
-        throw std::logic_error("TestServiceRegistry::getCollectorManager() not implemented");
-    }
-
-    Family&
-    getNodeFamily() override
-    {
-        return family_;
-    }
-
-    TimeKeeper&
-    getTimeKeeper() override
-    {
-        throw std::logic_error("TestServiceRegistry::timeKeeper() not implemented");
-    }
-
-    JobQueue&
-    getJobQueue() override
-    {
-        throw std::logic_error("TestServiceRegistry::getJobQueue() not implemented");
-    }
-
-    NodeCache&
-    getTempNodeCache() override
-    {
-        return tempNodeCache_;
-    }
-
-    CachedSLEs&
-    getCachedSLEs() override
-    {
-        return cachedSLEs_;
-    }
-
-    NetworkIDService&
-    getNetworkIDService() override
-    {
-        return networkIDService_;
-    }
-
-    // Protocol and validation services
-    AmendmentTable&
-    getAmendmentTable() override
-    {
-        throw std::logic_error("TestServiceRegistry::getAmendmentTable() not implemented");
-    }
-
-    HashRouter&
-    getHashRouter() override
-    {
-        return hashRouter_;
-    }
-
-    LoadFeeTrack&
-    getFeeTrack() override
-    {
-        return feeTrack_;
-    }
-
-    LoadManager&
-    getLoadManager() override
-    {
-        throw std::logic_error("TestServiceRegistry::getLoadManager() not implemented");
-    }
-
-    RCLValidations&
-    getValidations() override
-    {
-        throw std::logic_error("TestServiceRegistry::getValidations() not implemented");
-    }
-
-    ValidatorList&
-    getValidators() override
-    {
-        throw std::logic_error("TestServiceRegistry::validators() not implemented");
-    }
-
-    ValidatorSite&
-    getValidatorSites() override
-    {
-        throw std::logic_error("TestServiceRegistry::validatorSites() not implemented");
-    }
-
-    ManifestCache&
-    getValidatorManifests() override
-    {
-        throw std::logic_error("TestServiceRegistry::validatorManifests() not implemented");
-    }
-
-    ManifestCache&
-    getPublisherManifests() override
-    {
-        throw std::logic_error("TestServiceRegistry::publisherManifests() not implemented");
-    }
-
-    // Network services
-    Overlay&
-    getOverlay() override
-    {
-        throw std::logic_error("TestServiceRegistry::overlay() not implemented");
-    }
-
-    Cluster&
-    getCluster() override
-    {
-        throw std::logic_error("TestServiceRegistry::cluster() not implemented");
-    }
-
-    PeerReservationTable&
-    getPeerReservations() override
-    {
-        throw std::logic_error("TestServiceRegistry::peerReservations() not implemented");
-    }
-
-    Resource::Manager&
-    getResourceManager() override
-    {
-        throw std::logic_error("TestServiceRegistry::getResourceManager() not implemented");
-    }
-
-    // Storage services
-    NodeStore::Database&
-    getNodeStore() override
-    {
-        throw std::logic_error("TestServiceRegistry::getNodeStore() not implemented");
-    }
-
-    SHAMapStore&
-    getSHAMapStore() override
-    {
-        throw std::logic_error("TestServiceRegistry::getSHAMapStore() not implemented");
-    }
-
-    RelationalDatabase&
-    getRelationalDatabase() override
-    {
-        throw std::logic_error("TestServiceRegistry::getRelationalDatabase() not implemented");
-    }
-
-    // Ledger services
-    InboundLedgers&
-    getInboundLedgers() override
-    {
-        throw std::logic_error("TestServiceRegistry::getInboundLedgers() not implemented");
-    }
-
-    InboundTransactions&
-    getInboundTransactions() override
-    {
-        throw std::logic_error("TestServiceRegistry::getInboundTransactions() not implemented");
-    }
-
-    TaggedCache<uint256, AcceptedLedger>&
-    getAcceptedLedgerCache() override
-    {
-        throw std::logic_error("TestServiceRegistry::getAcceptedLedgerCache() not implemented");
-    }
-
-    LedgerMaster&
-    getLedgerMaster() override
-    {
-        throw std::logic_error("TestServiceRegistry::getLedgerMaster() not implemented");
-    }
-
-    LedgerCleaner&
-    getLedgerCleaner() override
-    {
-        throw std::logic_error("TestServiceRegistry::getLedgerCleaner() not implemented");
-    }
-
-    LedgerReplayer&
-    getLedgerReplayer() override
-    {
-        throw std::logic_error("TestServiceRegistry::getLedgerReplayer() not implemented");
-    }
-
-    PendingSaves&
-    getPendingSaves() override
-    {
-        return pendingSaves_;
-    }
-
-    OpenLedger&
-    getOpenLedger() override
-    {
-        throw std::logic_error("TestServiceRegistry::openLedger() not implemented");
-    }
-
-    OpenLedger const&
-    getOpenLedger() const override
-    {
-        throw std::logic_error("TestServiceRegistry::openLedger() const not implemented");
-    }
-
-    // Transaction and operation services
-    NetworkOPs&
-    getOPs() override
-    {
-        throw std::logic_error("TestServiceRegistry::getOPs() not implemented");
-    }
-
-    OrderBookDB&
-    getOrderBookDB() override
-    {
-        throw std::logic_error("TestServiceRegistry::getOrderBookDB() not implemented");
-    }
-
-    TransactionMaster&
-    getMasterTransaction() override
-    {
-        throw std::logic_error("TestServiceRegistry::getMasterTransaction() not implemented");
-    }
-
-    TxQ&
-    getTxQ() override
-    {
-        throw std::logic_error("TestServiceRegistry::getTxQ() not implemented");
-    }
-
-    PathRequestManager&
-    getPathRequestManager() override
-    {
-        throw std::logic_error("TestServiceRegistry::getPathRequestManager() not implemented");
-    }
-
-    // Server services
-    ServerHandler&
-    getServerHandler() override
-    {
-        throw std::logic_error("TestServiceRegistry::getServerHandler() not implemented");
-    }
-
-    perf::PerfLog&
-    getPerfLog() override
-    {
-        throw std::logic_error("TestServiceRegistry::getPerfLog() not implemented");
-    }
-
-    // Configuration and state
-    bool
-    isStopping() const override
-    {
-        return false;
-    }
-
-    beast::Journal
-    getJournal(std::string const& name) override
-    {
-        return logs_.journal(name);
-    }
-
-    boost::asio::io_context&
-    getIOContext() override
-    {
-        return io_context_;
-    }
-
-    Logs&
-    getLogs() override
-    {
-        return logs_;
-    }
-
-    std::optional<uint256> const&
-    getTrapTxID() const override
-    {
-        return trapTxID_;
-    }
-
-    DatabaseCon&
-    getWalletDB() override
-    {
-        throw std::logic_error("TestServiceRegistry::getWalletDB() not implemented");
-    }
-
-    // Temporary: Get the underlying Application
-    Application&
-    getApp() override
-    {
-        throw std::logic_error(
-            "TestServiceRegistry::app() not implemented - no Application available in tests");
-    }
-};
-
-}  // namespace test
-}  // namespace xrpl

src/tests/libxrpl/helpers/TxTest.cpp

@@ -1,252 +0,0 @@
-#include <helpers/TxTest.h>
-
-#include <xrpl/basics/base_uint.h>
-#include <xrpl/basics/chrono.h>
-#include <xrpl/basics/contract.h>
-#include <xrpl/ledger/ApplyView.h>
-#include <xrpl/ledger/CanonicalTXSet.h>
-#include <xrpl/ledger/Ledger.h>
-#include <xrpl/ledger/OpenView.h>
-#include <xrpl/ledger/ReadView.h>
-#include <xrpl/protocol/AccountID.h>
-#include <xrpl/protocol/Feature.h>
-#include <xrpl/protocol/Fees.h>
-#include <xrpl/protocol/Indexes.h>
-#include <xrpl/protocol/SField.h>
-#include <xrpl/protocol/STLedgerEntry.h>
-#include <xrpl/protocol/STTx.h>
-#include <xrpl/protocol/TER.h>
-#include <xrpl/protocol_autogen/ledger_entries/AccountRoot.h>
-#include <xrpl/protocol_autogen/ledger_entries/RippleState.h>
-#include <xrpl/protocol_autogen/transactions/AccountSet.h>
-#include <xrpl/protocol_autogen/transactions/Payment.h>
-#include <xrpl/tx/apply.h>
-
-#include <helpers/Account.h>
-#include <helpers/IOU.h>
-
-#include <cstdint>
-#include <memory>
-#include <optional>
-#include <stdexcept>
-#include <utility>
-#include <vector>
-
-namespace xrpl::test {
-
-//------------------------------------------------------------------------------
-// Feature helpers
-//------------------------------------------------------------------------------
-
-FeatureBitset
-allFeatures()
-{
-    static FeatureBitset const features = [] {
-        auto const& sa = allAmendments();
-        std::vector<uint256> feats;
-        feats.reserve(sa.size());
-        for ([[maybe_unused]] auto const& [name, _] : sa)
-        {
-            if (auto const f = getRegisteredFeature(name); f.has_value())
-                feats.push_back(*f);
-        }
-        return FeatureBitset(feats);
-    }();
-    return features;
-}
-
-//------------------------------------------------------------------------------
-// TxTest
-//------------------------------------------------------------------------------
-
-TxTest::TxTest(std::optional<FeatureBitset> features)
-{
-    // Convert FeatureBitset to unordered_set for Rules constructor
-    auto const featureBits = features.value_or(allFeatures());
-    foreachFeature(featureBits, [&](uint256 const& f) { featureSet_.insert(f); });
-
-    // Create rules with the specified features
-    rules_.emplace(featureSet_);
-
-    // Default fees for testing
-    Fees const fees{XRPAmount{10}, XRPAmount{10000000}, XRPAmount{2000000}};
-
-    // Create a genesis ledger as the base
-    closedLedger_ = std::make_shared<Ledger>(
-        create_genesis,
-        // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
-        *rules_,
-        fees,
-        std::vector<uint256>{featureSet_.begin(), featureSet_.end()},
-        registry_.getNodeFamily());
-
-    // Initialize time from the genesis ledger
-    now_ = closedLedger_->header().closeTime;
-
-    // Create an open view on top of the genesis ledger
-    openLedger_ =
-        std::make_shared<OpenView>(open_ledger, closedLedger_.get(), *rules_, closedLedger_);
-}
-
-bool
-TxTest::isEnabled(uint256 const& feature) const
-{
-    // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
-    return rules_->enabled(feature);
-}
-
-Rules const&
-TxTest::getRules() const
-{
-    // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
-    return *rules_;
-}
-
-[[nodiscard]] TxResult
-TxTest::submit(std::shared_ptr<STTx const> stx)
-{
-    auto result = apply(registry_, *openLedger_, *stx, tapNONE, registry_.getJournal("apply"));
-
-    // Track successfully applied transactions for canonical reordering on close
-    // We make a copy since the TransactionBase doesn't own the STTx
-    if (result.applied)
-        pendingTxs_.push_back(stx);
-
-    return TxResult{
-        .ter = result.ter,
-        .applied = result.applied,
-        .metadata = std::move(result).metadata,
-        .tx = std::move(stx)};
-}
-
-void
-TxTest::createAccount(Account const& account, XRPAmount xrp, uint32_t accountFlags)
-{
-    auto const paymentTer =
-        submit(transactions::PaymentBuilder{Account::master, account, xrp}, Account::master).ter;
-
-    if (paymentTer != tesSUCCESS)
-    {
-        throw std::runtime_error("TxTest::createAccount: failed to create account");
-    }
-
-    close();
-
-    if (accountFlags != 0)
-    {
-        auto const accountSetTer =
-            submit(transactions::AccountSetBuilder{account}.setSetFlag(accountFlags), account).ter;
-        if (accountSetTer != tesSUCCESS)
-        {
-            throw std::runtime_error("TxTest::createAccount: failed to set account flags");
-        }
-        close();
-    }
-}
-
-ledger_entries::AccountRoot
-TxTest::getAccountRoot(AccountID const& id) const
-{
-    auto const sle = getOpenLedger().read(keylet::account(id));
-    if (!sle)
-        Throw<std::runtime_error>("TxTest::getAccountRoot: account not found");
-    return ledger_entries::AccountRoot{std::const_pointer_cast<SLE const>(sle)};
-}
-
-OpenView&
-TxTest::getOpenLedger()
-{
-    return *openLedger_;
-}
-
-OpenView const&
-TxTest::getOpenLedger() const
-{
-    return *openLedger_;
-}
-
-ReadView const&
-TxTest::getClosedLedger() const
-{
-    return *closedLedger_;
-}
-
-void
-TxTest::close()
-{
-    // Build a new closed ledger from the previous closed ledger,
-    // similar to how buildLedgerImpl works:
-    // 1. Create a new Ledger from the previous closed ledger
-    // 2. Re-apply transactions in canonical order
-    // 3. Mark it as accepted/immutable
-
-    auto const& prevLedger = *closedLedger_;
-
-    auto const ledgerCloseTime = now_ + prevLedger.header().closeTimeResolution;
-
-    now_ = ledgerCloseTime;
-
-    auto newLedger = std::make_shared<Ledger>(prevLedger, ledgerCloseTime);
-
-    CanonicalTXSet txSet(prevLedger.header().hash);
-    for (auto const& tx : pendingTxs_)
-        txSet.insert(tx);
-
-    {
-        OpenView accum(&*newLedger);
-        for (auto const& [key, tx] : txSet)
-        {
-            auto result = apply(registry_, accum, *tx, tapNONE, registry_.getJournal("apply"));
-            if (!result.applied)
-            {
-                throw std::runtime_error("TxTest::close: failed to apply transaction");
-            }
-        }
-        accum.apply(*newLedger);
-    }
-
-    newLedger->setAccepted(ledgerCloseTime, newLedger->header().closeTimeResolution, true);
-
-    closedLedger_ = newLedger;
-
-    pendingTxs_.clear();
-
-    openLedger_ =
-        // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
-        std::make_shared<OpenView>(open_ledger, closedLedger_.get(), *rules_, closedLedger_);
-}
-
-void
-TxTest::advanceTime(NetClock::duration duration)
-{
-    now_ += duration;
-}
-
-NetClock::time_point
-TxTest::getCloseTime() const
-{
-    return now_;
-}
-
-STAmount
-TxTest::getBalance(AccountID const& account, IOU const& iou) const
-{
-    auto const sle = openLedger_->read(keylet::line(account, iou.issue()));
-    if (!sle)
-        return STAmount{iou.issue(), 0};
-
-    auto const rippleState = ledger_entries::RippleState{sle};
-
-    auto balance = rippleState.getBalance();
-    if (iou.issue().account == account)
-    {
-        throw std::logic_error("TxTest::getBalance: account is issuer");
-    }
-
-    balance.get<Issue>().account = iou.issue().account;
-    if (account > iou.issue().account)
-        balance.negate();
-    return balance;
-}
-
-}  // namespace xrpl::test

src/tests/libxrpl/helpers/TxTest.h

@@ -1,364 +0,0 @@
-#pragma once
-
-#include <xrpl/basics/Number.h>
-#include <xrpl/basics/chrono.h>
-#include <xrpl/beast/utility/Journal.h>
-#include <xrpl/core/ServiceRegistry.h>
-#include <xrpl/ledger/ApplyViewImpl.h>
-#include <xrpl/ledger/Ledger.h>
-#include <xrpl/ledger/OpenView.h>
-#include <xrpl/protocol/Feature.h>
-#include <xrpl/protocol/LedgerFormats.h>
-#include <xrpl/protocol/Rules.h>
-#include <xrpl/protocol/STTx.h>
-#include <xrpl/protocol/TER.h>
-#include <xrpl/protocol/TxFlags.h>
-#include <xrpl/protocol/XRPAmount.h>
-#include <xrpl/protocol_autogen/TransactionBuilderBase.h>
-#include <xrpl/protocol_autogen/ledger_entries/AccountRoot.h>
-#include <xrpl/tx/applySteps.h>
-
-#include <helpers/Account.h>
-#include <helpers/IOU.h>
-#include <helpers/TestServiceRegistry.h>
-
-#include <cmath>
-#include <concepts>
-#include <memory>
-#include <optional>
-#include <stdexcept>
-#include <type_traits>
-#include <unordered_set>
-#include <vector>
-
-namespace xrpl::test {
-
-//------------------------------------------------------------------------------
-// Amount helpers
-//------------------------------------------------------------------------------
-
-/**
- * @brief Convert XRP to drops (integral types).
- * @param xrp The amount in XRP.
- * @return The equivalent amount in drops as XRPAmount.
- */
-template <std::integral T>
-constexpr XRPAmount
-XRP(T xrp)
-{
-    return XRPAmount{static_cast<std::int64_t>(xrp) * DROPS_PER_XRP.drops()};
-}
-
-/**
- * @brief Convert XRP to drops (floating point types).
- * @param xrp The amount in XRP (may be fractional).
- * @return The equivalent amount in drops as XRPAmount.
- */
-template <std::floating_point T>
-XRPAmount
-XRP(T xrp)
-{
-    return XRPAmount{static_cast<std::int64_t>(std::round(xrp * DROPS_PER_XRP.drops()))};
-}
-
-/**
- * @brief Convert XRP to drops (Number type).
- * @param xrp The amount in XRP as a Number.
- * @return The equivalent amount in drops as XRPAmount.
- */
-inline XRPAmount
-XRP(Number const& xrp)
-{
-    return XRPAmount{static_cast<std::int64_t>(xrp * DROPS_PER_XRP.drops())};
-}
-
-//------------------------------------------------------------------------------
-// Flag helpers
-//------------------------------------------------------------------------------
-
-/**
- * @brief Convert AccountSet flag (asf) to LedgerState flag (lsf).
- * @param asf The AccountSet flag value.
- * @return The corresponding LedgerState flag.
- * @throws std::runtime_error if the flag is not supported.
- *
- * Supported flags:
- *   asfRequireDest, asfRequireAuth, asfDisallowXRP, asfDisableMaster,
- *   asfNoFreeze, asfGlobalFreeze, asfDefaultRipple, asfDepositAuth,
- *   asfAllowTrustLineClawback, asfDisallowIncomingCheck,
- *   asfDisallowIncomingNFTokenOffer, asfDisallowIncomingPayChan,
- *   asfDisallowIncomingTrustline, asfAllowTrustLineLocking
- */
-constexpr std::uint32_t
-asfToLsf(std::uint32_t asf)
-{
-    switch (asf)
-    {
-        case asfRequireDest:
-            return lsfRequireDestTag;
-        case asfRequireAuth:
-            return lsfRequireAuth;
-        case asfDisallowXRP:
-            return lsfDisallowXRP;
-        case asfDisableMaster:
-            return lsfDisableMaster;
-        case asfNoFreeze:
-            return lsfNoFreeze;
-        case asfGlobalFreeze:
-            return lsfGlobalFreeze;
-        case asfDefaultRipple:
-            return lsfDefaultRipple;
-        case asfDepositAuth:
-            return lsfDepositAuth;
-        case asfAllowTrustLineClawback:
-            return lsfAllowTrustLineClawback;
-        case asfDisallowIncomingCheck:
-            return lsfDisallowIncomingCheck;
-        case asfDisallowIncomingNFTokenOffer:
-            return lsfDisallowIncomingNFTokenOffer;
-        case asfDisallowIncomingPayChan:
-            return lsfDisallowIncomingPayChan;
-        case asfDisallowIncomingTrustline:
-            return lsfDisallowIncomingTrustline;
-        case asfAllowTrustLineLocking:
-            return lsfAllowTrustLineLocking;
-        default:
-            throw std::runtime_error("Unknown asf flag");
-    }
-}
-
-//------------------------------------------------------------------------------
-// Feature helpers
-//------------------------------------------------------------------------------
-
-/**
- * @brief Returns all testable amendments.
- * @note This is similar to jtx::testable_amendments() but for the TxTest framework.
- */
-FeatureBitset
-allFeatures();
-
-//------------------------------------------------------------------------------
-// TxResult
-//------------------------------------------------------------------------------
-
-/**
- * @brief Result of a transaction submission in TxTest.
- *
- * Contains the TER code, whether the transaction was applied,
- * optional metadata, and a reference to the submitted transaction.
- * Use standard gtest macros (EXPECT_EQ, EXPECT_TRUE, etc.) to verify results.
- */
-struct TxResult
-{
-    TER ter;                        /**< The transaction engine result code. */
-    bool applied;                   /**< Whether the transaction was applied to the ledger. */
-    std::optional<TxMeta> metadata; /**< Transaction metadata, if available. */
-    std::shared_ptr<STTx const> tx; /**< Pointer to the submitted transaction. */
-};
-
-/**
- * @brief A lightweight transaction testing harness.
- *
- * Unlike the JTx framework which requires a full Application and RPC layer,
- * TxTest applies transactions directly to an OpenView using the transactor
- * pipeline (preflight -> preclaim -> doApply).
- *
- * This makes it suitable for:
- * - Unit testing individual transactors
- * - Testing transaction validation logic
- * - Fast, focused tests without full server infrastructure
- *
- * @code
- *     TxTest env;
- *     env.submit(paymentTx).expectSuccess();
- *     env.submit(badTx).expectTer(tecNO_ENTRY);
- * @endcode
- */
-class TxTest
-{
-public:
-    /**
-     * @brief Construct a TxTest environment.
-     *
-     * Creates a genesis ledger and an open view on top of it.
-     *
-     * @param features Optional set of features to enable. If not specified,
-     *                 uses all testable amendments.
-     */
-    explicit TxTest(std::optional<FeatureBitset> features = std::nullopt);
-
-    /**
-     * @brief Check if a feature is enabled.
-     * @param feature The feature to check.
-     * @return True if the feature is enabled.
-     */
-    [[nodiscard]] bool
-    isEnabled(uint256 const& feature) const;
-
-    /**
-     * @brief Get the current rules.
-     * @return The current consensus rules.
-     */
-    [[nodiscard]] Rules const&
-    getRules() const;
-
-    /**
-     * @brief Submit a transaction from a builder.
-     *
-     * Convenience overload that accepts transaction builders.
-     * Automatically sets sequence and fee before submission.
-     *
-     * @tparam T A type derived from TransactionBuilderBase.
-     * @param builder The transaction builder.
-     * @param signer The account to sign with.
-     * @return TxResult containing the result code, applied status, and metadata.
-     */
-    template <typename T>
-        requires std::
-            derived_from<std::decay_t<T>, transactions::TransactionBuilderBase<std::decay_t<T>>>
-        [[nodiscard]] TxResult
-        submit(T&& builder, Account const& signer)
-    {
-        auto const& obj = builder.getSTObject();
-        auto accountId = obj[sfAccount];
-        // Only set sequence if not using a ticket (ticket sets sequence to 0)
-        if (!obj.isFieldPresent(sfTicketSequence))
-        {
-            builder.setSequence(getAccountRoot(accountId).getSequence());
-        }
-        else
-        {
-            builder.setSequence(0);
-        }
-        builder.setFee(XRPAmount(10));
-        return submit(builder.build(signer.pk(), signer.sk()).getSTTx());
-    }
-
-    /**
-     * @brief Submit a transaction to the open ledger.
-     *
-     * Applies the transaction through the full transactor pipeline:
-     * preflight -> preclaim -> doApply -> invariant checks
-     *
-     * Invariant checks are automatically run after doApply. If any
-     * invariant fails, the result will be tecINVARIANT_FAILED.
-     *
-     * @param stx The transaction to submit.
-     * @return TxResult containing the result code, applied status, and metadata.
-     */
-    [[nodiscard]] TxResult
-    submit(std::shared_ptr<STTx const> stx);
-
-    /**
-     * @brief Create a new account in the ledger.
-     *
-     * Sends a Payment from the master account to create and fund the account.
-     * Closes the ledger after creation. If accountFlags is non-zero, submits
-     * an AccountSet transaction and closes again.
-     *
-     * @param account The account to create.
-     * @param xrp The initial XRP balance.
-     * @param accountFlags Optional account flags to set. Defaults to 0
-     *        (no flags).
-     */
-    void
-    createAccount(Account const& account, XRPAmount xrp, uint32_t accountFlags = 0);
-
-    /**
-     * @brief Get the account root object from the current open ledger.
-     * @param id The account ID.
-     * @return The AccountRoot ledger entry.
-     * @throws std::runtime_error if the account does not exist.
-     * @todo Once we make keylet strongly typed, we can ditch this method.
-     */
-    [[nodiscard]] ledger_entries::AccountRoot
-    getAccountRoot(AccountID const& id) const;
-
-    /**
-     * @brief Get the current open ledger view.
-     * @return A mutable reference to the open ledger.
-     */
-    [[nodiscard]] OpenView&
-    getOpenLedger();
-
-    /**
-     * @brief Get the current open ledger view (const).
-     * @return A const reference to the open ledger.
-     */
-    [[nodiscard]] OpenView const&
-    getOpenLedger() const;
-
-    /**
-     * @brief Get the closed (base) ledger view.
-     * @return A const reference to the closed ledger.
-     */
-    [[nodiscard]] ReadView const&
-    getClosedLedger() const;
-
-    /**
-     * @brief Close the current ledger.
-     *
-     * Creates a new closed ledger from the current open ledger.
-     * All pending transactions are re-applied in canonical order.
-     */
-    void
-    close();
-
-    /**
-     * @brief Advance time without closing the ledger.
-     *
-     * Useful for testing time-dependent features like escrow release
-     * times or offer expirations.
-     *
-     * @param duration The amount of time to advance.
-     */
-    void
-    advanceTime(NetClock::duration duration);
-
-    /**
-     * @brief Get the current ledger close time.
-     * @return The current close time.
-     */
-    [[nodiscard]] NetClock::time_point
-    getCloseTime() const;
-
-    /**
-     * @brief Get the balance of an IOU for an account.
-     *
-     * Returns the balance from the perspective of the specified account.
-     * If the trust line doesn't exist, returns zero.
-     *
-     * @param account The account to check.
-     * @param iou The IOU to check the balance for.
-     * @return The balance as an STAmount.
-     * @todo Once we make keylet strongly typed, we can ditch this method.
-     */
-    [[nodiscard]] STAmount
-    getBalance(AccountID const& account, IOU const& iou) const;
-
-    /**
-     * @brief Get the service registry.
-     * @return A reference to the service registry.
-     */
-    ServiceRegistry&
-    getServiceRegistry()
-    {
-        return registry_;
-    }
-
-private:
-    TestServiceRegistry registry_;
-    std::unordered_set<uint256, beast::uhash<>> featureSet_;
-    std::optional<Rules> rules_;
-    std::shared_ptr<Ledger const> closedLedger_;
-    std::shared_ptr<OpenView> openLedger_;
-
-    /** Transactions submitted to the open ledger, for canonical reordering on close. */
-    std::vector<std::shared_ptr<STTx const>> pendingTxs_;
-
-    /** Current time (can be advanced arbitrarily for testing). */
-    NetClock::time_point now_;
-};
-
-}  // namespace xrpl::test

src/tests/libxrpl/tx/AccountSet.cpp

@@ -1,804 +0,0 @@
-#include <xrpl/protocol_autogen/transactions/AccountSet.h>
-
-#include <xrpl/basics/Slice.h>
-#include <xrpl/basics/base_uint.h>
-#include <xrpl/beast/utility/Zero.h>
-#include <xrpl/core/ServiceRegistry.h>
-#include <xrpl/ledger/helpers/DirectoryHelpers.h>
-#include <xrpl/protocol/Indexes.h>
-#include <xrpl/protocol/KeyType.h>
-#include <xrpl/protocol/LedgerFormats.h>
-#include <xrpl/protocol/Quality.h>
-#include <xrpl/protocol/Rate.h>
-#include <xrpl/protocol/SField.h>
-#include <xrpl/protocol/STArray.h>
-#include <xrpl/protocol/STObject.h>
-#include <xrpl/protocol/STTx.h>
-#include <xrpl/protocol/SecretKey.h>
-#include <xrpl/protocol/TER.h>
-#include <xrpl/protocol/TxFlags.h>
-#include <xrpl/protocol_autogen/ledger_entries/AccountRoot.h>
-#include <xrpl/protocol_autogen/transactions/Payment.h>
-#include <xrpl/protocol_autogen/transactions/SetRegularKey.h>
-#include <xrpl/protocol_autogen/transactions/SignerListSet.h>
-#include <xrpl/protocol_autogen/transactions/TicketCreate.h>
-#include <xrpl/protocol_autogen/transactions/TrustSet.h>
-
-#include <gtest/gtest.h>
-#include <helpers/Account.h>
-#include <helpers/IOU.h>
-#include <helpers/TxTest.h>
-
-#include <algorithm>
-#include <cstddef>
-#include <cstdint>
-#include <initializer_list>
-#include <limits>
-#include <memory>
-#include <string>
-#include <string_view>
-#include <utility>
-#include <vector>
-
-namespace xrpl::test {
-
-TEST(AccountSet, NullAccountSet)
-{
-    TxTest env;
-
-    Account const alice("alice");
-    env.createAccount(alice, XRP(10));
-
-    auto& view = env.getOpenLedger();
-
-    // ask for the ledger entry - account root, to check its flags
-    auto sle = view.read(keylet::account(alice));
-
-    EXPECT_NE(sle, nullptr);
-    ledger_entries::AccountRoot const accountRoot(sle);
-    EXPECT_EQ(accountRoot.getFlags(), 0);
-}
-
-TEST(AccountSet, MostFlags)
-{
-    Account const alice("alice");
-
-    TxTest env;
-    env.createAccount(alice, XRP(10000));
-
-    // Give alice a regular key so she can legally set and clear
-    // her asfDisableMaster flag.
-    Account const aliceRegularKey{"aliceRegularKey", KeyType::secp256k1};
-
-    env.createAccount(aliceRegularKey, XRP(10000));
-    env.close();
-
-    EXPECT_EQ(
-        env.submit(transactions::SetRegularKeyBuilder{alice}.setRegularKey(aliceRegularKey), alice)
-            .ter,
-        tesSUCCESS);
-    env.close();
-
-    auto testFlags = [&alice, &aliceRegularKey, &env](
-                         std::initializer_list<std::uint32_t> goodFlags) {
-        std::uint32_t const orig_flags = env.getAccountRoot(alice).getFlags();
-        for (std::uint32_t flag{1u}; flag < std::numeric_limits<std::uint32_t>::digits; ++flag)
-        {
-            if (flag == asfNoFreeze)
-            {
-                // The asfNoFreeze flag can't be cleared.  It is tested
-                // elsewhere.
-                continue;
-            }
-            if (flag == asfAuthorizedNFTokenMinter)
-            {
-                // The asfAuthorizedNFTokenMinter flag requires the
-                // presence or absence of the sfNFTokenMinter field in
-                // the transaction.  It is tested elsewhere.
-                continue;
-            }
-
-            if (flag == asfDisallowIncomingCheck || flag == asfDisallowIncomingPayChan ||
-                flag == asfDisallowIncomingNFTokenOffer || flag == asfDisallowIncomingTrustline)
-            {
-                // These flags are part of the DisallowIncoming amendment
-                // and are tested elsewhere
-                continue;
-            }
-            if (flag == asfAllowTrustLineClawback)
-            {
-                // The asfAllowTrustLineClawback flag can't be cleared.  It
-                // is tested elsewhere.
-                continue;
-            }
-            if (flag == asfAllowTrustLineLocking)
-            {
-                // These flags are part of the AllowTokenLocking amendment
-                // and are tested elsewhere
-                continue;
-            }
-            if (std::ranges::find(goodFlags, flag) != goodFlags.end())
-            {
-                // Good flag
-                EXPECT_FALSE(env.getAccountRoot(alice).isFlag(asfToLsf(flag)));
-
-                EXPECT_EQ(
-                    env.submit(transactions::AccountSetBuilder{alice}.setSetFlag(flag), alice).ter,
-                    tesSUCCESS);
-                env.close();
-
-                EXPECT_TRUE(env.getAccountRoot(alice).isFlag(asfToLsf(flag)));
-
-                EXPECT_EQ(
-                    env.submit(
-                           transactions::AccountSetBuilder{alice}.setClearFlag(flag),
-                           aliceRegularKey)
-                        .ter,
-                    tesSUCCESS);
-                env.close();
-
-                EXPECT_FALSE(env.getAccountRoot(alice).isFlag(asfToLsf(flag)));
-
-                std::uint32_t const now_flags = env.getAccountRoot(alice).getFlags();
-                EXPECT_EQ(now_flags, orig_flags);
-            }
-            else
-            {
-                // Bad flag
-                EXPECT_EQ(env.getAccountRoot(alice).getFlags(), orig_flags);
-                EXPECT_EQ(
-                    env.submit(transactions::AccountSetBuilder{alice}.setSetFlag(flag), alice).ter,
-                    tesSUCCESS);
-                env.close();
-                EXPECT_EQ(env.getAccountRoot(alice).getFlags(), orig_flags);
-
-                EXPECT_EQ(
-                    env.submit(
-                           transactions::AccountSetBuilder{alice}.setClearFlag(flag),
-                           aliceRegularKey)
-                        .ter,
-                    tesSUCCESS);
-                env.close();
-                EXPECT_EQ(env.getAccountRoot(alice).getFlags(), orig_flags);
-            }
-        }
-    };
-    testFlags({
-        asfRequireDest,
-        asfRequireAuth,
-        asfDisallowXRP,
-        asfGlobalFreeze,
-        asfDisableMaster,
-        asfDefaultRipple,
-        asfDepositAuth,
-    });
-}
-
-TEST(AccountSet, SetAndResetAccountTxnID)
-{
-    TxTest env;
-    Account const alice("alice");
-
-    env.createAccount(alice, XRP(10000));
-
-    std::uint32_t const orig_flags = env.getAccountRoot(alice).getFlags();
-
-    // asfAccountTxnID is special and not actually set as a flag,
-    // so we check the field presence instead
-    EXPECT_FALSE(env.getAccountRoot(alice).hasAccountTxnID());
-
-    EXPECT_EQ(
-        env.submit(transactions::AccountSetBuilder{alice}.setSetFlag(asfAccountTxnID), alice).ter,
-        tesSUCCESS);
-    env.close();
-
-    EXPECT_TRUE(env.getAccountRoot(alice).hasAccountTxnID());
-
-    EXPECT_EQ(
-        env.submit(transactions::AccountSetBuilder{alice}.setClearFlag(asfAccountTxnID), alice).ter,
-        tesSUCCESS);
-    env.close();
-
-    EXPECT_FALSE(env.getAccountRoot(alice).hasAccountTxnID());
-
-    std::uint32_t const now_flags = env.getAccountRoot(alice).getFlags();
-    EXPECT_EQ(now_flags, orig_flags);
-}
-
-TEST(AccountSet, SetNoFreeze)
-{
-    TxTest env;
-    Account const alice("alice");
-    Account const eric("eric");
-
-    env.createAccount(alice, XRP(10000));
-    env.close();
-
-    // Set eric as alice's regular key (eric doesn't need to be funded)
-    EXPECT_EQ(
-        env.submit(transactions::SetRegularKeyBuilder{alice}.setRegularKey(eric), alice).ter,
-        tesSUCCESS);
-    env.close();
-
-    // Verify alice doesn't have NoFreeze flag
-    EXPECT_FALSE(env.getAccountRoot(alice).isFlag(lsfNoFreeze));
-
-    // Setting NoFreeze with regular key should fail - requires master key
-    EXPECT_EQ(
-        env.submit(transactions::AccountSetBuilder{alice}.setSetFlag(asfNoFreeze), eric).ter,
-        tecNEED_MASTER_KEY);
-    env.close();
-
-    // Setting NoFreeze with master key should succeed
-    EXPECT_EQ(
-        env.submit(transactions::AccountSetBuilder{alice}.setSetFlag(asfNoFreeze), alice).ter,
-        tesSUCCESS);
-    env.close();
-
-    // Verify alice now has NoFreeze flag
-    EXPECT_TRUE(env.getAccountRoot(alice).isFlag(lsfNoFreeze));
-
-    // Try to clear NoFreeze - transaction succeeds but flag remains set
-    EXPECT_EQ(
-        env.submit(transactions::AccountSetBuilder{alice}.setClearFlag(asfNoFreeze), alice).ter,
-        tesSUCCESS);
-    env.close();
-
-    // Verify flag is still set (NoFreeze cannot be cleared once set)
-    EXPECT_TRUE(env.getAccountRoot(alice).isFlag(lsfNoFreeze));
-}
-
-TEST(AccountSet, Domain)
-{
-    TxTest env;
-    Account const alice("alice");
-
-    env.createAccount(alice, XRP(10000));
-    env.close();
-
-    // The Domain field is represented as the hex string of the lowercase
-    // ASCII of the domain. For example, the domain example.com would be
-    // represented as "6578616d706c652e636f6d".
-    //
-    // To remove the Domain field from an account, send an AccountSet with
-    // the Domain set to an empty string.
-    std::string const domain = "example.com";
-
-    // Set domain
-    EXPECT_EQ(
-        env.submit(transactions::AccountSetBuilder{alice}.setDomain(makeSlice(domain)), alice).ter,
-        tesSUCCESS);
-    env.close();
-
-    EXPECT_TRUE(env.getAccountRoot(alice).hasDomain());
-    // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
-    EXPECT_EQ(*env.getAccountRoot(alice).getDomain(), makeSlice(domain));
-
-    // Clear domain by setting empty
-    EXPECT_EQ(
-        env.submit(transactions::AccountSetBuilder{alice}.setDomain(Slice{}), alice).ter,
-        tesSUCCESS);
-    env.close();
-
-    EXPECT_FALSE(env.getAccountRoot(alice).hasDomain());
-
-    // The upper limit on the length is 256 bytes
-    // (defined as DOMAIN_BYTES_MAX in SetAccount)
-    // test the edge cases: 255, 256, 257.
-    std::size_t const maxLength = 256;
-    for (std::size_t len = maxLength - 1; len <= maxLength + 1; ++len)
-    {
-        std::string const domain2 = std::string(len - domain.length() - 1, 'a') + "." + domain;
-
-        EXPECT_EQ(domain2.length(), len);
-
-        if (len <= maxLength)
-        {
-            EXPECT_EQ(
-                env.submit(
-                       transactions::AccountSetBuilder{alice}.setDomain(makeSlice(domain2)), alice)
-                    .ter,
-                tesSUCCESS);
-            env.close();
-
-            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
-            EXPECT_EQ(*env.getAccountRoot(alice).getDomain(), makeSlice(domain2));
-        }
-        else
-        {
-            EXPECT_EQ(
-                env.submit(
-                       transactions::AccountSetBuilder{alice}.setDomain(makeSlice(domain2)), alice)
-                    .ter,
-                telBAD_DOMAIN);
-            env.close();
-        }
-    }
-}
-
-TEST(AccountSet, MessageKey)
-{
-    TxTest env;
-    Account const alice("alice");
-
-    env.createAccount(alice, XRP(10000));
-    env.close();
-
-    // Generate a random ed25519 key pair for the message key
-    auto const rkp = randomKeyPair(KeyType::ed25519);
-
-    // Set the message key
-    EXPECT_EQ(
-        env.submit(transactions::AccountSetBuilder{alice}.setMessageKey(rkp.first.slice()), alice)
-            .ter,
-        tesSUCCESS);
-    env.close();
-
-    EXPECT_TRUE(env.getAccountRoot(alice).hasMessageKey());
-    // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
-    EXPECT_EQ(*env.getAccountRoot(alice).getMessageKey(), rkp.first.slice());
-
-    // Clear the message key by setting to empty
-    EXPECT_EQ(
-        env.submit(transactions::AccountSetBuilder{alice}.setMessageKey(Slice{}), alice).ter,
-        tesSUCCESS);
-    env.close();
-
-    EXPECT_FALSE(env.getAccountRoot(alice).hasMessageKey());
-
-    // Try to set an invalid public key - should fail
-    using namespace std::string_literals;
-    EXPECT_EQ(
-        env.submit(
-               transactions::AccountSetBuilder{alice}.setMessageKey(
-                   makeSlice("NOT_REALLY_A_PUBKEY"s)),
-               alice)
-            .ter,
-        telBAD_PUBLIC_KEY);
-}
-
-TEST(AccountSet, WalletID)
-{
-    TxTest env;
-    Account const alice("alice");
-
-    env.createAccount(alice, XRP(10000));
-    env.close();
-
-    std::string_view const locator =
-        "9633EC8AF54F16B5286DB1D7B519EF49EEFC050C0C8AC4384F1D88ACD1BFDF05";
-    uint256 locatorHash{};
-    EXPECT_TRUE(locatorHash.parseHex(locator));
-
-    // Set the wallet locator
-    EXPECT_EQ(
-        env.submit(transactions::AccountSetBuilder{alice}.setWalletLocator(locatorHash), alice).ter,
-        tesSUCCESS);
-    env.close();
-
-    EXPECT_TRUE(env.getAccountRoot(alice).hasWalletLocator());
-    // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
-    EXPECT_EQ(*env.getAccountRoot(alice).getWalletLocator(), locatorHash);
-
-    // Clear the wallet locator by setting to zero
-    EXPECT_EQ(
-        env.submit(transactions::AccountSetBuilder{alice}.setWalletLocator(beast::zero), alice).ter,
-        tesSUCCESS);
-    env.close();
-
-    EXPECT_FALSE(env.getAccountRoot(alice).hasWalletLocator());
-}
-
-TEST(AccountSet, EmailHash)
-{
-    TxTest env;
-    Account const alice("alice");
-
-    env.createAccount(alice, XRP(10000));
-    env.close();
-
-    std::string_view const mh = "5F31A79367DC3137FADA860C05742EE6";
-    uint128 emailHash{};
-    EXPECT_TRUE(emailHash.parseHex(mh));
-
-    // Set the email hash
-    EXPECT_EQ(
-        env.submit(transactions::AccountSetBuilder{alice}.setEmailHash(emailHash), alice).ter,
-        tesSUCCESS);
-    env.close();
-
-    EXPECT_TRUE(env.getAccountRoot(alice).hasEmailHash());
-    // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
-    EXPECT_EQ(*env.getAccountRoot(alice).getEmailHash(), emailHash);
-
-    // Clear the email hash by setting to zero
-    EXPECT_EQ(
-        env.submit(transactions::AccountSetBuilder{alice}.setEmailHash(beast::zero), alice).ter,
-        tesSUCCESS);
-    env.close();
-
-    EXPECT_FALSE(env.getAccountRoot(alice).hasEmailHash());
-}
-
-TEST(AccountSet, TransferRate)
-{
-    struct TestCase
-    {
-        double set;
-        TER code;
-        double get;
-    };
-
-    // Test data: {rate to set, expected TER, expected stored rate}
-    std::vector<TestCase> const testData = {
-        {1.0, tesSUCCESS, 1.0},
-        {1.1, tesSUCCESS, 1.1},
-        {2.0, tesSUCCESS, 2.0},
-        {2.1, temBAD_TRANSFER_RATE, 2.0},  // > 2.0 is invalid
-        {0.0, tesSUCCESS, 1.0},            // 0 clears the rate (default = 1.0)
-        {2.0, tesSUCCESS, 2.0},
-        {0.9, temBAD_TRANSFER_RATE, 2.0},  // < 1.0 is invalid
-    };
-
-    TxTest env;
-    Account const alice("alice");
-
-    env.createAccount(alice, XRP(10000));
-    env.close();
-
-    for (auto const& r : testData)
-    {
-        auto const rateValue = static_cast<std::uint32_t>(QUALITY_ONE * r.set);
-
-        EXPECT_EQ(
-            env.submit(transactions::AccountSetBuilder{alice}.setTransferRate(rateValue), alice)
-                .ter,
-            r.code);
-        env.close();
-
-        // If the field is not present, expect the default value (1.0)
-        if (!env.getAccountRoot(alice).hasTransferRate())
-        {
-            EXPECT_EQ(r.get, 1.0);
-        }
-        else
-        {
-            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
-            EXPECT_EQ(
-                *env.getAccountRoot(alice).getTransferRate(),
-                static_cast<std::uint32_t>(r.get * QUALITY_ONE));
-        }
-    }
-}
-
-TEST(AccountSet, BadInputs)
-{
-    TxTest env;
-    Account const alice("alice");
-
-    env.createAccount(alice, XRP(10000));
-    env.close();
-
-    // Setting and clearing the same flag is invalid
-    EXPECT_EQ(
-        env.submit(
-               transactions::AccountSetBuilder{alice}
-                   .setSetFlag(asfDisallowXRP)
-                   .setClearFlag(asfDisallowXRP),
-               alice)
-            .ter,
-        temINVALID_FLAG);
-
-    EXPECT_EQ(
-        env.submit(
-               transactions::AccountSetBuilder{alice}
-                   .setSetFlag(asfRequireAuth)
-                   .setClearFlag(asfRequireAuth),
-               alice)
-            .ter,
-        temINVALID_FLAG);
-
-    EXPECT_EQ(
-        env.submit(
-               transactions::AccountSetBuilder{alice}
-                   .setSetFlag(asfRequireDest)
-                   .setClearFlag(asfRequireDest),
-               alice)
-            .ter,
-        temINVALID_FLAG);
-
-    // Setting asf flag while also using corresponding tf flag is invalid
-    EXPECT_EQ(
-        env.submit(
-               transactions::AccountSetBuilder{alice}
-                   .setSetFlag(asfDisallowXRP)
-                   .setFlags(tfAllowXRP),
-               alice)
-            .ter,
-        temINVALID_FLAG);
-
-    EXPECT_EQ(
-        env.submit(
-               transactions::AccountSetBuilder{alice}
-                   .setSetFlag(asfRequireAuth)
-                   .setFlags(tfOptionalAuth),
-               alice)
-            .ter,
-        temINVALID_FLAG);
-
-    EXPECT_EQ(
-        env.submit(
-               transactions::AccountSetBuilder{alice}
-                   .setSetFlag(asfRequireDest)
-                   .setFlags(tfOptionalDestTag),
-               alice)
-            .ter,
-        temINVALID_FLAG);
-
-    // Using invalid flags (mask) is invalid
-    EXPECT_EQ(
-        env.submit(
-               transactions::AccountSetBuilder{alice}
-                   .setSetFlag(asfRequireDest)
-                   .setFlags(tfAccountSetMask),
-               alice)
-            .ter,
-        temINVALID_FLAG);
-
-    // Disabling master key without an alternative key is invalid
-    EXPECT_EQ(
-        env.submit(transactions::AccountSetBuilder{alice}.setSetFlag(asfDisableMaster), alice).ter,
-        tecNO_ALTERNATIVE_KEY);
-}
-
-TEST(AccountSet, RequireAuthWithDir)
-{
-    TxTest env;
-    Account const alice("alice");
-    Account const bob("bob");
-
-    env.createAccount(alice, XRP(10000));
-    env.close();
-
-    // alice should have an empty directory
-    EXPECT_TRUE(dirIsEmpty(env.getClosedLedger(), keylet::ownerDir(alice.id())));
-
-    // Give alice a signer list, then there will be stuff in the directory
-    // Build the SignerEntries array
-    STArray signerEntries(1);
-    {
-        signerEntries.push_back(STObject::makeInnerObject(sfSignerEntry));
-        STObject& entry = signerEntries.back();
-        entry[sfAccount] = bob.id();
-        entry[sfSignerWeight] = std::uint16_t{1};
-    }
-
-    EXPECT_EQ(
-        env.submit(
-               transactions::SignerListSetBuilder{alice, 1}.setSignerEntries(signerEntries), alice)
-            .ter,
-        tesSUCCESS);
-    env.close();
-
-    EXPECT_FALSE(dirIsEmpty(env.getClosedLedger(), keylet::ownerDir(alice.id())));
-
-    // Setting RequireAuth should fail because alice has owner objects
-    EXPECT_EQ(
-        env.submit(transactions::AccountSetBuilder{alice}.setSetFlag(asfRequireAuth), alice).ter,
-        tecOWNERS);
-
-    // Remove the signer list (quorum = 0, no entries)
-    EXPECT_EQ(env.submit(transactions::SignerListSetBuilder{alice, 0}, alice).ter, tesSUCCESS);
-    env.close();
-
-    EXPECT_TRUE(dirIsEmpty(env.getClosedLedger(), keylet::ownerDir(alice.id())));
-
-    // Now setting RequireAuth should succeed
-    EXPECT_EQ(
-        env.submit(transactions::AccountSetBuilder{alice}.setSetFlag(asfRequireAuth), alice).ter,
-        tesSUCCESS);
-}
-
-TEST(AccountSet, Ticket)
-{
-    TxTest env;
-    Account const alice("alice");
-
-    env.createAccount(alice, XRP(10000));
-    env.close();
-
-    // Get alice's current sequence - the ticket will be created at seq + 1
-    std::uint32_t const aliceSeqBefore = env.getAccountRoot(alice.id()).getSequence();
-    std::uint32_t const ticketSeq = aliceSeqBefore + 1;
-
-    // Create a ticket
-    EXPECT_EQ(env.submit(transactions::TicketCreateBuilder{alice, 1}, alice).ter, tesSUCCESS);
-    env.close();
-
-    // Verify alice has 1 owner object (the ticket)
-    EXPECT_EQ(env.getAccountRoot(alice.id()).getOwnerCount(), 1u);
-    // Verify ticket exists
-    EXPECT_TRUE(env.getClosedLedger().exists(keylet::ticket(alice.id(), ticketSeq)));
-
-    // Try using a ticket that alice doesn't have
-    EXPECT_EQ(
-        env.submit(transactions::AccountSetBuilder{alice}.setTicketSequence(ticketSeq + 1), alice)
-            .ter,
-        terPRE_TICKET);
-    env.close();
-
-    // Verify ticket still exists
-    EXPECT_TRUE(env.getClosedLedger().exists(keylet::ticket(alice.id(), ticketSeq)));
-
-    // Get alice's sequence before using the ticket
-    std::uint32_t const aliceSeq = env.getAccountRoot(alice.id()).getSequence();
-
-    // Actually use alice's ticket (noop AccountSet)
-    EXPECT_EQ(
-        env.submit(transactions::AccountSetBuilder{alice}.setTicketSequence(ticketSeq), alice).ter,
-        tesSUCCESS);
-    env.close();
-
-    // Verify ticket is consumed (no owner objects)
-    EXPECT_EQ(env.getAccountRoot(alice.id()).getOwnerCount(), 0u);
-    EXPECT_FALSE(env.getClosedLedger().exists(keylet::ticket(alice.id(), ticketSeq)));
-
-    // Verify alice's sequence did NOT advance (ticket use doesn't increment seq)
-    EXPECT_EQ(env.getAccountRoot(alice.id()).getSequence(), aliceSeq);
-
-    // Try re-using a ticket that alice already used
-    EXPECT_EQ(
-        env.submit(transactions::AccountSetBuilder{alice}.setTicketSequence(ticketSeq), alice).ter,
-        tefNO_TICKET);
-}
-
-TEST(AccountSet, BadSigningKey)
-{
-    TxTest env;
-    Account const alice("alice");
-
-    env.createAccount(alice, XRP(10000));
-    env.close();
-
-    // Build a valid transaction first, then corrupt the signing key
-    auto stx = transactions::AccountSetBuilder{alice}
-                   .setSequence(env.getAccountRoot(alice.id()).getSequence())
-                   .setFee(XRPAmount{10})
-                   .build(alice.pk(), alice.sk())
-                   .getSTTx();
-
-    // Create a copy with a bad signing key
-    STObject obj = *stx;
-    obj.setFieldVL(sfSigningPubKey, makeSlice(std::string("badkey")));
-
-    auto result = env.submit(std::make_shared<STTx>(std::move(obj)));
-    EXPECT_EQ(result.ter, temBAD_SIGNATURE);
-    EXPECT_FALSE(result.applied);
-}
-
-TEST(AccountSet, Gateway)
-{
-    Account const alice("alice");
-    Account const bob("bob");
-    Account const gw("gateway");
-    IOU const USD("USD", gw);
-
-    // Test gateway with a variety of allowed transfer rates
-    for (double transferRate = 1.0; transferRate <= 2.0; transferRate += 0.03125)
-    {
-        TxTest env;
-
-        env.createAccount(gw, XRP(10000), asfDefaultRipple);
-        env.createAccount(alice, XRP(10000), asfDefaultRipple);
-        env.createAccount(bob, XRP(10000), asfDefaultRipple);
-        env.close();
-
-        // Set up trust lines: alice and bob trust gw for USD
-        EXPECT_EQ(
-            env.submit(transactions::TrustSetBuilder{alice}.setLimitAmount(USD.amount(10)), alice)
-                .ter,
-            tesSUCCESS);
-        EXPECT_EQ(
-            env.submit(transactions::TrustSetBuilder{bob}.setLimitAmount(USD.amount(10)), bob).ter,
-            tesSUCCESS);
-        env.close();
-
-        // Set transfer rate on the gateway
-        EXPECT_EQ(
-            env.submit(
-                   transactions::AccountSetBuilder{gw}.setTransferRate(
-                       static_cast<std::uint32_t>(transferRate * QUALITY_ONE)),
-                   gw)
-                .ter,
-            tesSUCCESS);
-        env.close();
-
-        // Calculate the amount with transfer rate applied
-        auto const amount = USD.amount(1);
-        Rate const rate(static_cast<std::uint32_t>(transferRate * QUALITY_ONE));
-        auto const amountWithRate = multiply(amount, rate);
-
-        // Gateway pays alice 10 USD
-        EXPECT_EQ(
-            env.submit(transactions::PaymentBuilder{gw, alice, USD.amount(10)}, gw).ter,
-            tesSUCCESS);
-        env.close();
-
-        // Alice pays bob 1 USD (with sendmax to cover transfer fee)
-        EXPECT_EQ(
-            env.submit(
-                   transactions::PaymentBuilder{alice, bob, USD.amount(1)}.setSendMax(
-                       USD.amount(10)),
-                   alice)
-                .ter,
-            tesSUCCESS);
-        env.close();
-
-        // Check balances
-        EXPECT_EQ(env.getBalance(alice.id(), USD), USD.amount(10) - amountWithRate);
-        EXPECT_EQ(env.getBalance(bob.id(), USD), USD.amount(1));
-    }
-
-    // Test out-of-bounds legacy transfer rates (4.0 and 4.294967295)
-    // These require direct ledger modification since the transactor blocks them
-    for (std::uint32_t const transferRate : {4000000000U, 4294967295U})
-    {
-        TxTest env;
-        env.createAccount(gw, XRP(10000), asfDefaultRipple);
-        env.createAccount(alice, XRP(10000), asfDefaultRipple);
-        env.createAccount(bob, XRP(10000), asfDefaultRipple);
-        env.close();
-
-        // Set up trust lines
-        EXPECT_EQ(
-            env.submit(transactions::TrustSetBuilder{alice}.setLimitAmount(USD.amount(10)), alice)
-                .ter,
-            tesSUCCESS);
-        EXPECT_EQ(
-            env.submit(transactions::TrustSetBuilder{bob}.setLimitAmount(USD.amount(10)), bob).ter,
-            tesSUCCESS);
-        env.close();
-
-        // Set an acceptable transfer rate first (we'll hack it later)
-        EXPECT_EQ(
-            env.submit(
-                   transactions::AccountSetBuilder{gw}.setTransferRate(
-                       static_cast<std::uint32_t>(2.0 * QUALITY_ONE)),
-                   gw)
-                .ter,
-            tesSUCCESS);
-        env.close();
-
-        // Directly modify the ledger to set an out-of-bounds transfer rate
-        // This bypasses the transactor's validation
-        auto& view = env.getOpenLedger();
-        auto slePtr = view.read(keylet::account(gw.id()));
-        ASSERT_NE(slePtr, nullptr);
-        auto sleCopy = std::make_shared<SLE>(*slePtr);
-        (*sleCopy)[sfTransferRate] = transferRate;
-        view.rawReplace(sleCopy);
-
-        // Calculate the amount with the legacy transfer rate
-        auto const amount = USD.amount(1);
-        auto const amountWithRate = multiply(amount, Rate(transferRate));
-
-        // Gateway pays alice 10 USD
-        EXPECT_EQ(
-            env.submit(transactions::PaymentBuilder{gw, alice, USD.amount(10)}, gw).ter,
-            tesSUCCESS);
-
-        // Alice pays bob 1 USD
-        EXPECT_EQ(
-            env.submit(
-                   transactions::PaymentBuilder{alice, bob, amount}.setSendMax(USD.amount(10)),
-                   alice)
-                .ter,
-            tesSUCCESS);
-
-        // Check balances
-        EXPECT_EQ(env.getBalance(alice.id(), USD), USD.amount(10) - amountWithRate);
-        EXPECT_EQ(env.getBalance(bob.id(), USD), amount);
-    }
-}
-
-}  // namespace xrpl::test

src/tests/libxrpl/tx/main.cpp

@@ -1,8 +0,0 @@
-#include <gtest/gtest.h>
-
-int
-main(int argc, char** argv)
-{
-    ::testing::InitGoogleTest(&argc, argv);
-    return RUN_ALL_TESTS();
-}

src/xrpld/app/consensus/RCLConsensus.cpp

@@ -159,8 +159,10 @@ RCLConsensus::Adaptor::acquireLedger(LedgerHash const& hash)
             // Tell the ledger acquire system that we need the consensus ledger
             acquiringLedger_ = hash;
 
-            app_.getInboundLedgers().acquireAsync(
-                jtADVANCE, "GetConsL1", hash, 0, InboundLedger::Reason::CONSENSUS);
+            app_.getJobQueue().addJob(jtADVANCE, "GetConsL1", [id = hash, &app = app_, this]() {
+                JLOG(j_.debug()) << "JOB advanceLedger getConsensusLedger1 started";
+                app.getInboundLedgers().acquireAsync(id, 0, InboundLedger::Reason::CONSENSUS);
+            });
         }
         return std::nullopt;
     }
@@ -1050,7 +1052,7 @@ void
 RCLConsensus::Adaptor::updateOperatingMode(std::size_t const positions) const
 {
     if ((positions == 0u) && app_.getOPs().isFull())
-        app_.getOPs().setMode(OperatingMode::CONNECTED, "updateOperatingMode: no positions");
+        app_.getOPs().setMode(OperatingMode::CONNECTED);
 }
 
 void

src/xrpld/app/consensus/RCLValidations.cpp

@@ -128,8 +128,12 @@ RCLValidationsAdaptor::acquire(LedgerHash const& hash)
     {
         JLOG(j_.warn()) << "Need validated ledger for preferred ledger analysis " << hash;
 
-        app_.getInboundLedgers().acquireAsync(
-            jtADVANCE, "GetConsL2", hash, 0, InboundLedger::Reason::CONSENSUS);
+        Application* pApp = &app_;
+
+        app_.getJobQueue().addJob(jtADVANCE, "GetConsL2", [pApp, hash, this]() {
+            JLOG(j_.debug()) << "JOB advanceLedger getConsensusLedger2 started";
+            pApp->getInboundLedgers().acquireAsync(hash, 0, InboundLedger::Reason::CONSENSUS);
+        });
         return std::nullopt;
     }
 

src/xrpld/app/ledger/InboundLedgers.h

@@ -26,12 +26,7 @@ public:
     // Queue. TODO review whether all callers of acquire() can use this
     // instead. Inbound ledger acquisition is asynchronous anyway.
     virtual void
-    acquireAsync(
-        JobType type,
-        std::string const& name,
-        uint256 const& hash,
-        std::uint32_t seq,
-        InboundLedger::Reason reason) = 0;
+    acquireAsync(uint256 const& hash, std::uint32_t seq, InboundLedger::Reason reason) = 0;
 
     virtual std::shared_ptr<InboundLedger>
     find(LedgerHash const& hash) = 0;

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

@@ -385,14 +385,7 @@ InboundLedger::onTimer(bool wasProgress, ScopedLockType&)
 
     if (!wasProgress)
     {
-        if (checkLocal())
-        {
-            // Done. Something else (probably consensus) built the ledger
-            // locally while waiting for data (or possibly before requesting)
-            XRPL_ASSERT(isDone(), "ripple::InboundLedger::onTimer : done");
-            JLOG(journal_.info()) << "Finished while waiting " << hash_;
-            return;
-        }
+        checkLocal();
 
         mByHash = true;
 

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

@@ -6,7 +6,6 @@
 #include <xrpld/overlay/PeerSet.h>
 
 #include <xrpl/basics/Blob.h>
-#include <xrpl/basics/CanProcess.h>
 #include <xrpl/basics/DecayingSample.h>
 #include <xrpl/basics/Log.h>
 #include <xrpl/basics/Slice.h>
@@ -84,15 +83,12 @@ public:
                 (reason != InboundLedger::Reason::CONSENSUS))
                 return {};
 
-            std::stringstream ss;
-
             bool isNew = true;
             std::shared_ptr<InboundLedger> inbound;
             {
                 ScopedLockType sl(mLock);
                 if (stopping_)
                 {
-                    JLOG(j_.debug()) << "Abort(stopping): " << ss.str();
                     return {};
                 }
 
@@ -111,61 +107,47 @@ public:
                     ++mCounter;
                 }
             }
-            ss << " IsNew: " << (isNew ? "true" : "false");
 
             if (inbound->isFailed())
-            {
-                JLOG(j_.debug()) << "Abort(failed): " << ss.str();
                 return {};
-            }
 
             if (!isNew)
                 inbound->update(seq);
 
             if (!inbound->isComplete())
-            {
-                JLOG(j_.debug()) << "InProgress: " << ss.str();
                 return {};
-            }
 
-            JLOG(j_.debug()) << "Complete: " << ss.str();
             return inbound->getLedger();
         };
         using namespace std::chrono_literals;
-        return perf::measureDurationAndLog(doAcquire, "InboundLedgersImp::acquire", 500ms, j_);
+        std::shared_ptr<Ledger const> ledger =
+            perf::measureDurationAndLog(doAcquire, "InboundLedgersImp::acquire", 500ms, j_);
+
+        return ledger;
     }
 
     void
-    acquireAsync(
-        JobType type,
-        std::string const& name,
-        uint256 const& hash,
-        std::uint32_t seq,
-        InboundLedger::Reason reason) override
+    acquireAsync(uint256 const& hash, std::uint32_t seq, InboundLedger::Reason reason) override
     {
-        if (auto check = std::make_shared<CanProcess const>(acquiresMutex_, pendingAcquires_, hash);
-            *check)
+        std::unique_lock lock(acquiresMutex_);
+        try
         {
-            app_.getJobQueue().addJob(type, name, [check, name, hash, seq, reason, this]() {
-                JLOG(j_.debug()) << "JOB acquireAsync " << name << " started ";
-                try
-                {
-                    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;
-                }
-            });
+            if (pendingAcquires_.contains(hash))
+                return;
+            pendingAcquires_.insert(hash);
+            scope_unlock const unlock(lock);
+            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;
+        }
+        pendingAcquires_.erase(hash);
     }
 
     std::shared_ptr<InboundLedger>

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

@@ -965,9 +965,8 @@ LedgerMaster::checkAccept(std::shared_ptr<Ledger const> const& ledger)
         return;
     }
 
-    JLOG(m_journal.info()) << "Advancing accepted ledger to " << ledger->header().seq << " ("
-                           << to_short_string(ledger->header().hash) << ") with >= " << minVal
-                           << " validations";
+    JLOG(m_journal.info()) << "Advancing accepted ledger to " << ledger->header().seq
+                           << " with >= " << minVal << " validations";
 
     ledger->setValidated();
     ledger->setFull();

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

@@ -25,8 +25,7 @@ TimeoutCounter::TimeoutCounter(
     QueueJobParameter&& jobParameter,
     beast::Journal journal)
     : app_(app)
-    , sink_(journal, to_short_string(hash) + " ")
-    , journal_(sink_)
+    , journal_(journal)
     , hash_(hash)
     , timerInterval_(interval)
     , queueJobParameter_(std::move(jobParameter))
@@ -42,7 +41,6 @@ TimeoutCounter::setTimer(ScopedLockType& sl)
 {
     if (isDone())
         return;
-    JLOG(journal_.debug()) << "Setting timer for " << timerInterval_.count() << "ms";
     timer_.expires_after(timerInterval_);
     timer_.async_wait([wptr = pmDowncast()](boost::system::error_code const& ec) {
         if (ec == boost::asio::error::operation_aborted)
@@ -50,10 +48,6 @@ TimeoutCounter::setTimer(ScopedLockType& sl)
 
         if (auto ptr = wptr.lock())
         {
-            JLOG(ptr->journal_.debug())
-                << "timer: ec: " << ec
-                << " (operation_aborted: " << boost::asio::error::operation_aborted << " - "
-                << (ec == boost::asio::error::operation_aborted ? "aborted" : "other") << ")";
             ScopedLockType sl(ptr->mtx_);
             ptr->queueJob(sl);
         }

src/xrpld/app/ledger/detail/TimeoutCounter.h

@@ -3,7 +3,6 @@
 #include <xrpld/app/main/Application.h>
 
 #include <xrpl/beast/utility/Journal.h>
-#include <xrpl/beast/utility/WrappedSink.h>
 #include <xrpl/core/Job.h>
 
 #include <boost/asio/basic_waitable_timer.hpp>
@@ -104,7 +103,6 @@ protected:
     // Used in this class for access to boost::asio::io_context and
     // xrpl::Overlay. Used in subtypes for the kitchen sink.
     Application& app_;
-    beast::WrappedSink sink_;
     beast::Journal journal_;
     mutable std::recursive_mutex mtx_;
 

src/xrpld/app/main/BasicApp.cpp

@@ -12,10 +12,10 @@ BasicApp::BasicApp(std::size_t numberOfThreads)
     work_.emplace(boost::asio::make_work_guard(io_context_));
     threads_.reserve(numberOfThreads);
 
-    for (std::size_t i = 0; i < numberOfThreads; ++i)
+    while ((numberOfThreads--) != 0u)
     {
-        threads_.emplace_back([this, i]() {
-            beast::setCurrentThreadName("io svc #" + std::to_string(i));
+        threads_.emplace_back([this, numberOfThreads]() {
+            beast::setCurrentThreadName("io svc #" + std::to_string(numberOfThreads));
             this->io_context_.run();
         });
     }

src/xrpld/app/misc/NetworkOPs.cpp

@@ -35,7 +35,6 @@
 #include <xrpld/rpc/MPTokenIssuanceID.h>
 #include <xrpld/rpc/ServerHandler.h>
 
-#include <xrpl/basics/CanProcess.h>
 #include <xrpl/basics/Log.h>
 #include <xrpl/basics/ToString.h>
 #include <xrpl/basics/UnorderedContainers.h>
@@ -486,7 +485,7 @@ public:
     isFull() override;
 
     void
-    setMode(OperatingMode om, char const* reason) override;
+    setMode(OperatingMode om) override;
 
     bool
     isBlocked() override;
@@ -924,7 +923,7 @@ NetworkOPsImp::strOperatingMode(bool const admin /* = false */) const
 inline void
 NetworkOPsImp::setStandAlone()
 {
-    setMode(OperatingMode::FULL, "setStandAlone");
+    setMode(OperatingMode::FULL);
 }
 
 inline void
@@ -1067,7 +1066,7 @@ NetworkOPsImp::processHeartbeatTimer()
         {
             if (mMode != OperatingMode::DISCONNECTED)
             {
-                setMode(OperatingMode::DISCONNECTED, "Heartbeat: insufficient peers");
+                setMode(OperatingMode::DISCONNECTED);
                 std::stringstream ss;
                 ss << "Node count (" << numPeers << ") has fallen "
                    << "below required minimum (" << minPeerCount_ << ").";
@@ -1091,7 +1090,7 @@ NetworkOPsImp::processHeartbeatTimer()
 
         if (mMode == OperatingMode::DISCONNECTED)
         {
-            setMode(OperatingMode::CONNECTED, "Heartbeat: sufficient peers");
+            setMode(OperatingMode::CONNECTED);
             JLOG(m_journal.info()) << "Node count (" << numPeers << ") is sufficient.";
             CLOG(clog.ss()) << "setting mode to CONNECTED based on " << numPeers << " peers. ";
         }
@@ -1102,11 +1101,11 @@ NetworkOPsImp::processHeartbeatTimer()
         CLOG(clog.ss()) << "mode: " << strOperatingMode(origMode, true);
         if (mMode == OperatingMode::SYNCING)
         {
-            setMode(OperatingMode::SYNCING, "Heartbeat: check syncing");
+            setMode(OperatingMode::SYNCING);
         }
         else if (mMode == OperatingMode::CONNECTED)
         {
-            setMode(OperatingMode::CONNECTED, "Heartbeat: check connected");
+            setMode(OperatingMode::CONNECTED);
         }
         auto newMode = mMode.load();
         if (origMode != newMode)
@@ -1810,7 +1809,7 @@ void
 NetworkOPsImp::setAmendmentBlocked()
 {
     amendmentBlocked_ = true;
-    setMode(OperatingMode::CONNECTED, "setAmendmentBlocked");
+    setMode(OperatingMode::CONNECTED);
 }
 
 inline bool
@@ -1841,7 +1840,7 @@ void
 NetworkOPsImp::setUNLBlocked()
 {
     unlBlocked_ = true;
-    setMode(OperatingMode::CONNECTED, "setUNLBlocked");
+    setMode(OperatingMode::CONNECTED);
 }
 
 inline void
@@ -1941,7 +1940,7 @@ NetworkOPsImp::checkLastClosedLedger(Overlay::PeerSequence const& peerList, uint
 
     if ((mMode == OperatingMode::TRACKING) || (mMode == OperatingMode::FULL))
     {
-        setMode(OperatingMode::CONNECTED, "check LCL: not on consensus ledger");
+        setMode(OperatingMode::CONNECTED);
     }
 
     if (consensus)
@@ -2029,8 +2028,8 @@ NetworkOPsImp::beginConsensus(
         // this shouldn't happen unless we jump ledgers
         if (mMode == OperatingMode::FULL)
         {
-            JLOG(m_journal.warn()) << "beginConsensus Don't have LCL, going to tracking";
-            setMode(OperatingMode::TRACKING, "beginConsensus: No LCL");
+            JLOG(m_journal.warn()) << "Don't have LCL, going to tracking";
+            setMode(OperatingMode::TRACKING);
             CLOG(clog) << "beginConsensus Don't have LCL, going to tracking. ";
         }
 
@@ -2158,7 +2157,7 @@ NetworkOPsImp::endConsensus(std::unique_ptr<std::stringstream> const& clog)
         // validations we have for LCL.  If the ledger is good enough, go to
         // TRACKING - TODO
         if (!needNetworkLedger_)
-            setMode(OperatingMode::TRACKING, "endConsensus: check tracking");
+            setMode(OperatingMode::TRACKING);
     }
 
     if (((mMode == OperatingMode::CONNECTED) || (mMode == OperatingMode::TRACKING)) &&
@@ -2171,7 +2170,7 @@ NetworkOPsImp::endConsensus(std::unique_ptr<std::stringstream> const& clog)
         if (registry_.get().getTimeKeeper().now() <
             (current->header().parentCloseTime + 2 * current->header().closeTimeResolution))
         {
-            setMode(OperatingMode::FULL, "endConsensus: check full");
+            setMode(OperatingMode::FULL);
         }
     }
 
@@ -2183,7 +2182,7 @@ NetworkOPsImp::consensusViewChange()
 {
     if ((mMode == OperatingMode::FULL) || (mMode == OperatingMode::TRACKING))
     {
-        setMode(OperatingMode::CONNECTED, "consensusViewChange");
+        setMode(OperatingMode::CONNECTED);
     }
 }
 
@@ -2487,7 +2486,7 @@ NetworkOPsImp::pubPeerStatus(std::function<Json::Value(void)> const& func)
 }
 
 void
-NetworkOPsImp::setMode(OperatingMode om, char const* reason)
+NetworkOPsImp::setMode(OperatingMode om)
 {
     using namespace std::chrono_literals;
     if (om == OperatingMode::CONNECTED)
@@ -2507,12 +2506,11 @@ NetworkOPsImp::setMode(OperatingMode om, char const* reason)
     if (mMode == om)
         return;
 
-    auto const sink = om < mMode ? m_journal.warn() : m_journal.info();
     mMode = om;
 
     accounting_.mode(om);
 
-    JLOG(sink) << "STATE->" << strOperatingMode() << " - " << reason;
+    JLOG(m_journal.info()) << "STATE->" << strOperatingMode();
     pubServer();
 }
 
@@ -2521,24 +2519,36 @@ NetworkOPsImp::recvValidation(std::shared_ptr<STValidation> const& val, std::str
 {
     JLOG(m_journal.trace()) << "recvValidation " << val->getLedgerHash() << " from " << source;
 
+    std::unique_lock lock(validationsMutex_);
+    BypassAccept bypassAccept = BypassAccept::no;
+    try
     {
-        CanProcess const check(validationsMutex_, pendingValidations_, val->getLedgerHash());
-        try
+        if (pendingValidations_.contains(val->getLedgerHash()))
         {
-            BypassAccept bypassAccept = check ? BypassAccept::no : BypassAccept::yes;
-            handleNewValidation(registry_.app(), val, source, bypassAccept, m_journal);
+            bypassAccept = BypassAccept::yes;
         }
-        catch (std::exception const& e)
+        else
         {
-            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();
+            pendingValidations_.insert(val->getLedgerHash());
         }
+        scope_unlock const unlock(lock);
+        handleNewValidation(registry_.get().getApp(), 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)
+    {
+        pendingValidations_.erase(val->getLedgerHash());
+    }
+    lock.unlock();
 
     pubValidation(val);
 

src/xrpld/peerfinder/detail/Counts.h

@@ -8,9 +8,6 @@
 
 namespace xrpl::PeerFinder {
 
-/** Direction of a slot count adjustment. */
-enum class CountAdjustment : int { Decrement = -1, Increment = 1 };
-
 /** Manages the count of available connections for the various slots. */
 class Counts
 {
@@ -19,14 +16,14 @@ public:
     void
     add(Slot const& s)
     {
-        adjust(s, CountAdjustment::Increment);
+        adjust(s, 1);
     }
 
     /** Removes the slot state and properties from the slot counts. */
     void
     remove(Slot const& s)
     {
-        adjust(s, CountAdjustment::Decrement);
+        adjust(s, -1);
     }
 
     /** Returns `true` if the slot can become active. */
@@ -210,40 +207,21 @@ public:
 
     //--------------------------------------------------------------------------
 private:
-    /** Increments or decrements a counter based on the adjustment direction. */
-    template <typename T>
-    static void
-    adjustCounter(T& counter, CountAdjustment dir)
-    {
-        switch (dir)
-        {
-            case CountAdjustment::Increment:
-                ++counter;
-                break;
-            case CountAdjustment::Decrement:
-                --counter;
-                break;
-        }
-    }
-
     // Adjusts counts based on the specified slot, in the direction indicated.
-    // Using ++/-- instead of += on std::size_t counters avoids UBSan
-    // unsigned-integer-overflow from implicit conversion of -1 to SIZE_MAX.
-    // A decrement on a zero counter is a real bug that UBSan should catch.
     void
-    adjust(Slot const& s, CountAdjustment const dir)
+    adjust(Slot const& s, int const n)
     {
         if (s.fixed())
-            adjustCounter(m_fixed, dir);
+            m_fixed += n;
 
         if (s.reserved())
-            adjustCounter(m_reserved, dir);
+            m_reserved += n;
 
         switch (s.state())
         {
             case Slot::accept:
                 XRPL_ASSERT(s.inbound(), "xrpl::PeerFinder::Counts::adjust : input is inbound");
-                adjustCounter(m_acceptCount, dir);
+                m_acceptCount += n;
                 break;
 
             case Slot::connect:
@@ -252,28 +230,28 @@ private:
                     !s.inbound(),
                     "xrpl::PeerFinder::Counts::adjust : input is not "
                     "inbound");
-                adjustCounter(m_attempts, dir);
+                m_attempts += n;
                 break;
 
             case Slot::active:
                 if (s.fixed())
-                    adjustCounter(m_fixed_active, dir);
+                    m_fixed_active += n;
                 if (!s.fixed() && !s.reserved())
                 {
                     if (s.inbound())
                     {
-                        adjustCounter(m_in_active, dir);
+                        m_in_active += n;
                     }
                     else
                     {
-                        adjustCounter(m_out_active, dir);
+                        m_out_active += n;
                     }
                 }
-                adjustCounter(m_active, dir);
+                m_active += n;
                 break;
 
             case Slot::closing:
-                adjustCounter(m_closingCount, dir);
+                m_closingCount += n;
                 break;
 
             // LCOV_EXCL_START

src/xrpld/rpc/handlers/server_info/ServerDefinitions.cpp

@@ -149,18 +149,6 @@ ServerDefinitions::ServerDefinitions() : defs_{Json::objectValue}
     defs_[jss::FIELDS] = Json::arrayValue;
 
     uint32_t i = 0;
-    {
-        Json::Value a = Json::arrayValue;
-        a[0U] = "Generic";
-        Json::Value v = Json::objectValue;
-        v[jss::nth] = 0;
-        v[jss::isVLEncoded] = false;
-        v[jss::isSerialized] = false;
-        v[jss::isSigningField] = false;
-        v[jss::type] = "Unknown";
-        a[1U] = v;
-        defs_[jss::FIELDS][i++] = a;
-    }
 
     {
         Json::Value a = Json::arrayValue;
@@ -227,21 +215,25 @@ ServerDefinitions::ServerDefinitions() : defs_{Json::objectValue}
         defs_[jss::FIELDS][i++] = a;
     }
 
-    for (auto const& [code, field] : xrpl::SField::getKnownCodeToField())
+    // copy into a sorted map to ensure deterministic output order (sorted by fieldCode)
+    static std::map<int, SField const*> const sortedFields(
+        xrpl::SField::getKnownCodeToField().begin(), xrpl::SField::getKnownCodeToField().end());
+
+    for (auto const& [code, field] : sortedFields)
     {
         if (field->fieldName.empty())
             continue;
 
         Json::Value innerObj = Json::objectValue;
 
-        uint32_t type = field->fieldType;
+        int32_t const type = field->fieldType;
 
         innerObj[jss::nth] = field->fieldValue;
 
         // whether the field is variable-length encoded this means that the length is included
         // before the content
         innerObj[jss::isVLEncoded] =
-            (type == 7U /* Blob */ || type == 8U /* AccountID */ || type == 19U /* Vector256 */);
+            (type == STI_VL || type == STI_ACCOUNT || type == STI_VECTOR256);
 
         // whether the field is included in serialization
         innerObj[jss::isSerialized] =