Restructure the spinlock code:

- Add function-based spinlock API - Improve comments - Reduce bouncing with contested locks
Modernize CountedObject infrastructure:
2026-10-23 20:17:22 +00:00 · 2026-10-05 19:42:50 -07:00 · 2026-10-05 19:42:50 -07:00 · 2026-10-05 19:42:50 -07:00 · 2026-10-05 19:42:50 -07:00 · 2026-10-05 19:42:49 -07:00
120 changed files with 1632 additions and 2755 deletions
@@ -44,12 +44,4 @@ runs:
            --conf:all tools.build:jobs=${BUILD_NPROC} \
            --conf:all tools.build:verbosity="${LOG_VERBOSITY}" \
            --conf:all tools.compilation:verbosity="${LOG_VERBOSITY}" \
-            --format=json \
-            . >"${RUNNER_TEMP}/conan-graph.json"
-
-    # Tools that run during the build may only load glibc from the Nix store,
-    # as their package ID survives a GCC runtime update.
-    - name: Check build-context packages for Nix store dependencies (Linux)
-      if: ${{ runner.os == 'Linux' }}
-      shell: bash
-      run: ./bin/check-build-context-runtime.sh "${RUNNER_TEMP}/conan-graph.json"
+            .
@@ -1,5 +1,5 @@
 {
-  "image_tag": "sha-1798262",
+  "image_tag": "sha-060957e",
  "configs": {
    "ubuntu": [
      {
@@ -74,7 +74,7 @@
        "extra_cmake_args": "-Dvalidator_keys=ON",
        "package": {
          "type": "deb",
-          "image": "ghcr.io/xrplf/xrpld/packaging-debian:sha-e6055dd"
+          "image": "ghcr.io/xrplf/xrpld/packaging-debian:sha-3a2d19f"
        }
      },
      {
@@ -86,7 +86,7 @@
        "extra_cmake_args": "-Dvalidator_keys=ON -Dassert=ON",
        "package": {
          "type": "deb",
-          "image": "ghcr.io/xrplf/xrpld/packaging-debian:sha-e6055dd",
+          "image": "ghcr.io/xrplf/xrpld/packaging-debian:sha-3a2d19f",
          "variant": "assert"
        }
      }
@@ -101,7 +101,7 @@
        "extra_cmake_args": "-Dvalidator_keys=ON",
        "package": {
          "type": "rpm",
-          "image": "ghcr.io/xrplf/xrpld/packaging-rhel:sha-e6055dd"
+          "image": "ghcr.io/xrplf/xrpld/packaging-rhel:sha-3a2d19f"
        }
      }
    ]
@@ -13,6 +13,7 @@ on:
      - "!nix/devshell.nix"
      - "!nix/check-tools/**"
      - "bin/default-loader-path.sh"
+      - "bin/install-sanitizer-libs.sh"
  pull_request:
    paths:
      - ".github/workflows/build-nix-images.yml"
@@ -5,6 +5,7 @@ on:
    branches:
      - develop
    paths:
+      - ".github/workflows/build-packaging-images.yml"
      - "bin/install-packaging-tools.sh"
      - "package/images/packaging/**"
  pull_request:
@@ -5,6 +5,7 @@ on:
    branches:
      - develop
    paths:
+      - ".github/workflows/build-pre-commit-image.yml"
      - "bin/pre-commit/Dockerfile"
      - "rust-toolchain.toml"
  pull_request:
@@ -34,7 +34,7 @@ permissions:
 jobs:
  audit:
    runs-on: ubuntu-latest
-    container: ghcr.io/xrplf/xrpld/nix-ubuntu:sha-1798262
+    container: ghcr.io/xrplf/xrpld/nix-ubuntu:sha-060957e
    permissions:
      contents: read
      # Needed to open an issue on scheduled failures.
@@ -17,4 +17,4 @@ jobs:
    uses: XRPLF/actions/.github/workflows/pre-commit.yml@279ec358f4a1be4088be3e024b07916fa97c75b6
    with:
      runs_on: ubuntu-latest
-      container: '{ "image": "ghcr.io/xrplf/xrpld/pre-commit:sha-3a2d19f" }'
+      container: '{ "image": "ghcr.io/xrplf/xrpld/pre-commit:sha-473fe44" }'
@@ -41,7 +41,7 @@ env:
 jobs:
  build:
    runs-on: ubuntu-latest
-    container: ghcr.io/xrplf/xrpld/nix-ubuntu:sha-1798262
+    container: ghcr.io/xrplf/xrpld/nix-ubuntu:sha-060957e
    steps:
      - name: Checkout repository
        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
@@ -34,7 +34,7 @@ jobs:
    needs: [determine-files]
    if: ${{ needs.determine-files.outputs.cpp_changed_files != '' || needs.determine-files.outputs.need_full_run == 'true' }}
    runs-on: ["self-hosted", "Linux", "X64", "heavy"]
-    container: "ghcr.io/xrplf/xrpld/nix-debian:sha-1798262"
+    container: "ghcr.io/xrplf/xrpld/nix-debian:sha-060957e"
    permissions:
      contents: read
      issues: write
@@ -28,7 +28,7 @@ permissions:
 jobs:
  clippy:
    runs-on: ubuntu-latest
-    container: ghcr.io/xrplf/xrpld/nix-ubuntu:sha-1798262
+    container: ghcr.io/xrplf/xrpld/nix-ubuntu:sha-060957e
    steps:
      - name: Checkout repository
        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
@@ -41,7 +41,7 @@ jobs:

  coverage:
    runs-on: ubuntu-latest
-    container: ghcr.io/xrplf/xrpld/nix-ubuntu:sha-1798262
+    container: ghcr.io/xrplf/xrpld/nix-ubuntu:sha-060957e
    steps:
      - name: Checkout repository
        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
@@ -70,7 +70,7 @@ jobs:

  doc:
    runs-on: ubuntu-latest
-    container: ghcr.io/xrplf/xrpld/nix-ubuntu:sha-1798262
+    container: ghcr.io/xrplf/xrpld/nix-ubuntu:sha-060957e
    steps:
      - name: Checkout repository
        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
@@ -40,7 +40,7 @@ defaults:
 jobs:
  upload:
    runs-on: ubuntu-latest
-    container: ghcr.io/xrplf/xrpld/nix-ubuntu:sha-1798262
+    container: ghcr.io/xrplf/xrpld/nix-ubuntu:sha-060957e
    env:
      REMOTE_NAME: ${{ inputs.remote_name }}
      CONAN_LOGIN_USERNAME_XRPLF: ${{ secrets.remote_username }}
@@ -29,7 +29,6 @@ Version 3.5.0 is not yet released.
 ### Additions in 3.5.0

 - `subscribe`, `unsubscribe`: Added an optional `mpt_issuances` request field, an array of MPT issuance IDs (hex strings). Subscribers receive a message with `type` `mptTransaction` for each validated transaction whose metadata affects a subscribed issuance; the message has the same fields as the `transactions` stream. MPT issuance subscriptions count toward the per-connection subscription limit. An empty array, a non-array value, or an invalid ID returns `invalidParams`. ([#5671](https://github.com/XRPLF/rippled/pull/5671))
- `ledger_entry`: Add full support for checks, NFT offers, payment channels, and signer lists. ([#6319](https://github.com/XRPLF/rippled/pull/6319))

 ### Bugfixes in 3.5.0

@@ -1,71 +0,0 @@
-#!/usr/bin/env bash
-# Fail if a binary of a build-context Conan package loads anything from the Nix
-# store other than glibc, or cannot resolve a library at all.
-#
-# Only binaries linked by the Nix toolchain are checked, i.e. those recording a
-# store path as their interpreter or RUNPATH. Prebuilt upstream binaries (such
-# as the ones the cmake package ships) use the system loader instead.
-#
-# Build-context packages provide the tools that run during the build (protoc,
-# grpc_cpp_plugin, ...). Their package ID does not change when a Nix toolchain
-# update moves the GCC runtime to a new store path, so a cached binary has to
-# get by with the pinned glibc alone. See docs/build/nix.md.
-#
-# Usage: bin/check-build-context-runtime.sh <graph.json>
-#   <graph.json> is the output of `conan install --format=json`.
-
-set -euo pipefail
-
-if [ "$#" -ne 1 ]; then
-    echo "usage: $0 <graph.json>" >&2
-    exit 2
-fi
-
-if [ "$(uname -s)" != "Linux" ]; then
-    echo "$0: Linux only" >&2
-    exit 2
-fi
-
-# TODO: Add jq to the Nix packages and use it here instead of Python.
-folders="$(python3 -c '
-import json, sys
-for node in json.load(open(sys.argv[1]))["graph"]["nodes"].values():
-    if node["context"] == "build" and node.get("package_folder"):
-        print(node["package_folder"])
-' "$1" | sort -u)"
-
-checked=0
-failed=0
-
-while IFS= read -r file; do
-    case "$(file -b "${file}")" in
-        ELF*) ;;
-        *) continue ;;
-    esac
-    [[ "$(readelf -ldW "${file}")" == */nix/store/* ]] || continue
-    checked=$((checked + 1))
-
-    # `ldd` lists the interpreter and every library as the loader resolves them.
-    if deps="$(ldd "${file}" 2>&1)"; then
-        bad="$(printf '%s\n' "${deps}" |
-            grep -E 'not found|/nix/store/' |
-            grep -vE '/nix/store/[^/]+-glibc-[^/]+/' || true)"
-    else
-        case "${deps}" in
-            *"not a dynamic executable"*) continue ;;
-        esac
-        bad="${deps}"
-    fi
-    if [ -n "${bad}" ]; then
-        failed=$((failed + 1))
-        echo "::error file=${file}::loads a library from the Nix store other than glibc"
-        echo "${file}"
-        echo "${bad}" | sed 's/^/    /'
-    fi
-done < <(
-    # shellcheck disable=SC2086 # one folder per line, no spaces in Conan paths
-    [ -z "${folders}" ] || find ${folders} -type f \( -perm -u+x -o -name '*.so*' \)
-)
-
-echo "Build-context packages: checked ${checked} binaries, ${failed} failed."
-[ "${failed}" -eq 0 ]
@@ -23,7 +23,7 @@ apt-get clean
 rm -rf /var/lib/apt/lists/*
 EOF

-ARG PRE_COMMIT_VERSION=4.6.2
+ARG PRE_COMMIT_VERSION=4.6.0
 RUN pip install --no-cache --break-system-packages \
    pre-commit==${PRE_COMMIT_VERSION}

@@ -77,24 +77,19 @@ if(is_clang)
    message(STATUS "  Ignorelist: ${ignorelist_path}")
 endif()

-# Define the SANITIZERS macro for BuildInfo.cpp, plus one of XRPL_ASAN,
-# XRPL_TSAN and XRPL_UBSAN per active sanitizer, so that code can test for a
-# specific one with #ifdef instead of parsing the dot-joined SANITIZERS string.
+# Define SANITIZERS macro for BuildInfo.cpp
 set(sanitizers_list)
 if(SANITIZERS MATCHES "address")
    set(enable_asan ON)
    list(APPEND sanitizers_list "ASAN")
-    target_compile_definitions(common INTERFACE XRPL_ASAN)
 endif()
 if(SANITIZERS MATCHES "thread")
    set(enable_tsan ON)
    list(APPEND sanitizers_list "TSAN")
-    target_compile_definitions(common INTERFACE XRPL_TSAN)
 endif()
 if(SANITIZERS MATCHES "undefinedbehavior")
    set(enable_ubsan ON)
    list(APPEND sanitizers_list "UBSAN")
-    target_compile_definitions(common INTERFACE XRPL_UBSAN)
 endif()

 if(sanitizers_list)
@@ -20,7 +20,7 @@
        "libarchive/3.8.7#c446109bd1f1d8ba7936c94189bc50e6%1782392403.066892",
        "jemalloc/5.3.1#1fc58d55316041f10fbc1e8a2eae632a%1776700028.228",
        "gtest/1.17.0#5224b3b3ff3b4ce1133cbdd27d53ee7d%1782392402.791979",
-        "grpc/1.81.1#aaa93ab6cda2f2baa6a84490582c8adf%1791284951.826256",
+        "grpc/1.81.1#b87796a4269034856cbc1a2522db16eb%1788275071.530512",
        "fast_float/8.2.10#f6f28d6bb22112078e7dbda611caf681%1785888854.601666",
        "ed25519/2015.03#ae761bdc52730a843f0809bdf6c1b1f6%1782307148.15562",
        "date/3.0.4#862e11e80030356b53c2c38599ceb32b%1782392402.538492",
@@ -34,15 +34,11 @@
    "build_requires": [
        "zlib/1.3.2#1cb806da49011867778ffb6ac7190fcb%1782392402.122708",
        "strawberryperl/5.32.1.1#8d114504d172cfea8ea1662d09b6333e%1782395692.540639",
-        "re2/20251105#8579cfd0bda4daf0683f9e3898f964b4%1782392402.431897",
        "protobuf/6.33.5#ff253ead763bd8d9904a52979cd21e81%1782392410.233933",
-        "openssl/3.6.3#f806de8933e3bf6f01016c6a888cee2e%1783945160.863288",
        "nasm/2.16.01#31e26f2ee3c4346ecd347911bd126904%1782395690.33162",
        "msys2/cci.latest#d22fe7b2808f5fd34d0a7923ace9c54f%1770657326.649",
        "m4/1.4.19#1727f439cf74e83826ec96d0b4904eee%1784541921.659",
-        "grpc/1.81.1#aaa93ab6cda2f2baa6a84490582c8adf%1791284951.826256",
        "cmake/4.3.3#840cf00ea09777e05c2050a50a82c722%1782392418.696091",
-        "c-ares/1.34.6#545240bb1c40e2cacd4362d6b8967650%1782392402.681654",
        "b2/5.4.2#ffd6084a119587e70f11cd45d1a386e2%1782392402.624226",
        "automake/1.16.5#b91b7c384c3deaa9d535be02da14d04f%1755524470.56",
        "autoconf/2.71#51077f068e61700d65bb05541ea1e4b0%1731054366.86",
@@ -49,17 +49,6 @@ tools.build:compiler_executables={'c':'{{ cc_exe }}','cpp':'{{ cxx_exe }}'}
 user.package:cppstd_version=23
 tools.info.package_id:confs+=["user.package:cppstd_version"]

-{% if os == "Linux" and context == "build" %}
-{# Build-context executables (protoc, grpc_cpp_plugin, build tools) run during the build #}
-{# and would otherwise load libstdc++/libgcc from a Nix store path #}
-{# that might change with a Nix toolchain update. #}
-{# --as-needed drops the ones they link but don't use, #}
-{# such as libatomic for grpc_cpp_plugin on arm64. #}
-{% set static_runtime_flags = ["-static-libstdc++", "-static-libgcc", "-Wl,--as-needed"] %}
-tools.build:exelinkflags+={{ static_runtime_flags }}
-tools.info.package_id:confs+=["tools.build:exelinkflags"]
-{% endif %}
-
 {% if os == "Macos" %}
 [buildenv]
 {# os.version adds -mmacosx-version-min to compiler command lines, #}
@@ -69,13 +58,3 @@ tools.info.package_id:confs+=["tools.build:exelinkflags"]
 {# Scoped to boost/* since it is the only gap. #}
 boost/*:MACOSX_DEPLOYMENT_TARGET={{ min_macos_version }}
 {% endif %}
-
-{% if os == "Linux" and context == "build" %}
-{# b2 links itself with its own script, which ignores exelinkflags #}
-{# and only takes CXXFLAGS when use_cxx_env is set. #}
-[options]
-b2/*:use_cxx_env=True
-
-[buildenv]
-b2/*:CXXFLAGS={{ static_runtime_flags | join(" ") }}
-{% endif %}
@@ -5,9 +5,6 @@ include(default)

 {% if not sanitizers %}
 {# Sanitizers not configured; no additional settings needed #}
-{% elif context == "build" %}
-{# Build-context packages are tools we run, not code we test, #}
-{# so don't instrument them #}
 {% else %}

 {% if compiler == "msvc" %}
@@ -49,8 +49,7 @@ class Xrpl(ConanFile):
    ]

    tool_requires = [
-        "grpc/<host_version>",
-        "protobuf/<host_version>",
+        "protobuf/6.33.5",
    ]

    default_options = {
@@ -124,10 +123,6 @@ class Xrpl(ConanFile):
        "xxhash/*:shared": False,
    }

-    # default_options only reach the host context;
-    # give tool_requires (and their dependencies) the same dependency options.
-    default_build_options = {k: v for k, v in default_options.items() if "/" in k}
-
    def set_version(self):
        self.version = self.version or DEV_VERSION

@@ -194,22 +194,10 @@ bin/check-nix-store-refs.sh ~/.conan2-nix
 ```

 It works on Linux too, but asserts something narrower there: the toolchain always
-writes the store into `PT_INTERP` and `RUNPATH`. That is fine for the pinned
-glibc, whose path does not move, but not for the GCC runtime, which moves with
-every GCC update. So [`conan/profiles/default`](../../conan/profiles/default)
-links build-context packages, whose executables run during the build, with
-`-static-libstdc++ -static-libgcc -Wl,--as-needed`, and
-[`conan/profiles/sanitizers`](../../conan/profiles/sanitizers) does not
-instrument them. CI checks that they load nothing from the store but glibc, from
-the graph `conan install --format=json` writes:
-
-```bash
-bin/check-build-context-runtime.sh graph.json
-```
-
-Only the binaries [`PatchNixBinary.cmake`](../../cmake/PatchNixBinary.cmake)
-retargets to the system loader have to be fully clean, and those are what CI
-checks:
+writes the store into `PT_INTERP` and `RUNPATH`, and CI builds inside an image
+whose store is fixed for its lifetime, so that is fine. Only the binaries
+[`PatchNixBinary.cmake`](../../cmake/PatchNixBinary.cmake) retargets to the
+system loader have to be clean, and those are what CI checks:

 ```bash
 bin/check-nix-store-refs.sh build/xrpld
@@ -1,29 +1,31 @@
 #pragma once

-#include <xrpl/beast/type_name.h>
+#include <xrpl/beast/utility/instrumentation.h>

+#include <boost/core/type_name.hpp>
+
+#include <algorithm>
 #include <atomic>
+#include <cstddef>
+#include <cstdint>
+#include <iterator>
 #include <string>
+#include <type_traits>
 #include <utility>
-#include <vector>

 namespace xrpl {

 /**
 * Manages all counted object types.
+ *
+ * Counters register themselves on a lock-free intrusive list maintained
+ * by this object when constructed. Because counters are never destroyed
+ * or removed, the ABA problem does not apply.
+ *
+ * The registry is iterable as a forward range.
 */
 class CountedObjects
 {
-public:
-    static CountedObjects&
-    getInstance() noexcept;
-
-    using Entry = std::pair<std::string, int>;
-    using List = std::vector<Entry>;
-
-    [[nodiscard]] List
-    getCounts(int minimumThreshold) const;
-
 public:
    /**
     * Implementation for @ref CountedObject.
@@ -33,68 +35,147 @@ public:
    class Counter
    {
    public:
-        Counter(std::string name) noexcept : name_(std::move(name)), count_(0)
-        {
-            // Insert ourselves at the front of the lock-free linked list
-            CountedObjects& instance = CountedObjects::getInstance();
-            Counter* head = nullptr;
+        Counter(std::string name) noexcept;

-            do
-            {
-                head = instance.head_.load();
-                next_ = head;
-            } while (instance.head_.exchange(this) != head);
+        // Counters are intrusive list nodes whose addresses are published
+        // in the registry; they must never be copied or moved. The atomic
+        // members already force this, but we make it explicit.
+        Counter(Counter const&) = delete;
+        Counter&
+        operator=(Counter const&) = delete;
+        Counter(Counter&&) = delete;
+        Counter&
+        operator=(Counter&&) = delete;

-            ++instance.count_;
-        }
-
-        ~Counter() noexcept = default;
-
-        int
+        std::uint32_t
        increment() noexcept
        {
-            return ++count_;
+            auto const newCount = count_.fetch_add(1, std::memory_order::relaxed) + 1;
+            XRPL_ASSERT(newCount != 0, "xrpl::CountedObjects::Counter::increment : no overflow");
+
+            auto maxCount = maxCount_.load(std::memory_order::relaxed);
+
+            while (newCount > maxCount &&
+                   !maxCount_.compare_exchange_weak(maxCount, newCount, std::memory_order::relaxed))
+            {
+            }
+
+            return newCount;
        }

-        int
+        std::uint32_t
        decrement() noexcept
        {
-            return --count_;
+            auto const prev = count_.fetch_sub(1, std::memory_order::relaxed);
+            XRPL_ASSERT(prev != 0, "xrpl::CountedObjects::Counter::decrement : no underflow");
+            return prev - 1;
        }

-        [[nodiscard]] int
-        getCount() const noexcept
+        [[nodiscard]] std::uint32_t
+        count() const noexcept
        {
-            return count_.load();
+            return count_.load(std::memory_order::relaxed);
        }

-        [[nodiscard]] Counter*
-        getNext() const noexcept
+        [[nodiscard]] std::uint32_t
+        max() const noexcept
        {
-            return next_;
+            return std::max(
+                count_.load(std::memory_order::relaxed),
+                maxCount_.load(std::memory_order::relaxed));
        }

        [[nodiscard]] std::string const&
-        getName() const noexcept
+        name() const noexcept
        {
            return name_;
        }

    private:
+        friend class CountedObjects;
+
+        Counter* next_ = nullptr;
+        std::atomic<std::uint32_t> count_ = 0;
+        std::atomic<std::uint32_t> maxCount_ = 0;
        std::string const name_;
-        std::atomic<int> count_;
-        Counter* next_;
    };

-private:
-    CountedObjects() noexcept;
-    ~CountedObjects() noexcept = default;
+    class Iterator
+    {
+    public:
+        using value_type = Counter const;
+        using reference = value_type&;
+        using pointer = value_type*;
+        using difference_type = std::ptrdiff_t;
+        using iterator_category = std::forward_iterator_tag;
+
+        explicit Iterator(Counter* c = nullptr) noexcept : current_(c)
+        {
+        }
+
+        reference
+        operator*() const noexcept
+        {
+            return *current_;
+        }
+
+        pointer
+        operator->() const noexcept
+        {
+            return current_;
+        }
+
+        Iterator&
+        operator++() noexcept
+        {
+            current_ = current_->next_;
+            return *this;
+        }
+
+        Iterator
+        operator++(int) noexcept
+        {
+            auto tmp = *this;
+            ++*this;
+            return tmp;
+        }
+
+        bool
+        operator==(Iterator const&) const noexcept = default;
+
+    private:
+        Counter* current_;
+    };
+
+    constexpr CountedObjects() noexcept = default;
+
+    [[nodiscard]] auto
+    begin() const noexcept
+    {
+        return Iterator{head_.load(std::memory_order::acquire)};
+    }
+
+    [[nodiscard]] auto
+    end() const noexcept
+    {
+        return Iterator{};
+    }

 private:
-    std::atomic<int> count_;
-    std::atomic<Counter*> head_;
+    std::atomic<Counter*> head_ = nullptr;
 };

+/** The global counted object registry. */
+inline constinit CountedObjects gCountedObjects;
+
+inline CountedObjects::Counter::Counter(std::string name) noexcept
+    : next_(gCountedObjects.head_.load(std::memory_order::relaxed)), name_(std::move(name))
+{
+    while (!gCountedObjects.head_.compare_exchange_weak(
+        next_, this, std::memory_order::release, std::memory_order::relaxed))
+        ;
+}
+
 //------------------------------------------------------------------------------

 /**
@@ -103,27 +184,37 @@ private:
 * Derived classes have their instances counted automatically. This is used
 * for reporting purposes.
 *
+ * The constructors are private and `Object` is befriended so that the
+ * CRTP parameter must be the deriving class itself: a copy-paste error
+ * like `class B : public CountedObject<A>` fails to compile instead of
+ * silently polluting A's count.
+ *
+ * @note This class has no move operations by design: a derived class's
+ *       move constructor falls back to the copy constructor for this
+ *       base, so the newly created instance is counted. This keeps the
+ *       invariant that count is the number of outstanding subobjects.
+ *
+ * @warning Counted objects constructed during dynamic initialization of
+ *          other translation units may have their increments discarded when
+ *          counter itself is dynamically initialized. Do not create counted
+ *          objects before main() begins.
+ *
 * @ingroup basics
 */
 template <class Object>
+    requires std::is_class_v<Object>
 class CountedObject
 {
-private:
-    static auto&
-    getCounter() noexcept
-    {
-        static CountedObjects::Counter kC{beast::typeName<Object>()};
-        return kC;
-    }
+    static inline CountedObjects::Counter counter{boost::core::type_name<Object>()};

    CountedObject() noexcept
    {
-        getCounter().increment();
+        counter.increment();
    }

    CountedObject(CountedObject const&) noexcept
    {
-        getCounter().increment();
+        counter.increment();
    }

    CountedObject&
@@ -132,7 +223,7 @@ private:
 public:
    ~CountedObject() noexcept
    {
-        getCounter().decrement();
+        counter.decrement();
    }

    friend Object;
@@ -3,11 +3,11 @@
 #pragma once

 #include <xrpl/basics/ByteUtilities.h>
-#include <xrpl/beast/type_name.h>
 #include <xrpl/beast/utility/instrumentation.h>

 #include <boost/align.hpp>
 #include <boost/container/static_vector.hpp>
+#include <boost/core/type_name.hpp>
 #include <boost/predef.h>

 #include <algorithm>
@@ -16,6 +16,7 @@
 #include <cstring>
 #include <mutex>
 #include <stdexcept>
+#include <typeinfo>
 #include <vector>

 #if BOOST_OS_LINUX
@@ -335,7 +336,7 @@ public:
                }) != cfg.end())
        {
            throw std::runtime_error(
-                "SlabAllocatorSet<" + beast::typeName<Type>() + ">: duplicate slab size");
+                "SlabAllocatorSet<" + boost::core::type_name<Type>() + ">: duplicate slab size");
        }

        for (auto const& c : cfg)
@@ -1,7 +1,8 @@
 #pragma once

 #include <xrpl/basics/sanitizers.h>
-#include <xrpl/beast/type_name.h>
+
+#include <boost/core/type_name.hpp>

 #include <exception>
 #include <string>
@@ -55,7 +56,7 @@ Throw(Args&&... args)
        std::is_convertible_v<E*, std::exception*>, "Exception must derive from std::exception.");

    E e(std::forward<Args>(args)...);
-    logThrow(std::string("Throwing exception of type " + beast::typeName<E>() + ": ") + e.what());
+    logThrow("Throwing exception of type " + boost::core::type_name<E>() + ": " + e.what());
    throw std::move(e);
 }

@@ -0,0 +1,200 @@
+#pragma once
+
+#include <concepts>
+#include <type_traits>
+#include <utility>
+
+namespace xrpl {
+
+/**
+ * Opt-in bitwise operators for scoped enumerations.
+ *
+ * Provides `&`, `|`, `^`, `~` and the corresponding compound assignment forms
+ * for any scoped enumeration with an unsigned underlying type that opts in by
+ * specializing @ref OptIn:
+ *
+ * @code
+ * namespace xrpl {
+ *
+ * enum class MyFlags : std::uint32_t { a = 1, b = 2, c = 4 };
+ *
+ * template <>
+ * struct enum_bitops::OptIn<MyFlags> : std::true_type {};
+ *
+ * }  // namespace xrpl
+ * @endcode
+ *
+ * The operators are constexpr and noexcept, and return the enumeration type.
+ *
+ * @par Where the specialization may be declared
+ *   In namespace xrpl, or at global scope with full qualification, and after
+ *   the enumeration is defined but before the operators are first used. This
+ *   cannot be done in a nested namespace or at class scope; for enumerations
+ *   nested in a class this means after the class definition.
+ *
+ * @par Where the operators are found
+ *   The operators are declared in namespace xrpl, so argument-dependent lookup
+ *   will find them only for enumerations declared in xrpl or nested in a class
+ *   declared directly in xrpl. Enumerations in a nested namespace will only be
+ *   found from code inside xrpl, and only if no enclosing scope declares an
+ *   operator of the same name; elsewhere they require using-declarations.
+ */
+namespace enum_bitops {
+
+/**
+ * Types that may be opted in to the bitwise operators.
+ *
+ * Satisfied by a scoped enumeration whose underlying type is an unsigned
+ * integer type.
+ *
+ * @tparam T The type to test.
+ */
+template <typename T>
+concept Eligible = std::is_scoped_enum_v<T> && std::unsigned_integral<std::underlying_type_t<T>>;
+
+/**
+ * Opt-in switch for the bitwise operators.
+ *
+ * The primary template derives from std::false_type. Specialize it to derive
+ * from std::true_type to enable the operators for an @ref Eligible enumeration.
+ *
+ * @tparam T The scoped enumeration to opt in.
+ */
+template <Eligible T>
+struct OptIn : std::false_type
+{
+};
+
+/**
+ * Enumerations for which the bitwise operators are enabled.
+ *
+ * Satisfied when @p T satisfies @ref Eligible and @ref OptIn has been
+ * specialized for it to derive from std::true_type.
+ *
+ * @tparam T The type to test.
+ */
+template <typename T>
+concept Candidate = Eligible<T> && OptIn<T>::value;
+
+}  // namespace enum_bitops
+
+// These are declared in xrpl, not in enum_bitops, so that argument-dependent
+// lookup finds them for enumerations whose associated namespace is xrpl.
+
+/**
+ * @name Bitwise operators for opted-in scoped enumerations
+ *
+ * Each operator applies the corresponding built-in operator to the
+ * underlying values and converts the result back to the enumeration type.
+ * Both operands must have the same enumeration type; there is no implicit
+ * conversion to or from the underlying type.
+ */
+/** @{ */
+
+/**
+ * Bitwise AND.
+ *
+ * @param lhs The left operand.
+ * @param rhs The right operand.
+ * @return The bits set in both @p lhs and @p rhs.
+ */
+template <enum_bitops::Candidate T>
+constexpr T
+operator&(T lhs, T rhs) noexcept
+{
+    return static_cast<T>(std::to_underlying(lhs) & std::to_underlying(rhs));
+}
+
+/**
+ * Bitwise OR.
+ *
+ * @param lhs The left operand.
+ * @param rhs The right operand.
+ * @return The bits set in @p lhs, in @p rhs, or in both.
+ */
+template <enum_bitops::Candidate T>
+constexpr T
+operator|(T lhs, T rhs) noexcept
+{
+    return static_cast<T>(std::to_underlying(lhs) | std::to_underlying(rhs));
+}
+
+/**
+ * Bitwise exclusive OR.
+ *
+ * @param lhs The left operand.
+ * @param rhs The right operand.
+ * @return The bits set in exactly one of @p lhs and @p rhs.
+ */
+template <enum_bitops::Candidate T>
+constexpr T
+operator^(T lhs, T rhs) noexcept
+{
+    return static_cast<T>(std::to_underlying(lhs) ^ std::to_underlying(rhs));
+}
+
+/**
+ * Bitwise complement.
+ *
+ * The result has every bit of the underlying type that is clear in
+ * @p val, including bits that no enumerator names. It is intended for
+ * clearing flags, as in `flags & ~flag`.
+ *
+ * @param val The operand.
+ * @return The complement of @p val.
+ */
+template <enum_bitops::Candidate T>
+constexpr T
+operator~(T val) noexcept
+{
+    return static_cast<T>(~std::to_underlying(val));
+}
+
+/**
+ * Bitwise AND assignment.
+ *
+ * @param lhs The value to modify.
+ * @param rhs The right operand.
+ * @return A reference to @p lhs.
+ */
+template <enum_bitops::Candidate T>
+constexpr T&
+operator&=(T& lhs, T rhs) noexcept
+{
+    lhs = lhs & rhs;
+    return lhs;
+}
+
+/**
+ * Bitwise OR assignment.
+ *
+ * @param lhs The value to modify.
+ * @param rhs The right operand.
+ * @return A reference to @p lhs.
+ */
+template <enum_bitops::Candidate T>
+constexpr T&
+operator|=(T& lhs, T rhs) noexcept
+{
+    lhs = lhs | rhs;
+    return lhs;
+}
+
+/**
+ * Bitwise exclusive OR assignment.
+ *
+ * @param lhs The value to modify.
+ * @param rhs The right operand.
+ * @return A reference to @p lhs.
+ */
+template <enum_bitops::Candidate T>
+constexpr T&
+operator^=(T& lhs, T rhs) noexcept
+{
+    lhs = lhs ^ rhs;
+    return lhs;
+}
+
+/** @} */
+
+}  // namespace xrpl
@@ -2,107 +2,212 @@

 #include <xrpl/beast/utility/instrumentation.h>  // IWYU pragma: keep

+#include <concepts>
+#include <cstdint>
+#include <limits>
+#include <memory>
 #include <type_traits>
+#include <utility>

 namespace xrpl {

-// safe_cast adds compile-time checks to a static_cast to ensure that
-// the destination can hold all values of the source.  This is particularly
-// handy when the source or destination is an enumeration type.
+/** Every value of @p Src can be represented by @p Dest.

-template <class Src, class Dest>
-concept SafeToCast = (std::is_integral_v<Src> && std::is_integral_v<Dest>) &&
-    (std::is_signed_v<Src> || std::is_unsigned_v<Dest>) &&
-    (std::is_signed_v<Src> != std::is_signed_v<Dest> ? sizeof(Dest) > sizeof(Src)
-                                                     : sizeof(Dest) >= sizeof(Src));
+    Given two integral types, the cast is safe when the destination can
+    hold every possible value of the source.

-template <class Dest, class Src>
+    Comparing the bounds requires care: we use @c std::cmp_less_equal and
+    @c std::cmp_greater_equal; the plain relational operators would apply
+    arithmetic conversions, resulting in incorrect results when comparing
+    across signedness.
+
+    Because @c std::cmp_* requires standard signed or unsigned integer
+    arguments, which excludes character types and bool, we first widen
+    all type bounds to the maximum-width integer type while preserving
+    signedness.
+
+    @note Extended integer types, like __int128 on gcc, cannot be safely
+          widened to a standard integer type, so the concept will reject
+          them.
+*/
+template <typename Src, typename Dest>
+concept SafeToCast = std::is_integral_v<Src> && std::is_integral_v<Dest> && []() consteval {
+    using WideSrc = std::conditional_t<std::is_signed_v<Src>, std::intmax_t, std::uintmax_t>;
+    using WideDest = std::conditional_t<std::is_signed_v<Dest>, std::intmax_t, std::uintmax_t>;
+
+    // Note: this guard must be an evaluated branch, and not a
+    // static_assert. The lambda body is outside the immediate
+    // context, so a substitution-time failure here would be a
+    // hard error rather than leaving the concept unsatisfied.
+    if constexpr (sizeof(Src) > sizeof(WideSrc) || sizeof(Dest) > sizeof(WideDest))
+    {
+        return false;
+    }
+    else
+    {
+        return std::cmp_less_equal(
+                   static_cast<WideDest>(std::numeric_limits<Dest>::min()),
+                   static_cast<WideSrc>(std::numeric_limits<Src>::min())) &&
+            std::cmp_greater_equal(
+                   static_cast<WideDest>(std::numeric_limits<Dest>::max()),
+                   static_cast<WideSrc>(std::numeric_limits<Src>::max()));
+    }
+}();
+
+/** Compile-time-checked static_cast that rejects non-value preserving casts.
+
+    @note There is deliberately no enum-to-enum overload, and no overload
+          returning the underlying type of an enum. For the latter, use
+          @c std::to_underlying.
+*/
+/** @{ */
+template <typename Dest, typename Src>
+    requires(std::is_integral_v<Dest> && std::is_integral_v<Src>)
 constexpr Dest
 safeCast(Src s) noexcept
-    requires(std::is_integral_v<Dest> && std::is_integral_v<Src>)
 {
    static_assert(
-        std::is_signed_v<Dest> || std::is_unsigned_v<Src>, "Cannot cast signed to unsigned");
-    constexpr unsigned kNotSame = std::is_signed_v<Dest> != std::is_signed_v<Src>;
-    static_assert(
-        sizeof(Dest) >= sizeof(Src) + kNotSame,
-        "Destination is too small to hold all values of source");
+        SafeToCast<Src, Dest>, "This cast is not value-preserving. Please use unsafeCast instead.");
    return static_cast<Dest>(s);
 }

-template <class Dest, class Src>
+template <typename Dest, typename Src>
+    requires(std::is_enum_v<Dest> && std::is_integral_v<Src>)
 constexpr Dest
 safeCast(Src s) noexcept
-    requires(std::is_enum_v<Dest> && std::is_integral_v<Src>)
 {
    return static_cast<Dest>(safeCast<std::underlying_type_t<Dest>>(s));
 }

-template <class Dest, class Src>
+template <typename Dest, typename Src>
+    requires(std::is_integral_v<Dest> && std::is_enum_v<Src>)
 constexpr Dest
 safeCast(Src s) noexcept
-    requires(std::is_integral_v<Dest> && std::is_enum_v<Src>)
 {
-    return safeCast<Dest>(static_cast<std::underlying_type_t<Src>>(s));
+    return safeCast<Dest>(std::to_underlying(s));
 }
+/** @} */

-// unsafe_cast explicitly flags a static_cast as not necessarily able to hold
-// all values of the source. It includes a compile-time check so that if
-// underlying types become safe, it can be converted to a safe_cast.
+/** Integral-to-integral cast that is known to be narrowing or sign-erasing.

-template <class Dest, class Src>
+    This explicitly flags a conversion that can lose information for some
+    values of the source type, where the call site accepts that loss (or
+    truncation is the intended behavior).
+
+    The compile-time check ensures the cast remains "unsafe": if the types
+    involved later change such that the conversion becomes inherently
+    value-preserving, the static assertion fires with instructions to
+    migrate the call site to @ref safeCast.
+
+    If the conversion's safety depends on a runtime precondition rather
+    than on the types, or varies across instantiations of generic code,
+    use @ref checkedCast instead.
+*/
+/** @{ */
+template <typename Dest, typename Src>
+    requires(std::is_integral_v<Dest> && std::is_integral_v<Src>)
 constexpr Dest
 unsafeCast(Src s) noexcept
-    requires(std::is_integral_v<Dest> && std::is_integral_v<Src>)
 {
    static_assert(
-        !SafeToCast<Src, Dest>,
-        "Only unsafe if casting signed to unsigned or "
-        "destination is too small");
+        !SafeToCast<Src, Dest>, "This cast is value-preserving. Please use safeCast instead.");
    return static_cast<Dest>(s);
 }

-template <class Dest, class Src>
+template <typename Dest, typename Src>
+    requires(std::is_enum_v<Dest> && std::is_integral_v<Src>)
 constexpr Dest
 unsafeCast(Src s) noexcept
-    requires(std::is_enum_v<Dest> && std::is_integral_v<Src>)
 {
    return static_cast<Dest>(unsafeCast<std::underlying_type_t<Dest>>(s));
 }

-template <class Dest, class Src>
+template <typename Dest, typename Src>
+    requires(std::is_integral_v<Dest> && std::is_enum_v<Src>)
 constexpr Dest
 unsafeCast(Src s) noexcept
-    requires(std::is_integral_v<Dest> && std::is_enum_v<Src>)
 {
-    return unsafeCast<Dest>(static_cast<std::underlying_type_t<Src>>(s));
+    return unsafeCast<Dest>(std::to_underlying(s));
+}
+/** @} */
+
+/** Integral-to-integral cast when the caller has performed a bounds check.
+
+    This documents that a runtime precondition or external invariant, which
+    is not necessarily visible to the compiler, guarantees that the requested
+    conversion is value-preserving for the values that can actually occur.
+
+    This is primarily meant for generic code, where the same expression may
+    be value-preserving for one instantiation but not for another, making
+    both @ref safeCast and @ref unsafeCast unusable.
+
+    Unlike @ref safeCast and @ref unsafeCast, this imposes no static check
+    on the type relationship: the caller's claim is about runtime values,
+    not about types.
+*/
+/** @{ */
+template <typename Dest, typename Src>
+    requires(std::is_integral_v<Dest> && std::is_integral_v<Src>)
+constexpr Dest
+checkedCast(Src s) noexcept
+{
+    return static_cast<Dest>(s);
 }

+template <typename Dest, typename Src>
+    requires(std::is_enum_v<Dest> && std::is_integral_v<Src>)
+constexpr Dest
+checkedCast(Src s) noexcept
+{
+    return static_cast<Dest>(checkedCast<std::underlying_type_t<Dest>>(s));
+}
+
+template <typename Dest, typename Src>
+    requires(std::is_integral_v<Dest> && std::is_enum_v<Src>)
+constexpr Dest
+checkedCast(Src s) noexcept
+{
+    return checkedCast<Dest>(std::to_underlying(s));
+}
+/** @} */
+
+/** Downcast within a class hierarchy, verified in debug builds.
+
+    Performs a static_cast down a hierarchy, but in debug builds verifies
+    via dynamic_cast that the object's dynamic type actually permits the
+    downcast. Both build modes execute the same conversion; debug builds
+    merely add the check.
+
+    The pointer form passes null through unchanged, as dynamic_cast does.
+
+    @note The check requires @p Src to be polymorphic; in release builds
+          an invalid downcast is undefined behavior on use, exactly as
+          with a bare static_cast.
+*/
+/** @{ */
 template <class Dest, class Src>
-    requires std::is_pointer_v<Dest>
+    requires(
+        std::is_pointer_v<Dest> && std::is_polymorphic_v<Src> &&
+        std::derived_from<std::remove_pointer_t<Dest>, Src> &&
+        (std::is_const_v<std::remove_pointer_t<Dest>> || !std::is_const_v<Src>) &&
+        (std::is_volatile_v<std::remove_pointer_t<Dest>> || !std::is_volatile_v<Src>))
 inline Dest
 safeDowncast(Src* s) noexcept
 {
-#ifdef NDEBUG
+    XRPL_ASSERT(
+        s == nullptr || dynamic_cast<Dest>(s) != nullptr, "xrpl::safeDowncast : valid downcast");
    return static_cast<Dest>(s);  // NOLINT(cppcoreguidelines-pro-type-static-cast-downcast)
-#else
-    auto* result = dynamic_cast<Dest>(s);
-    XRPL_ASSERT(result != nullptr, "xrpl::safeDowncast : pointer downcast is valid");
-    return result;
-#endif
 }

 template <class Dest, class Src>
-    requires std::is_lvalue_reference_v<Dest>
+    requires(
+        std::is_lvalue_reference_v<Dest> && std::is_polymorphic_v<Src> &&
+        std::derived_from<std::remove_reference_t<Dest>, Src>)
 inline Dest
 safeDowncast(Src& s) noexcept
 {
-#ifndef NDEBUG
-    XRPL_ASSERT(
-        dynamic_cast<std::add_pointer_t<std::remove_reference_t<Dest>>>(&s) != nullptr,
-        "xrpl::safeDowncast : reference downcast is valid");
-#endif
-    return static_cast<Dest>(s);  // NOLINT(cppcoreguidelines-pro-type-static-cast-downcast)
+    return *safeDowncast<std::add_pointer_t<std::remove_reference_t<Dest>>>(std::addressof(s));
 }
+/** @} */

 }  // namespace xrpl
@@ -4,88 +4,215 @@

 #include <xrpl/beast/utility/instrumentation.h>

+#include <boost/predef/architecture.h>
+
 #include <atomic>
+#include <concepts>
 #include <limits>
 #include <type_traits>

-#ifndef __aarch64__
+#if BOOST_ARCH_X86
 #include <immintrin.h>
 #endif

 namespace xrpl {

+/** An unsigned integral type suitable for use as a spinlock.
+
+    The type must be always lock-free when wrapped in std::atomic, so
+    that lock operations cannot themselves take a (library-level) lock.
+ */
+template <typename T>
+concept SpinlockValueType = std::is_unsigned_v<T> && std::atomic<T>::is_always_lock_free;
+
+/** A spinlock value type that additionally supports the atomic bitwise
+    operations required to pack multiple locks into a single integer.
+ */
+template <typename T>
+concept PackedSpinlockValueType = SpinlockValueType<T> && requires(std::atomic<T>& a, T v) {
+    { a.fetch_or(v) } -> std::same_as<T>;
+    { a.fetch_and(v) } -> std::same_as<T>;
+};
+
 namespace detail {
-/**
- * Inform the processor that we are in a tight spin-wait loop.
- *
- * Spinlocks caught in tight loops can result in the processor's pipeline
- * filling up with comparison operations, resulting in a misprediction at
- * the time the lock is finally acquired, necessitating pipeline flushing
- * which is ridiculously expensive and results in very high latency.
- *
- * This function instructs the processor to "pause" for some architecture
- * specific amount of time, to prevent this.
+
+/** Inform the processor that we are in a tight spin-wait loop.
+
+    Spinlocks caught in tight loops can result in the processor's pipeline
+    filling up with comparison operations, resulting in a misprediction at
+    the time the lock is finally acquired, necessitating pipeline flushing
+    which is ridiculously expensive and results in very high latency.
+
+    This function instructs the processor to "pause" for some architecture
+    specific amount of time, to prevent this.
 */
 inline void
 spinPause() noexcept
 {
-#ifdef __aarch64__
-    asm volatile("yield");
-#else
+#if BOOST_ARCH_X86
    _mm_pause();
+#elif BOOST_ARCH_ARM
+    asm volatile("yield" ::: "memory");
+#else
+#error No implementation available for spinPause to use
 #endif
 }

 }  // namespace detail

-/** @{ */
-/**
- * Classes to handle arrays of spinlocks packed into a single atomic integer:
- *
- * Packed spinlocks allow for tremendously space-efficient lock-sharding
- * but they come at a cost.
- *
- * First, the implementation is necessarily low-level and uses advanced
- * features like memory ordering and highly platform-specific tricks to
- * maximize performance. This imposes a significant and ongoing cost to
- * developers.
- *
- * Second, and perhaps most important, is that the packing of multiple
- * locks into a single integer which, albeit space-efficient, also has
- * performance implications stemming from data dependencies, increased
- * cache-coherency traffic between processors and heavier loads on the
- * processor's load/store units.
- *
- * To be sure, these locks can have advantages but they are definitely
- * not general purpose locks and should not be thought of or used that
- * way. The use cases for them are likely few and far between; without
- * a compelling reason to use them, backed by profiling data, it might
- * be best to use one of the standard locking primitives instead. Note
- * that in most common platforms, `std::mutex` is so heavily optimized
- * that it can, usually, outperform spinlocks.
- *
- * @tparam T An unsigned integral type (e.g. std::uint16_t)
- */
+//------------------------------------------------------------------------------

-/**
- * A class that grabs a single packed spinlock from an atomic integer.
- *
- * This class meets the requirements of Lockable:
- *     https://en.cppreference.com/w/cpp/named_req/Lockable
+/** Attempt to acquire a spinlock without blocking.
+
+    @note This interface is primarily intended for one-shot attempts to
+          acquire the lock. Avoid calling this function directly from a
+          loop and use @ref spinLock instead.
+
+    @tparam T An unsigned integral type.
+    @param lock The atomic variable used as the lock.
+    @return true if the lock was acquired, false if it was already held.
 */
-template <class T>
+template <SpinlockValueType T>
+[[nodiscard]] bool
+spinTryLock(std::atomic<T>& lock) noexcept
+{
+    // A compare-exchange is required here, not an unconditional exchange:
+    // a failed attempt must not modify the lock word, in case the atomic
+    // is shared with PackedSpinlock).
+    T expected = 0;
+
+    return lock.compare_exchange_strong(
+        expected,
+        std::numeric_limits<T>::max(),
+        std::memory_order::acquire,
+        std::memory_order::relaxed);
+    ;
+}
+
+/** Acquire a spinlock, blocking until available.
+
+    Uses a TTAS (test-and-test-and-set) pattern, so waiters share the cache
+    line read-only, helping to avoid unnecessary coherency traffic.
+
+    @tparam T An unsigned integral type.
+    @param lock The atomic variable used as the lock.
+ */
+template <SpinlockValueType T>
+void
+spinLock(std::atomic<T>& lock) noexcept
+{
+    do
+    {
+        // Relaxed ordering is sufficient for the spin: this load is only
+        // a filter. The acquire on the successful exchange in spinTryLock
+        // is what synchronizes the critical section.
+        while (lock.load(std::memory_order::relaxed) != 0)
+            detail::spinPause();
+    } while (!spinTryLock(lock));
+}
+
+/** Release a spinlock.
+
+    @tparam T An unsigned integral type.
+    @param lock The atomic variable used as the lock.
+ */
+template <SpinlockValueType T>
+void
+spinUnlock(std::atomic<T>& lock) noexcept
+{
+    lock.store(0, std::memory_order::release);
+}
+
+//------------------------------------------------------------------------------
+
+/** A Lockable interface to a spinlock implemented on top of an atomic.
+
+    @tparam T An unsigned integral type.
+
+    @note Using `PackedSpinlock` and `Spinlock` against the same underlying
+          atomic integer is possible but can result in `Spinlock` not being
+          able to acquire the lock during periods of high contention due to
+          the way the two locks operate: `Spinlock` spins and tries to grab
+          all the bits at once, whereas any given `PackedSpinlock` instance
+          only tries to grab one bit at a time. Caveat emptor.
+
+    This class meets the requirements of Lockable:
+        https://en.cppreference.com/w/cpp/named_req/Lockable
+ */
+template <SpinlockValueType T>
+class Spinlock
+{
+    std::atomic<T>& lock_;
+
+public:
+    Spinlock(Spinlock const&) = delete;
+    Spinlock&
+    operator=(Spinlock const&) = delete;
+
+    /** Construct a spinlock handle.
+
+        @param lock The atomic integer to spin against.
+
+        @note For performance reasons, you should strive to have `lock` be
+              on a cacheline by itself.
+     */
+    explicit Spinlock(std::atomic<T>& lock) noexcept : lock_(lock)
+    {
+    }
+
+    [[nodiscard]] bool
+    try_lock() noexcept  // NOLINT(readability-identifier-naming)
+    {
+        return spinTryLock(lock_);
+    }
+
+    void
+    lock() noexcept
+    {
+        spinLock(lock_);
+    }
+
+    void
+    unlock() noexcept
+    {
+        spinUnlock(lock_);
+    }
+};
+
+//------------------------------------------------------------------------------
+
+/** A Lockable interface to a packed spinlock implemented on top of an atomic.
+
+    Packed spinlocks offer tremendous space-efficient lock-sharding but
+    they come at a cost.
+
+    First, the implementation is necessarily low-level and uses advanced
+    features like memory ordering and highly platform-specific tricks to
+    maximize performance. This imposes a significant and ongoing cost to
+    developers.
+
+    Second, and perhaps most important, is that the packing of multiple
+    locks into a single integer which, albeit space-efficient, also has
+    performance implications stemming from data dependencies, increased
+    cache-coherency traffic between processors and heavier loads on the
+    processor's load/store units.
+
+    To be sure, these locks can have advantages but they are definitely
+    not general purpose locks and should not be thought of or used that
+    way. The use cases for them are likely few and far between; without
+    a compelling reason to use them, backed by profiling data, it might
+    be best to use one of the standard locking primitives instead. Note
+    that in most common platforms, `std::mutex` is so heavily optimized
+    that it can, usually, outperform spinlocks.
+
+    @tparam T An unsigned integral type (e.g. std::uint16_t)
+
+    This class meets the requirements of Lockable:
+        https://en.cppreference.com/w/cpp/named_req/Lockable
+ */
+template <PackedSpinlockValueType T>
 class PackedSpinlock
 {
-    // clang-format off
-    static_assert(std::is_unsigned_v<T>);
-    static_assert(std::atomic<T>::is_always_lock_free);
-    static_assert(
-        std::is_same_v<decltype(std::declval<std::atomic<T>&>().fetch_or(0)), T> &&
-        std::is_same_v<decltype(std::declval<std::atomic<T>&>().fetch_and(0)), T>,
-        "std::atomic<T>::fetch_and(T) and std::atomic<T>::fetch_and(T) are required by packed_spinlock");
-    // clang-format on
-
-private:
    std::atomic<T>& bits_;
    T const mask_;

@@ -94,120 +221,49 @@ public:
    PackedSpinlock&
    operator=(PackedSpinlock const&) = delete;

-    /**
-     * A single spinlock packed inside the specified atomic
-     *
-     * @param lock The atomic integer inside which the spinlock is packed.
-     * @param index The index of the spinlock this object acquires.
-     *
-     * @note For performance reasons, you should strive to have `lock` be
-     *       on a cacheline by itself.
+    /** Construct a packed spinlock handle for a single bit.
+
+        @param lock The atomic integer inside which the spinlock is packed.
+        @param index The index of the spinlock this object acquires.
+
+        @note For performance reasons, you should strive to have `lock` be
+              on a cacheline by itself.
     */
-    PackedSpinlock(std::atomic<T>& lock, int index) : bits_(lock), mask_(static_cast<T>(1) << index)
-    {
-        XRPL_ASSERT(
-            index >= 0 && (mask_ != 0),
-            "xrpl::PackedSpinlock::PackedSpinlock : valid index and mask");
-    }
-
-    [[nodiscard]] bool
-    try_lock()  // NOLINT(readability-identifier-naming)
-    {
-        return (bits_.fetch_or(mask_, std::memory_order_acquire) & mask_) == 0;
-    }
-
-    void
-    lock()
-    {
-        while (!try_lock())
-        {
-            // The use of relaxed memory ordering here is intentional and
-            // serves to help reduce cache coherency traffic during times
-            // of contention by avoiding writes that would definitely not
-            // result in the lock being acquired.
-            while ((bits_.load(std::memory_order_relaxed) & mask_) != 0)
-                detail::spinPause();
-        }
-    }
-
-    void
-    unlock()
-    {
-        bits_.fetch_and(~mask_, std::memory_order_release);
-    }
-};
-
-/**
- * A spinlock implemented on top of an atomic integer.
- *
- * @note Using `packed_spinlock` and `spinlock` against the same underlying
- *       atomic integer can result in `spinlock` not being able to actually
- *       acquire the lock during periods of high contention, because of how
- *       the two locks operate: `spinlock` will spin trying to grab all the
- *       bits at once, whereas any given `packed_spinlock` will only try to
- *       grab one bit at a time. Caveat emptor.
- *
- * This class meets the requirements of Lockable:
- *     https://en.cppreference.com/w/cpp/named_req/Lockable
- */
-template <class T>
-class Spinlock
-{
-    static_assert(std::is_unsigned_v<T>);
-    static_assert(std::atomic<T>::is_always_lock_free);
-
-private:
-    std::atomic<T>& lock_;
-
-public:
-    Spinlock(Spinlock const&) = delete;
-    Spinlock&
-    operator=(Spinlock const&) = delete;
-
-    /**
-     * Grabs the
-     *
-     * @param lock The atomic integer to spin against.
-     *
-     * @note For performance reasons, you should strive to have `lock` be
-     *       on a cacheline by itself.
-     */
-    Spinlock(std::atomic<T>& lock) : lock_(lock)
+    PackedSpinlock(std::atomic<T>& lock, int index) noexcept
+        : bits_(lock), mask_([index]() {
+            XRPL_ASSERT(
+                index >= 0 && index < std::numeric_limits<T>::digits,
+                "xrpl::PackedSpinlock::PackedSpinlock : valid index");
+            return static_cast<T>(T{1} << index);
+        }())
    {
    }

    [[nodiscard]] bool
-    try_lock()  // NOLINT(readability-identifier-naming)
+    try_lock() noexcept  // NOLINT(readability-identifier-naming)
    {
-        T expected = 0;
-
-        return lock_.compare_exchange_weak(
-            expected,
-            std::numeric_limits<T>::max(),
-            std::memory_order_acquire,
-            std::memory_order_relaxed);
+        return (bits_.fetch_or(mask_, std::memory_order::acquire) & mask_) == 0;
    }

    void
-    lock()
+    lock() noexcept
    {
-        while (!try_lock())
+        do
        {
            // The use of relaxed memory ordering here is intentional and
            // serves to help reduce cache coherency traffic during times
-            // of contention by avoiding writes that would definitely not
-            // result in the lock being acquired.
-            while (lock_.load(std::memory_order_relaxed) != 0)
+            // of contention by avoiding writes that are unlikely to grab
+            // the requested lock.
+            while ((bits_.load(std::memory_order::relaxed) & mask_) != 0)
                detail::spinPause();
-        }
+        } while (!try_lock());
    }

    void
-    unlock()
+    unlock() noexcept
    {
-        lock_.store(0, std::memory_order_release);
+        bits_.fetch_and(~mask_, std::memory_order::release);
    }
 };
-/** @} */

 }  // namespace xrpl
@@ -1,47 +0,0 @@
-#pragma once
-
-#include <cstdlib>
-#include <string>
-#include <type_traits>
-#include <typeinfo>
-
-#ifndef _MSC_VER
-#include <cxxabi.h>
-#endif
-
-namespace beast {
-
-template <typename T>
-std::string
-typeName()
-{
-    using TR = std::remove_reference_t<T>;
-
-    std::string name = typeid(TR).name();
-
-#ifndef _MSC_VER
-    if (auto s = abi::__cxa_demangle(name.c_str(), nullptr, nullptr, nullptr))
-    {
-        name = s;
-        // NOLINTNEXTLINE(cppcoreguidelines-no-malloc)
-        std::free(s);
-    }
-#endif
-
-    if (std::is_const_v<TR>)
-        name += " const";
-    if (std::is_volatile_v<TR>)
-        name += " volatile";
-    if (std::is_lvalue_reference_v<T>)
-    {
-        name += "&";
-    }
-    else if (std::is_rvalue_reference_v<T>)
-    {
-        name += "&&";
-    }
-
-    return name;
-}
-
-}  // namespace beast
@@ -2,26 +2,24 @@

 #pragma once

+#include <compare>
+#include <concepts>
+
 namespace beast {

 /**
 * Zero allows classes to offer efficient comparisons to zero.
 *
- * Zero is a struct to allow classes to efficiently compare with zero without
- * requiring an rvalue construction.
- *
 * It's often the case that we have classes which combine a number and a unit.
 * In such cases, comparisons like t > 0 or t != 0 make sense, but comparisons
- * like t > 1 or t != 1 do not.
+ * like t > 1 or t != 1 do not. Comparing against kZero expresses exactly that,
+ * without constructing a T.
 *
- * The class Zero allows such comparisons to be easily made.
- *
- * The comparing class T either needs to have a method called signum() which
- * returns a positive number, 0, or a negative; or there needs to be a signum
- * function which resolves in the namespace which takes an instance of T and
- * returns a positive, zero or negative number.
+ * A type T participates if either `t.signum()` or an unqualified `signum(t)`
+ * found by argument-dependent lookup returns an integer that is negative,
+ * zero, or positive according to the sign of t. Both `t == kZero` and
+ * `kZero == t` work, as do all six relational operators in either order.
 */
-
 struct Zero
 {
    explicit Zero() = default;
@@ -30,115 +28,44 @@ struct Zero
 inline constexpr Zero kZero{};

 /**
- * Default implementation of signum calls the method on the class.
+ * Default implementation of signum: call the member function.
 */
-template <typename T>
-auto
-signum(T const& t)
+template <class T>
+    requires requires(T const& t) {
+        { t.signum() } -> std::integral;
+    }
+[[nodiscard]] constexpr auto
+signum(T const& t) noexcept(noexcept(t.signum()))
 {
    return t.signum();
 }

-namespace detail::zero_helper {
+namespace detail {

-// For argument dependent lookup to function properly, calls to signum must
-// be made from a namespace that does not include overloads of the function..
+/**
+ * A type with a usable signum: either the member-based default above, or a
+ * `signum(t)` overload in T's own namespace, found by ADL. A user overload
+ * that is a better match than the template wins, as usual.
+ */
 template <class T>
-auto
-callSignum(T const& t)
+concept HasSignum = requires(T const& t) {
+    { signum(t) } -> std::integral;
+};
+
+}  // namespace detail
+
+template <detail::HasSignum T>
+[[nodiscard]] constexpr bool
+operator==(T const& t, Zero) noexcept(noexcept(signum(t)))
 {
-    return signum(t);
+    return signum(t) == 0;
 }

-}  // namespace detail::zero_helper
-
-// Handle operators where T is on the left side using signum.
-
-template <typename T>
-bool
-operator==(T const& t, Zero)
+template <detail::HasSignum T>
+[[nodiscard]] constexpr std::strong_ordering
+operator<=>(T const& t, Zero) noexcept(noexcept(signum(t)))
 {
-    return detail::zero_helper::callSignum(t) == 0;
-}
-
-template <typename T>
-bool
-operator!=(T const& t, Zero)
-{
-    return detail::zero_helper::callSignum(t) != 0;
-}
-
-template <typename T>
-bool
-operator<(T const& t, Zero)
-{
-    return detail::zero_helper::callSignum(t) < 0;
-}
-
-template <typename T>
-bool
-operator>(T const& t, Zero)
-{
-    return detail::zero_helper::callSignum(t) > 0;
-}
-
-template <typename T>
-bool
-operator>=(T const& t, Zero)
-{
-    return detail::zero_helper::callSignum(t) >= 0;
-}
-
-template <typename T>
-bool
-operator<=(T const& t, Zero)
-{
-    return detail::zero_helper::callSignum(t) <= 0;
-}
-
-// Handle operators where T is on the right side by
-// reversing the operation, so that T is on the left side.
-
-template <typename T>
-bool
-operator==(Zero, T const& t)
-{
-    return t == kZero;
-}
-
-template <typename T>
-bool
-operator!=(Zero, T const& t)
-{
-    return t != kZero;
-}
-
-template <typename T>
-bool
-operator<(Zero, T const& t)
-{
-    return t > kZero;
-}
-
-template <typename T>
-bool
-operator>(Zero, T const& t)
-{
-    return t < kZero;
-}
-
-template <typename T>
-bool
-operator>=(Zero, T const& t)
-{
-    return t <= kZero;
-}
-
-template <typename T>
-bool
-operator<=(Zero, T const& t)
-{
-    return t >= kZero;
+    return signum(t) <=> 0;
 }

 }  // namespace beast
@@ -1,7 +1,7 @@
 #pragma once

 #include <xrpl/basics/base_uint.h>
-#include <xrpl/basics/safe_cast.h>
+#include <xrpl/basics/enum_bitops.h>
 #include <xrpl/beast/utility/instrumentation.h>
 #include <xrpl/ledger/OwnerCounts.h>
 #include <xrpl/ledger/ReadView.h>
@@ -22,80 +22,39 @@

 namespace xrpl {

-// Bitwise flag enum with existing operator overloads
-// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
-enum ApplyFlags : std::uint32_t {
-    TapNone = 0x00,
+enum class ApplyFlags : std::uint32_t {
+    None = 0x00,

    // This is a local transaction with the
    // fail_hard flag set.
-    TapFailHard = 0x10,
+    FailHard = 0x10,

    // This is not the transaction's last pass
    // Transaction can be retried, soft failures allowed
-    TapRetry = 0x20,
+    Retry = 0x20,

    // Transaction came from a privileged source
-    TapUnlimited = 0x400,
+    Unlimited = 0x400,

    // Transaction is executing as part of a batch
-    TapBatch = 0x800,
+    Batch = 0x800,

    // Transaction shouldn't be applied
    // Signatures shouldn't be checked
-    TapDryRun = 0x1000,
+    DryRun = 0x1000,

    // Transaction is being preflighted as the payload of a
    // TransactionProposalCreate. Its signatures are collected on-ledger
    // afterward, so signature-presence checks (e.g. Batch signer matching)
    // are skipped at proposal-creation time (On-Chain Cosigner spec
    // §5.3.1.2).
-    TapProposal = 0x2000
+    Proposal = 0x2000
 };

-constexpr ApplyFlags
-operator|(ApplyFlags const& lhs, ApplyFlags const& rhs)
+template <>
+struct enum_bitops::OptIn<ApplyFlags> : std::true_type
 {
-    return safeCast<ApplyFlags>(
-        safeCast<std::underlying_type_t<ApplyFlags>>(lhs) |
-        safeCast<std::underlying_type_t<ApplyFlags>>(rhs));
-}
-
-static_assert((TapFailHard | TapRetry) == safeCast<ApplyFlags>(0x30u), "ApplyFlags operator |");
-static_assert((TapRetry | TapFailHard) == safeCast<ApplyFlags>(0x30u), "ApplyFlags operator |");
-
-constexpr ApplyFlags
-operator&(ApplyFlags const& lhs, ApplyFlags const& rhs)
-{
-    return safeCast<ApplyFlags>(
-        safeCast<std::underlying_type_t<ApplyFlags>>(lhs) &
-        safeCast<std::underlying_type_t<ApplyFlags>>(rhs));
-}
-
-static_assert((TapFailHard & TapRetry) == TapNone, "ApplyFlags operator &");
-static_assert((TapRetry & TapFailHard) == TapNone, "ApplyFlags operator &");
-
-constexpr ApplyFlags
-operator~(ApplyFlags const& flags)
-{
-    return safeCast<ApplyFlags>(~safeCast<std::underlying_type_t<ApplyFlags>>(flags));
-}
-
-static_assert(~TapRetry == safeCast<ApplyFlags>(0xFFFFFFDFu), "ApplyFlags operator ~");
-
-inline ApplyFlags
-operator|=(ApplyFlags& lhs, ApplyFlags const& rhs)
-{
-    lhs = lhs | rhs;
-    return lhs;
-}
-
-inline ApplyFlags
-operator&=(ApplyFlags& lhs, ApplyFlags const& rhs)
-{
-    lhs = lhs & rhs;
-    return lhs;
-}
+};

 //------------------------------------------------------------------------------

@@ -101,22 +101,6 @@ operator<<(std::ostream& os, AccountID const& x)
    return os;
 }

-/**
- * Initialize the global cache used to map AccountID to base58 conversions.
- *
- * The cache is optional and need not be initialized. But because conversion
- * is expensive (it requires a SHA-256 operation) in most cases the overhead
- * of the cache is worth the benefit.
- *
- * @param count The number of entries the cache should accommodate. Zero will
- *              disable the cache, releasing any memory associated with it.
- *
- * @note The function will only initialize the cache the first time it is
- *       invoked. Subsequent invocations do nothing.
- */
-void
-initAccountIdCache(std::size_t count);
-
 }  // namespace xrpl

 //------------------------------------------------------------------------------
@@ -1,10 +1,10 @@
 #pragma once

 #include <xrpl/basics/contract.h>
-#include <xrpl/beast/type_name.h>
 #include <xrpl/protocol/SOTemplate.h>

 #include <boost/container/flat_map.hpp>
+#include <boost/core/type_name.hpp>

 #include <algorithm>
 #include <cstddef>
@@ -84,7 +84,7 @@ public:
     * Derived classes will load the object with all the known formats.
     */
 private:
-    KnownFormats() : name_(beast::typeName<Derived>())
+    KnownFormats() : name_(boost::core::type_name<Derived>())
    {
    }

@@ -2,6 +2,7 @@

 #include <xrpl/basics/CountedObject.h>
 #include <xrpl/basics/UnorderedContainers.h>
+#include <xrpl/basics/enum_bitops.h>
 #include <xrpl/beast/utility/instrumentation.h>
 #include <xrpl/json/json_value.h>
 #include <xrpl/protocol/AccountID.h>
@@ -15,6 +16,7 @@
 #include <cstdint>
 #include <memory>
 #include <optional>
+#include <type_traits>
 #include <utility>
 #include <vector>

@@ -22,18 +24,8 @@ namespace xrpl {

 class STPathElement final : public CountedObject<STPathElement>
 {
-    unsigned int type_;
-    AccountID accountID_;
-    PathAsset assetID_;
-    AccountID issuerID_;
-
-    bool isOffer_;
-    std::size_t hashValue_;
-
 public:
-    // Bitwise values (typeCurrency | typeMPT)
-    // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
-    enum Type {
+    enum class Type : std::uint8_t {
        TypeNone = 0x00,
        TypeAccount = 0x01,   // Rippling through an account (vs taking an offer).
        TypeCurrency = 0x10,  // Currency follows.
@@ -45,6 +37,8 @@ public:
        // Combination of all types.
    };

+    using enum Type;
+
    STPathElement();
    STPathElement(STPathElement const&) = default;
    STPathElement&
@@ -62,42 +56,42 @@ public:
        bool forceAsset = false);

    STPathElement(
-        unsigned int uType,
+        Type type,
        AccountID const& account,
        PathAsset const& asset,
        AccountID const& issuer);

-    [[nodiscard]] std::uint32_t
-    getNodeType() const;
+    [[nodiscard]] Type
+    getNodeType() const noexcept;

    [[nodiscard]] bool
-    isOffer() const;
+    isOffer() const noexcept;

    [[nodiscard]] bool
-    isAccount() const;
+    isAccount() const noexcept;

    [[nodiscard]] bool
-    hasIssuer() const;
+    hasIssuer() const noexcept;

    [[nodiscard]] bool
-    hasCurrency() const;
+    hasCurrency() const noexcept;

    [[nodiscard]] bool
-    hasMPT() const;
+    hasMPT() const noexcept;

    [[nodiscard]] bool
-    hasAsset() const;
+    hasAsset() const noexcept;

    [[nodiscard]] bool
-    isNone() const;
+    isNone() const noexcept;

    // Nodes are either an account ID or a offer prefix. Offer prefixs denote a
    // class of offers.
    [[nodiscard]] AccountID const&
-    getAccountID() const;
+    getAccountID() const noexcept;

    [[nodiscard]] PathAsset const&
-    getPathAsset() const;
+    getPathAsset() const noexcept;

    [[nodiscard]] Currency const&
    getCurrency() const;
@@ -106,17 +100,35 @@ public:
    getMPTID() const;

    [[nodiscard]] AccountID const&
-    getIssuerID() const;
+    getIssuerID() const noexcept;

    [[nodiscard]] bool
-    isType(Type const& pe) const;
+    isType(Type pe) const noexcept;

-    bool
-    operator==(STPathElement const& t) const;
+    friend bool
+    operator==(STPathElement const& lhs, STPathElement const& rhs) noexcept
+    {
+        return lhs.isType(TypeAccount) == rhs.isType(TypeAccount) &&
+            lhs.hashValue_ == rhs.hashValue_ && lhs.accountID_ == rhs.accountID_ &&
+            lhs.assetID_ == rhs.assetID_ && lhs.issuerID_ == rhs.issuerID_;
+    }

 private:
    static std::size_t
    getHash(STPathElement const& element);
+
+    Type type_;
+    AccountID accountID_;
+    PathAsset assetID_;
+    AccountID issuerID_;
+
+    bool isOffer_;
+    std::size_t hashValue_;
+};
+
+template <>
+struct enum_bitops::OptIn<STPathElement::Type> : std::true_type
+{
 };

 template <class Hasher>
@@ -124,7 +136,7 @@ void
 hash_append(Hasher& h, STPathElement const& e) noexcept
 {
    using beast::hash_append;
-    hash_append(h, (e.getNodeType() & STPathElement::TypeAccount) != 0u);
+    hash_append(h, e.isType(STPathElement::TypeAccount));
    hash_append(h, e.getAccountID());
    hash_append(h, e.getPathAsset());
    hash_append(h, e.getIssuerID());
@@ -404,11 +416,11 @@ inline STPathElement::STPathElement(
 }

 inline STPathElement::STPathElement(
-    unsigned int uType,
+    Type type,
    AccountID const& account,
    PathAsset const& asset,
    AccountID const& issuer)
-    : type_(uType)
+    : type_(type)
    , accountID_(account)
    , assetID_(asset)
    , issuerID_(issuer)
@@ -423,56 +435,56 @@ inline STPathElement::STPathElement(
    hashValue_ = getHash(*this);
 }

-inline std::uint32_t
-STPathElement::getNodeType() const
+inline STPathElement::Type
+STPathElement::getNodeType() const noexcept
 {
    return type_;
 }

 inline bool
-STPathElement::isOffer() const
+STPathElement::isOffer() const noexcept
 {
    return isOffer_;
 }

 inline bool
-STPathElement::isAccount() const
+STPathElement::isAccount() const noexcept
 {
    return !isOffer();
 }

 inline bool
-STPathElement::isType(Type const& pe) const
+STPathElement::isType(Type pe) const noexcept
 {
-    return (type_ & pe) != 0u;
+    return (type_ & pe) != STPathElement::TypeNone;
 }

 inline bool
-STPathElement::hasIssuer() const
+STPathElement::hasIssuer() const noexcept
 {
    return isType(STPathElement::TypeIssuer);
 }

 inline bool
-STPathElement::hasCurrency() const
+STPathElement::hasCurrency() const noexcept
 {
    return isType(STPathElement::TypeCurrency);
 }

 inline bool
-STPathElement::hasMPT() const
+STPathElement::hasMPT() const noexcept
 {
    return isType(STPathElement::TypeMpt);
 }

 inline bool
-STPathElement::hasAsset() const
+STPathElement::hasAsset() const noexcept
 {
    return isType(STPathElement::TypeAsset);
 }

 inline bool
-STPathElement::isNone() const
+STPathElement::isNone() const noexcept
 {
    return getNodeType() == STPathElement::TypeNone;
 }
@@ -480,13 +492,13 @@ STPathElement::isNone() const
 // Nodes are either an account ID or a offer prefix. Offer prefixs denote a
 // class of offers.
 inline AccountID const&
-STPathElement::getAccountID() const
+STPathElement::getAccountID() const noexcept
 {
    return accountID_;
 }

 inline PathAsset const&
-STPathElement::getPathAsset() const
+STPathElement::getPathAsset() const noexcept
 {
    return assetID_;
 }
@@ -504,18 +516,11 @@ STPathElement::getMPTID() const
 }

 inline AccountID const&
-STPathElement::getIssuerID() const
+STPathElement::getIssuerID() const noexcept
 {
    return issuerID_;
 }

-inline bool
-STPathElement::operator==(STPathElement const& t) const
-{
-    return (type_ & TypeAccount) == (t.type_ & TypeAccount) && hashValue_ == t.hashValue_ &&
-        accountID_ == t.accountID_ && assetID_ == t.assetID_ && issuerID_ == t.issuerID_;
-}
-
 // ------------ STPath ------------

 inline STPath::STPath(std::vector<STPathElement> p) : path_(std::move(p))
@@ -392,6 +392,7 @@ JSS(max_ledger);                  // in/out: LedgerCleaner
 JSS(max_queue_size);              // out: TxQ
 JSS(max_spend_drops);             // out: AccountInfo
 JSS(max_spend_drops_total);       // out: AccountInfo
+JSS(maximum);
 JSS(mean);                        // out: get_aggregate_price
 JSS(median);                      // out: get_aggregate_price
 JSS(median_fee);                  // out: TxQ
@@ -51,7 +51,8 @@ public:
        beast::Journal journal = beast::Journal{beast::Journal::getNullSink()})
        : ApplyContext(registry, base, std::nullopt, tx, preclaimResult, baseFee, flags, journal)
    {
-        XRPL_ASSERT((flags & TapBatch) == 0, "Batch apply flag should not be set");
+        XRPL_ASSERT(
+            (flags & ApplyFlags::Batch) == ApplyFlags::None, "Batch apply flag should not be set");
    }

    std::reference_wrapper<ServiceRegistry> registry;
@@ -59,10 +59,11 @@ public:
        , parentBatchId(parentBatchId)
        , j(j)
    {
-        XRPL_ASSERT((flags & TapBatch) == TapBatch, "Batch apply flag should be set");
+        XRPL_ASSERT(
+            (flags & ApplyFlags::Batch) == ApplyFlags::Batch, "Batch apply flag should be set");
        XRPL_ASSERT_IF(
-            (flags & TapProposal) != TapNone,
-            (flags & TapDryRun) != TapNone,
+            (flags & ApplyFlags::Proposal) != ApplyFlags::None,
+            (flags & ApplyFlags::DryRun) != ApplyFlags::None,
            "xrpl::PreflightContext : proposal preflight implies dry run");
    }

@@ -74,10 +75,11 @@ public:
        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
        : registry(registry), tx(tx), rules(std::move(rules)), flags(flags), j(j)
    {
-        XRPL_ASSERT((flags & TapBatch) == 0, "Batch apply flag should not be set");
+        XRPL_ASSERT(
+            (flags & ApplyFlags::Batch) == ApplyFlags::None, "Batch apply flag should not be set");
        XRPL_ASSERT_IF(
-            (flags & TapProposal) != TapNone,
-            (flags & TapDryRun) != TapNone,
+            (flags & ApplyFlags::Proposal) != ApplyFlags::None,
+            (flags & ApplyFlags::DryRun) != ApplyFlags::None,
            "xrpl::PreflightContext : proposal preflight implies dry run");
    }

@@ -116,7 +118,7 @@ public:
        , j(j)
    {
        XRPL_ASSERT(
-            parentBatchId.has_value() == ((flags & TapBatch) == TapBatch),
+            parentBatchId.has_value() == ((flags & ApplyFlags::Batch) == ApplyFlags::Batch),
            "Parent Batch ID should be set if batch apply flag is set");
    }

@@ -129,7 +131,8 @@ public:
        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
        : PreclaimContext(registry, view, preflightResult, tx, flags, std::nullopt, j)
    {
-        XRPL_ASSERT((flags & TapBatch) == 0, "Batch apply flag should not be set");
+        XRPL_ASSERT(
+            (flags & ApplyFlags::Batch) == ApplyFlags::None, "Batch apply flag should not be set");
    }

    PreclaimContext&
@@ -41,7 +41,7 @@ struct ApplyResult
 inline bool
 isTecClaimHardFail(TER ter, ApplyFlags flags)
 {
-    return isTecClaim(ter) && ((flags & TapRetry) == 0u);
+    return isTecClaim(ter) && ((flags & ApplyFlags::Retry) == ApplyFlags::None);
 }

 /**
@@ -42,14 +42,6 @@ class ValidMPTIssuance
     */
    bool referenceHoldingMutated_ = false;

-    /**
-     * Flags cleared on an existing MPTokenIssuance, except lsfMPTLocked,
-     * which tfMPTUnlock clears legitimately. Every other issuance flag is
-     * fixed at creation or set-once via MPTokenIssuanceSet, so any bit
-     * accumulated here is a bug. Enforced post-fixCleanup3_5_0.
-     */
-    std::uint32_t issuanceFlagsCleared_ = 0;
-
    /**
     * MPTokens and RippleStates deleted during apply. finalize() checks each
     * holder's AccountRoot to detect vault pseudo-account holdings deleted
@@ -57,12 +57,6 @@ public:
        ReadView const& view,
        beast::Journal const& j) override;

-    /**
-     * Inner transaction types that preflight rejects before LendingProtocolV1_2.
-     *
-     * Once the amendment is enabled the list only matters when replaying older
-     * ledgers. Remove it when LendingProtocolV1_2 is retired.
-     */
    static constexpr auto kDisabledTxTypes = std::to_array<TxType>({
        ttVAULT_CREATE,
        ttVAULT_SET,
@@ -2,172 +2,172 @@ Detected OS: linux (Linux x86_64)

 Core build tools:
  ✅ cmake
-     cmake version 4.4.3
-     /nix/store/jcvvpih1046akxcwh9hdiak5q24jqcf0-cmake-4.4.3/bin/cmake
+     cmake version 4.1.2
+     /nix/store/r9941n32g4wyvggz2703dlplbdq8a6rd-cmake-4.1.2/bin/cmake
  ✅ conan
-     Conan version 2.32.0
-     /nix/store/q0g5grbh7zm8gfhhnq5h6fm1rbs9yv3n-conan-2.32.0/bin/conan
+     Conan version 2.28.1
+     /nix/store/lxny9y4jvjdws7hgz1mygvb7hjrpmna5-conan-2.28.1/bin/conan
  ✅ git
-     git version 2.55.0
-     /nix/store/lg46w7hrjx7kylsh6645c9l975i8h43b-git-2.55.0/bin/git
+     git version 2.54.0
+     /nix/store/bcnisk3ydfgv26v2gw3zlky24g00yww2-git-2.54.0/bin/git
  ✅ python3
-     Python 3.14.7
-     /nix/store/lb41b0anx1f98y9y5s9mdv97gjgsq740-python3-3.14.7/bin/python3.14
+     Python 3.13.13
+     /nix/store/60m4rxhg2fldqaak400c0lry96ijrzqn-python3-3.13.13/bin/python3.13

 Development tooling:
  ✅ ccache
     ccache version 4.13.6
-     /nix/store/p1a1s700dqsw1b3b8d2ba64nqw68zgpy-ccache-4.13.6/bin/ccache
+     /nix/store/c9wwl7s5i6rsfwvf4v0xbbmzx5m6jgfr-ccache-4.13.6/bin/ccache
  ✅ clang
-     clang version 22.1.8
-     /nix/store/dggxva67vs7virgsmd6xkwd6p7zsc5pn-clang-wrapper-22.1.8/bin/clang
+     clang version 22.1.7
+     /nix/store/ff0hrp9r9i3pa5arkdw0sgmzp8d576qi-clang-wrapper-22.1.7/bin/clang
  ✅ clang-22
-     clang version 22.1.8
-     /nix/store/ckz6y10v5dbyswpf9f6hd8kjfv84f920-clang-22/bin/clang-22
+     clang version 22.1.7
+     /nix/store/dagc2rq44gfbr7w7yvvqca3yqpc9gqbq-clang-22/bin/clang-22
  ✅ clang++
-     clang version 22.1.8
-     /nix/store/dggxva67vs7virgsmd6xkwd6p7zsc5pn-clang-wrapper-22.1.8/bin/clang++
+     clang version 22.1.7
+     /nix/store/ff0hrp9r9i3pa5arkdw0sgmzp8d576qi-clang-wrapper-22.1.7/bin/clang++
  ✅ clang++-22
-     clang version 22.1.8
-     /nix/store/lsishk8fwbdmlwr5fbwyd3yhhjsm67qr-clang++-22/bin/clang++-22
+     clang version 22.1.7
+     /nix/store/l5m8clin1npl605wdkd8mr18ggxww3z4-clang++-22/bin/clang++-22
  ✅ ClangBuildAnalyzer
     ClangBuildAnalyzer 1.6.0
-     /nix/store/gvx8im1c89vspwb8ixa91lr1dagbi241-clangbuildanalyzer-1.6.0/bin/ClangBuildAnalyzer
+     /nix/store/bshlmn8fqw55nsnm581xqlfbahfkykxx-clangbuildanalyzer-1.6.0/bin/ClangBuildAnalyzer
  ✅ curl
-     curl 8.22.0 (x86_64-pc-linux-gnu) libcurl/8.22.0 OpenSSL/3.5.8 zlib/1.3.2 libssh2/1.11.1 nghttp2/1.70.0 mit-krb5/1.22.2
-     /nix/store/305w9ipyg497mz9dq31abdf61qk58k29-curl-8.22.0-bin/bin/curl
+     curl 8.20.0 (x86_64-pc-linux-gnu) libcurl/8.20.0 OpenSSL/3.6.2 zlib/1.3.2 libssh2/1.11.1 nghttp2/1.69.0 mit-krb5/1.22.1
+     /nix/store/zbwymrp4lcfjc4kkk0n4779v0kjjz58z-curl-8.20.0-bin/bin/curl
  ✅ file
-     file-5.48
-     /nix/store/g0fbnccaan8q0rxlw43xnbyb90i94vlc-file-5.48/bin/file
+     file-5.47
+     /nix/store/bizyfqdw0h67wzqmp10knmf9s2pqahdb-file-5.47/bin/file
  ✅ less
-     less 710 (PCRE2 regular expressions)
-     /nix/store/zi4d0awnc6crz18s177bv9y2yz9al3lq-less-710/bin/less
+     less 692 (PCRE2 regular expressions)
+     /nix/store/c6bacbn93qg4a7g9n4czww8rg24dvysr-less-692/bin/less
  ✅ make
     GNU Make 4.4.1
-     /nix/store/z565rgmn9vccv2h0g87z725pw610jmm8-gnumake-4.4.1/bin/make
+     /nix/store/d3bwqm6bymhy3pdgbvf7vxjqfp31m3j1-gnumake-4.4.1/bin/make
  ✅ netstat
     net-tools 2.10
-     /nix/store/9i6j9lrsliyz1ww2f8xx18z36wc9n38a-net-tools-2.10/bin/netstat
+     /nix/store/jmyzqvgflnswmws7rnxx6g3zbj680xvd-net-tools-2.10/bin/netstat
  ✅ ninja
     1.13.2
-     /nix/store/4nsdla28c4177ssp0hlyv5l2yzj8wcba-ninja-1.13.2/bin/ninja
+     /nix/store/7a235m7crqbb4h49sak20fqxpw3n7hr0-ninja-1.13.2/bin/ninja
  ✅ perl
-     v5.42.3
-     /nix/store/8g4dmf7l8q1mf9w4wfmlcl8gvdgmhb8v-perl-5.42.3/bin/perl
+     v5.42.0
+     /nix/store/6plwsm6pkq79yjv4xvy8csk2pd4hzr67-perl-5.42.0/bin/perl
  ✅ pkg-config
     0.29.2
-     /nix/store/b9izmrfjp0qnnyahdwwrzdwi87s1h179-pkg-config-wrapper-0.29.2/bin/pkg-config
+     /nix/store/1m05k7xgfnw6jc21xxk5681ni3ar97wf-pkg-config-wrapper-0.29.2/bin/pkg-config
  ✅ vim
     VIM - Vi IMproved 9.2 (2026 Feb 14, compiled Jan 01 1980 00:00:00)
-     /nix/store/9swnd5pf8p8w1gwcbhdpm2yx705kbp38-vim-9.2.1001/bin/vim
+     /nix/store/hvyqx52g4g2fxhgpans3fksjj6lmlyaw-vim-9.2.0389/bin/vim
  ✅ zip
     Zip 3.0
-     /nix/store/5ypvkry3qra47dylc9kfk36r1q9vha80-zip-3.0/bin/zip
+     /nix/store/qnd2ag67hrjj0b6vbmisdshf50r6s72n-zip-3.0/bin/zip
  ✅ clang-apply-replacements
-     clang-apply-replacements version 22.1.8
-     /nix/store/dykdkqyz48al2mllwjpwgdxyxgkwhk9x-clang-tools-22.1.8/bin/clang-apply-replacements
+     clang-apply-replacements version 22.1.7
+     /nix/store/4zp1rjpj2xijrv4kqpwsy3ixwb2r6nlk-clang-tools-22.1.7/bin/clang-apply-replacements
  ✅ clang-apply-replacements-22
-     clang-apply-replacements version 22.1.8
-     /nix/store/m0aqc6dbryn1mvr0m2zsxxgpmahcvp6v-clang-apply-replacements-22/bin/clang-apply-replacements-22
+     clang-apply-replacements version 22.1.7
+     /nix/store/py2wihg0a96qcppv4hjmww547xabr0fb-clang-apply-replacements-22/bin/clang-apply-replacements-22
  ✅ clang-format
-     clang-format version 22.1.8
-     /nix/store/dykdkqyz48al2mllwjpwgdxyxgkwhk9x-clang-tools-22.1.8/bin/clang-format
+     clang-format version 22.1.7
+     /nix/store/4zp1rjpj2xijrv4kqpwsy3ixwb2r6nlk-clang-tools-22.1.7/bin/clang-format
  ✅ clang-format-22
-     clang-format version 22.1.8
-     /nix/store/grpzqmx46d3xr3ssrz4ibkl9xr7rvjzj-clang-format-22/bin/clang-format-22
+     clang-format version 22.1.7
+     /nix/store/kz820ccifjlwqnwqjsx7kbiajrgsmbrh-clang-format-22/bin/clang-format-22
  ✅ clang-tidy
-     LLVM version 22.1.8
-     /nix/store/dykdkqyz48al2mllwjpwgdxyxgkwhk9x-clang-tools-22.1.8/bin/clang-tidy
+     LLVM version 22.1.7
+     /nix/store/4zp1rjpj2xijrv4kqpwsy3ixwb2r6nlk-clang-tools-22.1.7/bin/clang-tidy
  ✅ clang-tidy-22
-     LLVM version 22.1.8
-     /nix/store/v9g20lw1q1qq9ljwvh5k580hgd9hmsv8-clang-tidy-22/bin/clang-tidy-22
+     LLVM version 22.1.7
+     /nix/store/gdrkvpw846lkyzh8y9p3zx50g6ml2v84-clang-tidy-22/bin/clang-tidy-22
  ✅ dot
-     dot - graphviz version 15.1.1 (0)
-     /nix/store/f7r47nc0d13xa4c2xaaxa6dp3pzm9sp1-graphviz-15.1.1/bin/dot
+     dot - graphviz version 12.2.1 (0)
+     /nix/store/12rgns2296s4qcja778gvcbx61z77rc4-graphviz-12.2.1/bin/dot
  ✅ doxygen
-     1.17.0
-     /nix/store/q6yx2nsimj9xmckmgw4br2cnapbgnqpk-doxygen-1.17.0/bin/doxygen
+     1.16.1
+     /nix/store/k0vzr5lvgq1byraknzwvk51wcgpnsrkh-doxygen-1.16.1/bin/doxygen
  ✅ gcovr
     gcovr 8.4
-     /nix/store/shx7mfl8n4kx11icvwyj5x7cmf6z5ahq-python3.14-gcovr-8.4/bin/gcovr
+     /nix/store/iyzi7fpyclqrha054adnizvif02lg49x-python3.13-gcovr-8.4/bin/gcovr
  ✅ gh
-     gh version 2.102.0 (2026-09-30)
-     /nix/store/66h5dr9v94x04myh2kabx06rq9763jfc-gh-2.102.0/bin/gh
+     gh version 2.94.0 (nixpkgs)
+     /nix/store/pidh15szlsb1vc41xdsa3xbdghdazvby-gh-2.94.0/bin/gh
  ✅ git-cliff
-     git-cliff 2.14.2
-     /nix/store/sl19b42d69b3w2vb9pxp6jbqk841z8vj-git-cliff-2.14.2/bin/git-cliff
+     git-cliff 2.13.1
+     /nix/store/1q851fs62shgjhc03fxxdkpzxdjg7k11-git-cliff-2.13.1/bin/git-cliff
  ✅ git-lfs
-     git-lfs/3.8.0 (3.8.0; linux amd64; go 1.26.8)
-     /nix/store/rp9ld1f6h83xmf2rb5fpib5wmr46fy9f-git-lfs-3.8.0/bin/git-lfs
+     git-lfs/3.7.1 (3.7.1; linux amd64; go 1.26.3)
+     /nix/store/6ljwpal7b1756708m33vj0crpral7mvl-git-lfs-3.7.1/bin/git-lfs
  ✅ gpg
     gpg (GnuPG) 2.4.9
-     /nix/store/8gm9aq3sspqmvvh7c0x7djcivj2x7yvn-gnupg-2.4.9/bin/gpg
+     /nix/store/wx7vk8babxkgy813r70yc67vcwnmagbx-gnupg-2.4.9/bin/gpg
  ✅ pre-commit
-     pre-commit 4.6.2
-     /nix/store/6blf72f7sdmlrqjggxvk5ij4cxb7fk4c-pre-commit-4.6.2/bin/pre-commit
+     pre-commit 4.5.1
+     /nix/store/bj6i9vl34cij5h0r165y40hrjqak0bmz-pre-commit-4.5.1/bin/pre-commit
  ✅ run-clang-tidy
     usage: run-clang-tidy [-h] [-allow-enabling-alpha-checkers]
-     /nix/store/a760dc8nldq1715410384bkk83idmm00-run-clang-tidy/bin/run-clang-tidy
+     /nix/store/sbg911hs9dbclrzlp04br3iyfpgnaj6r-run-clang-tidy/bin/run-clang-tidy
  ✅ run-clang-tidy-22
     usage: run-clang-tidy [-h] [-allow-enabling-alpha-checkers]
-     /nix/store/xwh85m9sa5h8fnpnlmqwfnf2sz9l59mm-run-clang-tidy-22/bin/run-clang-tidy-22
+     /nix/store/n8yak1ap308gvi7gmrniw0ybsx80fjws-run-clang-tidy-22/bin/run-clang-tidy-22

 Rust toolchain:
  ✅ cargo
     cargo 1.97.1 (c980f4866 2026-06-30)
-     /nix/store/60b0cz400q34wj2gzav5a41i7y6jzlw3-cargo-1.97.1-x86_64-unknown-linux-gnu/bin/cargo
+     /nix/store/88abzp43ywyzql1rhf8jh5aj5n5j7xzr-cargo-1.97.1-x86_64-unknown-linux-gnu/bin/cargo
  ✅ cargo-audit
-     cargo-audit-audit 0.22.2
-     /nix/store/kksgynfwir3pfii9qkbj3gcc61an0d4s-cargo-audit-0.22.2/bin/cargo-audit
+     cargo-audit-audit 0.22.1
+     /nix/store/2w9if868piw98xz057sz97jnjvf7hnvf-cargo-audit-0.22.1/bin/cargo-audit
  ✅ cargo-llvm-cov
-     cargo-llvm-cov 0.9.0
-     /nix/store/4y8qxx0mlm22hnxlw2cmbcwpxispw02h-cargo-llvm-cov-0.9.0/bin/cargo-llvm-cov
+     cargo-llvm-cov 0.8.5
+     /nix/store/jjpdf1l6izz6607a346ykra9sndzaw7h-cargo-llvm-cov-0.8.5/bin/cargo-llvm-cov
  ✅ cargo-nextest
-     cargo-nextest 0.9.146
-     /nix/store/q0anzqrazmdr8n1049ca28098q6lv2y8-cargo-nextest-0.9.146/bin/cargo-nextest
+     cargo-nextest 0.9.137
+     /nix/store/jhkr7gwyrchkml33gyns9cy0yn7b57qc-cargo-nextest-0.9.137/bin/cargo-nextest
  ✅ clippy-driver
     clippy 0.1.97 (8bab26f4f6 2026-07-14)
-     /nix/store/kk0kqdc4f7am21yp30rr8jcrnib5xqzy-rust-minimal-1.97.1/bin/clippy-driver
+     /nix/store/40d3mzka7r1ps71l0yv2fs6616nbw85m-rust-minimal-1.97.1/bin/clippy-driver
  ✅ rust-analyzer
     rust-analyzer 1.97.1 (8bab26f 2026-07-14)
-     /nix/store/4mglk7qw9jqbv5nwlx9ahdnpcn5sz70r-rust-analyzer-preview-1.97.1-x86_64-unknown-linux-gnu/bin/rust-analyzer
+     /nix/store/lr3m97p3hx1k22a7c44pb0wa7rbayhfi-rust-analyzer-preview-1.97.1-x86_64-unknown-linux-gnu/bin/rust-analyzer
  ✅ rust-nightly
-     rustc 1.101.0-nightly (282215592 2026-10-04)
-     /nix/store/qwyzkvba3f9569wjj45b4iyb7nz7qbnr-rust-nightly/bin/rust-nightly
+     rustc 1.99.0-nightly (87e5904f5 2026-07-20)
+     /nix/store/j7kf7a5h4xypzp6x1skg4dsdx2k4fwb3-rust-nightly/bin/rust-nightly
  ✅ rustc
     rustc 1.97.1 (8bab26f4f 2026-07-14)
-     /nix/store/kk0kqdc4f7am21yp30rr8jcrnib5xqzy-rust-minimal-1.97.1/bin/rustc
+     /nix/store/40d3mzka7r1ps71l0yv2fs6616nbw85m-rust-minimal-1.97.1/bin/rustc
  ✅ rustfmt
     rustfmt 1.9.0-stable (8bab26f4f6 2026-07-14)
-     /nix/store/y5gf8a3hix7pnwzdwcfpf3acqhzv3xy6-rustfmt-preview-1.97.1-x86_64-unknown-linux-gnu/bin/rustfmt
+     /nix/store/6f1icmb2za20kxn30pgmbv5jq9fnbf4z-rustfmt-preview-1.97.1-x86_64-unknown-linux-gnu/bin/rustfmt

 GCC toolchain:
  ✅ gcc
-     gcc (GCC) 15.3.0
-     /nix/store/bslmkbaiymxxdc6lwcdb1qyw745nds5j-gcc-wrapper-15.3.0/bin/gcc
+     gcc (GCC) 15.2.0
+     /nix/store/3dd6y3pq00i3r85l45jvz63wjya403nl-gcc-wrapper-15.2.0/bin/gcc
  ✅ gcc-15
-     gcc (GCC) 15.3.0
-     /nix/store/h6f2qc8kgwf7r81gwb10csvpjqfc2404-gcc-15/bin/gcc-15
+     gcc (GCC) 15.2.0
+     /nix/store/d6iri2s6bzqq5ac3fg25j6hgnn1lz44f-gcc-15/bin/gcc-15
  ✅ g++
-     g++ (GCC) 15.3.0
-     /nix/store/bslmkbaiymxxdc6lwcdb1qyw745nds5j-gcc-wrapper-15.3.0/bin/g++
+     g++ (GCC) 15.2.0
+     /nix/store/3dd6y3pq00i3r85l45jvz63wjya403nl-gcc-wrapper-15.2.0/bin/g++
  ✅ g++-15
-     g++ (GCC) 15.3.0
-     /nix/store/jwncv76v61ld9l99v0b1dkmf810if65s-g++-15/bin/g++-15
+     g++ (GCC) 15.2.0
+     /nix/store/gm3msmmxq055lm9gprkfjj9d2gdz1mpg-g++-15/bin/g++-15
  ✅ cpp
-     cpp (GCC) 15.3.0
-     /nix/store/bslmkbaiymxxdc6lwcdb1qyw745nds5j-gcc-wrapper-15.3.0/bin/cpp
+     cpp (GCC) 15.2.0
+     /nix/store/3dd6y3pq00i3r85l45jvz63wjya403nl-gcc-wrapper-15.2.0/bin/cpp
  ✅ cpp-15
-     cpp (GCC) 15.3.0
-     /nix/store/jmi558xj8v7lz2fm6wrradh40dp48zx9-cpp-15/bin/cpp-15
+     cpp (GCC) 15.2.0
+     /nix/store/bn3gmn0m7g4gn2i0yml46fljc7mghiq5-cpp-15/bin/cpp-15
  ✅ gcov
-     gcov (GCC) 15.3.0
-     /nix/store/n2ab7kf7mm84hna35x463mizcy52pf1h-gcc-15.3.0/bin/gcov
+     gcov (GCC) 15.2.0
+     /nix/store/xvv5sm5i8x0ks6ypfkzl7c4j9srnxz7k-gcc-15.2.0/bin/gcov

 Mold:
  ✅ mold
-     mold 2.42.1 (compatible with GNU ld)
-     /nix/store/9dcddrfxlfl9n3wfibi5jkmp22bjkvkh-mold-unwrapped-wrapper-2.42.1/bin/mold
+     mold 2.41.0 (compatible with GNU ld)
+     /nix/store/2w6fpgxjzzyqmd25wzplm23dfa49a0p2-mold-unwrapped-wrapper-2.41.0/bin/mold

 Skipping git-over-HTTPS check (CHECK_TOOLS_SKIP_CLONE is set).

@@ -2,172 +2,172 @@ Detected OS: linux (Linux aarch64)

 Core build tools:
  ✅ cmake
-     cmake version 4.4.3
-     /nix/store/39cq2g3d3flq2lmb6hc09grxs4xaax8p-cmake-4.4.3/bin/cmake
+     cmake version 4.1.2
+     /nix/store/nkcpxjifkambzlrwh27a8igvhnbchibg-cmake-4.1.2/bin/cmake
  ✅ conan
-     Conan version 2.32.0
-     /nix/store/vbr044x1zbq062kkw53zm0sm3slv8g56-conan-2.32.0/bin/conan
+     Conan version 2.28.1
+     /nix/store/8i2gyqgc00xvxg9xm6y7n0ilncdv8imw-conan-2.28.1/bin/conan
  ✅ git
-     git version 2.55.0
-     /nix/store/kj6aff4gmz3snpp35rl3gysbl9srd81a-git-2.55.0/bin/git
+     git version 2.54.0
+     /nix/store/ixp98f9avf8ikpdrmp40cj33g0dazyp9-git-2.54.0/bin/git
  ✅ python3
-     Python 3.14.7
-     /nix/store/81ag9nxz1flw3xjkv1vvqg8y2ipx2ins-python3-3.14.7/bin/python3.14
+     Python 3.13.13
+     /nix/store/lqn6mbgzzdrqq2qkwddcmxj9z6amdd86-python3-3.13.13/bin/python3.13

 Development tooling:
  ✅ ccache
     ccache version 4.13.6
-     /nix/store/nzb1lir9sw06fn4635kfx055myqanaz8-ccache-4.13.6/bin/ccache
+     /nix/store/2q39xi2kbi04ibga7635f2sl148d1mzv-ccache-4.13.6/bin/ccache
  ✅ clang
-     clang version 22.1.8
-     /nix/store/7z7by1cxa52mk7hjia1pimjvsd6aizhf-clang-wrapper-22.1.8/bin/clang
+     clang version 22.1.7
+     /nix/store/xjqffrq9i7la058s9865ig71l9sp1ys5-clang-wrapper-22.1.7/bin/clang
  ✅ clang-22
-     clang version 22.1.8
-     /nix/store/pqn36q5paasw7v8sjgz5fd90mfpgkkqr-clang-22/bin/clang-22
+     clang version 22.1.7
+     /nix/store/vcf6ilfwn57828hwzyp6zlyr24j9j6yw-clang-22/bin/clang-22
  ✅ clang++
-     clang version 22.1.8
-     /nix/store/7z7by1cxa52mk7hjia1pimjvsd6aizhf-clang-wrapper-22.1.8/bin/clang++
+     clang version 22.1.7
+     /nix/store/xjqffrq9i7la058s9865ig71l9sp1ys5-clang-wrapper-22.1.7/bin/clang++
  ✅ clang++-22
-     clang version 22.1.8
-     /nix/store/m9a3slb0lcixm2csgjz9s0nvj9m5ysnq-clang++-22/bin/clang++-22
+     clang version 22.1.7
+     /nix/store/xby0f6gamr7m27zp5cndsvghbp9lgb3c-clang++-22/bin/clang++-22
  ✅ ClangBuildAnalyzer
     ClangBuildAnalyzer 1.6.0
-     /nix/store/ml2991pbdhh0qcxqj9331lhpsg449vky-clangbuildanalyzer-1.6.0/bin/ClangBuildAnalyzer
+     /nix/store/h893hd4q1bb6ily2lby5dzyfrrzd2nvj-clangbuildanalyzer-1.6.0/bin/ClangBuildAnalyzer
  ✅ curl
-     curl 8.22.0 (aarch64-unknown-linux-gnu) libcurl/8.22.0 OpenSSL/3.5.8 zlib/1.3.2 libssh2/1.11.1 nghttp2/1.70.0 mit-krb5/1.22.2
-     /nix/store/94c2x2bl3xb7mx43sg1bs1hd7pnw83ac-curl-8.22.0-bin/bin/curl
+     curl 8.20.0 (aarch64-unknown-linux-gnu) libcurl/8.20.0 OpenSSL/3.6.2 zlib/1.3.2 libssh2/1.11.1 nghttp2/1.69.0 mit-krb5/1.22.1
+     /nix/store/i1s0lqwlrmjd2dxzgy2p84cxqqsb0bmk-curl-8.20.0-bin/bin/curl
  ✅ file
-     file-5.48
-     /nix/store/66sd1x1hls0yijibn00iz08jh4fnas9z-file-5.48/bin/file
+     file-5.47
+     /nix/store/dx973zg9km2w9albsib2vw9wyvacfrlw-file-5.47/bin/file
  ✅ less
-     less 710 (PCRE2 regular expressions)
-     /nix/store/n6z9dv3yjlgvfx1nmrx6qzyv8vzim1l2-less-710/bin/less
+     less 692 (PCRE2 regular expressions)
+     /nix/store/1blb3s7hhsr77wqi598m6k1qkfp3ms0w-less-692/bin/less
  ✅ make
     GNU Make 4.4.1
-     /nix/store/q07jxvck60qgrg4p1ywypddh5zz6i9s2-gnumake-4.4.1/bin/make
+     /nix/store/9ngw1ippk25jjj5fjxv36xbp6iq7rxdx-gnumake-4.4.1/bin/make
  ✅ netstat
     net-tools 2.10
-     /nix/store/rfmhd3f8drg3wqyr2mhyrlkd7vyp2pxv-net-tools-2.10/bin/netstat
+     /nix/store/7vdsz21f0s499s5yyqzp5s4676q4yxdd-net-tools-2.10/bin/netstat
  ✅ ninja
     1.13.2
-     /nix/store/lfkdyggn1ffslfd830l35jrvapr5lzri-ninja-1.13.2/bin/ninja
+     /nix/store/8ksx98gsbn5lmlizcmw57yd4sg0k2p58-ninja-1.13.2/bin/ninja
  ✅ perl
-     v5.42.3
-     /nix/store/nyp5q4d2cb0pghi4i7nscb97bqkb6kp3-perl-5.42.3/bin/perl
+     v5.42.0
+     /nix/store/5wnly69vv1i3y97al4v3xrqymf9hlzgq-perl-5.42.0/bin/perl
  ✅ pkg-config
     0.29.2
-     /nix/store/h82n3d0wdrgskdc3yvmz5l3c50h2snvp-pkg-config-wrapper-0.29.2/bin/pkg-config
+     /nix/store/c7vwy0gl1q0agl2h22gi0m9dg7xxad2l-pkg-config-wrapper-0.29.2/bin/pkg-config
  ✅ vim
     VIM - Vi IMproved 9.2 (2026 Feb 14, compiled Jan 01 1980 00:00:00)
-     /nix/store/h39h0qq4i80sp3yd7sxjn2wf497v5rln-vim-9.2.1001/bin/vim
+     /nix/store/v8c7pvx26irvy9k5sbwd183cyvckzzb3-vim-9.2.0389/bin/vim
  ✅ zip
     Zip 3.0
-     /nix/store/lfwhq17wfcmjy823fldhlhxj1hjchdzc-zip-3.0/bin/zip
+     /nix/store/5mh19mvbv9ym2sm9vymyyaac5l2cj2jq-zip-3.0/bin/zip
  ✅ clang-apply-replacements
-     clang-apply-replacements version 22.1.8
-     /nix/store/iv4dxwnzvl0lqj8jfyibwf5ijb8hjw2i-clang-tools-22.1.8/bin/clang-apply-replacements
+     clang-apply-replacements version 22.1.7
+     /nix/store/s53p2m776iqaz7acgr5csgpsd18w15h7-clang-tools-22.1.7/bin/clang-apply-replacements
  ✅ clang-apply-replacements-22
-     clang-apply-replacements version 22.1.8
-     /nix/store/7gq05wr155k0pm1b2k73pya3l35hgifl-clang-apply-replacements-22/bin/clang-apply-replacements-22
+     clang-apply-replacements version 22.1.7
+     /nix/store/bg4kn8z81hk7b9284rjqvr51wpfjqc24-clang-apply-replacements-22/bin/clang-apply-replacements-22
  ✅ clang-format
-     clang-format version 22.1.8
-     /nix/store/iv4dxwnzvl0lqj8jfyibwf5ijb8hjw2i-clang-tools-22.1.8/bin/clang-format
+     clang-format version 22.1.7
+     /nix/store/s53p2m776iqaz7acgr5csgpsd18w15h7-clang-tools-22.1.7/bin/clang-format
  ✅ clang-format-22
-     clang-format version 22.1.8
-     /nix/store/54pnici9imw8ff0j5m7nig7dwaxrnlhv-clang-format-22/bin/clang-format-22
+     clang-format version 22.1.7
+     /nix/store/79v57mzcw8ng8kl7p961ck08ymhp31v7-clang-format-22/bin/clang-format-22
  ✅ clang-tidy
-     LLVM version 22.1.8
-     /nix/store/iv4dxwnzvl0lqj8jfyibwf5ijb8hjw2i-clang-tools-22.1.8/bin/clang-tidy
+     LLVM version 22.1.7
+     /nix/store/s53p2m776iqaz7acgr5csgpsd18w15h7-clang-tools-22.1.7/bin/clang-tidy
  ✅ clang-tidy-22
-     LLVM version 22.1.8
-     /nix/store/0mmdxscn11irlmm7jvp1c0a32712s026-clang-tidy-22/bin/clang-tidy-22
+     LLVM version 22.1.7
+     /nix/store/wdyd6cb9z1lyi37lbzvwldgcc7yv1n5c-clang-tidy-22/bin/clang-tidy-22
  ✅ dot
-     dot - graphviz version 15.1.1 (0)
-     /nix/store/vz4zb8d1rfigzzdn3i0hd4kff28vk02l-graphviz-15.1.1/bin/dot
+     dot - graphviz version 12.2.1 (0)
+     /nix/store/58rrk4yzwpmyxvl8cqm18h3dhv24zf00-graphviz-12.2.1/bin/dot
  ✅ doxygen
-     1.17.0
-     /nix/store/6q4z332wc9jnvad71wjj87lgjxidhgzl-doxygen-1.17.0/bin/doxygen
+     1.16.1
+     /nix/store/hq32kzwpl89wgr49iq0gmqn9r5n072zq-doxygen-1.16.1/bin/doxygen
  ✅ gcovr
     gcovr 8.4
-     /nix/store/v548fjz51k2nmr257vjnd0zp3bxpc2r1-python3.14-gcovr-8.4/bin/gcovr
+     /nix/store/sml3xbbfhhlhk6h7jnlg19pdbx9b764b-python3.13-gcovr-8.4/bin/gcovr
  ✅ gh
-     gh version 2.102.0 (2026-09-30)
-     /nix/store/vgg6gnq74h76b4r2ac2q9366f2s5qxwx-gh-2.102.0/bin/gh
+     gh version 2.94.0 (nixpkgs)
+     /nix/store/7hh2qi0gj2ifbxbl56cjzbiyfc379bji-gh-2.94.0/bin/gh
  ✅ git-cliff
-     git-cliff 2.14.2
-     /nix/store/hrlgliq7l3fl2qrdlc197mvscs4n03rd-git-cliff-2.14.2/bin/git-cliff
+     git-cliff 2.13.1
+     /nix/store/bidn3pz53yd6qlg711917xx0q10hqmqv-git-cliff-2.13.1/bin/git-cliff
  ✅ git-lfs
-     git-lfs/3.8.0 (3.8.0; linux arm64; go 1.26.8)
-     /nix/store/pa2g4xdvr4a73m6mv4cqs0pik1ka1xp5-git-lfs-3.8.0/bin/git-lfs
+     git-lfs/3.7.1 (3.7.1; linux arm64; go 1.26.3)
+     /nix/store/4rsklvkbac5bayy0zv12kxyvspi4sshd-git-lfs-3.7.1/bin/git-lfs
  ✅ gpg
     gpg (GnuPG) 2.4.9
-     /nix/store/3qc90b7qkxz7na3xnpd2qb8yvcq8zdp6-gnupg-2.4.9/bin/gpg
+     /nix/store/ka4i8zz5ni3rzqnzcxbfvwr95fk8pn6q-gnupg-2.4.9/bin/gpg
  ✅ pre-commit
-     pre-commit 4.6.2
-     /nix/store/5f3av75nc7n7xbf2hlvlagzpp2g8g562-pre-commit-4.6.2/bin/pre-commit
+     pre-commit 4.5.1
+     /nix/store/n981w6hjfar2l81kxbxs2wxl64vwa5kj-pre-commit-4.5.1/bin/pre-commit
  ✅ run-clang-tidy
     usage: run-clang-tidy [-h] [-allow-enabling-alpha-checkers]
-     /nix/store/b1yccjmij9qiha8a8d9yxayjdh5cg2vq-run-clang-tidy/bin/run-clang-tidy
+     /nix/store/4z2fyklg78klallr7x9j02kz92hnxp4m-run-clang-tidy/bin/run-clang-tidy
  ✅ run-clang-tidy-22
     usage: run-clang-tidy [-h] [-allow-enabling-alpha-checkers]
-     /nix/store/v75dyrp7vwdgx5w2fzwsy00lf94qpz0i-run-clang-tidy-22/bin/run-clang-tidy-22
+     /nix/store/f8m0p9ad40brp9ahy4i0h27kqjkya1j9-run-clang-tidy-22/bin/run-clang-tidy-22

 Rust toolchain:
  ✅ cargo
     cargo 1.97.1 (c980f4866 2026-06-30)
-     /nix/store/nci0zxxj2fiq0dlkpqzbnqfh27wz4sq4-cargo-1.97.1-aarch64-unknown-linux-gnu/bin/cargo
+     /nix/store/6hch2qrr86n2sa2m90lrpxrfxxwbkayl-cargo-1.97.1-aarch64-unknown-linux-gnu/bin/cargo
  ✅ cargo-audit
-     cargo-audit-audit 0.22.2
-     /nix/store/zldaj03mfz9f21yiby5yymq7v8vqygd7-cargo-audit-0.22.2/bin/cargo-audit
+     cargo-audit-audit 0.22.1
+     /nix/store/9rxbrn9aa2r1z96186s69pc7vzizyfch-cargo-audit-0.22.1/bin/cargo-audit
  ✅ cargo-llvm-cov
-     cargo-llvm-cov 0.9.0
-     /nix/store/iwpcfjah31fgn99ph32ajzz7i22j6al5-cargo-llvm-cov-0.9.0/bin/cargo-llvm-cov
+     cargo-llvm-cov 0.8.5
+     /nix/store/vwjsi159n89szrx4yh5pc3jlf2gp4fld-cargo-llvm-cov-0.8.5/bin/cargo-llvm-cov
  ✅ cargo-nextest
-     cargo-nextest 0.9.146
-     /nix/store/p5svqr8x1rr7b1i8595pr8qafsr7s6fm-cargo-nextest-0.9.146/bin/cargo-nextest
+     cargo-nextest 0.9.137
+     /nix/store/qb6bcg2fjvm3r9s9j98nmffmf9xwh45s-cargo-nextest-0.9.137/bin/cargo-nextest
  ✅ clippy-driver
     clippy 0.1.97 (8bab26f4f6 2026-07-14)
-     /nix/store/ny64zks16ms5d70jk1qsiwsk0fr33ipp-rust-minimal-1.97.1/bin/clippy-driver
+     /nix/store/a6p27cg6b8szfixfyvkssx6l0c345zw8-rust-minimal-1.97.1/bin/clippy-driver
  ✅ rust-analyzer
     rust-analyzer 1.97.1 (8bab26f 2026-07-14)
-     /nix/store/d9s5skhvi1qxj940mylwym2rjicnc2kq-rust-analyzer-preview-1.97.1-aarch64-unknown-linux-gnu/bin/rust-analyzer
+     /nix/store/262830dlw2517lnagfx7i7agqgl4fmsd-rust-analyzer-preview-1.97.1-aarch64-unknown-linux-gnu/bin/rust-analyzer
  ✅ rust-nightly
-     rustc 1.101.0-nightly (282215592 2026-10-04)
-     /nix/store/rbsf1gr6f9ikv2izlyh8im117w6hs7h5-rust-nightly/bin/rust-nightly
+     rustc 1.99.0-nightly (87e5904f5 2026-07-20)
+     /nix/store/c59pxk1yikdlf129qwyg4fplmxcrha0k-rust-nightly/bin/rust-nightly
  ✅ rustc
     rustc 1.97.1 (8bab26f4f 2026-07-14)
-     /nix/store/ny64zks16ms5d70jk1qsiwsk0fr33ipp-rust-minimal-1.97.1/bin/rustc
+     /nix/store/a6p27cg6b8szfixfyvkssx6l0c345zw8-rust-minimal-1.97.1/bin/rustc
  ✅ rustfmt
     rustfmt 1.9.0-stable (8bab26f4f6 2026-07-14)
-     /nix/store/dplvgjikmv8909rk0dkqr90ryjg7xn0j-rustfmt-preview-1.97.1-aarch64-unknown-linux-gnu/bin/rustfmt
+     /nix/store/nd8g81wv1smnvdpy4whpcyv2siwjmaan-rustfmt-preview-1.97.1-aarch64-unknown-linux-gnu/bin/rustfmt

 GCC toolchain:
  ✅ gcc
-     gcc (GCC) 15.3.0
-     /nix/store/g7z555pl99vnwif4jxa05nk1qdc33i1n-gcc-wrapper-15.3.0/bin/gcc
+     gcc (GCC) 15.2.0
+     /nix/store/rn6svg593xsmn8qcjzk8x9pa1i62c4kb-gcc-wrapper-15.2.0/bin/gcc
  ✅ gcc-15
-     gcc (GCC) 15.3.0
-     /nix/store/vbdsfjk3j1xy5z329sl2d8vp6mq6x09i-gcc-15/bin/gcc-15
+     gcc (GCC) 15.2.0
+     /nix/store/h489d1rmjisfbxh5kmsb0a7c35j8qsdf-gcc-15/bin/gcc-15
  ✅ g++
-     g++ (GCC) 15.3.0
-     /nix/store/g7z555pl99vnwif4jxa05nk1qdc33i1n-gcc-wrapper-15.3.0/bin/g++
+     g++ (GCC) 15.2.0
+     /nix/store/rn6svg593xsmn8qcjzk8x9pa1i62c4kb-gcc-wrapper-15.2.0/bin/g++
  ✅ g++-15
-     g++ (GCC) 15.3.0
-     /nix/store/9ghl998ry4cxlsg6hnq5rn2iipnlkccm-g++-15/bin/g++-15
+     g++ (GCC) 15.2.0
+     /nix/store/9ywmhz8bmzknrn3pn84g46z8hj3vrmw5-g++-15/bin/g++-15
  ✅ cpp
-     cpp (GCC) 15.3.0
-     /nix/store/g7z555pl99vnwif4jxa05nk1qdc33i1n-gcc-wrapper-15.3.0/bin/cpp
+     cpp (GCC) 15.2.0
+     /nix/store/rn6svg593xsmn8qcjzk8x9pa1i62c4kb-gcc-wrapper-15.2.0/bin/cpp
  ✅ cpp-15
-     cpp (GCC) 15.3.0
-     /nix/store/wj0mv2fv2lhglvpjzhscqpbigkvik6br-cpp-15/bin/cpp-15
+     cpp (GCC) 15.2.0
+     /nix/store/vmjilh1b830qz9yh0a1jj5ads0jxizdk-cpp-15/bin/cpp-15
  ✅ gcov
-     gcov (GCC) 15.3.0
-     /nix/store/mszfsj00qnv9ygqcqz3w02qzxxskhvlb-gcc-15.3.0/bin/gcov
+     gcov (GCC) 15.2.0
+     /nix/store/rmwf5hpi1y2m1wpnfvlxmrhksm4djk2j-gcc-15.2.0/bin/gcov

 Mold:
  ✅ mold
-     mold 2.42.1 (compatible with GNU ld)
-     /nix/store/gbq334xbibaz4gn184j7gs58m2spgwi7-mold-unwrapped-wrapper-2.42.1/bin/mold
+     mold 2.41.0 (compatible with GNU ld)
+     /nix/store/f5qh5a0bx1dslmnf5n5gx0s6aljbswq3-mold-unwrapped-wrapper-2.41.0/bin/mold

 Skipping git-over-HTTPS check (CHECK_TOOLS_SKIP_CLONE is set).

@@ -1,39 +0,0 @@
-#include <xrpl/basics/CountedObject.h>
-
-#include <algorithm>
-
-namespace xrpl {
-
-CountedObjects&
-CountedObjects::getInstance() noexcept
-{
-    static CountedObjects kInstance;
-
-    return kInstance;
-}
-
-CountedObjects::CountedObjects() noexcept : count_(0), head_(nullptr)
-{
-}
-
-CountedObjects::List
-CountedObjects::getCounts(int minimumThreshold) const
-{
-    List counts;
-
-    // When other operations are concurrent, the count
-    // might be temporarily less than the actual count.
-    counts.reserve(count_.load());
-
-    for (auto* ctr = head_.load(); ctr != nullptr; ctr = ctr->getNext())
-    {
-        if (ctr->getCount() >= minimumThreshold)
-            counts.emplace_back(ctr->getName(), ctr->getCount());
-    }
-
-    std::ranges::sort(counts);
-
-    return counts;
-}
-
-}  // namespace xrpl
@@ -317,8 +317,8 @@ public:
            }
            else
            {
-                status = static_cast<Status>(
-                    static_cast<int>(Status::CustomCode) + unsafeCast<int>(getStatus.code()));
+                status = checkedCast<Status>(
+                    safeCast<int>(Status::CustomCode) + safeCast<int>(getStatus.code()));

                JLOG(journal.error()) << getStatus.ToString();
            }
@@ -8,6 +8,8 @@
 #include <xrpl/protocol/digest.h>
 #include <xrpl/protocol/tokens.h>

+#include <algorithm>
+#include <array>
 #include <atomic>
 #include <cstdint>
 #include <cstring>
@@ -19,85 +21,136 @@

 namespace xrpl {

-namespace detail {
+namespace {

-/**
- * Caches the base58 representations of AccountIDs
+/** If true, we implement a cache for account ID lookups.
+
+    This is generally a good idea and can improve performance, especially
+    when serving client requests.
+
+    The cache may generate warnings under some sanitizers; if you want to
+    disable caching, set this variable to false.
 */
-class AccountIdCache
+constexpr bool cacheAccountIDs = true;
+
+/** Represents a cached entry for the given AccountID.
+
+    We keep the size and alignment of the structure at 64 bytes to
+    make sure it fits within a cache line and avoid false sharing.
+ */
+struct alignas(64) CachedAccountID
 {
-private:
-    struct CachedAccountID
-    {
-        AccountID id;
-        char encoding[40] = {0};
-    };
+    /** The sequence lock for the entry.

-    // The actual cache
-    std::vector<CachedAccountID> cache_;
+        An even value means that the data is stable, whereas an odd
+        value indicates the data is being actively modified.

-    // We use a hash function designed to resist algorithmic complexity attacks
-    HardenedHash<> hasher_;
+        We use a 32-bit value to ensure that the counter will never
+        return to an observed value during a read window.
+     */
+    std::atomic<std::uint32_t> seq{0};

-    // 64 spinlocks, packed into a single 64-bit value
-    std::atomic<std::uint64_t> locks_ = 0;
+    /** The account id. */
+    AccountID id{};

-public:
-    AccountIdCache(std::size_t count) : cache_(count)
-    {
-        // This is non-binding, but we try to avoid wasting memory that
-        // is caused by overallocation.
-        cache_.shrink_to_fit();
-    }
+    /** The length of the cached encoding.

-    std::string
-    toBase58(AccountID const& id)
-    {
-        auto const index = hasher_(id) % cache_.size();
+        This field disambiguates collisions between ACCOUNT_ZERO and
+        never-written-to slots, since they would otherwise share the
+        same encoded bits.
+     */
+    std::uint8_t len = 0;

-        PackedSpinlock sl(locks_, index % 64);
-
-        {
-            std::scoped_lock const lock(sl);
-
-            // The check against the first character of the encoding ensures
-            // that we don't mishandle the case of the all-zero account:
-            if (cache_[index].encoding[0] != 0 && cache_[index].id == id)
-                return cache_[index].encoding;
-        }
-
-        auto ret = encodeBase58Token(TokenType::AccountID, id.data(), id.size());
-
-        XRPL_ASSERT(ret.size() <= 38, "xrpl::detail::AccountIdCache : maximum result size");
-
-        {
-            std::scoped_lock const lock(sl);
-            cache_[index].id = id;
-            std::strcpy(cache_[index].encoding, ret.c_str());
-        }
-
-        return ret;
-    }
+    /** The actual string encoding. */
+    char encoding[39] = {0};
 };

-}  // namespace detail
+static_assert(sizeof(CachedAccountID) == 64 && alignof(CachedAccountID) == 64);

-static std::unique_ptr<detail::AccountIdCache> gAccountIdCache;
+// The actual cache to use: a simple, direct-mapped, best-effort construct.
+//
+// We do not use a hardened hash for this because an AccountID is already
+// just cryptographically generated (i.e. uniformly distributed) bits and
+// there is no amplification, since collisions do not carry an additional
+// cost.
+//
+// The size is a "nice" power of 2 because it makes the calculation of an
+// index easier.
+constinit std::array<CachedAccountID, 65536> gAccountIdCache{};

-void
-initAccountIdCache(std::size_t count)
-{
-    if (!gAccountIdCache && count != 0)
-        gAccountIdCache = std::make_unique<detail::AccountIdCache>(count);
-}
+}  // namespace

 std::string
 toBase58(AccountID const& v)
 {
-    if (gAccountIdCache)
-        return gAccountIdCache->toBase58(v);
+    // Since the input bits are generated by a cryptographically secure
+    // hash construct, we can just pick any subset of them, no muss, no
+    // fuss.
+    auto const index = [&v]() -> std::uint16_t {
+        auto const data = v.data();

-    return encodeBase58Token(TokenType::AccountID, v.data(), v.size());
+        return static_cast<std::uint16_t>(data[0]) | (static_cast<std::uint16_t>(data[1]) << 8);
+    }();
+
+    if constexpr (cacheAccountIDs)
+    {
+        auto& slot = gAccountIdCache[index];
+
+        // This is the optimistic, store-free read path: a collision with a
+        // concurrent writer will be detected because the seq recheck fails
+        // and we fall through to the slow path.
+        //
+        // These unsynchronized reads of the slot fields are, formally, data
+        // races and, technically speaking, result in undefined behavior and
+        // a tool like TSAN might flag them. These should not have an impact
+        // on the correctness of the returned data: the sequence lock checks
+        // ensure we discard any data that was in flux.
+        if (auto const s0 = slot.seq.load(std::memory_order::acquire);
+            (s0 & 1) == 0 && slot.len != 0 && slot.id == v)
+        {
+            char buf[38];
+            auto const len = std::min<std::size_t>(slot.len, sizeof(buf));
+            std::memcpy(buf, slot.encoding, len);
+
+            // Prevents the loads above from sinking below the recheck; the
+            // acquire on s0 constrains later operations, not earlier ones.
+            std::atomic_thread_fence(std::memory_order::acquire);
+
+            // Everything read from the slot — the gates above and the bytes in
+            // buf — precedes this recheck and is validated by it. No slot access
+            // may follow it.
+            if (slot.seq.load(std::memory_order::relaxed) == s0)
+                return std::string(buf, len);
+        }
+    }
+
+    auto ret = encodeBase58Token(TokenType::AccountID, v.data(), v.size());
+
+    XRPL_ASSERT(!ret.empty() && ret.size() <= 38, "xrpl::toBase58 : maximum result size");
+
+    if constexpr (cacheAccountIDs)
+    {
+        auto& slot = gAccountIdCache[index];
+
+        // The CAS to an odd value excludes other writers; if it fails, another
+        // thread wrote or is writing into this slot. That is not a problem: we
+        // just don't store our result into the cache this time.
+        if (auto s0 = slot.seq.load(std::memory_order::relaxed); (s0 & 1) == 0 &&
+            slot.seq.compare_exchange_strong(s0, s0 + 1, std::memory_order::acquire))
+        {
+            slot.id = v;
+            slot.len = static_cast<std::uint8_t>(ret.size());
+            std::copy_n(ret.data(), ret.size(), slot.encoding);
+
+            // The acquire on the CAS above keeps the writes from becoming visible
+            // before the seqlock transitions to an odd value, which means readers
+            // can detect an in-progress write. This release publishes them before
+            // the seqlock transitions to an even value.
+            slot.seq.store(s0 + 2, std::memory_order::release);
+        }
+    }
+
+    return ret;
 }

 template <>
@@ -5,6 +5,7 @@
 #include <xrpl/basics/UnorderedContainers.h>
 #include <xrpl/basics/base_uint.h>
 #include <xrpl/basics/contract.h>
+#include <xrpl/basics/safe_cast.h>
 #include <xrpl/beast/hash/uhash.h>
 #include <xrpl/beast/utility/instrumentation.h>
 #include <xrpl/json/json_value.h>
@@ -17,9 +18,13 @@
 #include <xrpl/protocol/jss.h>

 #include <algorithm>
+#include <concepts>
 #include <cstddef>
+#include <cstdint>
 #include <memory>
+#include <optional>
 #include <stdexcept>
+#include <type_traits>
 #include <utility>
 #include <vector>

@@ -36,10 +41,10 @@ STPathElement::getHash(STPathElement const& element)
    //            important. We don't even really need to fully hash the whole
    //            base_uint here, as a few bytes would do for our use.
    //
-    // The note above is only true because the result of this function reaches
-    // nothing but STPathElement::operator==, where it is a fast-reject
-    // prefilter ahead of the field comparisons that decide the answer.  Do not
-    // use it to key a container.
+    // The note above is only true because the result of this function is only
+    // used by the STPathElement equality operator as a fast-reject prefilter,
+    // ahead of the field comparisons that then decide the answer. Do not use
+    // it to key a container.

    for (auto const x : element.getAccountID())
        hashAccount += (hashAccount * 257) ^ x;
@@ -106,12 +111,38 @@ STPathSet::operator=(STPathSet const& other)

 STPathSet::STPathSet(SerialIter& sit, SField const& name) : STBase(name)
 {
-    std::vector<STPathElement> path;
-    for (;;)
-    {
-        int const iType = sit.get8();
+    using enum STPathElement::Type;

-        if (iType == STPathElement::TypeNone || iType == STPathElement::TypeBoundary)
+    auto parsePathElementType = [](std::underlying_type_t<STPathElement::Type> byte) noexcept
+        -> std::optional<STPathElement::Type> {
+        if (byte == std::to_underlying(TypeBoundary))
+            return TypeBoundary;
+
+        constexpr auto knownBits = static_cast<std::underlying_type_t<STPathElement::Type>>(
+            std::to_underlying(TypeAccount) | std::to_underlying(TypeCurrency) |
+            std::to_underlying(TypeIssuer) | std::to_underlying(TypeMpt));
+
+        if ((byte & ~knownBits) != 0)
+            return std::nullopt;
+
+        return static_cast<STPathElement::Type>(byte);
+    };
+
+    std::vector<STPathElement> path;
+
+    std::optional<STPathElement::Type> type;
+
+    do
+    {
+        type = parsePathElementType(sit.get8());
+
+        if (!type)
+        {
+            JLOG(debugLog().error()) << "Bad path element in pathset";
+            Throw<std::runtime_error>("bad path element");
+        }
+
+        if (type == TypeNone || type == TypeBoundary)
        {
            if (path.empty())
            {
@@ -122,28 +153,11 @@ STPathSet::STPathSet(SerialIter& sit, SField const& name) : STBase(name)
            // Move rather than converting the vector to an STPath by copy.
            value_.emplace_back(std::move(path));
            path.clear();
-
-            if (iType == STPathElement::TypeNone)
-                return;
-        }
-        else if ((iType & ~STPathElement::TypeAll) != 0)
-        {
-            JLOG(debugLog().error()) << "Bad path element " << iType << " in pathset";
-            Throw<std::runtime_error>("bad path element");
        }
        else
        {
-            auto const hasAccount = (iType & STPathElement::TypeAccount) != 0u;
-            auto const hasCurrency = (iType & STPathElement::TypeCurrency) != 0u;
-            auto const hasIssuer = (iType & STPathElement::TypeIssuer) != 0u;
-            auto const hasMPT = (iType & STPathElement::TypeMpt) != 0u;
-
-            AccountID account;
-            PathAsset asset;
-            AccountID issuer;
-
-            if (hasAccount)
-                account = sit.get160();
+            bool const hasCurrency = ((*type & TypeCurrency) == TypeCurrency);
+            bool const hasMPT = ((*type & TypeMpt) == TypeMpt);

            if (hasCurrency && hasMPT)
            {
@@ -151,18 +165,26 @@ STPathSet::STPathSet(SerialIter& sit, SField const& name) : STBase(name)
                Throw<std::runtime_error>("bad path element: MPT and Currency");
            }

+            AccountID account;
+            AccountID issuer;
+
+            if ((*type & TypeAccount) == TypeAccount)
+                account = sit.get160();
+
+            PathAsset asset;
+
            if (hasCurrency)
                asset = Currency::fromRaw(sit.get160());

            if (hasMPT)
                asset = sit.get192();

-            if (hasIssuer)
+            if ((*type & TypeIssuer) == TypeIssuer)
                issuer = sit.get160();

            path.emplace_back(account, asset, issuer, hasCurrency || hasMPT);
        }
-    }
+    } while (type != TypeNone);
 }

 STBase*
@@ -216,24 +238,22 @@ STPath::getJson(JsonOptions) const
    for (auto const& it : path_)
    {
        json::Value elem(json::ValueType::Object);
-        auto const iType = it.getNodeType();

-        elem[jss::type] = iType;
+        elem[jss::type] = safeCast<std::uint32_t>(it.getNodeType());

-        if ((iType & STPathElement::TypeAccount) != 0u)
+        if (it.isType(STPathElement::TypeAccount))
            elem[jss::account] = to_string(it.getAccountID());

        XRPL_ASSERT(
-            ((iType & STPathElement::TypeCurrency) == 0u) ||
-                ((iType & STPathElement::TypeMpt) == 0u),
+            !(it.hasCurrency() && it.hasMPT()),
            "xrpl::STPath::getJson : not type Currency and MPT");
-        if ((iType & STPathElement::TypeCurrency) != 0u)
+        if (it.hasCurrency())
            elem[jss::currency] = to_string(it.getCurrency());

-        if ((iType & STPathElement::TypeMpt) != 0u)
+        if (it.hasMPT())
            elem[jss::mpt_issuance_id] = to_string(it.getMPTID());

-        if ((iType & STPathElement::TypeIssuer) != 0u)
+        if (it.hasIssuer())
            elem[jss::issuer] = to_string(it.getIssuerID());

        ret.append(elem);
@@ -265,34 +285,42 @@ STPathSet::add(Serializer& s) const
    XRPL_ASSERT(getFName().fieldType == STI_PATHSET, "xrpl::STPathSet::add : valid field type");
    bool first = true;

+    // Workaround, since `Serializer` does not accept strongly-typed enums
+    // yet. When support is added, the static_assert will trigger, and the
+    // lambda can be removed entirely.
+    auto const toByte = [](std::same_as<STPathElement::Type> auto t) noexcept {
+        static_assert(
+            !requires(Serializer& ser) { ser.add8(t); },
+            "Serializer::add8 now accepts STPathElement::Type directly; remove toByte.");
+        return std::to_underlying(t);
+    };
+
    for (auto const& spPath : value_)
    {
        if (!first)
-            s.add8(STPathElement::TypeBoundary);
+            s.add8(toByte(STPathElement::TypeBoundary));

        for (auto const& speElement : spPath)
        {
-            int const iType = speElement.getNodeType();
+            s.add8(toByte(speElement.getNodeType()));

-            s.add8(iType);
-
-            if ((iType & STPathElement::TypeAccount) != 0u)
+            if (speElement.isType(STPathElement::TypeAccount))
                s.addBitString(speElement.getAccountID());

-            if ((iType & STPathElement::TypeMpt) != 0u)
+            if (speElement.hasMPT())
                s.addBitString(speElement.getMPTID());

-            if ((iType & STPathElement::TypeCurrency) != 0u)
+            if (speElement.hasCurrency())
                s.addBitString(speElement.getCurrency());

-            if ((iType & STPathElement::TypeIssuer) != 0u)
+            if (speElement.hasIssuer())
                s.addBitString(speElement.getIssuerID());
        }

        first = false;
    }

-    s.add8(STPathElement::TypeNone);
+    s.add8(toByte(STPathElement::TypeNone));
 }

 }  // namespace xrpl
@@ -38,7 +38,7 @@ ApplyContext::ApplyContext(
    , parentBatchId_(parentBatchId)
 {
    XRPL_ASSERT(
-        parentBatchId.has_value() == ((flags_ & TapBatch) == TapBatch),
+        parentBatchId.has_value() == ((flags_ & ApplyFlags::Batch) == ApplyFlags::Batch),
        "Parent Batch ID should be set if batch apply flag is set");
    view_.emplace(&base_, flags_);
 }
@@ -53,13 +53,14 @@ std::optional<TxMeta>
 ApplyContext::apply(TER ter)
 {
    // NOLINTNEXTLINE(bugprone-unchecked-optional-access) view_ emplaced in constructor
-    return view_->apply(base_, tx, ter, parentBatchId_, (flags_ & TapDryRun) != 0u, journal);
+    return view_->apply(
+        base_, tx, ter, parentBatchId_, (flags_ & ApplyFlags::DryRun) != ApplyFlags::None, journal);
 }

 void
 ApplyContext::addOrderBook(Book const& book)
 {
-    if ((flags_ & TapDryRun) == TapNone)
+    if ((flags_ & ApplyFlags::DryRun) == ApplyFlags::None)
        registry.get().getOrderBookDB().addOrderBook(book);
 }

@@ -134,7 +134,7 @@ preflightCheckSigningKey(STObject const& sigObject, beast::Journal j)
 std::optional<NotTEC>
 preflightCheckSimulateKeys(ApplyFlags flags, STObject const& sigObject, beast::Journal j)
 {
-    if ((flags & TapDryRun) != 0u)  // simulation
+    if ((flags & ApplyFlags::DryRun) != ApplyFlags::None)  // simulation
    {
        std::optional<Slice> const signature = sigObject[~sfTxnSignature];
        if (signature && !signature->empty())
@@ -510,7 +510,8 @@ Transactor::minimumFee(
    Fees const& fees,
    ApplyFlags flags)
 {
-    return scaleFeeLoad(baseFee, registry.getFeeTrack(), fees, (flags & TapUnlimited) != 0u);
+    return scaleFeeLoad(
+        baseFee, registry.getFeeTrack(), fees, (flags & ApplyFlags::Unlimited) != ApplyFlags::None);
 }

 TER
@@ -521,7 +522,7 @@ Transactor::checkFee(PreclaimContext const& ctx, XRPAmount baseFee)

    auto const feePaid = ctx.tx[sfFee].xrp();

-    if ((ctx.flags & TapBatch) != 0u)
+    if ((ctx.flags & ApplyFlags::Batch) != ApplyFlags::None)
    {
        if (feePaid == beast::kZero)
            return tesSUCCESS;
@@ -951,7 +952,8 @@ Transactor::checkSign(
        return tesSUCCESS;
    }

-    if (((flags & TapDryRun) != 0u) && pkSigner.empty() && !sigObject.isFieldPresent(sfSigners))
+    if (((flags & ApplyFlags::DryRun) != ApplyFlags::None) && pkSigner.empty() &&
+        !sigObject.isFieldPresent(sfSigners))
    {
        // simulate: skip signature validation when neither SigningPubKey nor
        // Signers are provided
@@ -1122,7 +1124,7 @@ Transactor::checkMultiSign(
        }

        XRPL_ASSERT(
-            (flags & TapDryRun) || !spk.empty(),
+            (flags & ApplyFlags::DryRun) != ApplyFlags::None || !spk.empty(),
            "xrpl::Transactor::checkMultiSign : non-empty signer or "
            "simulation");
        AccountID const signingAcctIDFromPubKey =
@@ -1604,7 +1606,7 @@ Transactor::operator()()
        if (ctx_.size() > kOversizeMetaDataCap)
            result = tecOVERSIZE;

-        if (isTecClaim(result) && ((view().flags() & TapFailHard) != 0u))
+        if (isTecClaim(result) && ((view().flags() & ApplyFlags::FailHard) != ApplyFlags::None))
        {
            // If the TapFailHard flag is set, a tec result
            // must not do anything
@@ -1684,7 +1686,7 @@ Transactor::operator()()
    // Once we call apply, we will no longer be able to look at view()
    metadata = ctx_.apply(result);

-    if ((ctx_.flags() & TapDryRun) != 0u)
+    if ((ctx_.flags() & ApplyFlags::DryRun) != ApplyFlags::None)
        return logger(result, false, std::move(metadata));

    return logger(result, canApply, std::move(metadata));
@@ -215,7 +215,7 @@ applyBatchTransactions(
    auto applyOneTransaction = [&registry, &j, &parentBatchId, &batchView](STTx const& tx) {
        OpenView perTxBatchView(kBatchView, batchView);

-        auto const ret = apply(registry, perTxBatchView, parentBatchId, tx, TapBatch, j);
+        auto const ret = apply(registry, perTxBatchView, parentBatchId, tx, ApplyFlags::Batch, j);
        XRPL_ASSERT(
            ret.applied == (isTesSuccess(ret.ter) || isTecClaim(ret.ter)),
            "Inner transaction should not be applied");
@@ -274,7 +274,7 @@ applyTransaction(
 {
    // Returns false if the transaction has need not be retried.
    if (retryAssured)
-        flags = flags | TapRetry;
+        flags = flags | ApplyFlags::Retry;

    JLOG(j.debug()) << "TXN " << txn.getTransactionID() << (retryAssured ? "/retry" : "/final");

@@ -346,7 +346,8 @@ preflight(
    // builds; re-check the same invariant here so a release build can't
    // silently skip a proposed transaction's signature-presence checks
    // outside of a dry run.
-    if ((flags & TapProposal) != TapNone && (flags & TapDryRun) == TapNone)
+    if ((flags & ApplyFlags::Proposal) != ApplyFlags::None &&
+        (flags & ApplyFlags::DryRun) == ApplyFlags::None)
    {
        // LCOV_EXCL_START
        JLOG(j.fatal()) << "apply (preflight): TapProposal set without TapDryRun.";
@@ -377,7 +378,8 @@ preflight(
    PreflightContext const pfCtx(registry, tx, parentBatchId, rules, flags, j);

    // See the comment in the other preflight() overload above.
-    if ((flags & TapProposal) != TapNone && (flags & TapDryRun) == TapNone)
+    if ((flags & ApplyFlags::Proposal) != ApplyFlags::None &&
+        (flags & ApplyFlags::DryRun) == ApplyFlags::None)
    {
        // LCOV_EXCL_START
        JLOG(j.fatal()) << "apply (preflight): TapProposal set without TapDryRun.";
@@ -89,24 +89,17 @@ ValidMPTIssuance::visitEntry(bool isDelete, SLE::ConstRef before, SLE::ConstRef
            if (fix320Enabled && after->isFieldPresent(sfReferenceHolding))
                referenceHoldingSetOnCreate_ = true;
        }
-        else
+        else if (fix320Enabled)
        {
-            // lsfMPTLocked is the only issuance flag with a legal clear path
-            // (tfMPTUnlock); the rest are fixed at creation or set-once.
-            issuanceFlagsCleared_ |= before->getFlags() & ~after->getFlags() & ~lsfMPTLocked;
-
-            if (fix320Enabled)
+            // Modified issuance: detect any change to sfReferenceHolding.
+            bool const beforePresent = before->isFieldPresent(sfReferenceHolding);
+            bool const afterPresent = after->isFieldPresent(sfReferenceHolding);
+            if (beforePresent != afterPresent ||
+                (afterPresent &&
+                 before->getFieldH256(sfReferenceHolding) !=
+                     after->getFieldH256(sfReferenceHolding)))
            {
-                // Modified issuance: detect any change to sfReferenceHolding.
-                bool const beforePresent = before->isFieldPresent(sfReferenceHolding);
-                bool const afterPresent = after->isFieldPresent(sfReferenceHolding);
-                if (beforePresent != afterPresent ||
-                    (afterPresent &&
-                     before->getFieldH256(sfReferenceHolding) !=
-                         after->getFieldH256(sfReferenceHolding)))
-                {
-                    referenceHoldingMutated_ = true;
-                }
+                referenceHoldingMutated_ = true;
            }
        }
    }
@@ -206,16 +199,6 @@ ValidMPTIssuance::finalize(
            return false;
    }

-    // Post-fixCleanup3_5_0: no transaction may clear an issuance flag other
-    // than lsfMPTLocked, so downstream code can trust set-once flags such as
-    // lsfMPTCanTransfer.
-    if (rules.enabled(fixCleanup3_5_0) && issuanceFlagsCleared_ != 0)
-    {
-        JLOG(j.fatal()) << "Invariant failed: immutable MPTokenIssuance flag cleared: "
-                        << issuanceFlagsCleared_;
-        return false;
-    }
-
    // Deleting an MPToken with a non-zero MPTAmount is rejected.
    if (rules.enabled(fixCleanup3_5_0))
    {
@@ -985,7 +985,7 @@ std::optional<std::variant<Quality, AMMOffer<TIn, TOut>>>
 BookStep<TIn, TOut, TDerived>::tip(ReadView const& view) const
 {
    // This can be simplified (and sped up) if directories are never empty.
-    Sandbox sb(&view, TapNone);
+    Sandbox sb(&view, ApplyFlags::None);
    BookTip bt(sb, book_);
    auto const lobQuality = bt.step(j_) ? std::optional<Quality>(bt.quality()) : std::nullopt;
    // Multi-path offer generates an offer with the quality
@@ -57,10 +57,8 @@ checkNear(IOUAmount const& expected, IOUAmount const& actual)
 static bool
 isXRPAccount(STPathElement const& pe)
 {
-    if (pe.getNodeType() != STPathElement::TypeAccount)
-        return false;
-    return isXRP(pe.getAccountID());
-};
+    return pe.getNodeType() == STPathElement::TypeAccount && isXRP(pe.getAccountID());
+}

 static std::pair<TER, std::unique_ptr<Step>>
 toStep(
@@ -71,11 +69,8 @@ toStep(
 {
    auto& j = ctx.j;

-    if (ctx.isFirst && e1->isAccount() &&
-        ((e1->getNodeType() & STPathElement::TypeCurrency) != 0u) && e1->getPathAsset().isXRP())
-    {
+    if (ctx.isFirst && e1->isAccount() && e1->hasCurrency() && e1->getPathAsset().isXRP())
        return makeXrpEndpointStep(ctx, e1->getAccountID());
-    }

    if (ctx.isLast && isXRPAccount(*e1) && e2->isAccount())
        return makeXrpEndpointStep(ctx, e2->getAccountID());
@@ -117,15 +112,9 @@ toStep(
        // LCOV_EXCL_STOP
    }

-    XRPL_ASSERT(
-        (e2->getNodeType() & STPathElement::TypeAsset) ||
-            (e2->getNodeType() & STPathElement::TypeIssuer),
-        "xrpl::toStep : currency or issuer");
-    PathAsset const outAsset =
-        ((e2->getNodeType() & STPathElement::TypeAsset) != 0u) ? e2->getPathAsset() : curAsset;
-    auto const outIssuer = ((e2->getNodeType() & STPathElement::TypeIssuer) != 0u)
-        ? e2->getIssuerID()
-        : curAsset.getIssuer();
+    XRPL_ASSERT(e2->hasAsset() || e2->hasIssuer(), "xrpl::toStep : currency or issuer");
+    PathAsset const outAsset = e2->hasAsset() ? e2->getPathAsset() : curAsset;
+    auto const outIssuer = e2->hasIssuer() ? e2->getIssuerID() : curAsset.getIssuer();

    if (isXRP(curAsset) && outAsset.isXRP())
    {
@@ -197,16 +186,15 @@ toStrand(
    for (std::size_t i = 0; i < path.size(); ++i)
    {
        auto const& pe = path[i];
-        auto const t = pe.getNodeType();

-        if (((t & ~STPathElement::TypeAll) != 0u) || (t == 0u))
+        if ((pe.getNodeType() & ~STPathElement::TypeAll) != STPathElement::TypeNone || pe.isNone())
            return {temBAD_PATH, Strand{}};

-        bool const hasAccount = (t & STPathElement::TypeAccount) != 0u;
-        bool const hasIssuer = (t & STPathElement::TypeIssuer) != 0u;
-        bool const hasCurrency = (t & STPathElement::TypeCurrency) != 0u;
-        bool const hasMPT = (t & STPathElement::TypeMpt) != 0u;
-        bool const hasAsset = (t & STPathElement::TypeAsset) != 0u;
+        bool const hasAccount = pe.isType(STPathElement::TypeAccount);
+        bool const hasIssuer = pe.hasIssuer();
+        bool const hasCurrency = pe.hasCurrency();
+        bool const hasMPT = pe.hasMPT();
+        bool const hasAsset = pe.hasAsset();

        if (hasAccount && (hasIssuer || hasCurrency))
            return {temBAD_PATH, Strand{}};
@@ -250,9 +238,7 @@ toStrand(
    }();

    // Currency or MPT
-    auto hasAsset = [](STPathElement const pe) {
-        return pe.getNodeType() & STPathElement::TypeAsset;
-    };
+    auto hasAsset = [](STPathElement const& pe) { return pe.hasAsset(); };

    std::vector<STPathElement> normPath;
    // reserve enough for the path, the implied source, destination,
@@ -187,7 +187,8 @@ AccountSet::preclaim(PreclaimContext const& ctx)
        if (!dirIsEmpty(ctx.view, keylet::ownerDir(id)))
        {
            JLOG(ctx.j.trace()) << "Retry: Owner directory not empty.";
-            return ((ctx.flags & TapRetry) != 0u) ? TER{terOWNERS} : TER{tecOWNERS};
+            return ((ctx.flags & ApplyFlags::Retry) != ApplyFlags::None) ? TER{terOWNERS}
+                                                                         : TER{tecOWNERS};
        }
    }

@@ -295,7 +295,8 @@ OfferCreate::checkAcceptAsset(
        JLOG(j.debug()) << "delay: can't receive IOUs from non-existent issuer: "
                        << to_string(asset.getIssuer());

-        return ((flags & TapRetry) != 0u) ? TER{terNO_ACCOUNT} : TER{tecNO_ISSUER};
+        return ((flags & ApplyFlags::Retry) != ApplyFlags::None) ? TER{terNO_ACCOUNT}
+                                                                 : TER{tecNO_ISSUER};
    }

    // An account cannot create a trustline to itself, so no line can exist
@@ -318,7 +319,8 @@ OfferCreate::checkAcceptAsset(
                {
                    JLOG(j.debug()) << "delay: can't receive IOUs from issuer with "
                                       "DisallowIncomingTrustline set";
-                    return ((flags & TapRetry) != 0u) ? TER{terNO_LINE} : TER{tecNO_LINE};
+                    return ((flags & ApplyFlags::Retry) != ApplyFlags::None) ? TER{terNO_LINE}
+                                                                             : TER{tecNO_LINE};
                }
            }

@@ -326,7 +328,8 @@ OfferCreate::checkAcceptAsset(
            {
                if (!trustLine)
                {
-                    return ((flags & TapRetry) != 0u) ? TER{terNO_LINE} : TER{tecNO_LINE};
+                    return ((flags & ApplyFlags::Retry) != ApplyFlags::None) ? TER{terNO_LINE}
+                                                                             : TER{tecNO_LINE};
                }

                // Entries have a canonical representation, determined by a
@@ -342,7 +345,8 @@ OfferCreate::checkAcceptAsset(
                    JLOG(j.debug()) << "delay: can't receive IOUs from "
                                       "issuer without auth.";

-                    return ((flags & TapRetry) != 0u) ? TER{terNO_AUTH} : TER{tecNO_AUTH};
+                    return ((flags & ApplyFlags::Retry) != ApplyFlags::None) ? TER{terNO_AUTH}
+                                                                             : TER{tecNO_AUTH};
                }
            }

@@ -91,7 +91,8 @@ LoanSet::preflight(PreflightContext const& ctx)
    // A proposed LoanSet is stored unsigned; its CounterpartySignature is
    // collected on-ledger afterward, so its absence here is expected, not an
    // error (On-Chain Cosigner spec §5.3.1.2).
-    if (!tx.isFlag(tfInnerBatchTxn) && !counterPartySig && (ctx.flags & TapProposal) == 0)
+    if (!tx.isFlag(tfInnerBatchTxn) && !counterPartySig &&
+        (ctx.flags & ApplyFlags::Proposal) == ApplyFlags::None)
    {
        JLOG(ctx.j.warn()) << "LoanSet transaction must have a CounterpartySignature.";
        return temBAD_SIGNER;
@@ -54,8 +54,8 @@ TransactionProposalCreate::preflight(PreflightContext const& ctx)
    try
    {
        STTx const stx{STObject{proposedTx}};
-        auto const inner =
-            xrpl::preflight(ctx.registry, ctx.rules, stx, TapDryRun | TapProposal, ctx.j);
+        auto const inner = xrpl::preflight(
+            ctx.registry, ctx.rules, stx, ApplyFlags::DryRun | ApplyFlags::Proposal, ctx.j);
        if (!isTesSuccess(inner.ter))
        {
            JLOG(ctx.j.debug()) << "TransactionProposalCreate: proposed txn "
@@ -205,7 +205,7 @@ SponsorshipTransfer::preflight(PreflightContext const& ctx)
    // is collected on-ledger afterward, so its absence here is expected, not
    // an error (On-Chain Cosigner spec §5.3.1.2).
    if (isAccountReserveSponsorship && !ctx.tx.isFieldPresent(sfSponsorSignature) &&
-        (ctx.flags & TapProposal) == 0)
+        (ctx.flags & ApplyFlags::Proposal) == ApplyFlags::None)
    {
        JLOG(ctx.j.debug()) << "preflight: account sponsorship requires sfSponsorSignature";
        return temMALFORMED;
@@ -9,7 +9,6 @@
 #include <xrpl/ledger/ReadView.h>
 #include <xrpl/ledger/helpers/SponsorHelpers.h>
 #include <xrpl/protocol/AccountID.h>
-#include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/Protocol.h>
 #include <xrpl/protocol/SField.h>
 #include <xrpl/protocol/STAccount.h>  // IWYU pragma: keep
@@ -298,13 +297,11 @@ Batch::preflight(PreflightContext const& ctx)
        }

        auto const txType = stx.getFieldU16(sfTransactionType);
-        // Pre-LendingProtocolV1_2: SAV and Lending transactions cannot be Batch inners.
-        // Post-LendingProtocolV1_2: they continue through the normal Batch checks.
-        bool const rejectedPreV12 = !ctx.rules.enabled(featureLendingProtocolV1_2) &&
-            std::ranges::any_of(
-                kDisabledTxTypes, [txType](auto const& disabled) { return txType == disabled; });
-        if (rejectedPreV12)
+        if (std::ranges::any_of(
+                kDisabledTxTypes, [txType](auto const& disabled) { return txType == disabled; }))
+        {
            return temINVALID_INNER_BATCH;
+        }

        if (!stx.isFlag(tfInnerBatchTxn))
        {
@@ -362,7 +359,8 @@ Batch::preflight(PreflightContext const& ctx)
        // TapBatch — PreflightContext with a parentBatchId requires it.
        // LoanSet already short-circuits on tfInnerBatchTxn; it is also in
        // kDisabledTxTypes, so it never reaches this call.
-        ApplyFlags const innerFlags = TapBatch | (ctx.flags & (TapProposal | TapDryRun));
+        ApplyFlags const innerFlags =
+            ApplyFlags::Batch | (ctx.flags & (ApplyFlags::Proposal | ApplyFlags::DryRun));
        if (auto const preflightResult =
                xrpl::preflight(ctx.registry, ctx.rules, parentBatchId, stx, innerFlags, ctx.j);
            !isTesSuccess(preflightResult.ter))
@@ -434,7 +432,7 @@ Batch::preflightSigValidated(PreflightContext const& ctx)
    // A proposed Batch is stored unsigned; its BatchSigners are collected
    // on-ledger afterward, so the signer-presence match belongs to submission
    // time, not proposal creation (On-Chain Cosigner spec §5.3.1.2).
-    if ((ctx.flags & TapProposal) != 0)
+    if ((ctx.flags & ApplyFlags::Proposal) != ApplyFlags::None)
        return tesSUCCESS;

    auto const parentBatchId = ctx.tx.getTransactionID();
@@ -1890,7 +1890,7 @@ private:
            auto const flowResult = [&] {
                STAmount const deliver(eth(51'000'000));
                STAmount smax(btc(61'000'000));
-                PaymentSandbox sb(env.current().get(), TapNone);
+                PaymentSandbox sb(env.current().get(), ApplyFlags::None);
                STPathSet paths;
                auto ipe = [](MPTTester const& iss) {
                    return STPathElement(
@@ -1928,7 +1928,7 @@ private:
            env.app().getOpenLedger().modify([&](OpenView& view, beast::Journal j) {
                if (flowResult.removableOffers.empty())
                    return false;
-                Sandbox sb(&view, TapNone);
+                Sandbox sb(&view, ApplyFlags::None);
                for (auto const& o : flowResult.removableOffers)
                {
                    if (auto ok = sb.peek(keylet::offer(o)))
@@ -2049,7 +2049,7 @@ private:
            auto const flowResult = [&] {
                STAmount const deliver(USD(51));
                STAmount smax(BTC(61));
-                PaymentSandbox sb(env.current().get(), TapNone);
+                PaymentSandbox sb(env.current().get(), ApplyFlags::None);
                STPathSet paths;
                auto ipe = [](Issue const& iss) {
                    return STPathElement(
@@ -2087,7 +2087,7 @@ private:
            env.app().getOpenLedger().modify([&](OpenView& view, beast::Journal j) {
                if (flowResult.removableOffers.empty())
                    return false;
-                Sandbox sb(&view, TapNone);
+                Sandbox sb(&view, ApplyFlags::None);
                for (auto const& o : flowResult.removableOffers)
                {
                    if (auto ok = sb.peek(keylet::offer(o)))
@@ -4158,7 +4158,7 @@ private:
                auto jtx = env.jt(tx, Seq(1), Fee(10));
                env.app().config().features.erase(featureMPTokensV2);
                PreflightContext const ctx(
-                    env.app(), *jtx.stx, env.current()->rules(), TapNone, env.journal);
+                    env.app(), *jtx.stx, env.current()->rules(), ApplyFlags::None, env.journal);
                auto pf = AMMBid::checkExtraFeatures(ctx);
                BEAST_EXPECT(pf == false);
                env.app().config().features.insert(featureMPTokensV2);
@@ -4170,7 +4170,7 @@ private:
                jtx.jv["Asset2"].removeMember("mpt_issuance_id");
                jtx.stx = env.ust(jtx);
                PreflightContext const ctx(
-                    env.app(), *jtx.stx, env.current()->rules(), TapNone, env.journal);
+                    env.app(), *jtx.stx, env.current()->rules(), ApplyFlags::None, env.journal);
                auto pf = AMMBid::preflight(ctx);
                BEAST_EXPECT(pf == temBAD_AMM_TOKENS);
            }
@@ -3263,7 +3263,7 @@ private:
                auto jtx = env.jt(tx, Seq(1), Fee(baseFee));
                env.app().config().features.erase(featureAMM);
                PreflightContext const pfCtx(
-                    env.app(), *jtx.stx, env.current()->rules(), TapNone, env.journal);
+                    env.app(), *jtx.stx, env.current()->rules(), ApplyFlags::None, env.journal);
                auto pf = Transactor::invokePreflight<AMMBid>(pfCtx);
                BEAST_EXPECT(pf == temDISABLED);
                env.app().config().features.insert(featureAMM);
@@ -3274,7 +3274,7 @@ private:
                jtx.jv["TxnSignature"] = "deadbeef";
                jtx.stx = env.ust(jtx);
                PreflightContext const pfCtx(
-                    env.app(), *jtx.stx, env.current()->rules(), TapNone, env.journal);
+                    env.app(), *jtx.stx, env.current()->rules(), ApplyFlags::None, env.journal);
                auto pf = Transactor::invokePreflight<AMMBid>(pfCtx);
                BEAST_EXPECT(!isTesSuccess(pf));
            }
@@ -3285,7 +3285,7 @@ private:
                jtx.jv["Asset2"].removeMember("issuer");
                jtx.stx = env.ust(jtx);
                PreflightContext const pfCtx(
-                    env.app(), *jtx.stx, env.current()->rules(), TapNone, env.journal);
+                    env.app(), *jtx.stx, env.current()->rules(), ApplyFlags::None, env.journal);
                auto pf = Transactor::invokePreflight<AMMBid>(pfCtx);
                BEAST_EXPECT(pf == temBAD_AMM_TOKENS);
            }
@@ -594,7 +594,7 @@ public:
        stx->at(sfSigningPubKey) = makeSlice(std::string("badkey"));

        env.app().getOpenLedger().modify([&](OpenView& view, beast::Journal j) {
-            auto const result = xrpl::apply(env.app(), view, *stx, TapNone, j);
+            auto const result = xrpl::apply(env.app(), view, *stx, ApplyFlags::None, j);
            BEAST_EXPECT(result.ter == temBAD_SIGNATURE);
            BEAST_EXPECT(!result.applied);
            return result.applied;
@@ -47,6 +47,7 @@
 #include <xrpl/protocol/Indexes.h>
 #include <xrpl/protocol/Issue.h>
 #include <xrpl/protocol/KeyType.h>
+#include <xrpl/protocol/LedgerFormats.h>
 #include <xrpl/protocol/MPTIssue.h>
 #include <xrpl/protocol/Protocol.h>
 #include <xrpl/protocol/SField.h>
@@ -68,6 +69,7 @@
 #include <xrpl/tx/transactors/payment/Payment.h>
 #include <xrpl/tx/transactors/system/Batch.h>

+#include <algorithm>
 #include <cstddef>
 #include <cstdint>
 #include <exception>
@@ -118,6 +120,15 @@ class Batch_test : public beast::unit_test::Suite
        return env.rpc("json", "ledger", to_string(params));
    }

+    void
+    validateInnerTxn(jtx::Env& env, std::string const& batchID, TestLedgerData const& ledgerResult)
+    {
+        json::Value const jrr = env.rpc("tx", ledgerResult.txHash)[jss::result];
+        BEAST_EXPECT(jrr[sfTransactionType.jsonName] == ledgerResult.txType);
+        BEAST_EXPECT(jrr[jss::meta][sfTransactionResult.jsonName] == ledgerResult.result);
+        BEAST_EXPECT(jrr[jss::meta][sfParentBatchID.jsonName] == batchID);
+    }
+
    void
    validateClosedLedger(jtx::Env& env, std::vector<TestLedgerData> const& ledgerResults)
    {
@@ -133,14 +144,7 @@ class Batch_test : public beast::unit_test::Suite
            BEAST_EXPECT(txn[sfTransactionType.jsonName] == ledgerResult.txType);
            BEAST_EXPECT(meta[sfTransactionResult.jsonName] == ledgerResult.result);
            if (ledgerResult.batchID)
-            {
-                jtx::batch::validateInnerTxn(
-                    env,
-                    *ledgerResult.batchID,
-                    ledgerResult.txHash,
-                    ledgerResult.txType,
-                    ledgerResult.result);
-            }
+                validateInnerTxn(env, *ledgerResult.batchID, ledgerResult);
        }
    }

@@ -432,7 +436,7 @@ class Batch_test : public beast::unit_test::Suite
        {
            auto jtx = env.jt(pay(alice, bob, XRP(1)), Txflags(tfInnerBatchTxn));
            PreflightContext const pfCtx(
-                env.app(), *jtx.stx, env.current()->rules(), TapNone, env.journal);
+                env.app(), *jtx.stx, env.current()->rules(), ApplyFlags::None, env.journal);
            auto const pf = Transactor::invokePreflight<Payment>(pfCtx);
            BEAST_EXPECT(pf == temINVALID_INNER_BATCH);
        }
@@ -447,7 +451,7 @@ class Batch_test : public beast::unit_test::Suite
                disabledEnv.app(),
                *jtx.stx,
                disabledEnv.current()->rules(),
-                TapNone,
+                ApplyFlags::None,
                disabledEnv.journal);
            auto const pf = Transactor::invokePreflight<Payment>(pfCtx);
            BEAST_EXPECT(pf == temINVALID_FLAG);
@@ -458,7 +462,12 @@ class Batch_test : public beast::unit_test::Suite
        {
            auto jtx = env.jt(pay(alice, bob, XRP(1)));
            PreflightContext const pfCtx(
-                env.app(), *jtx.stx, UInt256{1}, env.current()->rules(), TapBatch, env.journal);
+                env.app(),
+                *jtx.stx,
+                UInt256{1},
+                env.current()->rules(),
+                ApplyFlags::Batch,
+                env.journal);
            auto const pf = Transactor::invokePreflight<Payment>(pfCtx);
            BEAST_EXPECT(pf == temINVALID_INNER_BATCH);
        }
@@ -1586,7 +1595,7 @@ class Batch_test : public beast::unit_test::Suite
                batch::Sig(std::vector<Reg>(kMaxBatchSigners + 1, bob)));

            env.app().getOpenLedger().modify([&](OpenView& view, beast::Journal j) {
-                auto const result = xrpl::apply(env.app(), view, *jt.stx, TapNone, j);
+                auto const result = xrpl::apply(env.app(), view, *jt.stx, ApplyFlags::None, j);
                BEAST_EXPECT(!result.applied && result.ter == temARRAY_TOO_LARGE);
                return result.applied;
            });
@@ -3136,7 +3145,9 @@ class Batch_test : public beast::unit_test::Suite
    {
        testcase("loan");

-        bool const lendingBatchEnabled = features[featureLendingProtocolV1_2];
+        bool const lendingBatchEnabled = !std::ranges::any_of(
+            Batch::kDisabledTxTypes,
+            [](auto const& disabled) { return disabled == ttLOAN_BROKER_SET; });

        using namespace test::jtx;

@@ -3285,12 +3296,8 @@ class Batch_test : public beast::unit_test::Suite
                    batch::Sig(borrower));
            }
            env.close();
+            BEAST_EXPECT(env.le(brokerKeylet));
            BEAST_EXPECT(!env.le(loanKeylet));
-            auto const brokerSleBefore = env.le(brokerKeylet);
-            if (!BEAST_EXPECT(brokerSleBefore))
-                return;
-            auto const coverAvailableBefore = brokerSleBefore->at(sfCoverAvailable);
-            auto const coverDepositAmount = asset(100).value();
            {
                // LoanSet normally charges at least 2x base fee, but since the
                // signature check is done by the batch, it only charges the
@@ -3309,65 +3316,19 @@ class Batch_test : public beast::unit_test::Suite
                            Fee(kNone),
                            Seq(kNone)),
                        lenderSeq + 1),
-                    batch::Inner(
-                        loan_broker::coverDeposit(lender, brokerKeylet.key, coverDepositAmount),
-                        lenderSeq + 2),
+                    batch::Inner(manage(lender, loanKeylet.key, tfLoanImpair), lenderSeq + 2),
                    batch::Sig(borrower));
            }
            env.close();
-            BEAST_EXPECT(static_cast<bool>(env.le(loanKeylet)) == lendingBatchEnabled);
-            if (auto const brokerSle = env.le(brokerKeylet); BEAST_EXPECT(brokerSle))
+            BEAST_EXPECT(env.le(brokerKeylet));
+            if (auto const sleLoan = env.le(loanKeylet);
+                lendingBatchEnabled ? BEAST_EXPECT(sleLoan) : !BEAST_EXPECT(!sleLoan))
            {
-                auto const expectedCover = lendingBatchEnabled
-                    ? coverAvailableBefore + coverDepositAmount
-                    : coverAvailableBefore;
-                BEAST_EXPECT(brokerSle->at(sfCoverAvailable) == expectedCover);
+                BEAST_EXPECT(sleLoan->isFlag(lsfLoanImpaired));
            }
        }
    }

-    void
-    testLendingAmendment(FeatureBitset features)
-    {
-        testcase("lending amendment");
-
-        using namespace test::jtx;
-
-        // Before LendingProtocolV1_2 a Vault inner transaction rejects the whole batch.
-        auto const checkVaultBatch = [this](FeatureBitset amendments) {
-            bool const lendingBatchEnabled = amendments[featureLendingProtocolV1_2];
-            Env env{*this, amendments};
-
-            Account const payer{"payer"};
-            Account const lender{"lender"};
-            env.fund(XRP(100'000), payer, lender);
-            env.close();
-
-            Vault const vault{env};
-            auto [create, vaultKeylet] = vault.create({.owner = lender, .asset = xrpIssue()});
-
-            auto const payerSeq = env.seq(payer);
-            auto const lenderSeq = env.seq(lender);
-            auto const batchFee = batch::calcBatchFee(env, 1, 2);
-            submitBatch(
-                env,
-                lendingBatchEnabled ? TER{tesSUCCESS} : TER{temINVALID_INNER_BATCH},
-                batch::outer(payer, payerSeq, batchFee, tfAllOrNothing),
-                batch::Inner(create, lenderSeq),
-                batch::Inner(
-                    vault.deposit(
-                        {.depositor = lender, .id = vaultKeylet.key, .amount = XRP(1'000)}),
-                    lenderSeq + 1),
-                batch::Sig(lender));
-            env.close();
-
-            BEAST_EXPECT(static_cast<bool>(env.le(vaultKeylet)) == lendingBatchEnabled);
-        };
-
-        checkVaultBatch(features - featureLendingProtocolV1_2);
-        checkVaultBatch(features);
-    }
-
    void
    testObjectCreateSequence(FeatureBitset features)
    {
@@ -4435,7 +4396,7 @@ class Batch_test : public beast::unit_test::Suite
        BEAST_EXPECT(!passesLocalChecks(stx, reason));
        BEAST_EXPECT(reason == "Cannot submit pseudo transactions.");
        env.app().getOpenLedger().modify([&](OpenView& view, beast::Journal j) {
-            auto const result = xrpl::apply(env.app(), view, stx, TapNone, j);
+            auto const result = xrpl::apply(env.app(), view, stx, ApplyFlags::None, j);
            BEAST_EXPECT(!result.applied && result.ter == temINVALID_FLAG);
            return result.applied;
        });
@@ -5681,7 +5642,7 @@ class Batch_test : public beast::unit_test::Suite
                    obj.setFieldU32(sfFlags, tfInnerBatchTxn);
                });

-                auto const result = xrpl::apply(env.app(), view, stx, TapNone, j);
+                auto const result = xrpl::apply(env.app(), view, stx, ApplyFlags::None, j);
                // Must NOT be applied — signature was never checked
                BEAST_EXPECT(!result.applied);
                return false;
@@ -5959,7 +5920,6 @@ class Batch_test : public beast::unit_test::Suite
        testCheckAllSignatures(features);
        testAccountSet(features);
        testAccountDelete(features);
-        testLendingAmendment(features);
        testLoan(features);
        testObjectCreateSequence(features);
        testObjectCreateTicket(features);
@@ -1745,7 +1745,8 @@ class ConfidentialTransfer_test : public ConfidentialTransferTestBase
                (*sle)[sfConfidentialBalanceVersion] = wrappedFrom;
                view.rawReplace(sle);

-                auto const result = xrpl::apply(env.app(), view, *jt.stx, TapNone, env.journal);
+                auto const result =
+                    xrpl::apply(env.app(), view, *jt.stx, ApplyFlags::None, env.journal);
                BEAST_EXPECT(result.ter == tesSUCCESS);
                return result.applied;
            }));
@@ -901,8 +901,7 @@ struct Credentials_test : public beast::unit_test::Suite

            {
                testcase("deleteSLE fail, bad SLE.");
-                auto view =
-                    std::make_shared<ApplyViewImpl>(env.current().get(), ApplyFlags::TapNone);
+                auto view = std::make_shared<ApplyViewImpl>(env.current().get(), ApplyFlags::None);
                auto ter = xrpl::credentials::deleteSLE(*view, {}, env.journal);
                BEAST_EXPECT(ter == tecNO_ENTRY);
            }
@@ -1125,7 +1124,7 @@ struct Credentials_test : public beast::unit_test::Suite
        // Create an ApplyViewImpl on top of the current closed ledger
        // and corrupt it by erasing the issuer's account SLE
        auto const open = env.current();
-        ApplyViewImpl av(&*open, TapNone);
+        ApplyViewImpl av(&*open, ApplyFlags::None);

        // Erase the issuer's account to simulate ledger corruption
        auto sleIssuer = av.peek(keylet::account(issuer.id()));
@@ -18,12 +18,10 @@
 #include <test/jtx/offer.h>
 #include <test/jtx/paths.h>
 #include <test/jtx/pay.h>
-#include <test/jtx/permissioned_domains.h>
 #include <test/jtx/rate.h>
 #include <test/jtx/regkey.h>
 #include <test/jtx/sendmax.h>
 #include <test/jtx/sig.h>
-#include <test/jtx/sponsor.h>
 #include <test/jtx/ter.h>
 #include <test/jtx/trust.h>
 #include <test/jtx/txflags.h>
@@ -1037,15 +1035,6 @@ class Delegate_test : public beast::unit_test::Suite
                env(delegate::set(gw, bob, {"PaymentMint"}));
                env.close();

-                // Cross-currency sfSendMax without any flag passes the granular
-                // template and is rejected by the granular semantic check, because
-                // the sfSendMax asset (XRP) is not the same as the sfAmount asset (USD).
-                env(pay(gw, alice, usd(500)),
-                    Sendmax(XRP(1001)),
-                    delegate::As(bob),
-                    Ter(terNO_DELEGATE_PERMISSION));
-                BEAST_EXPECT(expectOffers(env, carol, 1));
-
                // bob can not send cross currency payment on behalf of the gw,
                // even with PaymentMint permission and gw being the issuer.
                env(pay(gw, alice, usd(5000)),
@@ -1074,15 +1063,6 @@ class Delegate_test : public beast::unit_test::Suite
                env(delegate::set(alice, bob, {"PaymentBurn"}));
                env.close();

-                // Cross-currency sfSendMax without any flag passes the granular
-                // template and is rejected by the granular semantic check, because
-                // the sfSendMax asset (XRP) is not the same as the sfAmount asset (USD).
-                env(pay(alice, gw, usd(500)),
-                    Sendmax(XRP(1001)),
-                    delegate::As(bob),
-                    Ter(terNO_DELEGATE_PERMISSION));
-                BEAST_EXPECT(expectOffers(env, bob, 1));
-
                // bob can not send cross currency payment on behalf of alice,
                // even with PaymentBurn permission and gw being the issuer.
                env(pay(alice, gw, usd(5000)),
@@ -1283,34 +1263,6 @@ class Delegate_test : public beast::unit_test::Suite
                Domain(UInt256{1}),
                delegate::As(bob),
                Ter(terNO_DELEGATE_PERMISSION));
-
-            // sfPaths is not in the PaymentMint or PaymentBurn template.
-            env(pay(gw, alice, usd(100)),
-                Path(~XRP),
-                delegate::As(bob),
-                Ter(terNO_DELEGATE_PERMISSION));
-            env(pay(alice, gw, usd(50)),
-                Path(~XRP),
-                delegate::As(bob),
-                Ter(terNO_DELEGATE_PERMISSION));
-
-            // Valid Payment flags that are not in the PaymentMint or PaymentBurn template.
-            for (auto const flag : {tfPartialPayment, tfNoRippleDirect, tfLimitQuality})
-            {
-                env(pay(gw, alice, usd(100)),
-                    Txflags(flag),
-                    delegate::As(bob),
-                    Ter(terNO_DELEGATE_PERMISSION));
-                env(pay(alice, gw, usd(50)),
-                    Txflags(flag),
-                    delegate::As(bob),
-                    Ter(terNO_DELEGATE_PERMISSION));
-            }
-
-            // The same payments without the extra field or flag succeed.
-            env(pay(gw, alice, usd(100)), delegate::As(bob));
-            env(pay(alice, gw, usd(50)), delegate::As(bob));
-            env.require(Balance(alice, usd(50)));
        }

        // Delegate account holds no granular permissions for the tx type:
@@ -2314,107 +2266,6 @@ class Delegate_test : public beast::unit_test::Suite
            // terNO_DELEGATE_PERMISSION. The set of permitted flags for delegation is defined in
            // permissions.macro.
        }
-
-        // Fields and flags not in permissions.macro template are not permitted for delegation.
-        {
-            Env env(*this);
-            Account const alice{"alice"};
-            Account const bob{"bob"};
-            Account const credIssuer{"credIssuer"};
-            env.fund(XRP(100000), alice, bob, credIssuer);
-            env.close();
-
-            env(pdomain::setTx(credIssuer, {{.issuer = credIssuer, .credType = "credential"}}));
-            auto const domainID = pdomain::getNewDomain(env.meta());
-            env.close();
-
-            MPTTester mpt(env, alice, {.fund = false});
-            mpt.create({.flags = tfMPTCanLock | tfMPTCanTransfer});
-            env.close();
-
-            // bob holds every granular permission defined for MPTokenIssuanceSet
-            env(delegate::set(alice, bob, {"MPTokenIssuanceLock", "MPTokenIssuanceUnlock"}));
-            env.close();
-
-            // Any of those fields or flags not defined in permissions.macro are not permitted for
-            // delegation.
-            std::vector<MPTSet> const args = {
-                {.transferFee = 100},
-                {.metadata = "test"},
-                {.domainID = domainID},
-                {.flags = tfMPTSetCanTrade},
-                {.flags = tfMPTSetCanClawback},
-                {.immutableFlags = tifMPTTransferFee},
-                // a permitted flag does not unlock the extra fields
-                {.flags = tfMPTLock, .domainID = domainID},
-            };
-
-            for (auto arg : args)
-            {
-                arg.account = alice;
-                arg.delegate = bob;
-                arg.err = terNO_DELEGATE_PERMISSION;
-                mpt.set(arg);
-                env.close();
-            }
-        }
-    }
-
-    void
-    testGranularPermissionWithSponsorCommonFields()
-    {
-        testcase("test granular permission with sponsor common fields");
-        using namespace jtx;
-
-        Account const alice{"alice"};
-        Account const bob{"bob"};
-        Account const gw{"gw"};
-        Account const sponsor{"sponsor"};
-        auto const usd = gw["USD"];
-        auto const feeAmt = XRP(10);
-
-        // Sponsor fields are common fields, so they are permitted in every granular template.
-        // Fee sponsorship is allowed for a granular delegated transaction.
-        Env env(*this);
-        env.fund(XRP(10000), alice, bob, gw, sponsor);
-        env.trust(usd(200), alice);
-        env.close();
-
-        env(delegate::set(gw, bob, {"PaymentMint"}));
-        env.close();
-
-        // Co-signed: the sponsor account pays the fee.
-        auto const gwBalance = env.balance(gw);
-        auto const bobBalance = env.balance(bob);
-        auto const sponsorBalance = env.balance(sponsor);
-        env(pay(gw, alice, usd(50)),
-            delegate::As(bob),
-            Fee(feeAmt),
-            sponsor::As(sponsor, spfSponsorFee),
-            Sig(sfSponsorSignature, sponsor));
-        env.close();
-        env.require(Balance(alice, usd(50)));
-        BEAST_EXPECT(env.balance(gw) == gwBalance);
-        BEAST_EXPECT(env.balance(bob) == bobBalance);
-        BEAST_EXPECT(env.balance(sponsor) == sponsorBalance - feeAmt);
-
-        // Pre-funded: sponsorship(sponsor, bob) pays the fee, bob is sfDelegate.
-        env(sponsor::set_fee(sponsor, 0, XRP(100)), sponsor::SponseeAcc(bob));
-        env.close();
-        auto const sponsorFee = sponsor::sponsorshipFeeBalance(env, sponsor, bob);
-        env(pay(gw, alice, usd(50)),
-            delegate::As(bob),
-            Fee(feeAmt),
-            sponsor::As(sponsor, spfSponsorFee));
-        env.close();
-        env.require(Balance(alice, usd(100)));
-        BEAST_EXPECT(env.balance(gw) == gwBalance);
-        BEAST_EXPECT(env.balance(bob) == bobBalance);
-        BEAST_EXPECT(sponsor::sponsorshipFeeBalance(env, sponsor, bob) == sponsorFee - feeAmt);
-
-        // Reserve sponsorship is not tested here: checkSponsor rejects it with temINVALID for any
-        // delegated transaction before the permission check, regardless of the delegate's
-        // permissions. It is covered by testDelegateBlockReserveSponsor in Sponsor_test.
    }

    void
@@ -3151,7 +3002,6 @@ class Delegate_test : public beast::unit_test::Suite
        testTrustSetGranular();
        testAccountSetGranular();
        testMPTokenIssuanceSetGranular();
-        testGranularPermissionWithSponsorCommonFields();
        testSingleSign();
        testSingleSignBadSecret();
        testMultiSign();
@@ -2795,7 +2795,7 @@ struct EscrowToken_test : public beast::unit_test::Suite

            auto const seq1 = env.seq(alice);
            env.app().getOpenLedger().modify([&](OpenView& view, beast::Journal j) {
-                Sandbox sb(&view, TapNone);
+                Sandbox sb(&view, ApplyFlags::None);
                auto sleNew =
                    std::make_shared<SLE>(keylet::escrow(alice, SeqProxy::rawSequence(seq1)));
                MPTIssue const mpt{MPTIssue{makeMptID(1, AccountID(0x4985601))}};
@@ -3023,7 +3023,7 @@ struct EscrowToken_test : public beast::unit_test::Suite

            auto const seq1 = env.seq(alice);
            env.app().getOpenLedger().modify([&](OpenView& view, beast::Journal j) {
-                Sandbox sb(&view, TapNone);
+                Sandbox sb(&view, ApplyFlags::None);
                auto sleNew =
                    std::make_shared<SLE>(keylet::escrow(alice, SeqProxy::rawSequence(seq1)));
                MPTIssue const mpt{MPTIssue{makeMptID(1, AccountID(0x4985601))}};
@@ -1302,8 +1302,8 @@ struct Escrow_test : public beast::unit_test::Suite
                escrow::kFinishTime(env.now() + 1s),
                Seq(1),
                Fee(baseFee));
-            auto const pf =
-                preflight(env.app(), env.current()->rules(), *jtx.stx, TapNone, env.journal);
+            auto const pf = preflight(
+                env.app(), env.current()->rules(), *jtx.stx, ApplyFlags::None, env.journal);
            BEAST_EXPECT(isTesSuccess(pf.ter));
            BEAST_EXPECT(!pf.consequences.isBlocker());
            BEAST_EXPECT(pf.consequences.fee() == drops(baseFee));
@@ -1312,8 +1312,8 @@ struct Escrow_test : public beast::unit_test::Suite

        {
            auto const jtx = env.jt(escrow::cancel("bob", "alice", 3), Seq(1), Fee(baseFee));
-            auto const pf =
-                preflight(env.app(), env.current()->rules(), *jtx.stx, TapNone, env.journal);
+            auto const pf = preflight(
+                env.app(), env.current()->rules(), *jtx.stx, ApplyFlags::None, env.journal);
            BEAST_EXPECT(isTesSuccess(pf.ter));
            BEAST_EXPECT(!pf.consequences.isBlocker());
            BEAST_EXPECT(pf.consequences.fee() == drops(baseFee));
@@ -1322,8 +1322,8 @@ struct Escrow_test : public beast::unit_test::Suite

        {
            auto const jtx = env.jt(escrow::finish("bob", "alice", 3), Seq(1), Fee(baseFee));
-            auto const pf =
-                preflight(env.app(), env.current()->rules(), *jtx.stx, TapNone, env.journal);
+            auto const pf = preflight(
+                env.app(), env.current()->rules(), *jtx.stx, ApplyFlags::None, env.journal);
            BEAST_EXPECT(isTesSuccess(pf.ter));
            BEAST_EXPECT(!pf.consequences.isBlocker());
            BEAST_EXPECT(pf.consequences.fee() == drops(baseFee));
@@ -134,7 +134,7 @@ createInvalidFeeTx(
 bool
 applyFeeAndTestResult(jtx::Env& env, OpenView& view, STTx const& tx)
 {
-    auto const res = apply(env.app(), view, tx, ApplyFlags::TapNone, env.journal);
+    auto const res = apply(env.app(), view, tx, ApplyFlags::None, env.journal);
    return isTesSuccess(res.ter);
 }

@@ -333,7 +333,7 @@ struct FlowMPT_test : public beast::unit_test::Suite
                auto const flowResult = [&] {
                    STAmount const deliver(usd(5'100));
                    STAmount smax(btc(61));
-                    PaymentSandbox sb(env.current().get(), TapNone);
+                    PaymentSandbox sb(env.current().get(), ApplyFlags::None);
                    STPathSet paths;
                    auto ipe = [](Asset const& asset) {
                        return STPathElement(
@@ -371,7 +371,7 @@ struct FlowMPT_test : public beast::unit_test::Suite
                env.app().getOpenLedger().modify([&](OpenView& view, beast::Journal j) {
                    if (flowResult.removableOffers.empty())
                        return false;
-                    Sandbox sb(&view, TapNone);
+                    Sandbox sb(&view, ApplyFlags::None);
                    for (auto const& o : flowResult.removableOffers)
                    {
                        if (auto ok = sb.peek(keylet::offer(o)))
@@ -476,7 +476,7 @@ struct Flow_test : public beast::unit_test::Suite
            auto const flowResult = [&] {
                STAmount const deliver(usd(51));
                STAmount smax(btc(61));
-                PaymentSandbox sb(env.current().get(), TapNone);
+                PaymentSandbox sb(env.current().get(), ApplyFlags::None);
                STPathSet paths;
                auto ipe = [](Issue const& iss) {
                    return STPathElement(
@@ -514,7 +514,7 @@ struct Flow_test : public beast::unit_test::Suite
            env.app().getOpenLedger().modify([&](OpenView& view, beast::Journal j) {
                if (flowResult.removableOffers.empty())
                    return false;
-                Sandbox sb(&view, TapNone);
+                Sandbox sb(&view, ApplyFlags::None);
                for (auto const& o : flowResult.removableOffers)
                {
                    if (auto ok = sb.peek(keylet::offer(o)))
@@ -59,7 +59,7 @@ public:
        if (stx)
        {
            OpenView accum(&*res);
-            applyTransaction(env.app(), accum, *stx, false, TapNone, env.journal);
+            applyTransaction(env.app(), accum, *stx, false, ApplyFlags::None, env.journal);
            accum.apply(*res);
        }
        res->updateSkipList();
@@ -90,7 +90,7 @@ struct LedgerReplay_test : public beast::unit_test::Suite
        auto const lastClosedParent = ledgerMaster.getLedgerByHash(lastClosed->header().parentHash);

        auto const replayed = buildLedger(
-            LedgerReplay(lastClosedParent, lastClosed), TapNone, env.app(), env.journal);
+            LedgerReplay(lastClosedParent, lastClosed), ApplyFlags::None, env.app(), env.journal);

        BEAST_EXPECT(replayed->header().hash == lastClosed->header().hash);
    }
@@ -122,7 +122,7 @@ struct LedgerReplay_test : public beast::unit_test::Suite
        auto const lastClosedParent = ledgerMaster.getLedgerByHash(lastClosed->header().parentHash);

        auto const replayed = buildLedger(
-            LedgerReplay(lastClosedParent, lastClosed), TapNone, env.app(), env.journal);
+            LedgerReplay(lastClosedParent, lastClosed), ApplyFlags::None, env.app(), env.journal);

        BEAST_EXPECT(replayed->header().hash == lastClosed->header().hash);
    }
@@ -4059,7 +4059,7 @@ class MPToken_test : public beast::unit_test::Suite
                                 TER expectedTer,
                                 std::optional<std::uint64_t> expectedOutstanding,
                                 std::string const& label) {
-            ApplyViewImpl av(&*env.current(), TapNone);
+            ApplyViewImpl av(&*env.current(), ApplyFlags::None);
            auto const ter =
                accountSendMulti(av, issuer.id(), asset, receivers, env.app().getJournal("View"));
            BEAST_EXPECTS(ter == expectedTer, label);
@@ -776,7 +776,13 @@ class NFTokenBurn_test : public beast::unit_test::Suite
                test::StreamSink sink{beast::Severity::Warning};
                beast::Journal const jlog{sink};
                ApplyContext ac{
-                    env.app(), ov, tx, tesSUCCESS, env.current()->fees().base, TapNone, jlog};
+                    env.app(),
+                    ov,
+                    tx,
+                    tesSUCCESS,
+                    env.current()->fees().base,
+                    ApplyFlags::None,
+                    jlog};

                // Verify that the last page is present and contains one NFT.
                auto lastNFTokenPage = ac.view().peek(keylet::nftokenPageMax(alice));
@@ -808,7 +814,13 @@ class NFTokenBurn_test : public beast::unit_test::Suite
                test::StreamSink sink{beast::Severity::Warning};
                beast::Journal const jlog{sink};
                ApplyContext ac{
-                    env.app(), ov, tx, tesSUCCESS, env.current()->fees().base, TapNone, jlog};
+                    env.app(),
+                    ov,
+                    tx,
+                    tesSUCCESS,
+                    env.current()->fees().base,
+                    ApplyFlags::None,
+                    jlog};

                // Verify that the middle  page is present.
                auto lastNFTokenPage = ac.view().peek(keylet::nftokenPageMax(alice));
@@ -572,7 +572,7 @@ struct PayStrandMPT_test : public beast::unit_test::Suite
        inputs.defaultPathsAllowed = true;
        try
        {
-            PaymentSandbox sb{env.current().get(), TapNone};
+            PaymentSandbox sb{env.current().get(), ApplyFlags::None};
            {
                auto const r = ::xrpl::path::RippleCalc::rippleCalculate(
                    sb,
@@ -768,7 +768,8 @@ struct PayStrand_test : public beast::unit_test::Suite
                env,
                usd,
                std::nullopt,
-                STPath({STPathElement(0, xrpAccount(), xrpCurrency(), xrpAccount())}),
+                STPath({STPathElement(
+                    STPathElement::Type::TypeNone, xrpAccount(), xrpCurrency(), xrpAccount())}),
                temBAD_PATH);

            // The same account can't appear more than once on a path
@@ -1076,7 +1077,7 @@ struct PayStrand_test : public beast::unit_test::Suite
        inputs.defaultPathsAllowed = true;
        try
        {
-            PaymentSandbox sb{env.current().get(), TapNone};
+            PaymentSandbox sb{env.current().get(), ApplyFlags::None};
            {
                auto const r = ::xrpl::path::RippleCalc::rippleCalculate(
                    sb,
@@ -82,7 +82,7 @@ struct PseudoTx_test : public beast::unit_test::Suite
            BEAST_EXPECT(!passesLocalChecks(stx, reason));
            BEAST_EXPECT(reason == "Cannot submit pseudo transactions.");
            env.app().getOpenLedger().modify([&](OpenView& view, beast::Journal j) {
-                auto const result = xrpl::apply(env.app(), view, stx, TapNone, j);
+                auto const result = xrpl::apply(env.app(), view, stx, ApplyFlags::None, j);
                BEAST_EXPECT(!result.applied && result.ter == temINVALID);
                return result.applied;
            });
@@ -103,7 +103,8 @@ struct Regression_test : public beast::unit_test::Suite
            auto const jt = env.jt(pay(env.master, "alice", aliceAmount));
            OpenView accum(&*next);

-            auto const result = xrpl::apply(env.app(), accum, *jt.stx, TapNone, env.journal);
+            auto const result =
+                xrpl::apply(env.app(), accum, *jt.stx, ApplyFlags::None, env.journal);
            BEAST_EXPECT(isTesSuccess(result.ter));
            BEAST_EXPECT(result.applied);

@@ -126,7 +127,8 @@ struct Regression_test : public beast::unit_test::Suite

            OpenView accum(&*next);

-            auto const result = xrpl::apply(env.app(), accum, *jt.stx, TapNone, env.journal);
+            auto const result =
+                xrpl::apply(env.app(), accum, *jt.stx, ApplyFlags::None, env.journal);
            BEAST_EXPECT(result.ter == tecINSUFF_FEE);
            BEAST_EXPECT(result.applied);

@@ -303,12 +305,11 @@ struct Regression_test : public beast::unit_test::Suite
                return digest.asUInt256();
            }();

-            auto const mapCounts = [&](CountedObjects::List const& list) {
-                std::map<std::string, int> result;
-                for (auto const& e : list)
-                {
-                    result[e.first] = e.second;
-                }
+            auto const mapCounts = [] {
+                std::map<std::string, std::uint32_t> result;
+
+                for (auto const& c : gCountedObjects)
+                    result.emplace(c.name(), c.count());

                return result;
            };
@@ -317,11 +318,11 @@ struct Regression_test : public beast::unit_test::Suite
            {
                auto& cache = env.app().getCachedSLEs();
                cache.del(*digest, false);  // NOLINT(bugprone-unchecked-optional-access)
-                auto const beforeCounts = mapCounts(CountedObjects::getInstance().getCounts(0));
+                auto const beforeCounts = mapCounts();

                env(check::cash(alice, bobIndex, check::DeliverMin(XRP(100))), Ter(tecNO_ENTRY));

-                auto const afterCounts = mapCounts(CountedObjects::getInstance().getCounts(0));
+                auto const afterCounts = mapCounts();

                using namespace std::string_literals;
                BEAST_EXPECT(
@@ -915,8 +915,8 @@ public:
                sponsor::SponseeAcc(alice),
                Seq(1),
                Fee(baseFee));
-            auto const pf =
-                preflight(env.app(), env.current()->rules(), *jt.stx, TapNone, env.journal);
+            auto const pf = preflight(
+                env.app(), env.current()->rules(), *jt.stx, ApplyFlags::None, env.journal);
            BEAST_EXPECT(isTesSuccess(pf.ter));
            BEAST_EXPECT(!pf.consequences.isBlocker());
            BEAST_EXPECT(pf.consequences.fee() == drops(baseFee));
@@ -931,8 +931,8 @@ public:
                sponsor::SponseeAcc(alice),
                Seq(1),
                Fee(baseFee));
-            auto const pf =
-                preflight(env.app(), env.current()->rules(), *jt.stx, TapNone, env.journal);
+            auto const pf = preflight(
+                env.app(), env.current()->rules(), *jt.stx, ApplyFlags::None, env.journal);
            BEAST_EXPECT(isTesSuccess(pf.ter));
            BEAST_EXPECT(!pf.consequences.isBlocker());
            BEAST_EXPECT(pf.consequences.fee() == drops(baseFee));
@@ -946,8 +946,8 @@ public:
                sponsor::SponseeAcc(alice),
                Seq(1),
                Fee(baseFee));
-            auto const pf =
-                preflight(env.app(), env.current()->rules(), *jt.stx, TapNone, env.journal);
+            auto const pf = preflight(
+                env.app(), env.current()->rules(), *jt.stx, ApplyFlags::None, env.journal);
            BEAST_EXPECT(isTesSuccess(pf.ter));
            BEAST_EXPECT(!pf.consequences.isBlocker());
            BEAST_EXPECT(pf.consequences.fee() == drops(baseFee));
@@ -2242,7 +2242,8 @@ public:
                Seq(env.seq(alice)),
                sponsor::As(carol, spfSponsorFee));

-            auto const result = xrpl::apply(env.app(), overlay, *jt.stx, TapNone, env.journal);
+            auto const result =
+                xrpl::apply(env.app(), overlay, *jt.stx, ApplyFlags::None, env.journal);
            BEAST_EXPECT(result.ter == tecINSUFF_FEE);
            BEAST_EXPECT(result.applied);

@@ -2295,7 +2296,8 @@ public:
                Fee(fixFee),
                sponsor::As(sponsor, spfSponsorFee));

-            auto const pf = preflight(env.app(), overlay.rules(), *jt.stx, TapNone, env.journal);
+            auto const pf =
+                preflight(env.app(), overlay.rules(), *jt.stx, ApplyFlags::None, env.journal);
            BEAST_EXPECT(isTesSuccess(pf.ter));
            auto const pc = preclaim(pf, env.app(), overlay);
            BEAST_EXPECT(isTesSuccess(pc.ter));
@@ -252,7 +252,7 @@ class TheoreticalQuality_test : public beast::unit_test::Suite
        std::shared_ptr<ReadView const> closed,
        std::optional<Quality> const& expectedQ = {})
    {
-        PaymentSandbox const sb(closed.get(), TapNone);
+        PaymentSandbox const sb(closed.get(), ApplyFlags::None);
        AMMContext ammContext(rcp.srcAccount, false);

        auto const sendMaxIssue = [&rcp]() -> std::optional<Asset> {
@@ -989,7 +989,8 @@ public:
            Env::ParsedResult parsed;

            env.app().getOpenLedger().modify([&](OpenView& view, beast::Journal j) {
-                auto const result = xrpl::apply(env.app(), view, *jt.stx, TapNone, env.journal);
+                auto const result =
+                    xrpl::apply(env.app(), view, *jt.stx, ApplyFlags::None, env.journal);
                parsed.ter = result.ter;
                return result.applied;
            });
@@ -2424,8 +2425,8 @@ public:
        env.memoize("carol");
        {
            auto const jtx = env.jt(offerCancel(alice, 3), Seq(5), Fee(10));
-            auto const pf =
-                preflight(env.app(), env.current()->rules(), *jtx.stx, TapNone, env.journal);
+            auto const pf = preflight(
+                env.app(), env.current()->rules(), *jtx.stx, ApplyFlags::None, env.journal);
            BEAST_EXPECT(isTesSuccess(pf.ter));
            BEAST_EXPECT(!pf.consequences.isBlocker());
            BEAST_EXPECT(pf.consequences.fee() == drops(10));
@@ -2436,8 +2437,8 @@ public:
            auto usd = alice["USD"];

            auto const jtx = env.jt(trust("carol", usd(50000000)), Seq(1), Fee(10));
-            auto const pf =
-                preflight(env.app(), env.current()->rules(), *jtx.stx, TapNone, env.journal);
+            auto const pf = preflight(
+                env.app(), env.current()->rules(), *jtx.stx, ApplyFlags::None, env.journal);
            BEAST_EXPECT(isTesSuccess(pf.ter));
            BEAST_EXPECT(!pf.consequences.isBlocker());
            BEAST_EXPECT(pf.consequences.fee() == drops(10));
@@ -2446,8 +2447,8 @@ public:

        {
            auto const jtx = env.jt(ticket::create(alice, 1), Seq(1), Fee(10));
-            auto const pf =
-                preflight(env.app(), env.current()->rules(), *jtx.stx, TapNone, env.journal);
+            auto const pf = preflight(
+                env.app(), env.current()->rules(), *jtx.stx, ApplyFlags::None, env.journal);
            BEAST_EXPECT(isTesSuccess(pf.ter));
            BEAST_EXPECT(!pf.consequences.isBlocker());
            BEAST_EXPECT(pf.consequences.fee() == drops(10));
@@ -4002,7 +4003,7 @@ public:
        //  be callable via RPC.)
        env.app().getOpenLedger().modify([&](OpenView& view, beast::Journal j) {
            auto const tx = env.jt(noop(alice), Seq(aliceSeq), Fee(openLedgerCost(env)));
-            auto const result = xrpl::apply(env.app(), view, *tx.stx, TapUnlimited, j);
+            auto const result = xrpl::apply(env.app(), view, *tx.stx, ApplyFlags::Unlimited, j);
            BEAST_EXPECT(isTesSuccess(result.ter) && result.applied);
            return result.applied;
        });
@@ -4070,7 +4071,7 @@ public:
        //  be callable via RPC.)
        env.app().getOpenLedger().modify([&](OpenView& view, beast::Journal j) {
            auto const tx = env.jt(noop(alice), ticket::Use(tktSeq0 + 1), Fee(openLedgerCost(env)));
-            auto const result = xrpl::apply(env.app(), view, *tx.stx, TapUnlimited, j);
+            auto const result = xrpl::apply(env.app(), view, *tx.stx, ApplyFlags::Unlimited, j);
            BEAST_EXPECT(isTesSuccess(result.ter) && result.applied);
            return result.applied;
        });
@@ -122,7 +122,8 @@ InvariantsBase::doInvariantCheck(
    OpenView ov{*env.current()};
    test::StreamSink sink{beast::Severity::Warning};
    beast::Journal const jlog{sink};
-    ApplyContext ac{env.app(), ov, tx, tesSUCCESS, env.current()->fees().base, TapNone, jlog};
+    ApplyContext ac{
+        env.app(), ov, tx, tesSUCCESS, env.current()->fees().base, ApplyFlags::None, jlog};

    // Invariants normally run in the Transaction's "apply" (operator()) context, and can always
    // access global Rules.
@@ -36,7 +36,6 @@
 #include <functional>
 #include <initializer_list>
 #include <memory>
-#include <ranges>
 #include <source_location>
 #include <string>
 #include <tuple>
@@ -1100,62 +1099,6 @@ class InvariantsMPT_test : public InvariantsBase
                });
        }

-        // lsfMPTLocked is exempt because tfMPTUnlock clears it legitimately.
-        // Pre-fixCleanup3_5_0: clearing another issuance flag is allowed.
-        // Post-fixCleanup3_5_0: clearing another issuance flag trips the
-        // invariant.
-        {
-            std::uint32_t allFlags = 0;
-            for (auto const flag : std::views::values(getMPTokenIssuanceFlags()))
-                allFlags |= flag;
-            allFlags &= ~lsfMPTLocked;
-
-            MPTID id{};
-            Preclose const setup = [&](Account const&, Account const&, Env& env) {
-                Account const issuer{"issuer"};
-                env.fund(XRP(10'000), issuer);
-                env.close();
-                MPTTester mptt{env, issuer, kMptInitNoFund};
-                mptt.create({.flags = allFlags});
-                id = mptt.issuanceID();
-                env.close();
-                return true;
-            };
-            STTx const tx{ttACCOUNT_SET, [](STObject&) {}};
-
-            for (auto const flag : std::views::values(getMPTokenIssuanceFlags()))
-            {
-                if (flag == lsfMPTLocked)
-                    continue;
-                Precheck const clearFlag = [&, flag](
-                                               Account const&, Account const&, ApplyContext& ac) {
-                    auto sleIssuance = ac.view().peek(keylet::mptokenIssuance(id));
-                    if (!sleIssuance)
-                        return false;
-                    sleIssuance->setFieldU32(sfFlags, sleIssuance->getFlags() & ~flag);
-                    ac.view().update(sleIssuance);
-                    return true;
-                };
-
-                doInvariantCheck(
-                    makeEnv(all_ - fixCleanup3_5_0),
-                    {},
-                    clearFlag,
-                    XRPAmount{},
-                    tx,
-                    {tesSUCCESS, tesSUCCESS},
-                    setup);
-                doInvariantCheck(
-                    makeEnv(all_),
-                    {{"immutable MPTokenIssuance flag cleared"}},
-                    clearFlag,
-                    XRPAmount{},
-                    tx,
-                    {tecINVARIANT_FAILED, tefINVARIANT_FAILED},
-                    setup);
-            }
-        }
-
        // A vault pseudo-account's MPToken cannot be deleted by anything
        // other than a VaultDelete transaction. Set up a vault, then have
        // an arbitrary tx erase the pseudo's MPToken in precheck.
@@ -1223,12 +1166,6 @@ class InvariantsMPT_test : public InvariantsBase
                      0u})
                {
                    MPTID id{};
-                    // Issuance flags cannot be cleared after creation (and
-                    // ValidMPTIssuance now rejects it), so the CanTransfer /
-                    // CanTrade rows create the issuance without the bit
-                    // instead of stripping it in precheck.
-                    std::uint32_t const createFlags =
-                        (flag == 0u || flag == lsfMPTLocked) ? kMptDexFlags : (kMptDexFlags & flag);
                    auto const isSuccess = !gates.any() || flag == 0 ||
                        (tx == ttPAYMENT && !crossCurrencyPayment && (flag == ~lsfMPTCanTrade)) ||
                        (tx == ttAMM_WITHDRAW &&
@@ -1250,9 +1187,14 @@ class InvariantsMPT_test : public InvariantsBase
                            auto issuanceSle = ac.view().peek(keylet::mptokenIssuance(id));
                            if (!issuanceSle)
                                return false;
+                            auto const flags = issuanceSle->at(sfFlags);
                            if (flag == lsfMPTLocked)
                            {
-                                issuanceSle->at(sfFlags) = issuanceSle->at(sfFlags) | lsfMPTLocked;
+                                issuanceSle->at(sfFlags) = flags | lsfMPTLocked;
+                            }
+                            else if (flag != 0u)
+                            {
+                                issuanceSle->at(sfFlags) = flags & flag;
                            }
                            issuanceSle->at(sfOutstandingAmount) = 200;
                            ac.view().update(issuanceSle);
@@ -1273,11 +1215,7 @@ class InvariantsMPT_test : public InvariantsBase
                            Account const gw("gw");
                            env.fund(XRP(1'000), gw);
                            MPTTester const usd(
-                                {.env = env,
-                                 .issuer = gw,
-                                 .holders = {a1, a2},
-                                 .pay = 100,
-                                 .flags = createFlags});
+                                {.env = env, .issuer = gw, .holders = {a1, a2}, .pay = 100});
                            id = usd.issuanceID();
                            // Either gate enforces, so both must be off to stay
                            // advisory. Disable after setting up the MPT; the
@@ -811,7 +811,13 @@ class InvariantsMisc_test : public InvariantsBase
                test::StreamSink sink{beast::Severity::Warning};
                beast::Journal const jlog{sink};
                ApplyContext ac{
-                    env.app(), ov, tx, tesSUCCESS, env.current()->fees().base, TapNone, jlog};
+                    env.app(),
+                    ov,
+                    tx,
+                    tesSUCCESS,
+                    env.current()->fees().base,
+                    ApplyFlags::None,
+                    jlog};
                CurrentTransactionRulesGuard const rulesGuard(ov.rules());

                auto sleLoan = ac.view().peek(loanKeylet);
@@ -866,7 +872,13 @@ class InvariantsMisc_test : public InvariantsBase
                test::StreamSink sink{beast::Severity::Warning};
                beast::Journal const jlog{sink};
                ApplyContext ac{
-                    env.app(), ov, tx, tesSUCCESS, env.current()->fees().base, TapNone, jlog};
+                    env.app(),
+                    ov,
+                    tx,
+                    tesSUCCESS,
+                    env.current()->fees().base,
+                    ApplyFlags::None,
+                    jlog};
                CurrentTransactionRulesGuard const rulesGuard(ov.rules());

                auto sleLoan = ac.view().peek(loanKeylet);
@@ -979,7 +991,13 @@ class InvariantsMisc_test : public InvariantsBase
                    test::StreamSink sink{beast::Severity::Warning};
                    beast::Journal const jlog{sink};
                    ApplyContext ac{
-                        env.app(), ov, tx, tesSUCCESS, env.current()->fees().base, TapNone, jlog};
+                        env.app(),
+                        ov,
+                        tx,
+                        tesSUCCESS,
+                        env.current()->fees().base,
+                        ApplyFlags::None,
+                        jlog};
                    CurrentTransactionRulesGuard const rulesGuard(ov.rules());

                    auto sleLoan = ac.view().peek(loanKeylet);
@@ -1417,7 +1435,7 @@ class InvariantsMisc_test : public InvariantsBase
            test::StreamSink sink{beast::Severity::Warning};
            beast::Journal const jlog{sink};
            ApplyContext ac{
-                env.app(), ov, tx, tesSUCCESS, env.current()->fees().base, TapNone, jlog};
+                env.app(), ov, tx, tesSUCCESS, env.current()->fees().base, ApplyFlags::None, jlog};
            CurrentTransactionRulesGuard const rulesGuard(ov.rules());

            auto sle = ac.view().peek(vaultKeylet);
@@ -1484,7 +1502,7 @@ class InvariantsMisc_test : public InvariantsBase
            test::StreamSink sink{beast::Severity::Warning};
            beast::Journal const jlog{sink};
            ApplyContext ac{
-                env.app(), ov, tx, tesSUCCESS, env.current()->fees().base, TapNone, jlog};
+                env.app(), ov, tx, tesSUCCESS, env.current()->fees().base, ApplyFlags::None, jlog};
            CurrentTransactionRulesGuard const rulesGuard(ov.rules());

            // visitEntry only runs for entries the transaction touched, so
@@ -1541,7 +1559,8 @@ class InvariantsMisc_test : public InvariantsBase
        STTx const tx{ttACCOUNT_SET, [](STObject&) {}};
        test::StreamSink sink{beast::Severity::Warning};
        beast::Journal const jlog{sink};
-        ApplyContext ac{env.app(), ov, tx, tesSUCCESS, env.current()->fees().base, TapNone, jlog};
+        ApplyContext ac{
+            env.app(), ov, tx, tesSUCCESS, env.current()->fees().base, ApplyFlags::None, jlog};
        CurrentTransactionRulesGuard const rulesGuard(ov.rules());

        FailingTxInvariantCheck failing;
@@ -581,7 +581,7 @@ class InvariantsPseudoAccount_test : public InvariantsBase
            test::StreamSink sink{beast::Severity::Warning};
            beast::Journal const jlog{sink};
            ApplyContext ac{
-                env.app(), ov, tx, tesSUCCESS, env.current()->fees().base, TapNone, jlog};
+                env.app(), ov, tx, tesSUCCESS, env.current()->fees().base, ApplyFlags::None, jlog};
            CurrentTransactionRulesGuard const rulesGuard(ov.rules());

            auto sleBroker = ac.view().peek(brokerKeylet);
@@ -633,7 +633,7 @@ class InvariantsPseudoAccount_test : public InvariantsBase
            test::StreamSink sink{beast::Severity::Warning};
            beast::Journal const jlog{sink};
            ApplyContext ac{
-                env.app(), ov, tx, tesSUCCESS, env.current()->fees().base, TapNone, jlog};
+                env.app(), ov, tx, tesSUCCESS, env.current()->fees().base, ApplyFlags::None, jlog};
            CurrentTransactionRulesGuard const rulesGuard(ov.rules());

            auto sleBroker = ac.view().peek(brokerKeylet);
@@ -681,7 +681,7 @@ class InvariantsPseudoAccount_test : public InvariantsBase
            test::StreamSink sink{beast::Severity::Warning};
            beast::Journal const jlog{sink};
            ApplyContext ac{
-                env.app(), ov, tx, tesSUCCESS, env.current()->fees().base, TapNone, jlog};
+                env.app(), ov, tx, tesSUCCESS, env.current()->fees().base, ApplyFlags::None, jlog};
            CurrentTransactionRulesGuard const rulesGuard(ov.rules());

            auto sleBroker = ac.view().peek(brokerKeylet);
@@ -1088,7 +1088,13 @@ class InvariantsVault_test : public InvariantsBase
                test::StreamSink sink{beast::Severity::Warning};
                beast::Journal const jlog{sink};
                ApplyContext ac{
-                    env.app(), ov, tx, tesSUCCESS, env.current()->fees().base, TapNone, jlog};
+                    env.app(),
+                    ov,
+                    tx,
+                    tesSUCCESS,
+                    env.current()->fees().base,
+                    ApplyFlags::None,
+                    jlog};
                CurrentTransactionRulesGuard const rulesGuard(ov.rules());

                auto sleLoan = ac.view().peek(loanKeylet);
@@ -1140,7 +1146,7 @@ class InvariantsVault_test : public InvariantsBase
            test::StreamSink sink{beast::Severity::Warning};
            beast::Journal const jlog{sink};
            ApplyContext ac{
-                env.app(), ov, tx, tesSUCCESS, env.current()->fees().base, TapNone, jlog};
+                env.app(), ov, tx, tesSUCCESS, env.current()->fees().base, ApplyFlags::None, jlog};
            CurrentTransactionRulesGuard const rulesGuard(ov.rules());

            auto sleLoan = ac.view().peek(loanKeylet);
@@ -1302,7 +1308,13 @@ class InvariantsVault_test : public InvariantsBase
                test::StreamSink sink{beast::Severity::Warning};
                beast::Journal const jlog{sink};
                ApplyContext ac{
-                    env.app(), ov, tx, tesSUCCESS, env.current()->fees().base, TapNone, jlog};
+                    env.app(),
+                    ov,
+                    tx,
+                    tesSUCCESS,
+                    env.current()->fees().base,
+                    ApplyFlags::None,
+                    jlog};
                CurrentTransactionRulesGuard const rulesGuard(ov.rules());

                auto sleLoan = ac.view().peek(loanKeylet);
@@ -1357,7 +1369,13 @@ class InvariantsVault_test : public InvariantsBase
                    test::StreamSink sink{beast::Severity::Warning};
                    beast::Journal const jlog{sink};
                    ApplyContext ac{
-                        env.app(), ov, tx, tesSUCCESS, env.current()->fees().base, TapNone, jlog};
+                        env.app(),
+                        ov,
+                        tx,
+                        tesSUCCESS,
+                        env.current()->fees().base,
+                        ApplyFlags::None,
+                        jlog};
                    CurrentTransactionRulesGuard const rulesGuard(ov.rules());

                    auto sleLoan = ac.view().peek(loanKeylet);
@@ -1457,7 +1475,7 @@ class InvariantsVault_test : public InvariantsBase
            test::StreamSink sink{beast::Severity::Warning};
            beast::Journal const jlog{sink};
            ApplyContext ac{
-                env.app(), ov, tx, tesSUCCESS, env.current()->fees().base, TapNone, jlog};
+                env.app(), ov, tx, tesSUCCESS, env.current()->fees().base, ApplyFlags::None, jlog};
            CurrentTransactionRulesGuard const rulesGuard(ov.rules());

            {
@@ -1,857 +0,0 @@
-#include <test/app/lending/LoanTestBase.h>
-#include <test/jtx/Account.h>
-#include <test/jtx/Env.h>
-#include <test/jtx/JTx.h>
-#include <test/jtx/TestHelpers.h>
-#include <test/jtx/amount.h>
-#include <test/jtx/batch.h>
-#include <test/jtx/fee.h>
-#include <test/jtx/flags.h>
-#include <test/jtx/offer.h>
-#include <test/jtx/owners.h>
-#include <test/jtx/pay.h>
-#include <test/jtx/seq.h>
-#include <test/jtx/sig.h>
-#include <test/jtx/tags.h>
-#include <test/jtx/ter.h>
-#include <test/jtx/trust.h>
-#include <test/jtx/vault.h>
-
-#include <xrpl/basics/Number.h>
-#include <xrpl/basics/base_uint.h>
-#include <xrpl/basics/chrono.h>
-#include <xrpl/basics/strHex.h>
-#include <xrpl/beast/unit_test/suite.h>
-#include <xrpl/json/json_value.h>
-#include <xrpl/protocol/Feature.h>
-#include <xrpl/protocol/Indexes.h>
-#include <xrpl/protocol/Issue.h>
-#include <xrpl/protocol/Keylet.h>
-#include <xrpl/protocol/LedgerFormats.h>
-#include <xrpl/protocol/Protocol.h>
-#include <xrpl/protocol/SField.h>
-#include <xrpl/protocol/STAmount.h>
-#include <xrpl/protocol/SeqProxy.h>
-#include <xrpl/protocol/TER.h>
-#include <xrpl/protocol/TxFlags.h>
-#include <xrpl/protocol/Units.h>
-
-#include <algorithm>
-#include <chrono>
-#include <cstdint>
-
-namespace xrpl::test {
-
-// Vault and Lending transactions used as Batch inners under LendingProtocolV1_2.
-class LendingBatch_test : public LoanTestBase
-{
-private:
-    // Asserts a loan has been paid off in full: no principal, value, or
-    // remaining payments left on the loan; no debt left on the broker; and the
-    // vault's available assets back to `depositValue`.
-    void
-    assertLoanFullyRepaid(
-        jtx::Env const& env,
-        Keylet const& brokerKeylet,
-        Keylet const& vaultKeylet,
-        Keylet const& loanKeylet,
-        STAmount const& depositValue)
-    {
-        if (auto const loanSle = env.le(loanKeylet); BEAST_EXPECT(loanSle))
-        {
-            BEAST_EXPECT(loanSle->at(sfPrincipalOutstanding) == 0);
-            BEAST_EXPECT(loanSle->at(sfTotalValueOutstanding) == 0);
-            BEAST_EXPECT(loanSle->at(sfPaymentRemaining) == 0);
-        }
-        if (auto const brokerSle = env.le(brokerKeylet); BEAST_EXPECT(brokerSle))
-            BEAST_EXPECT(brokerSle->at(sfDebtTotal) == 0);
-        if (auto const vaultSle = env.le(vaultKeylet); BEAST_EXPECT(vaultSle))
-            BEAST_EXPECT(vaultSle->at(sfAssetsAvailable) == depositValue);
-    }
-
-    // LoanSet as a batch inner: the counterparty signs the outer batch, so
-    // this inner carries no signature of its own. Pass paymentTotal >= 2
-    // wherever the same batch also submits an early tfLoanFullPayment:
-    // computeFullPayment refuses it with tecKILLED when only the final
-    // scheduled payment is left.
-    static json::Value
-    loanSetInner(
-        jtx::Env& env,
-        jtx::Account const& account,
-        uint256 const& brokerID,
-        jtx::Account const& counterparty,
-        STAmount const& principal,
-        std::uint32_t paymentTotal)
-    {
-        using namespace jtx;
-        using namespace jtx::loan;
-
-        return env.json(
-            set(account, brokerID, principal.value()),
-            kCounterparty(counterparty.id()),
-            kPaymentTotal(paymentTotal),
-            Sig(kNone),
-            Fee(kNone),
-            Seq(kNone));
-    }
-
-    // Runs VaultCreate -> Deposit -> Withdraw -> Delete in one tfAllOrNothing
-    // batch and checks the vault is gone, the owner paid only the batch fee,
-    // and both owner count and sequence are back where they belong.
-    void
-    runVaultLifecycleBatch(jtx::Env& env, jtx::Account const& owner, json::Value const& createTx)
-    {
-        using namespace jtx;
-
-        Vault const vault{env};
-
-        auto const seq = env.seq(owner);
-        auto const balanceBefore = env.balance(owner);
-        auto const ownerCountBefore = env.ownerCount(owner);
-
-        // The outer Batch consumes owner's current sequence, so the first
-        // inner (VaultCreate) lands on seq + 1.
-        auto const vaultKeylet = keylet::vault(owner.id(), SeqProxy::rawSequence(seq + 1));
-        auto const depositAmount = XRP(1'000);
-
-        auto const batchFee = batch::calcBatchFee(env, 0, 4);
-        env(batch::outer(owner, seq, batchFee, tfAllOrNothing),
-            batch::Inner(createTx, seq + 1),
-            batch::Inner(
-                vault.deposit({.depositor = owner, .id = vaultKeylet.key, .amount = depositAmount}),
-                seq + 2),
-            batch::Inner(
-                vault.withdraw(
-                    {.depositor = owner, .id = vaultKeylet.key, .amount = depositAmount}),
-                seq + 3),
-            batch::Inner(vault.del({.owner = owner, .id = vaultKeylet.key}), seq + 4),
-            Ter(tesSUCCESS));
-        env.close();
-
-        BEAST_EXPECT(!env.le(vaultKeylet));
-        BEAST_EXPECT(env.balance(owner) == balanceBefore - batchFee);
-        BEAST_EXPECT(env.ownerCount(owner) == ownerCountBefore);
-        BEAST_EXPECT(env.seq(owner) == seq + 5);
-    }
-
-    void
-    testVaultLifecycle(FeatureBitset features)
-    {
-        // A single tfAllOrNothing batch runs an open-ended XRP vault through
-        // its whole lifecycle: create, deposit, withdraw everything back out,
-        // and delete.
-        testcase("vault lifecycle in a batch");
-
-        using namespace jtx;
-
-        Env env(*this, features);
-
-        Account const owner{"owner"};
-        env.fund(XRP(100'000), owner);
-        env.close();
-
-        auto const createTx = std::get<0>(Vault{env}.create({.owner = owner, .asset = xrpIssue()}));
-        runVaultLifecycleBatch(env, owner, createTx);
-    }
-
-    void
-    testClosedEndedVaultLifecycle(FeatureBitset features)
-    {
-        // Same lifecycle as testVaultLifecycle, but on a closed-ended vault
-        // submitted while it is still in the Subscription phase, where
-        // LendingProtocolV1_1 allows both deposit and withdraw.
-        testcase("vault lifecycle in a batch, closed-ended vault, subscription phase");
-
-        using namespace jtx;
-
-        Env env(*this, features);
-
-        Account const owner{"owner"};
-        env.fund(XRP(100'000), owner);
-        env.close();
-
-        auto const createTx = std::get<0>(Vault{env}.createClosedEnded(
-            {.owner = owner, .asset = xrpIssue(), .subscriptionOffset = std::chrono::seconds{60}}));
-        runVaultLifecycleBatch(env, owner, createTx);
-    }
-
-    void
-    testLoanLifecycleOpenEndedVault(FeatureBitset features)
-    {
-        // With LendingProtocolV1_1 off, an open-ended vault can host a broker,
-        // so vault creation, deposit, broker setup, loan origination, and an
-        // early full payoff all fit in one atomic batch. The borrower signs the
-        // outer as counterparty to the LoanSet inner and as the account behind
-        // the LoanPay inner.
-        testcase("loan lifecycle in a batch, open-ended vault");
-
-        using namespace jtx;
-
-        Env env(*this, features);
-
-        Account const lender{"lender"};
-        Account const borrower{"borrower"};
-        env.fund(XRP(1'000'000), lender, borrower);
-        env.close();
-
-        PrettyAsset const asset{xrpIssue(), 1'000'000};
-        Vault const vault{env};
-
-        auto const lenderSeq = env.seq(lender);
-        auto const borrowerSeq = env.seq(borrower);
-        auto const lenderBalanceBefore = env.balance(lender);
-        auto const borrowerBalanceBefore = env.balance(borrower);
-
-        auto const depositAmount = asset(50'000);
-        auto const principal = asset(1'000);
-
-        auto const vaultKeylet = keylet::vault(lender.id(), SeqProxy::rawSequence(lenderSeq + 1));
-        auto const brokerKeylet =
-            keylet::loanBroker(lender.id(), SeqProxy::rawSequence(lenderSeq + 3));
-        auto const loanKeylet = keylet::loan(brokerKeylet.key, SeqProxy::rawSequence(1));
-
-        auto const createTx = std::get<0>(vault.create({.owner = lender, .asset = xrpIssue()}));
-
-        // CoverRateMinimum/CoverRateLiquidation are left unset on the
-        // LoanBrokerSet inner below, which defaults both to zero, so this
-        // loan needs no first-loss cover deposit from the broker.
-        auto const loanSetTx = loanSetInner(env, lender, brokerKeylet.key, borrower, principal, 2);
-        auto const loanPayTx =
-            loan::pay(borrower, loanKeylet.key, principal.value(), tfLoanFullPayment);
-
-        auto const batchFee = batch::calcBatchFee(env, 1, 5);
-        env(batch::outer(lender, lenderSeq, batchFee, tfAllOrNothing),
-            batch::Inner(createTx, lenderSeq + 1),
-            batch::Inner(
-                vault.deposit(
-                    {.depositor = lender, .id = vaultKeylet.key, .amount = depositAmount.value()}),
-                lenderSeq + 2),
-            batch::Inner(loan_broker::set(lender, vaultKeylet.key), lenderSeq + 3),
-            batch::Inner(loanSetTx, lenderSeq + 4),
-            batch::Inner(loanPayTx, borrowerSeq),
-            batch::Sig(borrower),
-            Ter(tesSUCCESS));
-        env.close();
-
-        assertLoanFullyRepaid(env, brokerKeylet, vaultKeylet, loanKeylet, depositAmount.value());
-
-        // The borrower borrowed the principal and repaid it in full at zero
-        // interest and fees, so their balance nets to zero; the batch fee is
-        // paid entirely by the lender, who also funded the vault deposit.
-        BEAST_EXPECT(env.balance(borrower) == borrowerBalanceBefore);
-        BEAST_EXPECT(env.balance(lender) == lenderBalanceBefore - batchFee - depositAmount.value());
-    }
-
-    void
-    testLoanLifecycleClosedEndedVault(FeatureBitset features)
-    {
-        // Under LendingProtocolV1_1 a broker can attach only to a closed-ended
-        // vault, and LoanSet is refused outside the Investment phase, so the
-        // vault/broker setup and the loan/payoff run as two batches split at
-        // the Subscription -> Investment boundary.
-        testcase("loan lifecycle in a batch, closed-ended vault");
-
-        using namespace jtx;
-
-        Env env(*this, features);
-
-        Account const lender{"lender"};
-        Account const borrower{"borrower"};
-        env.fund(XRP(1'000'000), lender, borrower);
-        env.close();
-
-        PrettyAsset const asset{xrpIssue(), 1'000'000};
-        Vault const vault{env};
-
-        auto const lenderSeq1 = env.seq(lender);
-        auto const depositAmount = asset(50'000);
-
-        auto const vaultKeylet = keylet::vault(lender.id(), SeqProxy::rawSequence(lenderSeq1 + 1));
-        auto const brokerKeylet =
-            keylet::loanBroker(lender.id(), SeqProxy::rawSequence(lenderSeq1 + 3));
-
-        auto const created = vault.createClosedEnded(
-            {.owner = lender, .asset = xrpIssue(), .subscriptionOffset = std::chrono::seconds{60}});
-        auto const createTx = std::get<0>(created);
-        auto const subscriptionDate = std::get<2>(created);
-
-        // LoanBrokerSet checks only the vault's kind, not its phase, so setting
-        // up the broker is allowed here in the same batch, while the vault is
-        // still in the Subscription phase.
-        auto const batch1Fee = batch::calcBatchFee(env, 0, 3);
-        env(batch::outer(lender, lenderSeq1, batch1Fee, tfAllOrNothing),
-            batch::Inner(createTx, lenderSeq1 + 1),
-            batch::Inner(
-                vault.deposit(
-                    {.depositor = lender, .id = vaultKeylet.key, .amount = depositAmount.value()}),
-                lenderSeq1 + 2),
-            batch::Inner(loan_broker::set(lender, vaultKeylet.key), lenderSeq1 + 3),
-            Ter(tesSUCCESS));
-        env.close();
-
-        if (auto const vaultSle = env.le(vaultKeylet); BEAST_EXPECT(vaultSle))
-            BEAST_EXPECT(vaultSle->at(sfAssetsAvailable) == depositAmount.value());
-        BEAST_EXPECT(env.le(brokerKeylet));
-
-        vault.closePastSubscription(subscriptionDate);
-
-        auto const loanKeylet = keylet::loan(brokerKeylet.key, SeqProxy::rawSequence(1));
-        auto const principal = asset(1'000);
-
-        auto const lenderSeq2 = env.seq(lender);
-        auto const borrowerSeq = env.seq(borrower);
-        auto const lenderBalanceBefore = env.balance(lender);
-        auto const borrowerBalanceBefore = env.balance(borrower);
-
-        auto const loanSetTx = loanSetInner(env, lender, brokerKeylet.key, borrower, principal, 2);
-        auto const loanPayTx =
-            loan::pay(borrower, loanKeylet.key, principal.value(), tfLoanFullPayment);
-
-        auto const batch2Fee = batch::calcBatchFee(env, 1, 2);
-        env(batch::outer(lender, lenderSeq2, batch2Fee, tfAllOrNothing),
-            batch::Inner(loanSetTx, lenderSeq2 + 1),
-            batch::Inner(loanPayTx, borrowerSeq),
-            batch::Sig(borrower),
-            Ter(tesSUCCESS));
-        env.close();
-
-        assertLoanFullyRepaid(env, brokerKeylet, vaultKeylet, loanKeylet, depositAmount.value());
-
-        BEAST_EXPECT(env.balance(borrower) == borrowerBalanceBefore);
-        // The deposit already left the lender's balance in batch 1; batch 2
-        // only costs the batch fee, since LoanSet/LoanPay net to zero XRP.
-        BEAST_EXPECT(env.balance(lender) == lenderBalanceBefore - batch2Fee);
-    }
-
-    // Handles shared by testArbitrage and testArbitrageRollback.
-    struct ArbitrageSetup
-    {
-        jtx::PrettyAsset iou;
-        jtx::Account issuer;
-        jtx::Account lender;
-        jtx::Account borrower;
-        jtx::Account mm1;
-        jtx::Account mm2;
-        BrokerInfo broker;
-    };
-
-    // Broker with zero cover rates and no debt cap, so LoanSet needs no cover
-    // deposit. The borrower holds a trust line but no IOU, so the profit is
-    // exact. mm1 rests an offer selling 400 XRP for 1000 IOU; mm2 is funded
-    // but places its offer only inside testArbitrage's batch.
-    ArbitrageSetup
-    setupArbitrage(jtx::Env& env)
-    {
-        using namespace jtx;
-
-        Account const issuer{"issuer"};
-        Account const lender{"lender"};
-        Account const borrower{"borrower"};
-        Account const mm1{"mm1"};
-        Account const mm2{"mm2"};
-        env.fund(XRP(1'000'000), issuer, lender, borrower, mm1, mm2);
-        env(fset(issuer, asfDefaultRipple));
-        env.close();
-
-        PrettyAsset const iou = issuer[iouCurrency_];
-        STAmount const iouLimit = iou(1'000'000'000);
-        env(trust(lender, iouLimit));
-        env(trust(borrower, iouLimit));
-        env(trust(mm1, iouLimit));
-        env(trust(mm2, iouLimit));
-        env.close();
-
-        BrokerParameters params = BrokerParameters::defaults();
-        params.vaultDeposit = 100'000;
-        params.coverRateMin = TenthBips32{0};
-        params.coverDeposit = 0;
-        params.debtMax = 0;
-        params.coverRateLiquidation = TenthBips32{0};
-
-        env(pay(issuer, lender, iou(params.vaultDeposit)));
-        env(pay(issuer, mm2, iou(20'000)));
-        env.close();
-
-        BrokerInfo const broker{createVaultAndBroker(env, iou, lender, params)};
-
-        env(offer(mm1, iou(1'000), XRP(400)));
-        env.close();
-
-        return {
-            .iou = iou,
-            .issuer = issuer,
-            .lender = lender,
-            .borrower = borrower,
-            .mm1 = mm1,
-            .mm2 = mm2,
-            .broker = broker};
-    }
-
-    void
-    testArbitrage(FeatureBitset features)
-    {
-        // A borrower profits risk-free from a loan and two crossing DEX
-        // offers in one atomic batch. Crossed offers execute the moment both
-        // rest on the book, so mm2's offer is itself a batch inner, placed
-        // right after the borrower's buy leg consumes mm1.
-        testcase("arbitrage across a loan and two crossing offers in a batch");
-
-        using namespace jtx;
-
-        Env env(*this, features);
-        auto const setup = setupArbitrage(env);
-        auto const& iou = setup.iou;
-        auto const& lender = setup.lender;
-        auto const& borrower = setup.borrower;
-        auto const& broker = setup.broker;
-        auto const& mm2 = setup.mm2;
-
-        auto const loanKeylet = nextLoanKeylet(env, broker);
-        auto const principal = iou(1'000);
-
-        BEAST_EXPECT(env.balance(borrower, iou) == iou(0));
-
-        auto const borrowerSeq = env.seq(borrower);
-        auto const mm2Seq = env.seq(mm2);
-
-        auto const loanSetTx = loanSetInner(env, borrower, broker.brokerID, lender, principal, 2);
-        auto const loanPayTx =
-            loan::pay(borrower, loanKeylet.key, principal.value(), tfLoanFullPayment);
-
-        auto const batchFee = batch::calcBatchFee(env, 2, 5);
-        env(batch::outer(borrower, borrowerSeq, batchFee, tfAllOrNothing),
-            batch::Inner(loanSetTx, borrowerSeq + 1),
-            batch::Inner(
-                offer(borrower, XRP(400), principal.value(), tfFillOrKill), borrowerSeq + 2),
-            batch::Inner(offer(mm2, XRP(400), iou(1'008)), mm2Seq),
-            batch::Inner(
-                offer(borrower, iou(1'008).value(), XRP(400), tfFillOrKill), borrowerSeq + 3),
-            batch::Inner(loanPayTx, borrowerSeq + 4),
-            batch::Sig(lender, mm2),
-            Ter(tesSUCCESS));
-        env.close();
-
-        if (auto const loanSle = env.le(loanKeylet); BEAST_EXPECT(loanSle))
-            BEAST_EXPECT(loanSle->at(sfPrincipalOutstanding) == 0);
-        BEAST_EXPECT(env.balance(borrower, iou) == iou(8));
-        env.require(Offers(setup.mm1, 0));
-        env.require(Offers(mm2, 0));
-        if (auto const brokerSle = env.le(broker.brokerKeylet()); BEAST_EXPECT(brokerSle))
-            BEAST_EXPECT(brokerSle->at(sfDebtTotal) == 0);
-        if (auto const vaultSle = env.le(broker.vaultKeylet()); BEAST_EXPECT(vaultSle))
-        {
-            BEAST_EXPECT(
-                vaultSle->at(sfAssetsAvailable) == iou(broker.params.vaultDeposit).value());
-        }
-    }
-
-    void
-    testArbitrageRollback(FeatureBitset features)
-    {
-        // Without a second market maker willing to buy XRP back at the
-        // higher price, the sell leg's tfFillOrKill offer cannot fill and
-        // returns tecKILLED. tfAllOrNothing then rolls back every inner,
-        // including the loan origination; the outer batch itself still
-        // returns tesSUCCESS.
-        testcase("arbitrage batch rolls back when the sell offer cannot fill");
-
-        using namespace jtx;
-
-        Env env(*this, features);
-        auto const setup = setupArbitrage(env);
-        auto const& iou = setup.iou;
-        auto const& lender = setup.lender;
-        auto const& borrower = setup.borrower;
-        auto const& broker = setup.broker;
-
-        auto const brokerSleBefore = env.le(broker.brokerKeylet());
-        auto const vaultSleBefore = env.le(broker.vaultKeylet());
-        if (!BEAST_EXPECT(brokerSleBefore) || !BEAST_EXPECT(vaultSleBefore))
-            return;
-        auto const loanSequenceBefore = brokerSleBefore->at(sfLoanSequence);
-        auto const assetsAvailableBefore = vaultSleBefore->at(sfAssetsAvailable);
-
-        auto const loanKeylet = nextLoanKeylet(env, broker);
-        auto const principal = iou(1'000);
-
-        auto const borrowerSeq = env.seq(borrower);
-        auto const borrowerBalanceBefore = env.balance(borrower);
-
-        auto const loanSetTx = loanSetInner(env, borrower, broker.brokerID, lender, principal, 2);
-        auto const loanPayTx =
-            loan::pay(borrower, loanKeylet.key, principal.value(), tfLoanFullPayment);
-
-        auto const batchFee = batch::calcBatchFee(env, 1, 4);
-        env(batch::outer(borrower, borrowerSeq, batchFee, tfAllOrNothing),
-            batch::Inner(loanSetTx, borrowerSeq + 1),
-            batch::Inner(
-                offer(borrower, XRP(400), principal.value(), tfFillOrKill), borrowerSeq + 2),
-            batch::Inner(
-                offer(borrower, iou(1'008).value(), XRP(400), tfFillOrKill), borrowerSeq + 3),
-            batch::Inner(loanPayTx, borrowerSeq + 4),
-            batch::Sig(lender),
-            Ter(tesSUCCESS));
-        env.close();
-
-        BEAST_EXPECT(!env.le(loanKeylet));
-        if (auto const brokerSle = env.le(broker.brokerKeylet()); BEAST_EXPECT(brokerSle))
-        {
-            BEAST_EXPECT(brokerSle->at(sfLoanSequence) == loanSequenceBefore);
-            BEAST_EXPECT(brokerSle->at(sfDebtTotal) == 0);
-        }
-        BEAST_EXPECT(env.balance(borrower, iou) == iou(0));
-        BEAST_EXPECT(env.balance(borrower) == borrowerBalanceBefore - batchFee);
-        env.require(Offers(setup.mm1, 1));
-        if (auto const vaultSle = env.le(broker.vaultKeylet()); BEAST_EXPECT(vaultSle))
-            BEAST_EXPECT(vaultSle->at(sfAssetsAvailable) == assetsAvailableBefore);
-    }
-
-    // Originates a loan outside any batch: one payment due in a day, a day of
-    // grace, zero interest. PaymentTotal 1 is fine because callers only
-    // impair or default the loan and never pay it off early.
-    static void
-    originateLoan(
-        jtx::Env& env,
-        BrokerInfo const& broker,
-        jtx::Account const& lender,
-        jtx::Account const& borrower,
-        STAmount const& principal)
-    {
-        using namespace jtx;
-        using namespace jtx::loan;
-
-        env(set(lender, broker.brokerID, principal),
-            kCounterparty(borrower.id()),
-            kPaymentTotal(1),
-            kPaymentInterval(86400),
-            kGracePeriod(86400),
-            Sig(sfCounterpartySignature, borrower),
-            Fee(env.current()->fees().base * 2));
-        env.close();
-    }
-
-    void
-    testImpairAndCoverDeposit(FeatureBitset features)
-    {
-        // Impairing a loan records its exposure as the vault's unrealized
-        // loss; the broker tops up first-loss cover in the same batch. Under
-        // fixCleanup3_4_0 LoanManage refuses tfLoanImpair with tecTOO_SOON
-        // until a payment is late, so the impairment cannot share a batch
-        // with the LoanSet that creates the loan.
-        testcase("loan impairment and cover deposit in a batch");
-
-        using namespace jtx;
-
-        Env env(*this, features);
-
-        Account const lender{"lender"};
-        Account const borrower{"borrower"};
-        env.fund(XRP(100'000'000), lender, borrower);
-        env.close();
-
-        PrettyAsset const asset{xrpIssue(), 1'000'000};
-        auto const broker = createVaultAndBroker(env, asset, lender);
-
-        auto const loanKeylet = nextLoanKeylet(env, broker);
-        originateLoan(env, broker, lender, borrower, asset(1'000).value());
-
-        auto const loanSleBefore = env.le(loanKeylet);
-        if (!BEAST_EXPECT(loanSleBefore))
-            return;
-
-        // Advance past NextPaymentDueDate so the payment is late.
-        using D = NetClock::duration;
-        using Tp = NetClock::time_point;
-        env.close(Tp{D{loanSleBefore->at(sfNextPaymentDueDate) + 1}});
-
-        auto const brokerSleBefore = env.le(broker.brokerKeylet());
-        auto const vaultSleBefore = env.le(broker.vaultKeylet());
-        if (!BEAST_EXPECT(brokerSleBefore) || !BEAST_EXPECT(vaultSleBefore))
-            return;
-        auto const coverAvailableBefore = brokerSleBefore->at(sfCoverAvailable);
-        auto const lossUnrealizedBefore = vaultSleBefore->at(sfLossUnrealized);
-        auto const additionalCover = asset(500).value();
-
-        auto const lenderSeq = env.seq(lender);
-        auto const batchFee = batch::calcBatchFee(env, 0, 2);
-        env(batch::outer(lender, lenderSeq, batchFee, tfAllOrNothing),
-            batch::Inner(loan::manage(lender, loanKeylet.key, tfLoanImpair), lenderSeq + 1),
-            batch::Inner(
-                loan_broker::coverDeposit(lender, broker.brokerID, additionalCover), lenderSeq + 2),
-            Ter(tesSUCCESS));
-        env.close();
-
-        if (auto const loanSle = env.le(loanKeylet); BEAST_EXPECT(loanSle))
-            BEAST_EXPECT(loanSle->isFlag(lsfLoanImpaired));
-        // Zero interest and fees make the exposure equal the outstanding
-        // principal under both accounting modes.
-        if (auto const vaultSle = env.le(broker.vaultKeylet()); BEAST_EXPECT(vaultSle))
-        {
-            BEAST_EXPECT(
-                vaultSle->at(sfLossUnrealized) ==
-                lossUnrealizedBefore + loanSleBefore->at(sfPrincipalOutstanding));
-        }
-        if (auto const brokerSle = env.le(broker.brokerKeylet()); BEAST_EXPECT(brokerSle))
-            BEAST_EXPECT(brokerSle->at(sfCoverAvailable) == coverAvailableBefore + additionalCover);
-    }
-
-    void
-    testDefaultAndCoverWithdraw(FeatureBitset features)
-    {
-        // A defaulted loan burns first-loss cover per CoverRateLiquidation;
-        // the remainder can be withdrawn once DebtTotal drops to zero. The
-        // default runs in its own batch: LoanManage refuses tfLoanDefault
-        // with tecTOO_SOON until the grace period elapses, so it cannot share
-        // a batch with the LoanSet that creates the loan.
-        testcase("loan default and cover withdraw in a batch");
-
-        using namespace jtx;
-
-        Env env(*this, features);
-
-        Account const lender{"lender"};
-        Account const borrower{"borrower"};
-        env.fund(XRP(100'000'000), lender, borrower);
-        env.close();
-
-        PrettyAsset const asset{xrpIssue(), 1'000'000};
-        auto const broker = createVaultAndBroker(env, asset, lender);
-
-        auto const loanKeylet = nextLoanKeylet(env, broker);
-        originateLoan(env, broker, lender, borrower, asset(1'000).value());
-
-        auto const loanSleBefore = env.le(loanKeylet);
-        if (!BEAST_EXPECT(loanSleBefore))
-            return;
-
-        // Advance past NextPaymentDueDate + GracePeriod so the default is no
-        // longer refused with tecTOO_SOON.
-        auto const dueDate = loanSleBefore->at(sfNextPaymentDueDate);
-        auto const gracePeriod = loanSleBefore->at(sfGracePeriod);
-        using D = NetClock::duration;
-        using Tp = NetClock::time_point;
-        env.close(Tp{D{dueDate + gracePeriod + 1}});
-
-        auto const brokerSleBefore = env.le(broker.brokerKeylet());
-        auto const vaultSleBefore = env.le(broker.vaultKeylet());
-        if (!BEAST_EXPECT(brokerSleBefore) || !BEAST_EXPECT(vaultSleBefore))
-            return;
-
-        auto const coverAvailableBefore = brokerSleBefore->at(sfCoverAvailable);
-        auto const assetsAvailableBefore = vaultSleBefore->at(sfAssetsAvailable);
-        auto const assetsTotalBefore = vaultSleBefore->at(sfAssetsTotal);
-
-        TenthBips32 const coverRateMin{brokerSleBefore->at(sfCoverRateMinimum)};
-        TenthBips32 const coverRateLiquidation{brokerSleBefore->at(sfCoverRateLiquidation)};
-        Number const totalDefaultAmount{loanSleBefore->at(sfPrincipalOutstanding)};
-
-        // DefaultCovered = min(MinimumCover x CoverRateLiquidation,
-        // DefaultAmount, CoverAvailable), matching LoanManage::defaultLoan.
-        // Zero interest and fees make DefaultAmount equal the outstanding
-        // principal under both accounting modes, so no
-        // featureLendingProtocolV1_1 branch is needed here.
-        Number defaultCovered;
-        {
-            NumberRoundModeGuard const mg(Number::RoundingMode::Upward);
-            auto const minimumCover =
-                tenthBipsOfValue(Number{brokerSleBefore->at(sfDebtTotal)}, coverRateMin);
-            defaultCovered = std::min(
-                roundToAsset(
-                    asset.raw(),
-                    std::min(
-                        tenthBipsOfValue(minimumCover, coverRateLiquidation), totalDefaultAmount),
-                    loanSleBefore->at(sfLoanScale)),
-                Number{coverAvailableBefore});
-        }
-        auto const vaultDefaultAmount = totalDefaultAmount - defaultCovered;
-
-        auto const lenderSeq = env.seq(lender);
-        auto const lenderBalanceBefore = env.balance(lender);
-        auto const withdrawAmount = STAmount{asset.raw(), coverAvailableBefore - defaultCovered};
-
-        auto const batchFee = batch::calcBatchFee(env, 0, 2);
-        env(batch::outer(lender, lenderSeq, batchFee, tfAllOrNothing),
-            batch::Inner(loan::manage(lender, loanKeylet.key, tfLoanDefault), lenderSeq + 1),
-            batch::Inner(
-                loan_broker::coverWithdraw(lender, broker.brokerID, withdrawAmount), lenderSeq + 2),
-            Ter(tesSUCCESS));
-        env.close();
-
-        if (auto const loanSle = env.le(loanKeylet); BEAST_EXPECT(loanSle))
-        {
-            BEAST_EXPECT(loanSle->isFlag(lsfLoanDefault));
-            BEAST_EXPECT(loanSle->at(sfPrincipalOutstanding) == 0);
-        }
-        if (auto const brokerSle = env.le(broker.brokerKeylet()); BEAST_EXPECT(brokerSle))
-        {
-            BEAST_EXPECT(brokerSle->at(sfCoverAvailable) == 0);
-            BEAST_EXPECT(brokerSle->at(sfDebtTotal) == 0);
-        }
-        BEAST_EXPECT(env.balance(lender) == lenderBalanceBefore - batchFee + withdrawAmount);
-        // The default moves defaultCovered from the broker's cover to the
-        // vault; the cover withdraw pays out of the broker's own
-        // pseudo-account and does not touch the vault again.
-        if (auto const vaultSle = env.le(broker.vaultKeylet()); BEAST_EXPECT(vaultSle))
-        {
-            BEAST_EXPECT(vaultSle->at(sfAssetsAvailable) == assetsAvailableBefore + defaultCovered);
-            BEAST_EXPECT(vaultSle->at(sfAssetsTotal) == assetsTotalBefore - vaultDefaultAmount);
-        }
-    }
-
-    void
-    testIndependentVaultChain(FeatureBitset features)
-    {
-        // tfIndependent runs every inner regardless of earlier failures.
-        // VaultWithdraw fails before anything is deposited: the empty vault
-        // converts the amount to zero shares (tecPRECISION_LOSS). VaultDelete fails
-        // once the vault holds a deposit (tecHAS_OBLIGATIONS); both are
-        // tec-class results, so neither stops the inners that follow.
-        testcase("independent batch runs every inner despite failing inners");
-
-        using namespace jtx;
-
-        Env env(*this, features);
-
-        Account const owner{"owner"};
-        env.fund(XRP(100'000), owner);
-        env.close();
-
-        Vault const vault{env};
-
-        auto const seq = env.seq(owner);
-        auto const vaultKeylet = keylet::vault(owner.id(), SeqProxy::rawSequence(seq + 1));
-        auto const createTx = std::get<0>(vault.create({.owner = owner, .asset = xrpIssue()}));
-        auto const amount = XRP(1'000);
-
-        auto const batchFee = batch::calcBatchFee(env, 0, 4);
-        auto const batchTx = env.jt(
-            batch::outer(owner, seq, batchFee, tfIndependent),
-            batch::Inner(createTx, seq + 1),
-            batch::Inner(
-                vault.withdraw({.depositor = owner, .id = vaultKeylet.key, .amount = amount}),
-                seq + 2),
-            batch::Inner(
-                vault.deposit({.depositor = owner, .id = vaultKeylet.key, .amount = amount}),
-                seq + 3),
-            batch::Inner(vault.del({.owner = owner, .id = vaultKeylet.key}), seq + 4));
-        env(batchTx, Ter(tesSUCCESS));
-        env.close();
-
-        auto const batchID = strHex(batchTx.stx->getTransactionID());
-        auto const& innerIDs = batchTx.stx->getBatchTransactionIDs();
-        if (!BEAST_EXPECT(innerIDs.size() == 4))
-            return;
-        batch::validateInnerTxn(env, batchID, strHex(innerIDs[0]), "VaultCreate", "tesSUCCESS");
-        batch::validateInnerTxn(
-            env, batchID, strHex(innerIDs[1]), "VaultWithdraw", "tecPRECISION_LOSS");
-        batch::validateInnerTxn(env, batchID, strHex(innerIDs[2]), "VaultDeposit", "tesSUCCESS");
-        batch::validateInnerTxn(
-            env, batchID, strHex(innerIDs[3]), "VaultDelete", "tecHAS_OBLIGATIONS");
-
-        if (auto const vaultSle = env.le(vaultKeylet); BEAST_EXPECT(vaultSle))
-            BEAST_EXPECT(vaultSle->at(sfAssetsTotal) == amount.value());
-        BEAST_EXPECT(env.seq(owner) == seq + 5);
-    }
-
-    void
-    testIndependentLoanChain(FeatureBitset features)
-    {
-        // Same claim as testIndependentVaultChain, on a loan chain. The
-        // LoanSet inner leaves the borrower holding only the 1,000 principal,
-        // so a LoanPay for 2,000 fails preclaim's balance check
-        // (tecINSUFFICIENT_FUNDS); the cover deposit submitted after it
-        // still lands.
-        testcase("independent batch runs every loan inner despite a failing payment");
-
-        using namespace jtx;
-
-        Env env(*this, features);
-
-        Account const issuer{"issuer"};
-        Account const lender{"lender"};
-        Account const borrower{"borrower"};
-        env.fund(XRP(1'000'000), issuer, lender, borrower);
-        env(fset(issuer, asfDefaultRipple));
-        env.close();
-
-        PrettyAsset const iou = issuer[iouCurrency_];
-        STAmount const iouLimit = iou(1'000'000'000);
-        env(trust(lender, iouLimit));
-        env(trust(borrower, iouLimit));
-        env.close();
-
-        env(pay(issuer, lender, iou(2'000'000)));
-        env.close();
-
-        auto const broker = createVaultAndBroker(env, iou, lender);
-
-        auto const loanKeylet = nextLoanKeylet(env, broker);
-        auto const principal = iou(1'000);
-        auto const brokerSleBefore = env.le(broker.brokerKeylet());
-        if (!BEAST_EXPECT(brokerSleBefore))
-            return;
-        auto const coverAvailableBefore = brokerSleBefore->at(sfCoverAvailable);
-
-        auto const lenderSeq = env.seq(lender);
-        auto const borrowerSeq = env.seq(borrower);
-
-        auto const loanSetTx = loanSetInner(env, lender, broker.brokerID, borrower, principal, 2);
-        auto const loanPayTx =
-            loan::pay(borrower, loanKeylet.key, iou(2'000).value(), tfLoanFullPayment);
-        auto const additionalCover = iou(500);
-
-        auto const batchFee = batch::calcBatchFee(env, 1, 3);
-        auto const batchTx = env.jt(
-            batch::outer(lender, lenderSeq, batchFee, tfIndependent),
-            batch::Inner(loanSetTx, lenderSeq + 1),
-            batch::Inner(loanPayTx, borrowerSeq),
-            batch::Inner(
-                loan_broker::coverDeposit(lender, broker.brokerID, additionalCover), lenderSeq + 2),
-            batch::Sig(borrower));
-        env(batchTx, Ter(tesSUCCESS));
-        env.close();
-
-        auto const batchID = strHex(batchTx.stx->getTransactionID());
-        auto const& innerIDs = batchTx.stx->getBatchTransactionIDs();
-        if (!BEAST_EXPECT(innerIDs.size() == 3))
-            return;
-        batch::validateInnerTxn(env, batchID, strHex(innerIDs[0]), "LoanSet", "tesSUCCESS");
-        batch::validateInnerTxn(
-            env, batchID, strHex(innerIDs[1]), "LoanPay", "tecINSUFFICIENT_FUNDS");
-        batch::validateInnerTxn(
-            env, batchID, strHex(innerIDs[2]), "LoanBrokerCoverDeposit", "tesSUCCESS");
-
-        if (auto const loanSle = env.le(loanKeylet); BEAST_EXPECT(loanSle))
-            BEAST_EXPECT(loanSle->at(sfPrincipalOutstanding) == principal.value());
-        if (auto const brokerSle = env.le(broker.brokerKeylet()); BEAST_EXPECT(brokerSle))
-        {
-            BEAST_EXPECT(
-                brokerSle->at(sfCoverAvailable) == coverAvailableBefore + additionalCover.value());
-        }
-    }
-
-public:
-    void
-    run() override
-    {
-        // Batch rejects Vault and Lending inners before LendingProtocolV1_2.
-        FeatureBitset const lendingBatch{all_ | featureLendingProtocolV1_2};
-        for (auto const& features : {lendingBatch, lendingBatch | featureLendingProtocolV1_1})
-        {
-            testVaultLifecycle(features);
-            testArbitrage(features);
-            testArbitrageRollback(features);
-            testImpairAndCoverDeposit(features);
-            testDefaultAndCoverWithdraw(features);
-            testIndependentVaultChain(features);
-            testIndependentLoanChain(features);
-        }
-        testClosedEndedVaultLifecycle(lendingBatch | featureLendingProtocolV1_1);
-        testLoanLifecycleOpenEndedVault(lendingBatch);
-        testLoanLifecycleClosedEndedVault(lendingBatch | featureLendingProtocolV1_1);
-    }
-};
-
-BEAST_DEFINE_TESTSUITE(LendingBatch, tx, xrpl);
-
-}  // namespace xrpl::test
@@ -1249,7 +1249,8 @@ class LoanBroker_test : public beast::unit_test::Suite
        OpenView ov{*env.current()};
        test::StreamSink sink{beast::Severity::Warning};
        beast::Journal const jlog{sink};
-        ApplyContext ac{env.app(), ov, tx, tesSUCCESS, env.current()->fees().base, TapNone, jlog};
+        ApplyContext ac{
+            env.app(), ov, tx, tesSUCCESS, env.current()->fees().base, ApplyFlags::None, jlog};

        if (auto sleBroker = ac.view().peek(keylet::loanBroker(brokerKeylet.key)))
        {
@@ -1262,7 +1263,7 @@ class LoanBroker_test : public beast::unit_test::Suite

        // Invoke preclaim against the mutated (ApplyView) view; triggers
        // nullptr deref
-        PreclaimContext const pctx{env.app(), ac.view(), tesSUCCESS, tx, TapNone, jlog};
+        PreclaimContext const pctx{env.app(), ac.view(), tesSUCCESS, tx, ApplyFlags::None, jlog};
        (void)LoanBrokerCoverDeposit::preclaim(pctx);
    }

@@ -30,8 +30,11 @@
 #include <xrpl/protocol/Serializer.h>
 #include <xrpl/protocol/TER.h>
 #include <xrpl/protocol/TxFlags.h>
+#include <xrpl/protocol/TxFormats.h>
 #include <xrpl/protocol/jss.h>
+#include <xrpl/tx/transactors/system/Batch.h>

+#include <algorithm>
 #include <array>
 #include <cstddef>
 #include <cstdint>
@@ -495,7 +498,8 @@ private:
        // From FIND-001
        testcase << "Batch Bypass Counterparty";

-        bool const lendingBatchEnabled = features[featureLendingProtocolV1_2];
+        bool const lendingBatchEnabled = !std::ranges::any_of(
+            Batch::kDisabledTxTypes, [](auto const& disabled) { return disabled == ttLOAN_SET; });

        using namespace jtx;
        using namespace std::chrono_literals;
@@ -108,7 +108,7 @@ private:
            auto const peek = [keylet, &env, this](std::function<bool(SLE&, SLE&)> fn) -> bool {
                return env.app().getOpenLedger().modify(
                    [&](OpenView& view, beast::Journal j) -> bool {
-                        Sandbox sb(&view, TapNone);
+                        Sandbox sb(&view, ApplyFlags::None);
                        auto vault = sb.peek(keylet::vault(keylet.key));
                        if (!BEAST_EXPECT(vault))
                            return false;
@@ -300,7 +300,7 @@ private:
        env.app().getOpenLedger().modify([&](OpenView& view, beast::Journal j) {
            for (auto const field : encryptedBalanceFields)
            {
-                Sandbox sb(&view, TapNone);
+                Sandbox sb(&view, ApplyFlags::None);
                auto const token = sb.peek(tokenKeylet);
                if (!BEAST_EXPECT(token))
                    return false;
@@ -1902,7 +1902,7 @@ negUnlSizeTest(
 bool
 applyAndTestResult(jtx::Env& env, OpenView& view, STTx const& tx, bool pass)
 {
-    auto const res = apply(env.app(), view, tx, ApplyFlags::TapNone, env.journal);
+    auto const res = apply(env.app(), view, tx, ApplyFlags::None, env.journal);
    if (pass)
    {
        return isTesSuccess(res.ter);
@@ -15,8 +15,6 @@
 #include <concepts>
 #include <cstdint>
 #include <optional>
-#include <source_location>
-#include <string>
 #include <utility>
 #include <vector>

@@ -61,29 +59,6 @@ calcConfidentialBatchFee(jtx::Env const& env, uint32_t const& numSigners, uint32
 json::Value
 outer(jtx::Account const& account, uint32_t seq, STAmount const& fee, std::uint32_t flags);

-/**
- * @brief Expect an inner Batch transaction to be recorded with the given
- * type and result, and with ParentBatchID pointing at its outer Batch.
- *
- * Looks the inner transaction up with the `tx` RPC, so the ledger holding the
- * batch must already be closed. Failures are reported at the caller's line.
- *
- * @param env The test environment.
- * @param batchID Hash of the outer Batch transaction.
- * @param txHash Hash of the inner transaction.
- * @param txType Expected TransactionType, e.g. "Payment".
- * @param result Expected TransactionResult, e.g. "tesSUCCESS".
- * @param loc Call site to report failures at.
- */
-void
-validateInnerTxn(
-    Env& env,
-    std::string const& batchID,
-    std::string const& txHash,
-    std::string const& txType,
-    std::string const& result,
-    std::source_location const& loc = std::source_location::current());
-
 /**
 * @brief Adds an inner Batch transaction to a JTx and autofills it.
 */
@@ -27,8 +27,6 @@
 #include <cstdint>
 #include <optional>
 #include <ostream>
-#include <source_location>
-#include <string>
 #include <utility>

 namespace xrpl::test::jtx::batch {
@@ -64,30 +62,6 @@ outer(jtx::Account const& account, uint32_t seq, STAmount const& fee, std::uint3
    return jv;
 }

-void
-validateInnerTxn(
-    Env& env,
-    std::string const& batchID,
-    std::string const& txHash,
-    std::string const& txType,
-    std::string const& result,
-    std::source_location const& loc)
-{
-    json::Value const jrr = env.rpc("tx", txHash)[jss::result];
-    env.test.expect(
-        jrr[sfTransactionType.jsonName] == txType, "TransactionType", loc.file_name(), loc.line());
-    env.test.expect(
-        jrr[jss::meta][sfTransactionResult.jsonName] == result,
-        "TransactionResult",
-        loc.file_name(),
-        loc.line());
-    env.test.expect(
-        jrr[jss::meta][sfParentBatchID.jsonName] == batchID,
-        "ParentBatchID",
-        loc.file_name(),
-        loc.line());
-}
-
 void
 Inner::operator()(Env& env, JTx& jt) const
 {
@@ -32,7 +32,7 @@ bumpLastPage(
 {
    std::expected<void, Error> res{};
    env.app().getOpenLedger().modify([&](OpenView& view, beast::Journal j) -> bool {
-        Sandbox sb(&view, TapNone);
+        Sandbox sb(&view, ApplyFlags::None);

        // Find the root page
        auto sleRoot = sb.peek(directory);
@@ -313,7 +313,7 @@ struct Directory_test : public beast::unit_test::Suite
        // All the offers have been cancelled, so the book
        // should have no entries and be empty:
        {
-            Sandbox const sb(env.closed().get(), TapNone);
+            Sandbox const sb(env.closed().get(), ApplyFlags::None);
            UInt256 const bookBase = getBookBase({xrpIssue(), usd, std::nullopt});

            BEAST_EXPECT(dirIsEmpty(sb, keylet::page(bookBase)));
@@ -352,7 +352,7 @@ struct Directory_test : public beast::unit_test::Suite

        {
            // Create a chain of three pages:
-            Sandbox sb(env.closed().get(), TapNone);
+            Sandbox sb(env.closed().get(), ApplyFlags::None);
            makePages(sb, kBase, 3);

            // Insert an item in the middle page:
@@ -376,7 +376,7 @@ struct Directory_test : public beast::unit_test::Suite

        {
            // Create a chain of four pages:
-            Sandbox sb(env.closed().get(), TapNone);
+            Sandbox sb(env.closed().get(), ApplyFlags::None);
            makePages(sb, kBase, 4);

            // Now add items on pages 1 and 2:
@@ -131,7 +131,7 @@ class PaymentSandbox_test : public beast::unit_test::Suite
        STAmount const toDebit(usdGw1(20));
        {
            // accountSend, no deferredCredits
-            ApplyViewImpl av(&*env.current(), TapNone);
+            ApplyViewImpl av(&*env.current(), ApplyFlags::None);

            auto const iss = usdGw1;
            auto const startingAmount =
@@ -156,7 +156,7 @@ class PaymentSandbox_test : public beast::unit_test::Suite

        {
            // directSendNoFee, no deferredCredits
-            ApplyViewImpl av(&*env.current(), TapNone);
+            ApplyViewImpl av(&*env.current(), ApplyFlags::None);

            auto const iss = usdGw1;
            auto const startingAmount =
@@ -177,7 +177,7 @@ class PaymentSandbox_test : public beast::unit_test::Suite

        {
            // accountSend, w/ deferredCredits
-            ApplyViewImpl av(&*env.current(), TapNone);
+            ApplyViewImpl av(&*env.current(), ApplyFlags::None);
            PaymentSandbox pv(&av);

            auto const iss = usdGw1;
@@ -205,7 +205,7 @@ class PaymentSandbox_test : public beast::unit_test::Suite

        {
            // directSendNoFee, w/ deferredCredits
-            ApplyViewImpl av(&*env.current(), TapNone);
+            ApplyViewImpl av(&*env.current(), ApplyFlags::None);
            PaymentSandbox pv(&av);

            auto const iss = usdGw1;
@@ -221,7 +221,7 @@ class PaymentSandbox_test : public beast::unit_test::Suite

        {
            // redeemIOU, w/ deferredCredits
-            ApplyViewImpl av(&*env.current(), TapNone);
+            ApplyViewImpl av(&*env.current(), ApplyFlags::None);
            PaymentSandbox pv(&av);

            auto const iss = usdGw1;
@@ -237,7 +237,7 @@ class PaymentSandbox_test : public beast::unit_test::Suite

        {
            // issueIOU, w/ deferredCredits
-            ApplyViewImpl av(&*env.current(), TapNone);
+            ApplyViewImpl av(&*env.current(), ApplyFlags::None);
            PaymentSandbox pv(&av);

            auto const iss = usdGw1;
@@ -253,7 +253,7 @@ class PaymentSandbox_test : public beast::unit_test::Suite

        {
            // accountSend, w/ deferredCredits and stacked views
-            ApplyViewImpl av(&*env.current(), TapNone);
+            ApplyViewImpl av(&*env.current(), ApplyFlags::None);
            PaymentSandbox pv(&av);

            auto const iss = usdGw1;
@@ -319,7 +319,7 @@ class PaymentSandbox_test : public beast::unit_test::Suite
        STAmount const hugeAmt(
            issue, STAmount::kMaxValue, STAmount::kMaxOffset - 1, false, STAmount::Unchecked{});

-        ApplyViewImpl av(&*env.current(), TapNone);
+        ApplyViewImpl av(&*env.current(), ApplyFlags::None);
        PaymentSandbox pv(&av);
        pv.creditHookIOU(gw, alice, hugeAmt, -tinyAmt);
        BEAST_EXPECT(pv.balanceHookIOU(alice, gw, hugeAmt) == tinyAmt);
@@ -347,7 +347,7 @@ class PaymentSandbox_test : public beast::unit_test::Suite
        env.fund(reserve(env, 1), alice);

        env.close();
-        ApplyViewImpl av(&*env.current(), TapNone);
+        ApplyViewImpl av(&*env.current(), ApplyFlags::None);
        PaymentSandbox sb(&av);
        {
            // Send alice an amount and spend it. The deferredCredits will cause
@@ -380,7 +380,7 @@ class PaymentSandbox_test : public beast::unit_test::Suite
        auto const usd = gw["USD"];
        Account const alice("alice");

-        ApplyViewImpl av(&*env.current(), TapNone);
+        ApplyViewImpl av(&*env.current(), ApplyFlags::None);
        PaymentSandbox sb(&av);

        // The currency we pass for the last argument mimics the currency that
@@ -412,7 +412,7 @@ class PaymentSandbox_test : public beast::unit_test::Suite
        env.fund(XRP(10000), alice, sponsor);
        env.close();

-        ApplyViewImpl av(&*env.current(), TapNone);
+        ApplyViewImpl av(&*env.current(), ApplyFlags::None);
        PaymentSandbox sb(&av);

        // Test basic owner count hook without sponsor
@@ -189,7 +189,7 @@ class View_test : public beast::unit_test::Suite
        Env env(*this);
        wipe(env.app().getOpenLedger());
        auto const open = env.current();
-        ApplyViewImpl v(&*open, TapNone);
+        ApplyViewImpl v(&*open, ApplyFlags::None);
        succ(v, 0, std::nullopt);
        v.insert(sle(1));
        BEAST_EXPECT(v.exists(k(1)));
@@ -222,7 +222,7 @@ class View_test : public beast::unit_test::Suite
        Env env(*this);
        wipe(env.app().getOpenLedger());
        auto const open = env.current();
-        ApplyViewImpl v0(&*open, TapNone);
+        ApplyViewImpl v0(&*open, ApplyFlags::None);
        v0.insert(sle(1));
        v0.insert(sle(2));
        v0.insert(sle(4));
@@ -288,7 +288,7 @@ class View_test : public beast::unit_test::Suite
        Env env(*this);
        wipe(env.app().getOpenLedger());
        auto const open = env.current();
-        ApplyViewImpl v0(&*open, TapNone);
+        ApplyViewImpl v0(&*open, ApplyFlags::None);
        v0.rawInsert(sle(1, 1));
        v0.rawInsert(sle(2, 2));
        v0.rawInsert(sle(4, 4));
@@ -368,22 +368,22 @@ class View_test : public beast::unit_test::Suite
                BEAST_EXPECT(v1.seq() == v0.seq());
                BEAST_EXPECT(v1.parentCloseTime() == v1.parentCloseTime());

-                ApplyViewImpl v2(&v1, TapRetry);
+                ApplyViewImpl v2(&v1, ApplyFlags::Retry);
                BEAST_EXPECT(v2.parentCloseTime() == v1.parentCloseTime());
                BEAST_EXPECT(v2.seq() == v1.seq());
-                BEAST_EXPECT(v2.flags() == TapRetry);
+                BEAST_EXPECT(v2.flags() == ApplyFlags::Retry);

                Sandbox const v3(&v2);
                BEAST_EXPECT(v3.seq() == v2.seq());
                BEAST_EXPECT(v3.parentCloseTime() == v2.parentCloseTime());
-                BEAST_EXPECT(v3.flags() == TapRetry);
+                BEAST_EXPECT(v3.flags() == ApplyFlags::Retry);
            }
            {
-                ApplyViewImpl v1(&v0, TapRetry);
+                ApplyViewImpl v1(&v0, ApplyFlags::Retry);
                PaymentSandbox v2(&v1);
                BEAST_EXPECT(v2.seq() == v0.seq());
                BEAST_EXPECT(v2.parentCloseTime() == v0.parentCloseTime());
-                BEAST_EXPECT(v2.flags() == TapRetry);
+                BEAST_EXPECT(v2.flags() == ApplyFlags::Retry);
                PaymentSandbox const v3(&v2);
                BEAST_EXPECT(v3.seq() == v2.seq());
                BEAST_EXPECT(v3.parentCloseTime() == v2.parentCloseTime());
@@ -1028,7 +1028,7 @@ class View_test : public beast::unit_test::Suite
            wipe(*ledger);
            ledger->rawInsert(sle(1));
            ReadView const& v0 = *ledger;
-            ApplyViewImpl v1(&v0, TapNone);
+            ApplyViewImpl v1(&v0, ApplyFlags::None);
            {
                Sandbox v2(&v1);
                v2.erase(v2.peek(k(1)));
@@ -9,6 +9,7 @@
 #include <xrpl/json/json_value.h>
 #include <xrpl/protocol/jss.h>

+#include <algorithm>
 #include <thread>

 namespace xrpl {
@@ -52,36 +53,59 @@ class GetCounts_test : public beast::unit_test::Suite
            // check counts, default params
            result = env.rpc("get_counts")[jss::result];
            BEAST_EXPECT(result[jss::status] == "success");
-            // compare with values reported by CountedObjects
-            auto const& objectCounts = CountedObjects::getInstance().getCounts(10);
-            for (auto const& it : objectCounts)
+
+            // compare with values reported by the registry
+            auto const& counters = result[jss::counters];
+
+            for (auto const& c : gCountedObjects)
            {
-                BEAST_EXPECTS(result.isMember(it.first), it.first);
-                BEAST_EXPECTS(result[it.first].asInt() == it.second, it.first);
+                if (auto const count = c.count(); count >= 10)
+                {
+                    BEAST_EXPECTS(counters.isMember(c.name()), c.name());
+                    BEAST_EXPECTS(counters[c.name()][jss::current].asUInt() == count, c.name());
+                }
            }
+
            BEAST_EXPECT(!result.isMember(jss::local_txs));
        }
-
        {
            // make request with min threshold 100 and verify
-            // that only STObject and NodeObject are reported
+            // that only counters at or above the threshold are reported
            result = env.rpc("get_counts", "100")[jss::result];
            BEAST_EXPECT(result[jss::status] == "success");

-            // compare with values reported by CountedObjects
-            auto const& objectCounts = CountedObjects::getInstance().getCounts(100);
-            for (auto const& it : objectCounts)
-            {
-                BEAST_EXPECTS(result.isMember(it.first), it.first);
-                BEAST_EXPECTS(result[it.first].asInt() == it.second, it.first);
-            }
-            BEAST_EXPECT(!result.isMember("Transaction"));
-            BEAST_EXPECT(!result.isMember("STTx"));
-            BEAST_EXPECT(!result.isMember("STArray"));
-            BEAST_EXPECT(!result.isMember("HashRouterEntry"));
-            BEAST_EXPECT(!result.isMember("STLedgerEntry"));
-        }
+            auto const& counters = result[jss::counters];

+            // every registry counter at/above threshold must be reported, with
+            // a matching current value
+            for (auto const& c : gCountedObjects)
+            {
+                if (auto const count = c.count(); count >= 100)
+                {
+                    BEAST_EXPECTS(counters.isMember(c.name()), c.name());
+                    BEAST_EXPECTS(counters[c.name()][jss::current].asUInt() == count, c.name());
+                }
+            }
+
+            // conversely, every reported entry must be a known counter that met
+            // the threshold, and its maximum must be consistent
+            for (auto const& name : counters.getMemberNames())
+            {
+                auto const it = std::ranges::find_if(
+                    gCountedObjects, [&](auto const& c) { return c.name() == name; });
+                BEAST_EXPECTS(it != gCountedObjects.end(), name);
+
+                auto const& entry = counters[name];
+                BEAST_EXPECTS(entry[jss::current].asUInt() >= 100, name);
+                BEAST_EXPECTS(entry[jss::maximum].asUInt() >= entry[jss::current].asUInt(), name);
+            }
+
+            BEAST_EXPECT(!counters.isMember("xrpl::Transaction"));
+            BEAST_EXPECT(!counters.isMember("xrpl::STTx"));
+            BEAST_EXPECT(!counters.isMember("xrpl::STArray"));
+            BEAST_EXPECT(!counters.isMember("xrpl::HashRouterEntry"));
+            BEAST_EXPECT(!counters.isMember("xrpl::STLedgerEntry"));
+        }
        {
            // local_txs field will exist when there are open Txs
            env(pay(alice, bob, alice["USD"](5)));
Author	SHA1	Message	Date
Nik Bougalis	02e40e7a00	Restructure the spinlock code: - Add function-based spinlock API - Improve comments - Reduce bouncing with contested locks	2026-10-05 19:42:50 -07:00
Nik Bougalis	f14395427e	Modernize CountedObject infrastructure: - Replace the lazy singleton with a constinit registry of per-type static counters. The `getInstance` method is removed. - A concurrency bug that would corrupt the list of counters during insertion has been fixed. - Debug asserts can detect incorrect accounting that can result in counter under- or overflow. - `CountedObject` can only be used as a CRTP base for its own type parameter. - Track the current and maximum values of counter. This results in a change in the output of `get_counts`, with individual counters now reported as sub-objects of a `counters` object.	2026-10-05 19:42:50 -07:00
Nik Bougalis	b707bac74f	Improve AccountID base58 conversion cache: The previous cache guarded a configurably-sized vector with 64 packed spinlocks. Two aspects of that setup were not worth the cost: - Callers were forced to perform atomic RMW operations on a single word which was shared by all 64 locks; this caused the lock line to bounce between cores on every lookup. - The configurable size and runtime initialization resulted in complexity that did not yield a meaningful improvement in performance. This commit ditches the 64 packed spinlocks, replacing them with per-entry sequence locks, allowing readers on the fast path to avoid performing any stores at all. Cache entries are now carefully sized and aligned to fit into a typical cache line, which helps avoid false sharing and any unnecessary coherence traffic. The cache is now a fixed array of 65,536 entries. The size was chosen to balance capacity against memory overhead and to keep the indexing operation fast and simple: since AccountID values are uniformly distributed, two bytes can serve directly as the index without requiring additional hashing. Note: The reader path will perform unsynchronized reads against concurrent writes; the sequence lock protocol detects and discards any data observed mid-update, so these races are benign. A sanitizer like TSAN can still flag them and the warnings are expected. A compile-time knob to disable the cache is available, if necessary.	2026-10-05 19:42:50 -07:00
Nik Bougalis	da2b5d5eaf	Remove beast::typeName Replace Beast's demangling wrapper (originally by @HowardHinnant) with calls to `boost::core::type_name`, eliminating the low-level dependency and manual memory management from the codebase.	2026-10-05 19:42:50 -07:00
Nik Bougalis	4de4902200	Rework and clean up the safe_cast framework: The SafeToCast concept transposed its signedness clause: it was written in <Dest, Src> order but it declared <Src, Dest>. This introduced what can be best described as a polarity bug. As a result: * Signed-to-wider-unsigned casts were wrongly deemed safe. * Unsigned-to-wider-signed casts were wrongly deemed unsafe. The root cause was drift caused by the safety condition being repeated in the concept and again as a static_assert in safeCast. The checking is now done only in the concept and is expressed in terms of range coverage, and not via a sizeof/signedness proxy. This change also improves the handling of bool (which previously compiled despite truncating) and eliminates the platform-dependent accept/reject behavior for same-size types. Additional fixes: * The pointer form of safeDowncast now performs the same static_cast in all builds. The dynamic_cast check is now entirely contained in the XRPL_ASSERT. * Extended integer types wider than intmax_t (e.g. __int128) are now excluded from SafeToCast instead of silently misevaluating through wrapped bounds; they remain expressible via unsafeCast. Cleanups: * Remove the single-parameter enum overload of safeCast: it had an explicitly-specified template argument binding to Src, where all sibling overload bound to Dest, silently yielding the underlying type from expressions that read as casts to an enum. * Add checkedCast for conversions guarded by runtime bounds checks where safety varies per instantiation. * Constrain safeDowncast to polymorphic sources and genuine public unambiguous downcasts, rejecting upcasts and unrelated types. * Route enum conversions through std::to_underlying; clarify the unsafeCast/checkedCast documentation split.	2026-10-05 19:42:49 -07:00
Nik Bougalis	2ea1f09dcb	Modernize beast::Zero for C++20 - Replace the twelve comparison operators with two `constexpr`-capable replacements: `==` and `<=>` and allow the compiler to synthesize the rest. - Constrain `==` and `<=>` using concepts and mark them as conditionally noexcept). - Remove the detail::zero_helper indirection which did not do what its comment claimed.	2026-10-05 19:30:38 -07:00
Nik Bougalis	68b4b894de	Make ApplyFlags a scoped enumeration: Convert ApplyFlags to a scoped enum, drop the now-redundant `Tap` prefix from its enumerators and replace the hand-written bitwise operators by opting in to enum_bitops. No functional change.	2026-10-05 19:30:38 -07:00
Nik Bougalis	defd83e5a6	Make STPathElement::Type a scoped enumeration: `STPathElement` stored its type as an `unsigned int`, returned it as a `std::uint32_t`, while the flags themselves were an unscoped `enum` (i.e. an `int`). The type field has always been serialized as a single byte. This commit turns `STPathElement::Type` into a scoped `enum` with a fixed sized that matches the serialized width, and opts it into the bitwise operators from `enum_bitops.h`: - Store the type as `Type`, and use `Type` for the constructor parameter and the return type of `getNodeType()`. - Keep the existing spellings such as `STPathElement::TypeAccount` valid through `using enum`. - Replace raw mask tests in the serializer, JSON output, strand construction and pathfinder with the existing predicates. - Validate the type byte once when deserializing, before any field is read, and restructure the loop around that. - Make `operator==` a hidden friend. - Mark the trivial accessors `noexcept`. No functional changes are intended. The one observable difference is the rejection error generated for a malformed path element: if the currency and MPT bits are both set and the input is truncated within the account field, the invalid bit combination is detected first; previously the short read would be detected. Such elements are rejected either way.	2026-10-05 19:30:38 -07:00
Nik Bougalis	452e31a05f	Introduce opt-in bitwise operators for scoped enumerations: Scoped enumerations do not support bitwise operators, so using an `enum class` as a set of flags requires extensive casting at call sites or a hand-written set of operators for each type. Add `enum_bitops.h`, which provides `&`, `\|`, `^`, `~` along with the compound assignment forms for any scoped enumeration that has an unsigned underlying type and is opted in: enum class Flags : std::uint8_t { a = 1, b = 2 }; // Opt into bitwise operations template <> struct enum_bitops::OptIn<Flags> : std::true_type {}; All synthesized operators are constexpr and noexcept, and preserve the enumeration type.	2026-10-05 19:30:37 -07:00