Merge branch 'develop' into mvadari/fix-defs

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

@@ -93,6 +93,7 @@ test.core > xrpl.basics
 test.core > xrpl.core
 test.core > xrpld.core
 test.core > xrpl.json
+test.core > xrpl.protocol
 test.core > xrpl.rdb
 test.core > xrpl.server
 test.csf > xrpl.basics
@@ -187,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/DecayingSample.h

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

include/xrpl/basics/Slice.h

@@ -11,7 +11,6 @@
 #include <limits>
 #include <stdexcept>
 #include <string>
-#include <string_view>
 #include <type_traits>
 #include <vector>
 
@@ -232,11 +231,4 @@ makeSlice(std::basic_string<char, Traits, Alloc> const& s)
     return Slice(s.data(), s.size());
 }
 
-template <class Traits>
-Slice
-makeSlice(std::basic_string_view<char, Traits> s)
-{
-    return Slice(s.data(), s.size());
-}
-
 }  // namespace xrpl

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/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/proto/xrpl.proto

@@ -246,15 +246,7 @@ message TMGetObjectByHash {
 
 message TMLedgerNode {
   required bytes nodedata = 1;
-
-  // Used when protocol version <2.3. Not set for ledger base data.
-  optional bytes nodeid = 2;
-
-  // Used when protocol version >=2.3. Neither value is set for ledger base data.
-  oneof reference {
-    bytes id = 3;      // Set for inner nodes.
-    uint32 depth = 4;  // Set for leaf nodes.
-  }
+  optional bytes nodeid = 2;  // missing for ledger base data
 }
 
 enum TMLedgerInfoType {

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/shamap/SHAMap.h

@@ -16,7 +16,6 @@
 
 #include <set>
 #include <stack>
-#include <tuple>
 #include <vector>
 
 namespace xrpl {
@@ -74,22 +73,6 @@ enum class SHAMapState {
 
     See https://en.wikipedia.org/wiki/Merkle_tree
  */
-
-/** Holds a SHAMap node's identity, serialized data, and leaf status.
-    Used by getNodeFat to return node data for peer synchronization.
-*/
-struct SHAMapNodeData
-{
-    SHAMapNodeID nodeID;
-    Blob data;
-    bool isLeaf;
-
-    SHAMapNodeData(SHAMapNodeID const& id, Blob d, bool leaf)
-        : nodeID(id), data(std::move(d)), isLeaf(leaf)
-    {
-    }
-};
-
 class SHAMap
 {
 private:
@@ -102,7 +85,7 @@ private:
     /** The sequence of the ledger that this map references, if any. */
     std::uint32_t ledgerSeq_ = 0;
 
-    SHAMapTreeNodePtr root_;
+    intr_ptr::SharedPtr<SHAMapTreeNode> root_;
     mutable SHAMapState state_;
     SHAMapType const type_;
     bool backed_ = true;         // Map is backed by the database
@@ -267,10 +250,10 @@ public:
     std::vector<std::pair<SHAMapNodeID, uint256>>
     getMissingNodes(int maxNodes, SHAMapSyncFilter* filter);
 
-    [[nodiscard]] bool
+    bool
     getNodeFat(
         SHAMapNodeID const& wanted,
-        std::vector<SHAMapNodeData>& data,
+        std::vector<std::pair<SHAMapNodeID, Blob>>& data,
         bool fatLeaves,
         std::uint32_t depth) const;
 
@@ -297,42 +280,10 @@ public:
     void
     serializeRoot(Serializer& s) const;
 
-    /** Add a root node to the SHAMap during synchronization.
-     *
-     * This function is used when receiving the root node of a SHAMap from a peer during ledger
-     * synchronization. The node must already have been deserialized.
-     *
-     * @param hash The expected hash of the root node.
-     * @param rootNode A deserialized root node to add.
-     * @param filter Optional sync filter to track received nodes.
-     * @return Status indicating whether the node was useful, duplicate, or invalid.
-     *
-     * @note This function expects the rootNode to be a valid, deserialized SHAMapTreeNode. The
-     *       caller is responsible for deserialization and basic validation before calling this
-     *       function.
-     */
     SHAMapAddNode
-    addRootNode(SHAMapHash const& hash, SHAMapTreeNodePtr rootNode, SHAMapSyncFilter const* filter);
-
-    /** Add a known node at a specific position in the SHAMap during synchronization.
-     *
-     * This function is used when receiving nodes from peers during ledger synchronization. The node
-     * is inserted at the position specified by nodeID. The node must already have been
-     * deserialized.
-     *
-     * @param nodeID The position in the tree where this node belongs.
-     * @param treeNode A deserialized tree node to add.
-     * @param filter Optional sync filter to track received nodes.
-     * @return Status indicating whether the node was useful, duplicate, or invalid.
-     *
-     * @note This function expects that the caller has already validated that the nodeID is
-     * consistent with the node's content.
-     */
+    addRootNode(SHAMapHash const& hash, Slice const& rootNode, SHAMapSyncFilter* filter);
     SHAMapAddNode
-    addKnownNode(
-        SHAMapNodeID const& nodeID,
-        SHAMapTreeNodePtr treeNode,
-        SHAMapSyncFilter const* filter);
+    addKnownNode(SHAMapNodeID const& nodeID, Slice const& rawNode, SHAMapSyncFilter* filter);
 
     // status functions
     void
@@ -375,32 +326,36 @@ public:
     invariants() const;
 
 private:
-    using SharedPtrNodeStack = std::stack<std::pair<SHAMapTreeNodePtr, SHAMapNodeID>>;
+    using SharedPtrNodeStack =
+        std::stack<std::pair<intr_ptr::SharedPtr<SHAMapTreeNode>, SHAMapNodeID>>;
     using DeltaRef =
         std::pair<boost::intrusive_ptr<SHAMapItem const>, boost::intrusive_ptr<SHAMapItem const>>;
 
     // tree node cache operations
-    SHAMapTreeNodePtr
+    intr_ptr::SharedPtr<SHAMapTreeNode>
     cacheLookup(SHAMapHash const& hash) const;
 
     void
-    canonicalize(SHAMapHash const& hash, SHAMapTreeNodePtr&) const;
+    canonicalize(SHAMapHash const& hash, intr_ptr::SharedPtr<SHAMapTreeNode>&) const;
 
     // database operations
-    SHAMapTreeNodePtr
+    intr_ptr::SharedPtr<SHAMapTreeNode>
     fetchNodeFromDB(SHAMapHash const& hash) const;
-    SHAMapTreeNodePtr
+    intr_ptr::SharedPtr<SHAMapTreeNode>
     fetchNodeNT(SHAMapHash const& hash) const;
-    SHAMapTreeNodePtr
-    fetchNodeNT(SHAMapHash const& hash, SHAMapSyncFilter const* filter) const;
-    SHAMapTreeNodePtr
+    intr_ptr::SharedPtr<SHAMapTreeNode>
+    fetchNodeNT(SHAMapHash const& hash, SHAMapSyncFilter* filter) const;
+    intr_ptr::SharedPtr<SHAMapTreeNode>
     fetchNode(SHAMapHash const& hash) const;
-    SHAMapTreeNodePtr
-    checkFilter(SHAMapHash const& hash, SHAMapSyncFilter const* filter) const;
+    intr_ptr::SharedPtr<SHAMapTreeNode>
+    checkFilter(SHAMapHash const& hash, SHAMapSyncFilter* filter) const;
 
     /** Update hashes up to the root */
     void
-    dirtyUp(SharedPtrNodeStack& stack, uint256 const& target, SHAMapTreeNodePtr terminal);
+    dirtyUp(
+        SharedPtrNodeStack& stack,
+        uint256 const& target,
+        intr_ptr::SharedPtr<SHAMapTreeNode> terminal);
 
     /** Walk towards the specified id, returning the node.  Caller must check
         if the return is nullptr, and if not, if the node->peekItem()->key() ==
@@ -422,21 +377,25 @@ private:
     preFlushNode(intr_ptr::SharedPtr<Node> node) const;
 
     /** write and canonicalize modified node */
-    SHAMapTreeNodePtr
-    writeNode(NodeObjectType t, SHAMapTreeNodePtr node) const;
+    intr_ptr::SharedPtr<SHAMapTreeNode>
+    writeNode(NodeObjectType t, intr_ptr::SharedPtr<SHAMapTreeNode> node) const;
 
     // returns the first item at or below this node
     SHAMapLeafNode*
-    firstBelow(SHAMapTreeNodePtr node, SharedPtrNodeStack& stack, int branch = 0) const;
+    firstBelow(intr_ptr::SharedPtr<SHAMapTreeNode>, SharedPtrNodeStack& stack, int branch = 0)
+        const;
 
     // returns the last item at or below this node
     SHAMapLeafNode*
-    lastBelow(SHAMapTreeNodePtr node, SharedPtrNodeStack& stack, int branch = branchFactor) const;
+    lastBelow(
+        intr_ptr::SharedPtr<SHAMapTreeNode> node,
+        SharedPtrNodeStack& stack,
+        int branch = branchFactor) const;
 
     // helper function for firstBelow and lastBelow
     SHAMapLeafNode*
     belowHelper(
-        SHAMapTreeNodePtr node,
+        intr_ptr::SharedPtr<SHAMapTreeNode> node,
         SharedPtrNodeStack& stack,
         int branch,
         std::tuple<int, std::function<bool(int)>, std::function<void(int&)>> const& loopParams)
@@ -448,19 +407,20 @@ private:
     descend(SHAMapInnerNode*, int branch) const;
     SHAMapTreeNode*
     descendThrow(SHAMapInnerNode*, int branch) const;
-    SHAMapTreeNodePtr
+    intr_ptr::SharedPtr<SHAMapTreeNode>
     descend(SHAMapInnerNode&, int branch) const;
-    SHAMapTreeNodePtr
+    intr_ptr::SharedPtr<SHAMapTreeNode>
     descendThrow(SHAMapInnerNode&, int branch) const;
 
     // Descend with filter
     // If pending, callback is called as if it called fetchNodeNT
-    using descendCallback = std::function<void(SHAMapTreeNodePtr, SHAMapHash const&)>;
+    using descendCallback =
+        std::function<void(intr_ptr::SharedPtr<SHAMapTreeNode>, SHAMapHash const&)>;
     SHAMapTreeNode*
     descendAsync(
         SHAMapInnerNode* parent,
         int branch,
-        SHAMapSyncFilter const* filter,
+        SHAMapSyncFilter* filter,
         bool& pending,
         descendCallback&&) const;
 
@@ -469,11 +429,11 @@ private:
         SHAMapInnerNode* parent,
         SHAMapNodeID const& parentID,
         int branch,
-        SHAMapSyncFilter const* filter) const;
+        SHAMapSyncFilter* filter) const;
 
     // Non-storing
     // Does not hook the returned node to its parent
-    SHAMapTreeNodePtr
+    intr_ptr::SharedPtr<SHAMapTreeNode>
     descendNoStore(SHAMapInnerNode&, int branch) const;
 
     /** If there is only one leaf below this node, get its contents */
@@ -535,10 +495,10 @@ private:
 
         // nodes we may have acquired from deferred reads
         using DeferredNode = std::tuple<
-            SHAMapInnerNode*,    // parent node
-            SHAMapNodeID,        // parent node ID
-            int,                 // branch
-            SHAMapTreeNodePtr>;  // node
+            SHAMapInnerNode*,                      // parent node
+            SHAMapNodeID,                          // parent node ID
+            int,                                   // branch
+            intr_ptr::SharedPtr<SHAMapTreeNode>>;  // node
 
         int deferred_;
         std::mutex deferLock_;
@@ -564,7 +524,7 @@ private:
     gmn_ProcessDeferredReads(MissingNodes&);
 
     // fetch from DB helper function
-    SHAMapTreeNodePtr
+    intr_ptr::SharedPtr<SHAMapTreeNode>
     finishFetch(SHAMapHash const& hash, std::shared_ptr<NodeObject> const& object) const;
 };
 

include/xrpl/shamap/SHAMapAccountStateLeafNode.h

@@ -27,7 +27,7 @@ public:
     {
     }
 
-    SHAMapTreeNodePtr
+    intr_ptr::SharedPtr<SHAMapTreeNode>
     clone(std::uint32_t cowid) const final
     {
         return intr_ptr::make_shared<SHAMapAccountStateLeafNode>(item_, cowid, hash_);

include/xrpl/shamap/SHAMapInnerNode.h

@@ -87,7 +87,7 @@ public:
     void
     partialDestructor() override;
 
-    SHAMapTreeNodePtr
+    intr_ptr::SharedPtr<SHAMapTreeNode>
     clone(std::uint32_t cowid) const override;
 
     SHAMapNodeType
@@ -121,19 +121,19 @@ public:
     getChildHash(int m) const;
 
     void
-    setChild(int m, SHAMapTreeNodePtr child);
+    setChild(int m, intr_ptr::SharedPtr<SHAMapTreeNode> child);
 
     void
-    shareChild(int m, SHAMapTreeNodePtr const& child);
+    shareChild(int m, intr_ptr::SharedPtr<SHAMapTreeNode> const& child);
 
     SHAMapTreeNode*
     getChildPointer(int branch);
 
-    SHAMapTreeNodePtr
+    intr_ptr::SharedPtr<SHAMapTreeNode>
     getChild(int branch);
 
-    SHAMapTreeNodePtr
-    canonicalizeChild(int branch, SHAMapTreeNodePtr node);
+    intr_ptr::SharedPtr<SHAMapTreeNode>
+    canonicalizeChild(int branch, intr_ptr::SharedPtr<SHAMapTreeNode> node);
 
     // sync functions
     bool
@@ -161,10 +161,10 @@ public:
     void
     invariants(bool is_root = false) const override;
 
-    static SHAMapTreeNodePtr
+    static intr_ptr::SharedPtr<SHAMapTreeNode>
     makeFullInner(Slice data, SHAMapHash const& hash, bool hashValid);
 
-    static SHAMapTreeNodePtr
+    static intr_ptr::SharedPtr<SHAMapTreeNode>
     makeCompressedInner(Slice data);
 };
 

include/xrpl/shamap/SHAMapTreeNode.h

@@ -166,6 +166,4 @@ private:
     makeTransactionWithMeta(Slice data, SHAMapHash const& hash, bool hashValid);
 };
 
-using SHAMapTreeNodePtr = intr_ptr::SharedPtr<SHAMapTreeNode>;
-
 }  // namespace xrpl

include/xrpl/shamap/SHAMapTxLeafNode.h

@@ -26,7 +26,7 @@ public:
     {
     }
 
-    SHAMapTreeNodePtr
+    intr_ptr::SharedPtr<SHAMapTreeNode>
     clone(std::uint32_t cowid) const final
     {
         return intr_ptr::make_shared<SHAMapTxLeafNode>(item_, cowid, hash_);

include/xrpl/shamap/SHAMapTxPlusMetaLeafNode.h

@@ -27,7 +27,7 @@ public:
     {
     }
 
-    SHAMapTreeNodePtr
+    intr_ptr::SharedPtr<SHAMapTreeNode>
     clone(std::uint32_t cowid) const override
     {
         return intr_ptr::make_shared<SHAMapTxPlusMetaLeafNode>(item_, cowid, hash_);

include/xrpl/shamap/TreeNodeCache.h

@@ -11,5 +11,5 @@ using TreeNodeCache = TaggedCache<
     SHAMapTreeNode,
     /*IsKeyCache*/ false,
     intr_ptr::SharedWeakUnionPtr<SHAMapTreeNode>,
-    SHAMapTreeNodePtr>;
+    intr_ptr::SharedPtr<SHAMapTreeNode>>;
 }  // namespace xrpl

include/xrpl/shamap/detail/TaggedPointer.h

@@ -148,7 +148,7 @@ public:
     /** Get the number of elements in each array and a pointer to the start
         of each array.
     */
-    [[nodiscard]] std::tuple<std::uint8_t, SHAMapHash*, SHAMapTreeNodePtr*>
+    [[nodiscard]] std::tuple<std::uint8_t, SHAMapHash*, intr_ptr::SharedPtr<SHAMapTreeNode>*>
     getHashesAndChildren() const;
 
     /** Get the `hashes` array */
@@ -156,7 +156,7 @@ public:
     getHashes() const;
 
     /** Get the `children` array */
-    [[nodiscard]] SHAMapTreeNodePtr*
+    [[nodiscard]] intr_ptr::SharedPtr<SHAMapTreeNode>*
     getChildren() const;
 
     /** Call the `f` callback for all 16 (branchFactor) branches - even if

include/xrpl/shamap/detail/TaggedPointer.ipp

@@ -25,7 +25,8 @@ static_assert(
 // Terminology: A chunk is the memory being allocated from a block. A block
 // contains multiple chunks. This is the terminology the boost documentation
 // uses. Pools use "Simple Segregated Storage" as their storage format.
-constexpr size_t elementSizeBytes = (sizeof(SHAMapHash) + sizeof(SHAMapTreeNodePtr));
+constexpr size_t elementSizeBytes =
+    (sizeof(SHAMapHash) + sizeof(intr_ptr::SharedPtr<SHAMapTreeNode>));
 
 constexpr size_t blockSizeBytes = kilobytes(512);
 
@@ -362,7 +363,8 @@ inline TaggedPointer::TaggedPointer(
                 // keep
                 new (&dstHashes[dstIndex]) SHAMapHash{srcHashes[srcIndex]};
 
-                new (&dstChildren[dstIndex]) SHAMapTreeNodePtr{std::move(srcChildren[srcIndex])};
+                new (&dstChildren[dstIndex])
+                    intr_ptr::SharedPtr<SHAMapTreeNode>{std::move(srcChildren[srcIndex])};
                 ++dstIndex;
                 ++srcIndex;
             }
@@ -373,7 +375,7 @@ inline TaggedPointer::TaggedPointer(
                 if (dstIsDense)
                 {
                     new (&dstHashes[dstIndex]) SHAMapHash{};
-                    new (&dstChildren[dstIndex]) SHAMapTreeNodePtr{};
+                    new (&dstChildren[dstIndex]) intr_ptr::SharedPtr<SHAMapTreeNode>{};
                     ++dstIndex;
                 }
             }
@@ -381,7 +383,7 @@ inline TaggedPointer::TaggedPointer(
             {
                 // add
                 new (&dstHashes[dstIndex]) SHAMapHash{};
-                new (&dstChildren[dstIndex]) SHAMapTreeNodePtr{};
+                new (&dstChildren[dstIndex]) intr_ptr::SharedPtr<SHAMapTreeNode>{};
                 ++dstIndex;
                 if (srcIsDense)
                 {
@@ -394,7 +396,7 @@ inline TaggedPointer::TaggedPointer(
                 if (dstIsDense)
                 {
                     new (&dstHashes[dstIndex]) SHAMapHash{};
-                    new (&dstChildren[dstIndex]) SHAMapTreeNodePtr{};
+                    new (&dstChildren[dstIndex]) intr_ptr::SharedPtr<SHAMapTreeNode>{};
                     ++dstIndex;
                 }
                 if (srcIsDense)
@@ -411,7 +413,7 @@ inline TaggedPointer::TaggedPointer(
         for (int i = dstIndex; i < dstNumAllocated; ++i)
         {
             new (&dstHashes[i]) SHAMapHash{};
-            new (&dstChildren[i]) SHAMapTreeNodePtr{};
+            new (&dstChildren[i]) intr_ptr::SharedPtr<SHAMapTreeNode>{};
         }
         *this = std::move(dst);
     }
@@ -431,7 +433,7 @@ inline TaggedPointer::TaggedPointer(
     // allocate hashes and children, but do not run constructors
     TaggedPointer newHashesAndChildren{RawAllocateTag{}, toAllocate};
     SHAMapHash *newHashes, *oldHashes;
-    SHAMapTreeNodePtr *newChildren, *oldChildren;
+    intr_ptr::SharedPtr<SHAMapTreeNode>*newChildren, *oldChildren;
     std::uint8_t newNumAllocated;
     // structured bindings can't be captured in c++ 17; use tie instead
     std::tie(newNumAllocated, newHashes, newChildren) = newHashesAndChildren.getHashesAndChildren();
@@ -442,7 +444,8 @@ inline TaggedPointer::TaggedPointer(
         // new arrays are dense, old arrays are sparse
         iterNonEmptyChildIndexes(isBranch, [&](auto branchNum, auto indexNum) {
             new (&newHashes[branchNum]) SHAMapHash{oldHashes[indexNum]};
-            new (&newChildren[branchNum]) SHAMapTreeNodePtr{std::move(oldChildren[indexNum])};
+            new (&newChildren[branchNum])
+                intr_ptr::SharedPtr<SHAMapTreeNode>{std::move(oldChildren[indexNum])};
         });
         // Run the constructors for the remaining elements
         for (int i = 0; i < SHAMapInnerNode::branchFactor; ++i)
@@ -450,7 +453,7 @@ inline TaggedPointer::TaggedPointer(
             if ((1 << i) & isBranch)
                 continue;
             new (&newHashes[i]) SHAMapHash{};
-            new (&newChildren[i]) SHAMapTreeNodePtr{};
+            new (&newChildren[i]) intr_ptr::SharedPtr<SHAMapTreeNode>{};
         }
     }
     else
@@ -460,14 +463,14 @@ inline TaggedPointer::TaggedPointer(
         iterNonEmptyChildIndexes(isBranch, [&](auto branchNum, auto indexNum) {
             new (&newHashes[curCompressedIndex]) SHAMapHash{oldHashes[indexNum]};
             new (&newChildren[curCompressedIndex])
-                SHAMapTreeNodePtr{std::move(oldChildren[indexNum])};
+                intr_ptr::SharedPtr<SHAMapTreeNode>{std::move(oldChildren[indexNum])};
             ++curCompressedIndex;
         });
         // Run the constructors for the remaining elements
         for (int i = curCompressedIndex; i < newNumAllocated; ++i)
         {
             new (&newHashes[i]) SHAMapHash{};
-            new (&newChildren[i]) SHAMapTreeNodePtr{};
+            new (&newChildren[i]) intr_ptr::SharedPtr<SHAMapTreeNode>{};
         }
     }
 
@@ -481,7 +484,7 @@ inline TaggedPointer::TaggedPointer(std::uint8_t numChildren)
     for (std::size_t i = 0; i < numAllocated; ++i)
     {
         new (&hashes[i]) SHAMapHash{};
-        new (&children[i]) SHAMapTreeNodePtr{};
+        new (&children[i]) intr_ptr::SharedPtr<SHAMapTreeNode>{};
     }
 }
 
@@ -519,13 +522,14 @@ TaggedPointer::isDense() const
     return (tp_ & tagMask) == boundaries.size() - 1;
 }
 
-[[nodiscard]] inline std::tuple<std::uint8_t, SHAMapHash*, SHAMapTreeNodePtr*>
+[[nodiscard]] inline std::tuple<std::uint8_t, SHAMapHash*, intr_ptr::SharedPtr<SHAMapTreeNode>*>
 TaggedPointer::getHashesAndChildren() const
 {
     auto const [tag, ptr] = decode();
     auto const hashes = reinterpret_cast<SHAMapHash*>(ptr);
     std::uint8_t numAllocated = boundaries[tag];
-    auto const children = reinterpret_cast<SHAMapTreeNodePtr*>(hashes + numAllocated);
+    auto const children =
+        reinterpret_cast<intr_ptr::SharedPtr<SHAMapTreeNode>*>(hashes + numAllocated);
     return {numAllocated, hashes, children};
 };
 
@@ -535,7 +539,7 @@ TaggedPointer::getHashes() const
     return reinterpret_cast<SHAMapHash*>(tp_ & ptrMask);
 };
 
-[[nodiscard]] inline SHAMapTreeNodePtr*
+[[nodiscard]] inline intr_ptr::SharedPtr<SHAMapTreeNode>*
 TaggedPointer::getChildren() const
 {
     auto [unused1, unused2, result] = getHashesAndChildren();

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/libxrpl/shamap/SHAMap.cpp

@@ -97,7 +97,10 @@ SHAMap::snapShot(bool isMutable) const
 }
 
 void
-SHAMap::dirtyUp(SharedPtrNodeStack& stack, uint256 const& target, SHAMapTreeNodePtr child)
+SHAMap::dirtyUp(
+    SharedPtrNodeStack& stack,
+    uint256 const& target,
+    intr_ptr::SharedPtr<SHAMapTreeNode> child)
 {
     // walk the tree up from through the inner nodes to the root_
     // update hashes and links
@@ -162,7 +165,7 @@ SHAMap::findKey(uint256 const& id) const
     return leaf;
 }
 
-SHAMapTreeNodePtr
+intr_ptr::SharedPtr<SHAMapTreeNode>
 SHAMap::fetchNodeFromDB(SHAMapHash const& hash) const
 {
     XRPL_ASSERT(backed_, "xrpl::SHAMap::fetchNodeFromDB : is backed");
@@ -170,7 +173,7 @@ SHAMap::fetchNodeFromDB(SHAMapHash const& hash) const
     return finishFetch(hash, obj);
 }
 
-SHAMapTreeNodePtr
+intr_ptr::SharedPtr<SHAMapTreeNode>
 SHAMap::finishFetch(SHAMapHash const& hash, std::shared_ptr<NodeObject> const& object) const
 {
     XRPL_ASSERT(backed_, "xrpl::SHAMap::finishFetch : is backed");
@@ -205,8 +208,8 @@ SHAMap::finishFetch(SHAMapHash const& hash, std::shared_ptr<NodeObject> const& o
 }
 
 // See if a sync filter has a node
-SHAMapTreeNodePtr
-SHAMap::checkFilter(SHAMapHash const& hash, SHAMapSyncFilter const* filter) const
+intr_ptr::SharedPtr<SHAMapTreeNode>
+SHAMap::checkFilter(SHAMapHash const& hash, SHAMapSyncFilter* filter) const
 {
     if (auto nodeData = filter->getNode(hash))
     {
@@ -231,8 +234,8 @@ SHAMap::checkFilter(SHAMapHash const& hash, SHAMapSyncFilter const* filter) cons
 
 // Get a node without throwing
 // Used on maps where missing nodes are expected
-SHAMapTreeNodePtr
-SHAMap::fetchNodeNT(SHAMapHash const& hash, SHAMapSyncFilter const* filter) const
+intr_ptr::SharedPtr<SHAMapTreeNode>
+SHAMap::fetchNodeNT(SHAMapHash const& hash, SHAMapSyncFilter* filter) const
 {
     auto node = cacheLookup(hash);
     if (node)
@@ -254,7 +257,7 @@ SHAMap::fetchNodeNT(SHAMapHash const& hash, SHAMapSyncFilter const* filter) cons
     return node;
 }
 
-SHAMapTreeNodePtr
+intr_ptr::SharedPtr<SHAMapTreeNode>
 SHAMap::fetchNodeNT(SHAMapHash const& hash) const
 {
     auto node = cacheLookup(hash);
@@ -266,7 +269,7 @@ SHAMap::fetchNodeNT(SHAMapHash const& hash) const
 }
 
 // Throw if the node is missing
-SHAMapTreeNodePtr
+intr_ptr::SharedPtr<SHAMapTreeNode>
 SHAMap::fetchNode(SHAMapHash const& hash) const
 {
     auto node = fetchNodeNT(hash);
@@ -288,10 +291,10 @@ SHAMap::descendThrow(SHAMapInnerNode* parent, int branch) const
     return ret;
 }
 
-SHAMapTreeNodePtr
+intr_ptr::SharedPtr<SHAMapTreeNode>
 SHAMap::descendThrow(SHAMapInnerNode& parent, int branch) const
 {
-    SHAMapTreeNodePtr ret = descend(parent, branch);
+    intr_ptr::SharedPtr<SHAMapTreeNode> ret = descend(parent, branch);
 
     if (!ret && !parent.isEmptyBranch(branch))
         Throw<SHAMapMissingNode>(type_, parent.getChildHash(branch));
@@ -306,7 +309,7 @@ SHAMap::descend(SHAMapInnerNode* parent, int branch) const
     if ((ret != nullptr) || !backed_)
         return ret;
 
-    SHAMapTreeNodePtr node = fetchNodeNT(parent->getChildHash(branch));
+    intr_ptr::SharedPtr<SHAMapTreeNode> node = fetchNodeNT(parent->getChildHash(branch));
     if (!node)
         return nullptr;
 
@@ -314,10 +317,10 @@ SHAMap::descend(SHAMapInnerNode* parent, int branch) const
     return node.get();
 }
 
-SHAMapTreeNodePtr
+intr_ptr::SharedPtr<SHAMapTreeNode>
 SHAMap::descend(SHAMapInnerNode& parent, int branch) const
 {
-    SHAMapTreeNodePtr node = parent.getChild(branch);
+    intr_ptr::SharedPtr<SHAMapTreeNode> node = parent.getChild(branch);
     if (node || !backed_)
         return node;
 
@@ -331,10 +334,10 @@ SHAMap::descend(SHAMapInnerNode& parent, int branch) const
 
 // Gets the node that would be hooked to this branch,
 // but doesn't hook it up.
-SHAMapTreeNodePtr
+intr_ptr::SharedPtr<SHAMapTreeNode>
 SHAMap::descendNoStore(SHAMapInnerNode& parent, int branch) const
 {
-    SHAMapTreeNodePtr ret = parent.getChild(branch);
+    intr_ptr::SharedPtr<SHAMapTreeNode> ret = parent.getChild(branch);
     if (!ret && backed_)
         ret = fetchNode(parent.getChildHash(branch));
     return ret;
@@ -345,7 +348,7 @@ SHAMap::descend(
     SHAMapInnerNode* parent,
     SHAMapNodeID const& parentID,
     int branch,
-    SHAMapSyncFilter const* filter) const
+    SHAMapSyncFilter* filter) const
 {
     XRPL_ASSERT(parent->isInner(), "xrpl::SHAMap::descend : valid parent input");
     XRPL_ASSERT(
@@ -358,7 +361,7 @@ SHAMap::descend(
     if (child == nullptr)
     {
         auto const& childHash = parent->getChildHash(branch);
-        SHAMapTreeNodePtr childNode = fetchNodeNT(childHash, filter);
+        intr_ptr::SharedPtr<SHAMapTreeNode> childNode = fetchNodeNT(childHash, filter);
 
         if (childNode)
         {
@@ -374,7 +377,7 @@ SHAMapTreeNode*
 SHAMap::descendAsync(
     SHAMapInnerNode* parent,
     int branch,
-    SHAMapSyncFilter const* filter,
+    SHAMapSyncFilter* filter,
     bool& pending,
     descendCallback&& callback) const
 {
@@ -431,7 +434,7 @@ SHAMap::unshareNode(intr_ptr::SharedPtr<Node> node, SHAMapNodeID const& nodeID)
 
 SHAMapLeafNode*
 SHAMap::belowHelper(
-    SHAMapTreeNodePtr node,
+    intr_ptr::SharedPtr<SHAMapTreeNode> node,
     SharedPtrNodeStack& stack,
     int branch,
     std::tuple<int, std::function<bool(int)>, std::function<void(int&)>> const& loopParams) const
@@ -476,7 +479,8 @@ SHAMap::belowHelper(
     return nullptr;
 }
 SHAMapLeafNode*
-SHAMap::lastBelow(SHAMapTreeNodePtr node, SharedPtrNodeStack& stack, int branch) const
+SHAMap::lastBelow(intr_ptr::SharedPtr<SHAMapTreeNode> node, SharedPtrNodeStack& stack, int branch)
+    const
 {
     auto init = branchFactor - 1;
     auto cmp = [](int i) { return i >= 0; };
@@ -485,7 +489,8 @@ SHAMap::lastBelow(SHAMapTreeNodePtr node, SharedPtrNodeStack& stack, int branch)
     return belowHelper(node, stack, branch, {init, cmp, incr});
 }
 SHAMapLeafNode*
-SHAMap::firstBelow(SHAMapTreeNodePtr node, SharedPtrNodeStack& stack, int branch) const
+SHAMap::firstBelow(intr_ptr::SharedPtr<SHAMapTreeNode> node, SharedPtrNodeStack& stack, int branch)
+    const
 {
     auto init = 0;
     auto cmp = [](int i) { return i <= branchFactor; };
@@ -694,8 +699,10 @@ SHAMap::delItem(uint256 const& id)
 
     SHAMapNodeType const type = leaf->getType();
 
+    using TreeNodeType = intr_ptr::SharedPtr<SHAMapTreeNode>;
+
     // What gets attached to the end of the chain (For now, nothing, since we deleted the leaf)
-    SHAMapTreeNodePtr prevNode;
+    TreeNodeType prevNode;
 
     while (!stack.empty())
     {
@@ -721,7 +728,7 @@ SHAMap::delItem(uint256 const& id)
                 // no children below this branch
                 //
                 // Note: This is unnecessary due to the std::move above but left here for safety
-                prevNode = SHAMapTreeNodePtr{};
+                prevNode = TreeNodeType{};
             }
             else if (bc == 1)
             {
@@ -734,7 +741,7 @@ SHAMap::delItem(uint256 const& id)
                     {
                         if (!node->isEmptyBranch(i))
                         {
-                            node->setChild(i, SHAMapTreeNodePtr{});
+                            node->setChild(i, TreeNodeType{});
                             break;
                         }
                     }
@@ -930,8 +937,8 @@ SHAMap::fetchRoot(SHAMapHash const& hash, SHAMapSyncFilter* filter)
     @note The node must have already been unshared by having the caller
           first call SHAMapTreeNode::unshare().
  */
-SHAMapTreeNodePtr
-SHAMap::writeNode(NodeObjectType t, SHAMapTreeNodePtr node) const
+intr_ptr::SharedPtr<SHAMapTreeNode>
+SHAMap::writeNode(NodeObjectType t, intr_ptr::SharedPtr<SHAMapTreeNode> node) const
 {
     XRPL_ASSERT(node->cowid() == 0, "xrpl::SHAMap::writeNode : valid input node");
     XRPL_ASSERT(backed_, "xrpl::SHAMap::writeNode : is backed");
@@ -1148,7 +1155,7 @@ SHAMap::dump(bool hash) const
     JLOG(journal_.info()) << leafCount << " resident leaves";
 }
 
-SHAMapTreeNodePtr
+intr_ptr::SharedPtr<SHAMapTreeNode>
 SHAMap::cacheLookup(SHAMapHash const& hash) const
 {
     auto ret = f_.getTreeNodeCache()->fetch(hash.as_uint256());
@@ -1157,7 +1164,7 @@ SHAMap::cacheLookup(SHAMapHash const& hash) const
 }
 
 void
-SHAMap::canonicalize(SHAMapHash const& hash, SHAMapTreeNodePtr& node) const
+SHAMap::canonicalize(SHAMapHash const& hash, intr_ptr::SharedPtr<SHAMapTreeNode>& node) const
 {
     XRPL_ASSERT(backed_, "xrpl::SHAMap::canonicalize : is backed");
     XRPL_ASSERT(node->cowid() == 0, "xrpl::SHAMap::canonicalize : valid node input");

src/libxrpl/shamap/SHAMapDelta.cpp

@@ -261,7 +261,7 @@ SHAMap::walkMap(std::vector<SHAMapMissingNode>& missingNodes, int maxMissing) co
         {
             if (!node->isEmptyBranch(i))
             {
-                SHAMapTreeNodePtr const nextNode = descendNoStore(*node, i);
+                intr_ptr::SharedPtr<SHAMapTreeNode> const nextNode = descendNoStore(*node, i);
 
                 if (nextNode)
                 {
@@ -286,7 +286,7 @@ SHAMap::walkMapParallel(std::vector<SHAMapMissingNode>& missingNodes, int maxMis
         return false;
 
     using StackEntry = intr_ptr::SharedPtr<SHAMapInnerNode>;
-    std::array<SHAMapTreeNodePtr, 16> topChildren;
+    std::array<intr_ptr::SharedPtr<SHAMapTreeNode>, 16> topChildren;
     {
         auto const& innerRoot = intr_ptr::static_pointer_cast<SHAMapInnerNode>(root_);
         for (int i = 0; i < 16; ++i)
@@ -331,7 +331,8 @@ SHAMap::walkMapParallel(std::vector<SHAMapMissingNode>& missingNodes, int maxMis
                         {
                             if (node->isEmptyBranch(i))
                                 continue;
-                            SHAMapTreeNodePtr const nextNode = descendNoStore(*node, i);
+                            intr_ptr::SharedPtr<SHAMapTreeNode> const nextNode =
+                                descendNoStore(*node, i);
 
                             if (nextNode)
                             {

src/libxrpl/shamap/SHAMapInnerNode.cpp

@@ -37,7 +37,7 @@ SHAMapInnerNode::~SHAMapInnerNode() = default;
 void
 SHAMapInnerNode::partialDestructor()
 {
-    SHAMapTreeNodePtr* children = nullptr;
+    intr_ptr::SharedPtr<SHAMapTreeNode>* children = nullptr;
     // structured bindings can't be captured in c++ 17; use tie instead
     std::tie(std::ignore, std::ignore, children) = hashesAndChildren_.getHashesAndChildren();
     iterNonEmptyChildIndexes([&](auto branchNum, auto indexNum) { children[indexNum].reset(); });
@@ -69,7 +69,7 @@ SHAMapInnerNode::getChildIndex(int i) const
     return hashesAndChildren_.getChildIndex(isBranch_, i);
 }
 
-SHAMapTreeNodePtr
+intr_ptr::SharedPtr<SHAMapTreeNode>
 SHAMapInnerNode::clone(std::uint32_t cowid) const
 {
     auto const branchCount = getBranchCount();
@@ -79,7 +79,7 @@ SHAMapInnerNode::clone(std::uint32_t cowid) const
     p->isBranch_ = isBranch_;
     p->fullBelowGen_ = fullBelowGen_;
     SHAMapHash *cloneHashes = nullptr, *thisHashes = nullptr;
-    SHAMapTreeNodePtr *cloneChildren = nullptr, *thisChildren = nullptr;
+    intr_ptr::SharedPtr<SHAMapTreeNode>*cloneChildren = nullptr, *thisChildren = nullptr;
     // structured bindings can't be captured in c++ 17; use tie instead
     std::tie(std::ignore, cloneHashes, cloneChildren) =
         p->hashesAndChildren_.getHashesAndChildren();
@@ -118,7 +118,7 @@ SHAMapInnerNode::clone(std::uint32_t cowid) const
     return p;
 }
 
-SHAMapTreeNodePtr
+intr_ptr::SharedPtr<SHAMapTreeNode>
 SHAMapInnerNode::makeFullInner(Slice data, SHAMapHash const& hash, bool hashValid)
 {
     // A full inner node is serialized as 16 256-bit hashes, back to back:
@@ -153,7 +153,7 @@ SHAMapInnerNode::makeFullInner(Slice data, SHAMapHash const& hash, bool hashVali
     return ret;
 }
 
-SHAMapTreeNodePtr
+intr_ptr::SharedPtr<SHAMapTreeNode>
 SHAMapInnerNode::makeCompressedInner(Slice data)
 {
     // A compressed inner node is serialized as a series of 33 byte chunks,
@@ -207,7 +207,7 @@ void
 SHAMapInnerNode::updateHashDeep()
 {
     SHAMapHash* hashes = nullptr;
-    SHAMapTreeNodePtr* children = nullptr;
+    intr_ptr::SharedPtr<SHAMapTreeNode>* children = nullptr;
     // structured bindings can't be captured in c++ 17; use tie instead
     std::tie(std::ignore, hashes, children) = hashesAndChildren_.getHashesAndChildren();
     iterNonEmptyChildIndexes([&](auto branchNum, auto indexNum) {
@@ -265,7 +265,7 @@ SHAMapInnerNode::getString(SHAMapNodeID const& id) const
 
 // We are modifying an inner node
 void
-SHAMapInnerNode::setChild(int m, SHAMapTreeNodePtr child)
+SHAMapInnerNode::setChild(int m, intr_ptr::SharedPtr<SHAMapTreeNode> child)
 {
     XRPL_ASSERT(
         (m >= 0) && (m < branchFactor), "xrpl::SHAMapInnerNode::setChild : valid branch input");
@@ -307,7 +307,7 @@ SHAMapInnerNode::setChild(int m, SHAMapTreeNodePtr child)
 
 // finished modifying, now make shareable
 void
-SHAMapInnerNode::shareChild(int m, SHAMapTreeNodePtr const& child)
+SHAMapInnerNode::shareChild(int m, intr_ptr::SharedPtr<SHAMapTreeNode> const& child)
 {
     XRPL_ASSERT(
         (m >= 0) && (m < branchFactor), "xrpl::SHAMapInnerNode::shareChild : valid branch input");
@@ -337,7 +337,7 @@ SHAMapInnerNode::getChildPointer(int branch)
     return hashesAndChildren_.getChildren()[index].get();
 }
 
-SHAMapTreeNodePtr
+intr_ptr::SharedPtr<SHAMapTreeNode>
 SHAMapInnerNode::getChild(int branch)
 {
     XRPL_ASSERT(
@@ -364,8 +364,8 @@ SHAMapInnerNode::getChildHash(int m) const
     return zeroSHAMapHash;
 }
 
-SHAMapTreeNodePtr
-SHAMapInnerNode::canonicalizeChild(int branch, SHAMapTreeNodePtr node)
+intr_ptr::SharedPtr<SHAMapTreeNode>
+SHAMapInnerNode::canonicalizeChild(int branch, intr_ptr::SharedPtr<SHAMapTreeNode> node)
 {
     XRPL_ASSERT(
         branch >= 0 && branch < branchFactor,

src/libxrpl/shamap/SHAMapNodeID.cpp

@@ -129,9 +129,7 @@ selectBranch(SHAMapNodeID const& id, uint256 const& hash)
 SHAMapNodeID
 SHAMapNodeID::createID(int depth, uint256 const& key)
 {
-    XRPL_ASSERT(
-        depth >= 0 && depth <= SHAMap::leafDepth,
-        "xrpl::SHAMapNodeID::createID : valid branch input");
+    XRPL_ASSERT((depth >= 0) && (depth < 65), "xrpl::SHAMapNodeID::createID : valid branch input");
     return SHAMapNodeID(depth, key & depthMask(depth));
 }
 

src/libxrpl/shamap/SHAMapSync.cpp

@@ -66,7 +66,7 @@ SHAMap::visitNodes(std::function<bool(SHAMapTreeNode&)> const& function) const
         {
             if (!node->isEmptyBranch(pos))
             {
-                SHAMapTreeNodePtr const child = descendNoStore(*node, pos);
+                intr_ptr::SharedPtr<SHAMapTreeNode> const child = descendNoStore(*node, pos);
                 if (!function(*child))
                     return;
 
@@ -204,7 +204,8 @@ SHAMap::gmn_ProcessNodes(MissingNodes& mn, MissingNodes::StackEntry& se)
                 branch,
                 mn.filter_,
                 pending,
-                [node, nodeID, branch, &mn](SHAMapTreeNodePtr found, SHAMapHash const&) {
+                [node, nodeID, branch, &mn](
+                    intr_ptr::SharedPtr<SHAMapTreeNode> found, SHAMapHash const&) {
                     // a read completed asynchronously
                     std::unique_lock<std::mutex> const lock{mn.deferLock_};
                     mn.finishedReads_.emplace_back(node, nodeID, branch, std::move(found));
@@ -267,7 +268,8 @@ SHAMap::gmn_ProcessDeferredReads(MissingNodes& mn)
     int complete = 0;
     while (complete != mn.deferred_)
     {
-        std::tuple<SHAMapInnerNode*, SHAMapNodeID, int, SHAMapTreeNodePtr> deferredNode;
+        std::tuple<SHAMapInnerNode*, SHAMapNodeID, int, intr_ptr::SharedPtr<SHAMapTreeNode>>
+            deferredNode;
         {
             std::unique_lock<std::mutex> lock{mn.deferLock_};
 
@@ -415,7 +417,7 @@ SHAMap::getMissingNodes(int max, SHAMapSyncFilter* filter)
 bool
 SHAMap::getNodeFat(
     SHAMapNodeID const& wanted,
-    std::vector<SHAMapNodeData>& data,
+    std::vector<std::pair<SHAMapNodeID, Blob>>& data,
     bool fatLeaves,
     std::uint32_t depth) const
 {
@@ -461,7 +463,7 @@ SHAMap::getNodeFat(
         // Add this node to the reply
         s.erase();
         node->serializeForWire(s);
-        data.emplace_back(nodeID, s.getData(), node->isLeaf());
+        data.emplace_back(nodeID, s.getData());
 
         if (node->isInner())
         {
@@ -491,7 +493,7 @@ SHAMap::getNodeFat(
                             // Just include this node
                             s.erase();
                             childNode->serializeForWire(s);
-                            data.emplace_back(childID, s.getData(), childNode->isLeaf());
+                            data.emplace_back(childID, s.getData());
                         }
                     }
                 }
@@ -509,18 +511,8 @@ SHAMap::serializeRoot(Serializer& s) const
 }
 
 SHAMapAddNode
-SHAMap::addRootNode(
-    SHAMapHash const& hash,
-    SHAMapTreeNodePtr rootNode,
-    SHAMapSyncFilter const* filter)
+SHAMap::addRootNode(SHAMapHash const& hash, Slice const& rootNode, SHAMapSyncFilter* filter)
 {
-    XRPL_ASSERT(rootNode, "xrpl::SHAMap::addRootNode : non-null root node");
-    if (!rootNode)
-    {
-        JLOG(journal_.error()) << "Null node received";
-        return SHAMapAddNode::invalid();
-    }
-
     // we already have a root_ node
     if (root_->getHash().isNonZero())
     {
@@ -530,16 +522,14 @@ SHAMap::addRootNode(
     }
 
     XRPL_ASSERT(cowid_ >= 1, "xrpl::SHAMap::addRootNode : valid cowid");
-    if (rootNode->getHash() != hash)
-    {
-        JLOG(journal_.warn()) << "Corrupt node received";
+    auto node = SHAMapTreeNode::makeFromWire(rootNode);
+    if (!node || node->getHash() != hash)
         return SHAMapAddNode::invalid();
-    }
 
     if (backed_)
-        canonicalize(hash, rootNode);
+        canonicalize(hash, node);
 
-    root_ = std::move(rootNode);
+    root_ = node;
 
     if (root_->isLeaf())
         clearSynching();
@@ -556,23 +546,9 @@ SHAMap::addRootNode(
 }
 
 SHAMapAddNode
-SHAMap::addKnownNode(
-    SHAMapNodeID const& nodeID,
-    SHAMapTreeNodePtr treeNode,
-    SHAMapSyncFilter const* filter)
+SHAMap::addKnownNode(SHAMapNodeID const& node, Slice const& rawNode, SHAMapSyncFilter* filter)
 {
-    XRPL_ASSERT(!nodeID.isRoot(), "xrpl::SHAMap::addKnownNode : valid node input");
-    if (nodeID.isRoot())
-    {
-        JLOG(journal_.error()) << "Root node received";
-        return SHAMapAddNode::invalid();
-    }
-    XRPL_ASSERT(treeNode, "xrpl::SHAMap::addKnownNode : non-null tree node");
-    if (!treeNode)
-    {
-        JLOG(journal_.error()) << "Null node received";
-        return SHAMapAddNode::invalid();
-    }
+    XRPL_ASSERT(!node.isRoot(), "xrpl::SHAMap::addKnownNode : valid node input");
 
     if (!isSynching())
     {
@@ -586,14 +562,14 @@ SHAMap::addKnownNode(
 
     while (currNode->isInner() &&
            !safe_downcast<SHAMapInnerNode*>(currNode)->isFullBelow(generation) &&
-           (currNodeID.getDepth() < nodeID.getDepth()))
+           (currNodeID.getDepth() < node.getDepth()))
     {
-        int const branch = selectBranch(currNodeID, nodeID.getNodeID());
+        int const branch = selectBranch(currNodeID, node.getNodeID());
         XRPL_ASSERT(branch >= 0, "xrpl::SHAMap::addKnownNode : valid branch");
         auto inner = safe_downcast<SHAMapInnerNode*>(currNode);
         if (inner->isEmptyBranch(branch))
         {
-            JLOG(journal_.warn()) << "Add known node for empty branch" << nodeID;
+            JLOG(journal_.warn()) << "Add known node for empty branch" << node;
             return SHAMapAddNode::invalid();
         }
 
@@ -609,44 +585,67 @@ SHAMap::addKnownNode(
         if (currNode != nullptr)
             continue;
 
-        if (childHash != treeNode->getHash())
+        auto newNode = SHAMapTreeNode::makeFromWire(rawNode);
+
+        if (!newNode || childHash != newNode->getHash())
         {
             JLOG(journal_.warn()) << "Corrupt node received";
             return SHAMapAddNode::invalid();
         }
 
+        // In rare cases, a node can still be corrupt even after hash
+        // validation. For leaf nodes, we perform an additional check to
+        // ensure the node's position in the tree is consistent with its
+        // content to prevent inconsistencies that could
+        // propagate further down the line.
+        if (newNode->isLeaf())
+        {
+            auto const& actualKey =
+                safe_downcast<SHAMapLeafNode const*>(newNode.get())->peekItem()->key();
+
+            // Validate that this leaf belongs at the target position
+            auto const expectedNodeID = SHAMapNodeID::createID(node.getDepth(), actualKey);
+            if (expectedNodeID.getNodeID() != node.getNodeID())
+            {
+                JLOG(journal_.debug())
+                    << "Leaf node position mismatch: "
+                    << "expected=" << expectedNodeID.getNodeID() << ", actual=" << node.getNodeID();
+                return SHAMapAddNode::invalid();
+            }
+        }
+
         // Inner nodes must be at a level strictly less than 64
         // but leaf nodes (while notionally at level 64) can be
         // at any depth up to and including 64:
         if ((currNodeID.getDepth() > leafDepth) ||
-            (treeNode->isInner() && currNodeID.getDepth() == leafDepth))
+            (newNode->isInner() && currNodeID.getDepth() == leafDepth))
         {
             // Map is provably invalid
             state_ = SHAMapState::Invalid;
             return SHAMapAddNode::useful();
         }
 
-        if (currNodeID != nodeID)
+        if (currNodeID != node)
         {
             // Either this node is broken or we didn't request it (yet)
-            JLOG(journal_.warn()) << "unable to hook node " << nodeID;
+            JLOG(journal_.warn()) << "unable to hook node " << node;
             JLOG(journal_.info()) << " stuck at " << currNodeID;
-            JLOG(journal_.info()) << "got depth=" << nodeID.getDepth()
+            JLOG(journal_.info()) << "got depth=" << node.getDepth()
                                   << ", walked to= " << currNodeID.getDepth();
             return SHAMapAddNode::useful();
         }
 
         if (backed_)
-            canonicalize(childHash, treeNode);
+            canonicalize(childHash, newNode);
 
-        treeNode = prevNode->canonicalizeChild(branch, std::move(treeNode));
+        newNode = prevNode->canonicalizeChild(branch, std::move(newNode));
 
         if (filter != nullptr)
         {
             Serializer s;
-            treeNode->serializeWithPrefix(s);
+            newNode->serializeWithPrefix(s);
             filter->gotNode(
-                false, childHash, ledgerSeq_, std::move(s.modData()), treeNode->getType());
+                false, childHash, ledgerSeq_, std::move(s.modData()), newNode->getType());
         }
 
         return SHAMapAddNode::useful();

src/libxrpl/shamap/SHAMapTreeNode.cpp

@@ -25,7 +25,7 @@
 
 namespace xrpl {
 
-SHAMapTreeNodePtr
+intr_ptr::SharedPtr<SHAMapTreeNode>
 SHAMapTreeNode::makeTransaction(Slice data, SHAMapHash const& hash, bool hashValid)
 {
     auto item = make_shamapitem(sha512Half(HashPrefix::transactionID, data), data);
@@ -36,7 +36,7 @@ SHAMapTreeNode::makeTransaction(Slice data, SHAMapHash const& hash, bool hashVal
     return intr_ptr::make_shared<SHAMapTxLeafNode>(std::move(item), 0);
 }
 
-SHAMapTreeNodePtr
+intr_ptr::SharedPtr<SHAMapTreeNode>
 SHAMapTreeNode::makeTransactionWithMeta(Slice data, SHAMapHash const& hash, bool hashValid)
 {
     Serializer s(data.data(), data.size());
@@ -60,7 +60,7 @@ SHAMapTreeNode::makeTransactionWithMeta(Slice data, SHAMapHash const& hash, bool
     return intr_ptr::make_shared<SHAMapTxPlusMetaLeafNode>(std::move(item), 0);
 }
 
-SHAMapTreeNodePtr
+intr_ptr::SharedPtr<SHAMapTreeNode>
 SHAMapTreeNode::makeAccountState(Slice data, SHAMapHash const& hash, bool hashValid)
 {
     Serializer s(data.data(), data.size());
@@ -87,7 +87,7 @@ SHAMapTreeNode::makeAccountState(Slice data, SHAMapHash const& hash, bool hashVa
     return intr_ptr::make_shared<SHAMapAccountStateLeafNode>(std::move(item), 0);
 }
 
-SHAMapTreeNodePtr
+intr_ptr::SharedPtr<SHAMapTreeNode>
 SHAMapTreeNode::makeFromWire(Slice rawNode)
 {
     if (rawNode.empty())
@@ -118,7 +118,7 @@ SHAMapTreeNode::makeFromWire(Slice rawNode)
     Throw<std::runtime_error>("wire: Unknown type (" + std::to_string(type) + ")");
 }
 
-SHAMapTreeNodePtr
+intr_ptr::SharedPtr<SHAMapTreeNode>
 SHAMapTreeNode::makeFromPrefix(Slice rawNode, SHAMapHash const& hash)
 {
     if (rawNode.size() < 4)

src/test/app/LedgerNodeHelpers_test.cpp

@@ -1,350 +0,0 @@
-#include <xrpld/app/ledger/detail/LedgerNodeHelpers.h>
-
-#include <xrpl/basics/IntrusivePointer.h>
-#include <xrpl/basics/base_uint.h>
-#include <xrpl/beast/unit_test/suite.h>
-#include <xrpl/protocol/Serializer.h>
-#include <xrpl/shamap/SHAMap.h>
-#include <xrpl/shamap/SHAMapAccountStateLeafNode.h>
-#include <xrpl/shamap/SHAMapInnerNode.h>
-#include <xrpl/shamap/SHAMapItem.h>
-#include <xrpl/shamap/SHAMapTreeNode.h>
-
-#include <boost/smart_ptr/intrusive_ptr.hpp>
-
-#include <xrpl.pb.h>
-
-#include <bit>
-#include <cstdint>
-#include <string>
-
-namespace xrpl::tests {
-
-class LedgerNodeHelpers_test : public beast::unit_test::suite
-{
-    static boost::intrusive_ptr<SHAMapItem>
-    makeTestItem(std::uint32_t seed)
-    {
-        Serializer s;
-        s.add32(seed);
-        s.add32(seed + 1);
-        s.add32(seed + 2);
-        return make_shamapitem(s.getSHA512Half(), s.slice());
-    }
-
-    static std::string
-    serializeNode(SHAMapTreeNodePtr const& node)
-    {
-        Serializer s;
-        node->serializeForWire(s);
-        auto const slice = s.slice();
-        return std::string(std::bit_cast<char const*>(slice.data()), slice.size());
-    }
-
-    void
-    testValidateLedgerNode()
-    {
-        // In the tests below the validity of the content of the node data and ID fields is not
-        // checked - only that the fields have values when expected. The content of the fields is
-        // verified in the other tests in this file.
-        testcase("validateLedgerNode");
-
-        // Invalid: missing all fields.
-        {
-            protocol::TMLedgerNode const node;
-            BEAST_EXPECT(!validateLedgerNode(node));
-        }
-
-        // Invalid: missing `nodedata` field.
-        {
-            protocol::TMLedgerNode node;
-            node.set_nodeid("test_nodeid");
-            BEAST_EXPECT(!validateLedgerNode(node));
-        }
-
-        // Invalid: missing `nodedata` field.
-        {
-            protocol::TMLedgerNode node;
-            node.set_id("test_nodeid");
-            BEAST_EXPECT(!validateLedgerNode(node));
-        }
-
-        // Invalid: missing `nodedata` field.
-        {
-            protocol::TMLedgerNode node;
-            node.set_depth(1);
-            BEAST_EXPECT(!validateLedgerNode(node));
-        }
-
-        // Valid: legacy `nodeid` field.
-        {
-            protocol::TMLedgerNode node;
-            node.set_nodedata("test_data");
-            node.set_nodeid("test_nodeid");
-            BEAST_EXPECT(validateLedgerNode(node));
-        }
-
-        // Invalid: has both legacy `nodeid` and new `id` fields.
-        {
-            protocol::TMLedgerNode node;
-            node.set_nodedata("test_data");
-            node.set_nodeid("test_nodeid");
-            node.set_id("test_nodeid");
-            BEAST_EXPECT(!validateLedgerNode(node));
-        }
-
-        // Invalid: has both legacy `nodeid` and new `depth` fields.
-        {
-            protocol::TMLedgerNode node;
-            node.set_nodedata("test_data");
-            node.set_nodeid("test_nodeid");
-            node.set_depth(5);
-            BEAST_EXPECT(!validateLedgerNode(node));
-        }
-
-        // Valid: new `id` field.
-        {
-            protocol::TMLedgerNode node;
-            node.set_nodedata("test_data");
-            node.set_id("test_id");
-            BEAST_EXPECT(validateLedgerNode(node));
-        }
-
-        // Valid: new `depth` field.
-        {
-            protocol::TMLedgerNode node;
-            node.set_nodedata("test_data");
-            node.set_depth(5);
-            BEAST_EXPECT(validateLedgerNode(node));
-        }
-
-        // Valid: `depth` at minimum depth.
-        {
-            protocol::TMLedgerNode node;
-            node.set_nodedata("test_data");
-            node.set_depth(0);
-            BEAST_EXPECT(validateLedgerNode(node));
-        }
-
-        // Valid: `depth` at arbitrary depth between minimum and maximum.
-        {
-            protocol::TMLedgerNode node;
-            node.set_nodedata("test_data");
-            node.set_depth(10);
-            BEAST_EXPECT(validateLedgerNode(node));
-        }
-
-        // Valid: `depth` at maximum depth.
-        {
-            protocol::TMLedgerNode node;
-            node.set_nodedata("test_data");
-            node.set_depth(SHAMap::leafDepth);
-            BEAST_EXPECT(validateLedgerNode(node));
-        }
-
-        // Invalid: `depth` is greater than maximum depth.
-        {
-            protocol::TMLedgerNode node;
-            node.set_nodedata("test_data");
-            node.set_depth(SHAMap::leafDepth + 1);
-            BEAST_EXPECT(!validateLedgerNode(node));
-        }
-    }
-
-    void
-    testGetTreeNode()
-    {
-        testcase("getTreeNode");
-
-        // Valid: inner node. It must have at least one child for `serializeNode` to work.
-        {
-            auto const innerNode = intr_ptr::make_shared<SHAMapInnerNode>(1);
-            auto const childNode = intr_ptr::make_shared<SHAMapInnerNode>(1);
-            innerNode->setChild(0, childNode);
-            auto const innerData = serializeNode(innerNode);
-            auto const result = getTreeNode(innerData);
-            BEAST_EXPECT(result && result->isInner());
-        }
-
-        // Valid: leaf node.
-        {
-            auto const leafItem = makeTestItem(12345);
-            auto const leafNode = intr_ptr::make_shared<SHAMapAccountStateLeafNode>(leafItem, 1);
-            auto const leafData = serializeNode(leafNode);
-            auto const result = getTreeNode(leafData);
-            BEAST_EXPECT(result && result->isLeaf());
-        }
-
-        // Invalid: empty data.
-        {
-            auto const result = getTreeNode("");
-            BEAST_EXPECT(!result);
-        }
-
-        // Invalid: garbage data.
-        {
-            auto const result = getTreeNode("invalid");
-            BEAST_EXPECT(!result);
-        }
-
-        // Invalid: truncated data.
-        {
-            auto const leafItem = makeTestItem(54321);
-            auto const leafNode = intr_ptr::make_shared<SHAMapAccountStateLeafNode>(leafItem, 1);
-            // Truncate the data to trigger an exception in SHAMapTreeNode::makeAccountState when
-            // the data is used to deserialize the node.
-            uint256 const tag;
-            auto const leafData = serializeNode(leafNode).substr(0, tag.bytes - 1);
-            auto const result = getTreeNode(leafData);
-            BEAST_EXPECT(!result);
-        }
-    }
-
-    void
-    testGetSHAMapNodeID()
-    {
-        testcase("getSHAMapNodeID");
-
-        {
-            // Tests using inner nodes at various depths.
-            auto const innerNode = intr_ptr::make_shared<SHAMapInnerNode>(1);
-            auto const childNode = intr_ptr::make_shared<SHAMapInnerNode>(1);
-            innerNode->setChild(0, childNode);
-            auto const innerData = serializeNode(innerNode);
-
-            // Valid: legacy `nodeid` field at arbitrary depth.
-            {
-                auto const innerDepth = 3;
-                auto const innerID = SHAMapNodeID::createID(innerDepth, uint256{});
-
-                protocol::TMLedgerNode node;
-                node.set_nodedata(innerData);
-                node.set_nodeid(innerID.getRawString());
-                auto const result = getSHAMapNodeID(node, innerNode);
-                BEAST_EXPECT(result == innerID);
-            }
-
-            // Valid: new `id` field at minimum depth.
-            {
-                auto const innerDepth = 0;
-                auto const innerID = SHAMapNodeID::createID(innerDepth, uint256{});
-
-                protocol::TMLedgerNode node;
-                node.set_nodedata(innerData);
-                node.set_id(innerID.getRawString());
-                auto const result = getSHAMapNodeID(node, innerNode);
-                BEAST_EXPECT(result == innerID);
-            }
-
-            // Invalid: new `depth` field should not be used for inner nodes.
-            {
-                protocol::TMLedgerNode node;
-                node.set_nodedata(innerData);
-                node.set_depth(10);
-                auto const result = getSHAMapNodeID(node, innerNode);
-                BEAST_EXPECT(!result);
-            }
-        }
-
-        {
-            // Tests using leaf nodes at various depths.
-            auto const leafItem = makeTestItem(12345);
-            auto const leafNode = intr_ptr::make_shared<SHAMapAccountStateLeafNode>(leafItem, 1);
-            auto const leafData = serializeNode(leafNode);
-            auto const leafKey = leafItem->key();
-
-            // Valid: legacy `nodeid` field at arbitrary depth.
-            {
-                auto const leafDepth = 5;
-                auto const leafID = SHAMapNodeID::createID(leafDepth, leafKey);
-
-                protocol::TMLedgerNode ledgerNode;
-                ledgerNode.set_nodedata(leafData);
-                ledgerNode.set_nodeid(leafID.getRawString());
-                auto const result = getSHAMapNodeID(ledgerNode, leafNode);
-                BEAST_EXPECT(result == leafID);
-            }
-
-            // Invalid: new `id` field should not be used for leaf nodes.
-            {
-                auto const leafDepth = 5;
-                auto const leafID = SHAMapNodeID::createID(leafDepth, leafKey);
-
-                protocol::TMLedgerNode ledgerNode;
-                ledgerNode.set_nodedata(leafData);
-                ledgerNode.set_id(leafID.getRawString());
-                auto const result = getSHAMapNodeID(ledgerNode, leafNode);
-                BEAST_EXPECT(!result);
-            }
-
-            // Valid: new `depth` field at minimum depth.
-            {
-                auto const leafDepth = 0;
-                auto const leafID = SHAMapNodeID::createID(leafDepth, leafKey);
-
-                protocol::TMLedgerNode node;
-                node.set_nodedata(leafData);
-                node.set_depth(leafDepth);
-                auto const result = getSHAMapNodeID(node, leafNode);
-                BEAST_EXPECT(result == leafID);
-            }
-
-            // Valid: new `depth` field at arbitrary depth between minimum and maximum.
-            {
-                auto const leafDepth = 10;
-                auto const leafID = SHAMapNodeID::createID(leafDepth, leafKey);
-
-                protocol::TMLedgerNode ledgerNode;
-                ledgerNode.set_nodedata(leafData);
-                ledgerNode.set_depth(leafDepth);
-                auto const result = getSHAMapNodeID(ledgerNode, leafNode);
-                BEAST_EXPECT(result == leafID);
-            }
-
-            // Valid: new `depth` field at maximum depth.
-            // Note that we do not test a depth greater than the maximum depth, because the proto
-            // message is assumed to have been validated by the time the getSHAMapNodeID function is
-            // called.
-            {
-                auto const leafDepth = SHAMap::leafDepth;
-                auto const leafID = SHAMapNodeID::createID(leafDepth, leafKey);
-
-                protocol::TMLedgerNode node;
-                node.set_nodedata(leafData);
-                node.set_depth(leafDepth);
-                auto const result = getSHAMapNodeID(node, leafNode);
-                BEAST_EXPECT(result == leafID);
-            }
-
-            // Invalid: legacy `nodeid` field where the node ID is inconsistent with the key.
-            {
-                auto const otherItem = makeTestItem(54321);
-                auto const otherNode =
-                    intr_ptr::make_shared<SHAMapAccountStateLeafNode>(otherItem, 1);
-                auto const otherData = serializeNode(otherNode);
-                auto const otherKey = otherItem->key();
-                auto const otherDepth = 1;
-                auto const otherID = SHAMapNodeID::createID(otherDepth, otherKey);
-
-                protocol::TMLedgerNode ledgerNode;
-                ledgerNode.set_nodedata(otherData);
-                ledgerNode.set_nodeid(otherID.getRawString());
-                auto const result = getSHAMapNodeID(ledgerNode, leafNode);
-                BEAST_EXPECT(!result);
-            }
-        }
-    }
-
-public:
-    void
-    run() override
-    {
-        testValidateLedgerNode();
-        testGetTreeNode();
-        testGetSHAMapNodeID();
-    }
-};
-
-BEAST_DEFINE_TESTSUITE(LedgerNodeHelpers, app, xrpl);
-
-}  // namespace xrpl::tests

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/core/Config_test.cpp

@@ -7,6 +7,7 @@
 #include <xrpl/basics/BasicConfig.h>
 #include <xrpl/beast/unit_test/suite.h>
 #include <xrpl/beast/utility/temp_dir.h>
+#include <xrpl/protocol/SystemParameters.h>  // IWYU pragma: keep
 #include <xrpl/server/Port.h>
 
 #include <boost/filesystem/operations.hpp>

src/test/overlay/ProtocolVersion_test.cpp

@@ -63,8 +63,8 @@ public:
                 negotiateProtocolVersion("RTXP/1.2, XRPL/2.0, XRPL/2.1") == make_protocol(2, 1));
             BEAST_EXPECT(negotiateProtocolVersion("XRPL/2.2") == make_protocol(2, 2));
             BEAST_EXPECT(
-                negotiateProtocolVersion("RTXP/1.2, XRPL/2.3, XRPL/2.4, XRPL/999.999") ==
-                make_protocol(2, 3));
+                negotiateProtocolVersion("RTXP/1.2, XRPL/2.2, XRPL/2.3, XRPL/999.999") ==
+                make_protocol(2, 2));
             BEAST_EXPECT(negotiateProtocolVersion("XRPL/999.999, WebSocket/1.0") == std::nullopt);
             BEAST_EXPECT(negotiateProtocolVersion("") == std::nullopt);
         }

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/test/shamap/SHAMapSync_test.cpp

@@ -1,6 +1,7 @@
 #include <test/shamap/common.h>
 #include <test/unit_test/SuiteJournal.h>
 
+#include <xrpl/basics/Blob.h>
 #include <xrpl/basics/SHAMapHash.h>
 #include <xrpl/basics/Slice.h>
 #include <xrpl/basics/base_uint.h>
@@ -114,17 +115,14 @@ public:
         destination.setSynching();
 
         {
-            std::vector<SHAMapNodeData> a;
+            std::vector<std::pair<SHAMapNodeID, Blob>> a;
 
             BEAST_EXPECT(source.getNodeFat(SHAMapNodeID(), a, rand_bool(eng_), rand_int(eng_, 2)));
 
             unexpected(a.empty(), "NodeSize");
 
-            auto node = SHAMapTreeNode::makeFromWire(makeSlice(a[0].data));
-            if (!node)
-                fail("", __FILE__, __LINE__);
-            BEAST_EXPECT(
-                destination.addRootNode(source.getHash(), std::move(node), nullptr).isGood());
+            BEAST_EXPECT(destination.addRootNode(source.getHash(), makeSlice(a[0].second), nullptr)
+                             .isGood());
         }
 
         do
@@ -138,7 +136,7 @@ public:
                 break;
 
             // get as many nodes as possible based on this information
-            std::vector<SHAMapNodeData> b;
+            std::vector<std::pair<SHAMapNodeID, Blob>> b;
 
             for (auto& it : nodesMissing)
             {
@@ -160,10 +158,8 @@ public:
                 // Don't use BEAST_EXPECT here b/c it will be called a
                 // non-deterministic number of times and the number of tests run
                 // should be deterministic
-                auto node = SHAMapTreeNode::makeFromWire(makeSlice(b[i].data));
-                if (!node)
-                    fail("", __FILE__, __LINE__);
-                if (!destination.addKnownNode(b[i].nodeID, std::move(node), nullptr).isUseful())
+                if (!destination.addKnownNode(b[i].first, makeSlice(b[i].second), nullptr)
+                         .isUseful())
                     fail("", __FILE__, __LINE__);
             }
         } while (true);

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/ledger/InboundLedger.h

@@ -9,7 +9,6 @@
 
 #include <mutex>
 #include <set>
-#include <string_view>
 #include <utility>
 
 namespace xrpl {
@@ -132,16 +131,16 @@ private:
     processData(std::shared_ptr<Peer> peer, protocol::TMLedgerData& data);
 
     bool
-    takeHeader(std::string_view data);
+    takeHeader(std::string const& data);
 
     void
-    receiveNode(protocol::TMLedgerData& packet, SHAMapAddNode& san);
+    receiveNode(protocol::TMLedgerData& packet, SHAMapAddNode&);
 
     bool
-    takeTxRootNode(std::string_view data, SHAMapAddNode& san);
+    takeTxRootNode(Slice const& data, SHAMapAddNode&);
 
     bool
-    takeAsRootNode(std::string_view data, SHAMapAddNode& san);
+    takeAsRootNode(Slice const& data, SHAMapAddNode&);
 
     std::vector<uint256>
     neededTxHashes(int max, SHAMapSyncFilter* filter) const;

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

@@ -4,7 +4,6 @@
 #include <xrpld/app/ledger/InboundLedgers.h>
 #include <xrpld/app/ledger/LedgerMaster.h>
 #include <xrpld/app/ledger/TransactionStateSF.h>
-#include <xrpld/app/ledger/detail/LedgerNodeHelpers.h>
 #include <xrpld/app/ledger/detail/TimeoutCounter.h>
 #include <xrpld/app/main/Application.h>
 #include <xrpld/overlay/Message.h>
@@ -43,8 +42,8 @@
 #include <mutex>
 #include <random>
 #include <sstream>
+#include <stdexcept>
 #include <string>
-#include <string_view>
 #include <tuple>
 #include <unordered_map>
 #include <utility>
@@ -794,7 +793,7 @@ InboundLedger::filterNodes(
 */
 // data must not have hash prefix
 bool
-InboundLedger::takeHeader(std::string_view data)
+InboundLedger::takeHeader(std::string const& data)
 {
     // Return value: true=normal, false=bad data
     JLOG(journal_.trace()) << "got header acquiring ledger " << hash_;
@@ -882,31 +881,20 @@ InboundLedger::receiveNode(protocol::TMLedgerData& packet, SHAMapAddNode& san)
     {
         auto const f = filter.get();
 
-        for (auto const& ledgerNode : packet.nodes())
+        for (auto const& node : packet.nodes())
         {
-            auto treeNode = getTreeNode(ledgerNode.nodedata());
-            if (!treeNode)
-            {
-                JLOG(journal_.warn()) << "Got invalid node data";
-                san.incInvalid();
-                return;
-            }
+            auto const nodeID = deserializeSHAMapNodeID(node.nodeid());
 
-            auto const nodeID = getSHAMapNodeID(ledgerNode, treeNode);
             if (!nodeID)
-            {
-                JLOG(journal_.warn()) << "Got invalid node id";
-                san.incInvalid();
-                return;
-            }
+                throw std::runtime_error("data does not properly deserialize");
 
             if (nodeID->isRoot())
             {
-                san += map.addRootNode(rootHash, std::move(treeNode), f);
+                san += map.addRootNode(rootHash, makeSlice(node.nodedata()), f);
             }
             else
             {
-                san += map.addKnownNode(*nodeID, std::move(treeNode), f);
+                san += map.addKnownNode(*nodeID, makeSlice(node.nodedata()), f);
             }
 
             if (!san.isGood())
@@ -946,7 +934,7 @@ InboundLedger::receiveNode(protocol::TMLedgerData& packet, SHAMapAddNode& san)
     Call with a lock
 */
 bool
-InboundLedger::takeAsRootNode(std::string_view data, SHAMapAddNode& san)
+InboundLedger::takeAsRootNode(Slice const& data, SHAMapAddNode& san)
 {
     if (failed_ || mHaveState)
     {
@@ -962,17 +950,9 @@ InboundLedger::takeAsRootNode(std::string_view data, SHAMapAddNode& san)
         // LCOV_EXCL_STOP
     }
 
-    auto treeNode = getTreeNode(data);
-    if (!treeNode)
-    {
-        JLOG(journal_.warn()) << "Got invalid node data";
-        san.incInvalid();
-        return false;
-    }
-
     AccountStateSF filter(mLedger->stateMap().family().db(), app_.getLedgerMaster());
-    san += mLedger->stateMap().addRootNode(
-        SHAMapHash{mLedger->header().accountHash}, std::move(treeNode), &filter);
+    san +=
+        mLedger->stateMap().addRootNode(SHAMapHash{mLedger->header().accountHash}, data, &filter);
     return san.isGood();
 }
 
@@ -980,7 +960,7 @@ InboundLedger::takeAsRootNode(std::string_view data, SHAMapAddNode& san)
     Call with a lock
 */
 bool
-InboundLedger::takeTxRootNode(std::string_view data, SHAMapAddNode& san)
+InboundLedger::takeTxRootNode(Slice const& data, SHAMapAddNode& san)
 {
     if (failed_ || mHaveTransactions)
     {
@@ -996,17 +976,8 @@ InboundLedger::takeTxRootNode(std::string_view data, SHAMapAddNode& san)
         // LCOV_EXCL_STOP
     }
 
-    auto treeNode = getTreeNode(data);
-    if (!treeNode)
-    {
-        JLOG(journal_.warn()) << "Got invalid node data";
-        san.incInvalid();
-        return false;
-    }
-
     TransactionStateSF filter(mLedger->txMap().family().db(), app_.getLedgerMaster());
-    san += mLedger->txMap().addRootNode(
-        SHAMapHash{mLedger->header().txHash}, std::move(treeNode), &filter);
+    san += mLedger->txMap().addRootNode(SHAMapHash{mLedger->header().txHash}, data, &filter);
     return san.isGood();
 }
 
@@ -1103,13 +1074,13 @@ InboundLedger::processData(std::shared_ptr<Peer> peer, protocol::TMLedgerData& p
             }
 
             if (!mHaveState && (packet.nodes().size() > 1) &&
-                !takeAsRootNode(packet.nodes(1).nodedata(), san))
+                !takeAsRootNode(makeSlice(packet.nodes(1).nodedata()), san))
             {
                 JLOG(journal_.warn()) << "Included AS root invalid";
             }
 
             if (!mHaveTransactions && (packet.nodes().size() > 2) &&
-                !takeTxRootNode(packet.nodes(2).nodedata(), san))
+                !takeTxRootNode(makeSlice(packet.nodes(2).nodedata()), san))
             {
                 JLOG(journal_.warn()) << "Included TX root invalid";
             }
@@ -1140,13 +1111,13 @@ InboundLedger::processData(std::shared_ptr<Peer> peer, protocol::TMLedgerData& p
 
         ScopedLockType const sl(mtx_);
 
-        // Verify nodes are complete
-        for (auto const& ledgerNode : packet.nodes())
+        // Verify node IDs and data are complete
+        for (auto const& node : packet.nodes())
         {
-            if (!validateLedgerNode(ledgerNode))
+            if (!node.has_nodeid() || !node.has_nodedata())
             {
-                JLOG(journal_.warn()) << "Got malformed ledger node";
-                peer->charge(Resource::feeMalformedRequest, "ledgerNode");
+                JLOG(journal_.warn()) << "Got bad node";
+                peer->charge(Resource::feeMalformedRequest, "ledger_data bad node");
                 return -1;
             }
         }

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

@@ -2,13 +2,13 @@
 
 #include <xrpld/app/ledger/InboundLedger.h>
 #include <xrpld/app/ledger/LedgerMaster.h>
-#include <xrpld/app/ledger/detail/LedgerNodeHelpers.h>
 #include <xrpld/app/main/Application.h>
 #include <xrpld/overlay/PeerSet.h>
 
 #include <xrpl/basics/Blob.h>
 #include <xrpl/basics/DecayingSample.h>
 #include <xrpl/basics/Log.h>
+#include <xrpl/basics/Slice.h>
 #include <xrpl/basics/UnorderedContainers.h>
 #include <xrpl/basics/base_uint.h>
 #include <xrpl/basics/scope.h>
@@ -248,20 +248,23 @@ public:
         Serializer s;
         try
         {
-            for (auto const& ledgerNode : packet_ptr->nodes())
+            for (int i = 0; i < packet_ptr->nodes().size(); ++i)
             {
-                if (!validateLedgerNode(ledgerNode))
+                auto const& node = packet_ptr->nodes(i);
+
+                if (!node.has_nodeid() || !node.has_nodedata())
                     return;
 
-                auto const treeNode = getTreeNode(ledgerNode.nodedata());
-                if (!treeNode)
+                auto newNode = SHAMapTreeNode::makeFromWire(makeSlice(node.nodedata()));
+
+                if (!newNode)
                     return;
 
                 s.erase();
-                treeNode->serializeWithPrefix(s);
+                newNode->serializeWithPrefix(s);
 
                 app_.getLedgerMaster().addFetchPack(
-                    treeNode->getHash().as_uint256(), std::make_shared<Blob>(s.begin(), s.end()));
+                    newNode->getHash().as_uint256(), std::make_shared<Blob>(s.begin(), s.end()));
             }
         }
         catch (std::exception const&)  // NOLINT(bugprone-empty-catch)

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

@@ -1,11 +1,11 @@
 #include <xrpld/app/ledger/InboundTransactions.h>
 
-#include <xrpld/app/ledger/detail/LedgerNodeHelpers.h>
 #include <xrpld/app/ledger/detail/TransactionAcquire.h>
 #include <xrpld/app/main/Application.h>
 #include <xrpld/overlay/PeerSet.h>
 
 #include <xrpl/basics/Log.h>
+#include <xrpl/basics/Slice.h>
 #include <xrpl/basics/UnorderedContainers.h>
 #include <xrpl/beast/insight/Collector.h>
 #include <xrpl/protocol/RippleLedgerHash.h>
@@ -14,7 +14,6 @@
 #include <xrpl/shamap/SHAMap.h>
 #include <xrpl/shamap/SHAMapMissingNode.h>
 #include <xrpl/shamap/SHAMapNodeID.h>
-#include <xrpl/shamap/SHAMapTreeNode.h>
 
 #include <xrpl.pb.h>
 
@@ -145,38 +144,29 @@ public:
             return;
         }
 
-        std::vector<std::pair<SHAMapNodeID, SHAMapTreeNodePtr>> data;
+        std::vector<std::pair<SHAMapNodeID, Slice>> data;
         data.reserve(packet.nodes().size());
 
-        for (auto const& ledgerNode : packet.nodes())
+        for (auto const& node : packet.nodes())
         {
-            if (!validateLedgerNode(ledgerNode))
+            if (!node.has_nodeid() || !node.has_nodedata())
             {
-                JLOG(j_.warn()) << "Got malformed ledger node";
-                peer->charge(Resource::feeMalformedRequest, "ledgerNode");
+                peer->charge(Resource::feeMalformedRequest, "ledger_data");
                 return;
             }
 
-            auto treeNode = getTreeNode(ledgerNode.nodedata());
-            if (!treeNode)
+            auto const id = deserializeSHAMapNodeID(node.nodeid());
+
+            if (!id)
             {
-                JLOG(j_.warn()) << "Got invalid node data";
-                peer->charge(Resource::feeInvalidData, "node_data");
+                peer->charge(Resource::feeInvalidData, "ledger_data");
                 return;
             }
 
-            auto const nodeID = getSHAMapNodeID(ledgerNode, treeNode);
-            if (!nodeID)
-            {
-                JLOG(j_.warn()) << "Got invalid node id";
-                peer->charge(Resource::feeInvalidData, "node_id");
-                return;
-            }
-
-            data.emplace_back(*nodeID, std::move(treeNode));
+            data.emplace_back(*id, makeSlice(node.nodedata()));
         }
 
-        if (!ta->takeNodes(std::move(data), peer).isUseful())
+        if (!ta->takeNodes(data, peer).isUseful())
             peer->charge(Resource::feeUselessData, "ledger_data not useful");
     }
 

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

@@ -1,91 +0,0 @@
-#include <xrpld/app/ledger/detail/LedgerNodeHelpers.h>
-
-#include <xrpl/basics/Slice.h>
-#include <xrpl/basics/safe_cast.h>
-#include <xrpl/beast/utility/instrumentation.h>
-#include <xrpl/shamap/SHAMap.h>
-#include <xrpl/shamap/SHAMapLeafNode.h>
-#include <xrpl/shamap/SHAMapNodeID.h>
-#include <xrpl/shamap/SHAMapTreeNode.h>
-
-#include <xrpl.pb.h>
-
-#include <exception>
-#include <optional>
-#include <string_view>
-
-namespace xrpl {
-
-bool
-validateLedgerNode(protocol::TMLedgerNode const& ledgerNode)
-{
-    if (!ledgerNode.has_nodedata())
-        return false;
-
-    if (ledgerNode.has_nodeid())
-        return !ledgerNode.has_id() && !ledgerNode.has_depth();
-
-    return ledgerNode.has_id() ||
-        (ledgerNode.has_depth() && ledgerNode.depth() <= SHAMap::leafDepth);
-}
-
-SHAMapTreeNodePtr
-getTreeNode(std::string_view data)
-{
-    auto const slice = makeSlice(data);
-    try
-    {
-        return SHAMapTreeNode::makeFromWire(slice);
-    }
-    catch (std::exception const&)
-    {
-        return {};
-    }
-}
-
-std::optional<SHAMapNodeID>
-getSHAMapNodeID(protocol::TMLedgerNode const& ledgerNode, SHAMapTreeNodePtr const& treeNode)
-{
-    if (ledgerNode.has_id() || ledgerNode.has_depth())
-    {
-        if (treeNode->isInner())
-        {
-            if (!ledgerNode.has_id())
-                return std::nullopt;
-
-            return deserializeSHAMapNodeID(ledgerNode.id());
-        }
-
-        if (treeNode->isLeaf())
-        {
-            if (!ledgerNode.has_depth())
-                return std::nullopt;
-
-            auto const key =
-                safe_downcast<SHAMapLeafNode const*>(treeNode.get())->peekItem()->key();
-            return SHAMapNodeID::createID(ledgerNode.depth(), key);
-        }
-
-        UNREACHABLE("xrpl::getSHAMapNodeID : tree node is neither inner nor leaf");
-        return std::nullopt;
-    }
-
-    if (!ledgerNode.has_nodeid())
-        return std::nullopt;
-
-    auto nodeID = deserializeSHAMapNodeID(ledgerNode.nodeid());
-    if (!nodeID.has_value())
-        return std::nullopt;
-
-    if (treeNode->isLeaf())
-    {
-        auto const key = safe_downcast<SHAMapLeafNode const*>(treeNode.get())->peekItem()->key();
-        auto const expected_id = SHAMapNodeID::createID(static_cast<int>(nodeID->getDepth()), key);
-        if (nodeID->getNodeID() != expected_id.getNodeID())
-            return std::nullopt;
-    }
-
-    return nodeID;
-}
-
-}  // namespace xrpl

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

@@ -1,72 +0,0 @@
-#pragma once
-
-#include <xrpl/basics/IntrusivePointer.h>
-#include <xrpl/shamap/SHAMapNodeID.h>
-#include <xrpl/shamap/SHAMapTreeNode.h>
-
-#include <optional>
-#include <string_view>
-
-namespace protocol {
-class TMLedgerNode;
-}  // namespace protocol
-
-namespace xrpl {
-
-/**
- * @brief Validates a ledger node proto message.
- *
- * This function checks whether a ledger node has the expected fields (for non-ledger base data):
- * - The node must have `nodedata`.
- * - If the legacy `nodeid` field is present then the new `id` and `depth` fields must not be
- *   present.
- * - If the new `id` or `depth` fields are present (it is a oneof field, so only one of the two can
- *   be set) then the legacy `nodeid` must not be present.
- * - If the `depth` field is present then it must be between 0 and SHAMap::leafDepth (inclusive).
- *
- * @param ledgerNode The ledger node to validate.
- * @return true if the ledger node has the expected fields, false otherwise.
- */
-[[nodiscard]] bool
-validateLedgerNode(protocol::TMLedgerNode const& ledgerNode);
-
-/**
- * @brief Deserializes a SHAMapTreeNode from wire format data.
- *
- * This function attempts to create a SHAMapTreeNode from the provided data string. If the data is
- * malformed or deserialization fails, the function returns a nullptr instead of throwing an
- * exception.
- *
- * @param data The serialized node data in wire format.
- * @return The deserialized tree node if successful, or a nullptr if deserialization fails.
- */
-[[nodiscard]] SHAMapTreeNodePtr
-getTreeNode(std::string_view data);
-
-/**
- * @brief Extracts or reconstructs the SHAMapNodeID from a ledger node proto message.
- *
- * This function retrieves the SHAMapNodeID for a tree node, with behavior that depends on which
- * field is set and the node type (inner vs. leaf).
- *
- * When the legacy `nodeid` field is set in the message:
- * - For all nodes: Deserializes the node ID from the field.
- * - For leaf nodes: Validates that the node ID is consistent with the leaf's key.
- *
- * When the new `id` or `depth` field is set in the message:
- * - For inner nodes: Deserializes the node ID from the `id` field.
- * - For leaf nodes: Reconstructs the node ID using both the depth from the `depth` field and the
- *   key from the leaf node's item.
- * Note that root nodes may be inner nodes or leaf nodes.
- *
- * @param ledgerNode The validated protocol message containing the ledger node data.
- * @param treeNode The deserialized tree node (inner or leaf node).
- * @return An optional containing the node ID if extraction/reconstruction succeeds, or std::nullopt
- *         if the required fields are missing or validation fails.
- * @note This function expects that the caller has already validated the ledger node by calling the
- *       `validateLedgerNode` function and obtained a valid tree node by calling `getTreeNode`.
- */
-[[nodiscard]] std::optional<SHAMapNodeID>
-getSHAMapNodeID(protocol::TMLedgerNode const& ledgerNode, SHAMapTreeNodePtr const& treeNode);
-
-}  // namespace xrpl

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

@@ -7,13 +7,13 @@
 #include <xrpld/overlay/PeerSet.h>
 
 #include <xrpl/basics/Log.h>
+#include <xrpl/basics/Slice.h>
 #include <xrpl/basics/base_uint.h>
 #include <xrpl/core/Job.h>
 #include <xrpl/server/NetworkOPs.h>
 #include <xrpl/shamap/SHAMap.h>
 #include <xrpl/shamap/SHAMapAddNode.h>
 #include <xrpl/shamap/SHAMapMissingNode.h>
-#include <xrpl/shamap/SHAMapTreeNode.h>
 
 #include <xrpl.pb.h>
 
@@ -173,7 +173,7 @@ TransactionAcquire::trigger(std::shared_ptr<Peer> const& peer)
 
 SHAMapAddNode
 TransactionAcquire::takeNodes(
-    std::vector<std::pair<SHAMapNodeID, SHAMapTreeNodePtr>> data,
+    std::vector<std::pair<SHAMapNodeID, Slice>> const& data,
     std::shared_ptr<Peer> const& peer)
 {
     ScopedLockType const sl(mtx_);

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

@@ -21,8 +21,8 @@ public:
 
     SHAMapAddNode
     takeNodes(
-        std::vector<std::pair<SHAMapNodeID, SHAMapTreeNodePtr>> data,
-        std::shared_ptr<Peer> const& peer);
+        std::vector<std::pair<SHAMapNodeID, Slice>> const& data,
+        std::shared_ptr<Peer> const&);
 
     void
     init(int startPeers);

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/overlay/Peer.h

@@ -17,7 +17,6 @@ enum class ProtocolFeature {
     ValidatorListPropagation,
     ValidatorList2Propagation,
     LedgerReplay,
-    LedgerNodeDepth,
 };
 
 /** Represents a peer connection in the overlay. */

src/xrpld/overlay/detail/PeerImp.cpp

@@ -61,7 +61,6 @@
 #include <xrpl/server/Handoff.h>
 #include <xrpl/server/LoadFeeTrack.h>
 #include <xrpl/server/NetworkOPs.h>
-#include <xrpl/shamap/SHAMap.h>
 #include <xrpl/shamap/SHAMapNodeID.h>
 #include <xrpl/tx/apply.h>
 
@@ -566,8 +565,6 @@ PeerImp::supportsFeature(ProtocolFeature f) const
             return protocol_ >= make_protocol(2, 1);
         case ProtocolFeature::ValidatorList2Propagation:
             return protocol_ >= make_protocol(2, 2);
-        case ProtocolFeature::LedgerNodeDepth:
-            return protocol_ >= make_protocol(2, 3);
         case ProtocolFeature::LedgerReplay:
             return ledgerReplayEnabled_;
     }
@@ -1614,8 +1611,7 @@ PeerImp::onMessage(std::shared_ptr<protocol::TMGetLedger> const& m)
         }
     }
 
-    // Verify and parse ledger node IDs
-    std::vector<SHAMapNodeID> nodeIDs;
+    // Verify ledger node IDs
     if (itype != protocol::liBASE)
     {
         if (m->nodeids_size() <= 0)
@@ -1624,16 +1620,13 @@ PeerImp::onMessage(std::shared_ptr<protocol::TMGetLedger> const& m)
             return;
         }
 
-        nodeIDs.reserve(m->nodeids_size());
         for (auto const& nodeId : m->nodeids())
         {
-            auto parsed = deserializeSHAMapNodeID(nodeId);
-            if (!parsed)
+            if (deserializeSHAMapNodeID(nodeId) == std::nullopt)
             {
                 badData("Invalid SHAMap node ID");
                 return;
             }
-            nodeIDs.push_back(std::move(*parsed));
         }
     }
 
@@ -1656,11 +1649,10 @@ PeerImp::onMessage(std::shared_ptr<protocol::TMGetLedger> const& m)
 
     // Queue a job to process the request
     std::weak_ptr<PeerImp> const weak = shared_from_this();
-    app_.getJobQueue().addJob(
-        jtLEDGER_REQ, "RcvGetLedger", [weak, m, nodeIDs = std::move(nodeIDs)]() mutable {
-            if (auto peer = weak.lock())
-                peer->processLedgerRequest(m, std::move(nodeIDs));
-        });
+    app_.getJobQueue().addJob(jtLEDGER_REQ, "RcvGetLedger", [weak, m]() {
+        if (auto peer = weak.lock())
+            peer->processLedgerRequest(m);
+    });
 }
 
 void
@@ -3369,9 +3361,7 @@ PeerImp::getTxSet(std::shared_ptr<protocol::TMGetLedger> const& m) const
 }
 
 void
-PeerImp::processLedgerRequest(
-    std::shared_ptr<protocol::TMGetLedger> const& m,
-    std::vector<SHAMapNodeID> nodeIDs)
+PeerImp::processLedgerRequest(std::shared_ptr<protocol::TMGetLedger> const& m)
 {
     // Do not resource charge a peer responding to a relay
     if (!m->has_requestcookie())
@@ -3456,25 +3446,26 @@ PeerImp::processLedgerRequest(
     }
 
     // Add requested node data to reply
-    if (!nodeIDs.empty())
+    if (m->nodeids_size() > 0)
     {
         std::uint32_t const defaultDepth = isHighLatency() ? 2 : 1;
         auto const queryDepth{m->has_querydepth() ? m->querydepth() : defaultDepth};
 
-        std::vector<SHAMapNodeData> data;
-        auto const useLedgerNodeDepth = supportsFeature(ProtocolFeature::LedgerNodeDepth);
+        std::vector<std::pair<SHAMapNodeID, Blob>> data;
 
-        for (auto const& nodeID : nodeIDs)
+        for (int i = 0;
+             i < m->nodeids_size() && ledgerData.nodes_size() < Tuning::softMaxReplyNodes;
+             ++i)
         {
-            if (ledgerData.nodes_size() >= Tuning::softMaxReplyNodes)
-                break;
+            auto const shaMapNodeId{deserializeSHAMapNodeID(m->nodeids(i))};
 
             data.clear();
             data.reserve(Tuning::softMaxReplyNodes);
 
             try
             {
-                if (map->getNodeFat(nodeID, data, fatLeaves, queryDepth))
+                // NOLINTNEXTLINE(bugprone-unchecked-optional-access) nodeids checked in onGetLedger
+                if (map->getNodeFat(*shaMapNodeId, data, fatLeaves, queryDepth))
                 {
                     JLOG(p_journal_.trace())
                         << "processLedgerRequest: getNodeFat got " << data.size() << " nodes";
@@ -3483,26 +3474,9 @@ PeerImp::processLedgerRequest(
                     {
                         if (ledgerData.nodes_size() >= Tuning::hardMaxReplyNodes)
                             break;
-
                         protocol::TMLedgerNode* node{ledgerData.add_nodes()};
-
-                        node->set_nodedata(d.data.data(), d.data.size());
-
-                        // When the LedgerNodeDepth protocol feature is not supported by the peer,
-                        // we always set the `nodeid` field. However, when it is supported then we
-                        // set the `id` field for inner nodes and the `depth` field for leaf nodes.
-                        if (!useLedgerNodeDepth)
-                        {
-                            node->set_nodeid(d.nodeID.getRawString());
-                        }
-                        else if (d.isLeaf)
-                        {
-                            node->set_depth(d.nodeID.getDepth());
-                        }
-                        else
-                        {
-                            node->set_id(d.nodeID.getRawString());
-                        }
+                        node->set_nodeid(d.first.getRawString());
+                        node->set_nodedata(d.second.data(), d.second.size());
                     }
                 }
                 else
@@ -3541,7 +3515,7 @@ PeerImp::processLedgerRequest(
                     info += ", no hash specified";
 
                 JLOG(p_journal_.warn())
-                    << "processLedgerRequest: getNodeFat with nodeId " << nodeID
+                    << "processLedgerRequest: getNodeFat with nodeId " << *shaMapNodeId
                     << " and ledger info type " << info << " throws exception: " << e.what();
             }
         }

src/xrpld/overlay/detail/PeerImp.h

@@ -14,7 +14,6 @@
 #include <xrpl/protocol/STTx.h>
 #include <xrpl/protocol/STValidation.h>
 #include <xrpl/resource/Fees.h>
-#include <xrpl/shamap/SHAMapNodeID.h>
 
 #include <boost/circular_buffer.hpp>
 #include <boost/endian/conversion.hpp>
@@ -793,9 +792,7 @@ private:
     getTxSet(std::shared_ptr<protocol::TMGetLedger> const& m) const;
 
     void
-    processLedgerRequest(
-        std::shared_ptr<protocol::TMGetLedger> const& m,
-        std::vector<SHAMapNodeID> nodeIDs);
+    processLedgerRequest(std::shared_ptr<protocol::TMGetLedger> const& m);
 };
 
 //------------------------------------------------------------------------------

src/xrpld/overlay/detail/ProtocolVersion.cpp

@@ -28,7 +28,6 @@ namespace xrpl {
 constexpr ProtocolVersion const supportedProtocolList[]{
     {2, 1},
     {2, 2},
-    {2, 3},
 };
 
 // This ugly construct ensures that supportedProtocolList is sorted in strictly

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] =