diff --git a/.clang-tidy b/.clang-tidy
index 6a967532db..6a7005b464 100644
--- a/.clang-tidy
+++ b/.clang-tidy
@@ -7,6 +7,7 @@ Checks: "-*,
   bugprone-bad-signal-to-kill-thread,
   bugprone-bool-pointer-implicit-conversion,
   bugprone-casting-through-void,
+  bugprone-capturing-this-in-member-variable,
   bugprone-chained-comparison,
   bugprone-compare-pointer-to-member-virtual-function,
   bugprone-copy-constructor-init,
@@ -28,6 +29,7 @@ Checks: "-*,
   bugprone-misplaced-operator-in-strlen-in-alloc,
   bugprone-misplaced-pointer-arithmetic-in-alloc,
   bugprone-misplaced-widening-cast,
+  bugprone-misleading-setter-of-reference,
   bugprone-move-forwarding-reference,
   bugprone-multi-level-implicit-pointer-conversion,
   bugprone-multiple-new-in-one-expression,
@@ -85,6 +87,7 @@ Checks: "-*,
   cppcoreguidelines-pro-type-static-cast-downcast,
   cppcoreguidelines-rvalue-reference-param-not-moved,
   cppcoreguidelines-use-default-member-init,
+  cppcoreguidelines-use-enum-class,
   cppcoreguidelines-virtual-class-destructor,
   hicpp-ignored-remove-result,
   misc-const-correctness,
@@ -109,6 +112,7 @@ Checks: "-*,
   modernize-use-nodiscard,
   modernize-use-override,
   modernize-use-ranges,
+  modernize-use-scoped-lock,
   modernize-use-starts-ends-with,
   modernize-use-std-numbers,
   modernize-use-using,
@@ -122,6 +126,7 @@ Checks: "-*,
   performance-move-constructor-init,
   performance-no-automatic-move,
   performance-trivially-destructible,
+  readability-ambiguous-smartptr-reset-call,
   readability-avoid-nested-conditional-operator,
   readability-avoid-return-with-void-value,
   readability-braces-around-statements,
diff --git a/.github/actions/print-env/action.yml b/.github/actions/print-env/action.yml
deleted file mode 100644
index 3527ca6f02..0000000000
--- a/.github/actions/print-env/action.yml
+++ /dev/null
@@ -1,43 +0,0 @@
-name: Print build environment
-description: "Print environment and some tooling versions"
-
-runs:
-  using: composite
-  steps:
-    - name: Check configuration (Windows)
-      if: ${{ runner.os == 'Windows' }}
-      shell: bash
-      run: |
-        echo 'Checking environment variables.'
-        set
-
-    - name: Check configuration (Linux and macOS)
-      if: ${{ runner.os == 'Linux' || runner.os == 'macOS' }}
-      shell: bash
-      run: |
-        echo 'Checking path.'
-        echo ${PATH} | tr ':' '\n'
-
-        echo 'Checking environment variables.'
-        env | sort
-
-        echo 'Checking compiler version.'
-        ${{ runner.os == 'Linux' && '${CC}' || 'clang' }} --version
-
-        echo 'Checking Ninja version.'
-        ninja --version
-
-        echo 'Checking nproc version.'
-        nproc --version
-
-    - name: Check configuration (all)
-      shell: bash
-      run: |
-        echo 'Checking Ccache version.'
-        ccache --version
-
-        echo 'Checking CMake version.'
-        cmake --version
-
-        echo 'Checking Conan version.'
-        conan --version
diff --git a/.github/dependabot.yml b/.github/dependabot.yml
index 66e319e0e7..0e6b840fe7 100644
--- a/.github/dependabot.yml
+++ b/.github/dependabot.yml
@@ -33,17 +33,6 @@ updates:
       prefix: "ci: [DEPENDABOT] "
     target-branch: develop
 
-  - package-ecosystem: github-actions
-    directory: .github/actions/print-env/
-    schedule:
-      interval: weekly
-      day: monday
-      time: "04:00"
-      timezone: Etc/GMT
-    commit-message:
-      prefix: "ci: [DEPENDABOT] "
-    target-branch: develop
-
   - package-ecosystem: github-actions
     directory: .github/actions/setup-conan/
     schedule:
diff --git a/.github/scripts/levelization/results/ordering.txt b/.github/scripts/levelization/results/ordering.txt
index c3b35bd379..7c43864c54 100644
--- a/.github/scripts/levelization/results/ordering.txt
+++ b/.github/scripts/levelization/results/ordering.txt
@@ -189,10 +189,16 @@ test.toplevel > xrpl.json
 test.unit_test > xrpl.basics
 test.unit_test > xrpl.protocol
 tests.libxrpl > xrpl.basics
+tests.libxrpl > xrpl.core
 tests.libxrpl > xrpl.json
+tests.libxrpl > xrpl.ledger
 tests.libxrpl > xrpl.net
+tests.libxrpl > xrpl.nodestore
 tests.libxrpl > xrpl.protocol
 tests.libxrpl > xrpl.protocol_autogen
+tests.libxrpl > xrpl.server
+tests.libxrpl > xrpl.shamap
+tests.libxrpl > xrpl.tx
 xrpl.conditions > xrpl.basics
 xrpl.conditions > xrpl.protocol
 xrpl.core > xrpl.basics
diff --git a/.github/workflows/pre-commit.yml b/.github/workflows/pre-commit.yml
index 89255f0e47..2f15b82266 100644
--- a/.github/workflows/pre-commit.yml
+++ b/.github/workflows/pre-commit.yml
@@ -14,7 +14,7 @@ on:
 jobs:
   # Call the workflow in the XRPLF/actions repo that runs the pre-commit hooks.
   run-hooks:
-    uses: XRPLF/actions/.github/workflows/pre-commit.yml@9307df762265e15c745ddcdb38a581c989f7f349
+    uses: XRPLF/actions/.github/workflows/pre-commit.yml@5e942d61bf32f7557a7c159cfac4712a687b3e3a
     with:
       runs_on: ubuntu-latest
       container: '{ "image": "ghcr.io/xrplf/ci/tools-rippled-pre-commit:sha-41ec7c1" }'
diff --git a/.github/workflows/reusable-build-test-config.yml b/.github/workflows/reusable-build-test-config.yml
index c2c862d73f..b4cb266004 100644
--- a/.github/workflows/reusable-build-test-config.yml
+++ b/.github/workflows/reusable-build-test-config.yml
@@ -116,7 +116,7 @@ jobs:
         run: echo "CCACHE_LOGFILE=${{ runner.temp }}/ccache.log" >> "${GITHUB_ENV}"
 
       - name: Print build environment
-        uses: ./.github/actions/print-env
+        uses: XRPLF/actions/print-env@8f811899319ef002e7a088c77c57d95aba602a97
 
       - name: Get number of processors
         uses: XRPLF/actions/get-nproc@cf0433aa74563aead044a1e395610c96d65a37cf
diff --git a/.github/workflows/reusable-clang-tidy-files.yml b/.github/workflows/reusable-clang-tidy-files.yml
index 9b99f418b1..75969060a5 100644
--- a/.github/workflows/reusable-clang-tidy-files.yml
+++ b/.github/workflows/reusable-clang-tidy-files.yml
@@ -40,7 +40,7 @@ jobs:
           enable_ccache: false
 
       - name: Print build environment
-        uses: ./.github/actions/print-env
+        uses: XRPLF/actions/print-env@8f811899319ef002e7a088c77c57d95aba602a97
 
       - name: Get number of processors
         uses: XRPLF/actions/get-nproc@cf0433aa74563aead044a1e395610c96d65a37cf
diff --git a/.github/workflows/upload-conan-deps.yml b/.github/workflows/upload-conan-deps.yml
index f14efde05b..49c9ab041a 100644
--- a/.github/workflows/upload-conan-deps.yml
+++ b/.github/workflows/upload-conan-deps.yml
@@ -75,7 +75,7 @@ jobs:
           enable_ccache: false
 
       - name: Print build environment
-        uses: ./.github/actions/print-env
+        uses: XRPLF/actions/print-env@8f811899319ef002e7a088c77c57d95aba602a97
 
       - name: Get number of processors
         uses: XRPLF/actions/get-nproc@cf0433aa74563aead044a1e395610c96d65a37cf
diff --git a/API-CHANGELOG.md b/API-CHANGELOG.md
index d5faaf70af..56a45c132a 100644
--- a/API-CHANGELOG.md
+++ b/API-CHANGELOG.md
@@ -28,6 +28,8 @@ This section contains changes targeting a future version.
 
 ### Additions
 
+- `ledger_entry`, `account_objects`: The `Delegate` ledger entry now includes an optional `DestinationNode` field, which stores the index into the authorized account's owner directory. This field is present on entries created after bidirectional directory tracking was introduced and may appear in RPC responses for those entries. ([#6681](https://github.com/XRPLF/rippled/pull/6681))
+
 - `server_definitions`: Added the following new sections to the response ([#6321](https://github.com/XRPLF/rippled/pull/6321)):
   - `TRANSACTION_FORMATS`: Describes the fields and their optionality for each transaction type, including common fields shared across all transactions.
   - `LEDGER_ENTRY_FORMATS`: Describes the fields and their optionality for each ledger entry type, including common fields shared across all ledger entries.
@@ -40,6 +42,14 @@ This section contains changes targeting a future version.
 - Peer Crawler: The `port` field in `overlay.active[]` now consistently returns an integer instead of a string for outbound peers. [#6318](https://github.com/XRPLF/rippled/pull/6318)
 - `ping`: The `ip` field is no longer returned as an empty string for proxied connections without a forwarded-for header. It is now omitted, consistent with the behavior for identified connections. [#6730](https://github.com/XRPLF/rippled/pull/6730)
 - gRPC `GetLedgerDiff`: Fixed error message that incorrectly said "base ledger not validated" when the desired ledger was not validated. [#6730](https://github.com/XRPLF/rippled/pull/6730)
+- `account_channels`: The `destination_account` field now returns an error if the value is not a string. [#6529](https://github.com/XRPLF/rippled/pull/6529)
+- `subscribe`: The `taker` field in the `books` array now returns an error if the value is not a string. [#6529](https://github.com/XRPLF/rippled/pull/6529)
+- `account_info`: The `urlgravatar` field now uses HTTPS instead of HTTP. [#6529](https://github.com/XRPLF/rippled/pull/6529)
+- `ledger`: The `full`, `accounts`, `transactions`, `expand`, `binary`, `owner_funds`, and `queue` fields now return an error if the value is not a boolean. [#6529](https://github.com/XRPLF/rippled/pull/6529)
+- `ledger_data`: The `binary` field now returns an error if the value is not a boolean. [#6529](https://github.com/XRPLF/rippled/pull/6529)
+- `submit`: The `fail_hard` field now returns an error if the value is not a boolean. [#6529](https://github.com/XRPLF/rippled/pull/6529)
+- `subscribe`: The `taker` field in the `books` array now returns `actMalformed` instead of `badIssuer` if the value is not a valid account. [#6529](https://github.com/XRPLF/rippled/pull/6529)
+- Fixed a bug in `Forwarded` HTTP header parsing where the extracted IP address could be incorrect when no comma or semicolon delimiter follows the address. This could cause the server to misidentify a client's IP address when operating behind a reverse proxy. [#6529](https://github.com/XRPLF/rippled/pull/6529)
 
 ## XRP Ledger server version 3.1.0
 
diff --git a/include/xrpl/basics/Log.h b/include/xrpl/basics/Log.h
index 58cca4f486..5c63166d93 100644
--- a/include/xrpl/basics/Log.h
+++ b/include/xrpl/basics/Log.h
@@ -15,6 +15,7 @@
 namespace xrpl {
 
 // DEPRECATED use beast::severities::Severity instead
+// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
 enum LogSeverity {
     lsINVALID = -1,  // used to indicate an invalid severity
     lsTRACE = 0,     // Very low-level progress information, details inside
@@ -207,6 +208,8 @@ public:
     fromString(std::string const& s);
 
 private:
+    // Need to be named before converting
+    // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
     enum {
         // Maximum line length for log messages.
         // If the message exceeds this length it will be truncated with
diff --git a/include/xrpl/basics/Mutex.hpp b/include/xrpl/basics/Mutex.hpp
index 5855ee2017..4432e27b4b 100644
--- a/include/xrpl/basics/Mutex.hpp
+++ b/include/xrpl/basics/Mutex.hpp
@@ -131,7 +131,7 @@ public:
      * @tparam LockType The type of lock to use
      * @return A lock on the mutex and a reference to the protected data
      */
-    template <template <typename...> typename LockType = std::lock_guard>
+    template <template <typename...> typename LockType = std::scoped_lock>
     Lock<ProtectedDataType const, LockType, MutexType>
     lock() const
     {
@@ -144,7 +144,7 @@ public:
      * @tparam LockType The type of lock to use
      * @return A lock on the mutex and a reference to the protected data
      */
-    template <template <typename...> typename LockType = std::lock_guard>
+    template <template <typename...> typename LockType = std::scoped_lock>
     Lock<ProtectedDataType, LockType, MutexType>
     lock()
     {
diff --git a/include/xrpl/basics/Number.h b/include/xrpl/basics/Number.h
index d14b17a042..b82cb628b9 100644
--- a/include/xrpl/basics/Number.h
+++ b/include/xrpl/basics/Number.h
@@ -70,7 +70,7 @@ isPowerOfTen(T value)
 struct MantissaRange
 {
     using rep = std::uint64_t;
-    enum mantissa_scale { small, large };
+    enum class mantissa_scale { small, large };
 
     explicit constexpr MantissaRange(mantissa_scale scale_)
         : min(getMin(scale_)), log(logTen(min).value_or(-1)), scale(scale_)
@@ -88,9 +88,9 @@ private:
     {
         switch (scale_)
         {
-            case small:
+            case mantissa_scale::small:
                 return 1'000'000'000'000'000ULL;
-            case large:
+            case mantissa_scale::large:
                 return 1'000'000'000'000'000'000ULL;
             default:
                 // Since this can never be called outside a non-constexpr
@@ -384,7 +384,7 @@ public:
     root2(Number f);
 
     // Thread local rounding control.  Default is to_nearest
-    enum rounding_mode { to_nearest, towards_zero, downward, upward };
+    enum class rounding_mode { to_nearest, towards_zero, downward, upward };
     static rounding_mode
     getround();
     // Returns previously set mode
@@ -443,14 +443,14 @@ private:
     static thread_local rounding_mode mode_;
     // The available ranges for mantissa
 
-    constexpr static MantissaRange smallRange{MantissaRange::small};
+    constexpr static MantissaRange smallRange{MantissaRange::mantissa_scale::small};
     static_assert(isPowerOfTen(smallRange.min));
     static_assert(smallRange.min == 1'000'000'000'000'000LL);
     static_assert(smallRange.max == 9'999'999'999'999'999LL);
     static_assert(smallRange.log == 15);
     static_assert(smallRange.min < maxRep);
     static_assert(smallRange.max < maxRep);
-    constexpr static MantissaRange largeRange{MantissaRange::large};
+    constexpr static MantissaRange largeRange{MantissaRange::mantissa_scale::large};
     static_assert(isPowerOfTen(largeRange.min));
     static_assert(largeRange.min == 1'000'000'000'000'000'000ULL);
     static_assert(largeRange.max == internalrep(9'999'999'999'999'999'999ULL));
@@ -759,9 +759,9 @@ to_string(MantissaRange::mantissa_scale const& scale)
 {
     switch (scale)
     {
-        case MantissaRange::small:
+        case MantissaRange::mantissa_scale::small:
             return "small";
-        case MantissaRange::large:
+        case MantissaRange::mantissa_scale::large:
             return "large";
         default:
             throw std::runtime_error("Bad scale");
diff --git a/include/xrpl/basics/SlabAllocator.h b/include/xrpl/basics/SlabAllocator.h
index 39be029b42..ddcc89d2da 100644
--- a/include/xrpl/basics/SlabAllocator.h
+++ b/include/xrpl/basics/SlabAllocator.h
@@ -92,7 +92,7 @@ class SlabAllocator
             std::uint8_t* ret = nullptr;  // NOLINT(misc-const-correctness)
 
             {
-                std::lock_guard const l(m_);
+                std::scoped_lock const l(m_);
 
                 ret = l_;
 
@@ -121,7 +121,7 @@ class SlabAllocator
         {
             XRPL_ASSERT(own(ptr), "xrpl::SlabAllocator::SlabBlock::deallocate : own input");
 
-            std::lock_guard const l(m_);
+            std::scoped_lock const l(m_);
 
             // Use memcpy to avoid unaligned UB
             // (will optimize to equivalent code)
diff --git a/include/xrpl/basics/TaggedCache.h b/include/xrpl/basics/TaggedCache.h
index 8cb0c6bfdf..95703f0633 100644
--- a/include/xrpl/basics/TaggedCache.h
+++ b/include/xrpl/basics/TaggedCache.h
@@ -166,7 +166,7 @@ public:
 
 private:
     SharedPointerType
-    initialFetch(key_type const& key, std::lock_guard<mutex_type> const& l);
+    initialFetch(key_type const& key, std::scoped_lock<mutex_type> const& l);
 
     void
     collect_metrics();
@@ -266,7 +266,7 @@ private:
         typename KeyValueCacheType::map_type& partition,
         SweptPointersVector& stuffToSweep,
         std::atomic<int>& allRemovals,
-        std::lock_guard<std::recursive_mutex> const&);
+        std::scoped_lock<std::recursive_mutex> const&);
 
     [[nodiscard]] std::thread
     sweepHelper(
@@ -275,7 +275,7 @@ private:
         typename KeyOnlyCacheType::map_type& partition,
         SweptPointersVector&,
         std::atomic<int>& allRemovals,
-        std::lock_guard<std::recursive_mutex> const&);
+        std::scoped_lock<std::recursive_mutex> const&);
 
     beast::Journal m_journal;
     clock_type& m_clock;
diff --git a/include/xrpl/basics/TaggedCache.ipp b/include/xrpl/basics/TaggedCache.ipp
index 6879ad435d..67c80b554e 100644
--- a/include/xrpl/basics/TaggedCache.ipp
+++ b/include/xrpl/basics/TaggedCache.ipp
@@ -69,7 +69,7 @@ inline std::size_t
 TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
     size() const
 {
-    std::lock_guard lock(m_mutex);
+    std::scoped_lock lock(m_mutex);
     return m_cache.size();
 }
 
@@ -86,7 +86,7 @@ inline int
 TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
     getCacheSize() const
 {
-    std::lock_guard lock(m_mutex);
+    std::scoped_lock lock(m_mutex);
     return m_cache_count;
 }
 
@@ -103,7 +103,7 @@ inline int
 TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
     getTrackSize() const
 {
-    std::lock_guard lock(m_mutex);
+    std::scoped_lock lock(m_mutex);
     return m_cache.size();
 }
 
@@ -120,7 +120,7 @@ inline float
 TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
     getHitRate()
 {
-    std::lock_guard lock(m_mutex);
+    std::scoped_lock lock(m_mutex);
     auto const total = static_cast<float>(m_hits + m_misses);
     return m_hits * (100.0f / std::max(1.0f, total));
 }
@@ -138,7 +138,7 @@ inline void
 TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
     clear()
 {
-    std::lock_guard lock(m_mutex);
+    std::scoped_lock lock(m_mutex);
     m_cache.clear();
     m_cache_count = 0;
 }
@@ -156,7 +156,7 @@ inline void
 TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
     reset()
 {
-    std::lock_guard lock(m_mutex);
+    std::scoped_lock lock(m_mutex);
     m_cache.clear();
     m_cache_count = 0;
     m_hits = 0;
@@ -177,7 +177,7 @@ inline bool
 TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
     touch_if_exists(KeyComparable const& key)
 {
-    std::lock_guard lock(m_mutex);
+    std::scoped_lock lock(m_mutex);
     auto const iter(m_cache.find(key));
     if (iter == m_cache.end())
     {
@@ -212,7 +212,7 @@ TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash,
 
     auto const start = std::chrono::steady_clock::now();
     {
-        std::lock_guard lock(m_mutex);
+        std::scoped_lock lock(m_mutex);
 
         if (m_target_size == 0 || (static_cast<int>(m_cache.size()) <= m_target_size))
         {
@@ -269,7 +269,7 @@ TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash,
 {
     // Remove from cache, if !valid, remove from map too. Returns true if
     // removed from cache
-    std::lock_guard lock(m_mutex);
+    std::scoped_lock lock(m_mutex);
 
     auto cit = m_cache.find(key);
 
@@ -309,7 +309,7 @@ TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash,
 {
     // Return canonical value, store if needed, refresh in cache
     // Return values: true=we had the data already
-    std::lock_guard lock(m_mutex);
+    std::scoped_lock lock(m_mutex);
 
     auto cit = m_cache.find(key);
 
@@ -423,7 +423,7 @@ inline SharedPointerType
 TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
     fetch(key_type const& key)
 {
-    std::lock_guard<mutex_type> l(m_mutex);
+    std::scoped_lock<mutex_type> l(m_mutex);
     auto ret = initialFetch(key, l);
     if (!ret)
         ++m_misses;
@@ -474,7 +474,7 @@ inline auto
 TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
     insert(key_type const& key) -> std::enable_if_t<IsKeyCache, ReturnType>
 {
-    std::lock_guard lock(m_mutex);
+    std::scoped_lock lock(m_mutex);
     clock_type::time_point const now(m_clock.now());
     auto [it, inserted] = m_cache.emplace(
         std::piecewise_construct, std::forward_as_tuple(key), std::forward_as_tuple(now));
@@ -538,7 +538,7 @@ TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash,
     std::vector<key_type> v;
 
     {
-        std::lock_guard lock(m_mutex);
+        std::scoped_lock lock(m_mutex);
         v.reserve(m_cache.size());
         for (auto const& _ : m_cache)
             v.push_back(_.first);
@@ -560,7 +560,7 @@ inline double
 TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
     rate() const
 {
-    std::lock_guard lock(m_mutex);
+    std::scoped_lock lock(m_mutex);
     auto const tot = m_hits + m_misses;
     if (tot == 0)
         return 0;
@@ -582,7 +582,7 @@ TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash,
     fetch(key_type const& digest, Handler const& h)
 {
     {
-        std::lock_guard l(m_mutex);
+        std::scoped_lock l(m_mutex);
         if (auto ret = initialFetch(digest, l))
             return ret;
     }
@@ -591,7 +591,7 @@ TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash,
     if (!sle)
         return {};
 
-    std::lock_guard l(m_mutex);
+    std::scoped_lock l(m_mutex);
     ++m_misses;
     auto const [it, inserted] = m_cache.emplace(digest, Entry(m_clock.now(), std::move(sle)));
     if (!inserted)
@@ -611,7 +611,7 @@ template <
     class Mutex>
 inline SharedPointerType
 TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
-    initialFetch(key_type const& key, std::lock_guard<mutex_type> const& l)
+    initialFetch(key_type const& key, std::scoped_lock<mutex_type> const& l)
 {
     auto cit = m_cache.find(key);
     if (cit == m_cache.end())
@@ -655,7 +655,7 @@ TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash,
     {
         beast::insight::Gauge::value_type hit_rate(0);
         {
-            std::lock_guard lock(m_mutex);
+            std::scoped_lock lock(m_mutex);
             auto const total(m_hits + m_misses);
             if (total != 0)
                 hit_rate = (m_hits * 100) / total;
@@ -681,7 +681,7 @@ TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash,
         typename KeyValueCacheType::map_type& partition,
         SweptPointersVector& stuffToSweep,
         std::atomic<int>& allRemovals,
-        std::lock_guard<std::recursive_mutex> const&)
+        std::scoped_lock<std::recursive_mutex> const&)
 {
     return std::thread([&, this]() {
         int cacheRemovals = 0;
@@ -761,7 +761,7 @@ TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash,
         typename KeyOnlyCacheType::map_type& partition,
         SweptPointersVector&,
         std::atomic<int>& allRemovals,
-        std::lock_guard<std::recursive_mutex> const&)
+        std::scoped_lock<std::recursive_mutex> const&)
 {
     return std::thread([&, this]() {
         int cacheRemovals = 0;
diff --git a/include/xrpl/basics/hardened_hash.h b/include/xrpl/basics/hardened_hash.h
index 3ff14c22c8..2722a5a4a7 100644
--- a/include/xrpl/basics/hardened_hash.h
+++ b/include/xrpl/basics/hardened_hash.h
@@ -32,7 +32,7 @@ make_seed_pair() noexcept
         // state_t& operator=(state_t const&) = delete;
     };
     static state_t state;
-    std::lock_guard const lock(state.mutex);
+    std::scoped_lock const lock(state.mutex);
     return {state.dist(state.gen), state.dist(state.gen)};
 }
 
diff --git a/include/xrpl/basics/random.h b/include/xrpl/basics/random.h
index adf579442e..a4018b7e5f 100644
--- a/include/xrpl/basics/random.h
+++ b/include/xrpl/basics/random.h
@@ -60,7 +60,7 @@ default_prng()
     thread_local beast::xor_shift_engine engine = [] {
         std::uint64_t seed = 0;
         {
-            std::lock_guard const lk(m);
+            std::scoped_lock const lk(m);
             std::uniform_int_distribution<std::uint64_t> distribution{1};
             seed = distribution(seeder);
         }
diff --git a/include/xrpl/beast/asio/io_latency_probe.h b/include/xrpl/beast/asio/io_latency_probe.h
index dccb6d24b4..f85f399196 100644
--- a/include/xrpl/beast/asio/io_latency_probe.h
+++ b/include/xrpl/beast/asio/io_latency_probe.h
@@ -83,7 +83,7 @@ public:
     void
     sample_one(Handler&& handler)
     {
-        std::lock_guard const lock(m_mutex);
+        std::scoped_lock const lock(m_mutex);
         if (m_cancel)
             throw std::logic_error("io_latency_probe is canceled");
         boost::asio::post(
@@ -98,7 +98,7 @@ public:
     void
     sample(Handler&& handler)
     {
-        std::lock_guard const lock(m_mutex);
+        std::scoped_lock const lock(m_mutex);
         if (m_cancel)
             throw std::logic_error("io_latency_probe is canceled");
         boost::asio::post(
@@ -122,14 +122,14 @@ private:
     void
     addref()
     {
-        std::lock_guard const lock(m_mutex);
+        std::scoped_lock const lock(m_mutex);
         ++m_count;
     }
 
     void
     release()
     {
-        std::lock_guard const lock(m_mutex);
+        std::scoped_lock const lock(m_mutex);
         if (--m_count == 0)
             m_cond.notify_all();
     }
@@ -192,7 +192,7 @@ private:
             m_handler(elapsed);
 
             {
-                std::lock_guard const lock(m_probe->m_mutex);
+                std::scoped_lock const lock(m_probe->m_mutex);
                 if (m_probe->m_cancel)
                     return;
             }
diff --git a/include/xrpl/beast/test/yield_to.h b/include/xrpl/beast/test/yield_to.h
index 4723fb49b8..6c7f293122 100644
--- a/include/xrpl/beast/test/yield_to.h
+++ b/include/xrpl/beast/test/yield_to.h
@@ -115,7 +115,7 @@ enable_yield_to::spawn(F0&& f, FN&&... fn)
         boost::context::fixedsize_stack(2 * 1024 * 1024),
         [&](yield_context yield) {
             f(yield);
-            std::lock_guard const lock{m_};
+            std::scoped_lock const lock{m_};
             if (--running_ == 0)
                 cv_.notify_all();
         },
diff --git a/include/xrpl/beast/unit_test/match.h b/include/xrpl/beast/unit_test/match.h
index 084e2bc464..dbafd67da5 100644
--- a/include/xrpl/beast/unit_test/match.h
+++ b/include/xrpl/beast/unit_test/match.h
@@ -14,7 +14,7 @@ namespace beast::unit_test {
 class selector
 {
 public:
-    enum mode_t {
+    enum class mode_t {
         // Run all tests except manual ones
         all,
 
@@ -53,8 +53,8 @@ public:
 template <class>
 selector::selector(mode_t mode, std::string const& pattern) : mode_(mode), pat_(pattern)
 {
-    if (mode_ == automatch && pattern.empty())
-        mode_ = all;
+    if (mode_ == mode_t::automatch && pattern.empty())
+        mode_ = mode_t::all;
 }
 
 template <class>
@@ -63,18 +63,18 @@ selector::operator()(suite_info const& s)
 {
     switch (mode_)
     {
-        case automatch:
+        case mode_t::automatch:
             // suite or full name
             if (s.name() == pat_ || s.full_name() == pat_)
             {
-                mode_ = none;
+                mode_ = mode_t::none;
                 return true;
             }
 
             // check module
             if (pat_ == s.module())
             {
-                mode_ = module;
+                mode_ = mode_t::module;
                 library_ = s.library();
                 return !s.manual();
             }
@@ -82,7 +82,7 @@ selector::operator()(suite_info const& s)
             // check library
             if (pat_ == s.library())
             {
-                mode_ = library;
+                mode_ = mode_t::library;
                 return !s.manual();
             }
 
@@ -96,19 +96,19 @@ selector::operator()(suite_info const& s)
 
             return false;
 
-        case suite:
+        case mode_t::suite:
             return pat_ == s.name();
 
-        case module:
+        case mode_t::module:
             return pat_ == s.module() && !s.manual();
 
-        case library:
+        case mode_t::library:
             return pat_ == s.library() && !s.manual();
 
-        case none:
+        case mode_t::none:
             return false;
 
-        case all:
+        case mode_t::all:
         default:
             break;
     };
@@ -138,28 +138,28 @@ selector::operator()(suite_info const& s)
 inline selector
 match_auto(std::string const& name)
 {
-    return selector(selector::automatch, name);
+    return selector(selector::mode_t::automatch, name);
 }
 
 /** Return a predicate that matches all suites not marked manual. */
 inline selector
 match_all()
 {
-    return selector(selector::all);
+    return selector(selector::mode_t::all);
 }
 
 /** Returns a predicate that matches a specific suite. */
 inline selector
 match_suite(std::string const& name)
 {
-    return selector(selector::suite, name);
+    return selector(selector::mode_t::suite, name);
 }
 
 /** Returns a predicate that matches all suites in a library. */
 inline selector
 match_library(std::string const& name)
 {
-    return selector(selector::library, name);
+    return selector(selector::mode_t::library, name);
 }
 
 }  // namespace beast::unit_test
diff --git a/include/xrpl/beast/unit_test/reporter.h b/include/xrpl/beast/unit_test/reporter.h
index 066d628ea2..58bea93b2f 100644
--- a/include/xrpl/beast/unit_test/reporter.h
+++ b/include/xrpl/beast/unit_test/reporter.h
@@ -62,6 +62,8 @@ private:
     {
         using run_time = std::pair<std::string, typename clock_type::duration>;
 
+        // Need to be named before converting
+        // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
         enum { max_top = 10 };
 
         std::size_t suites = 0;
diff --git a/include/xrpl/beast/unit_test/runner.h b/include/xrpl/beast/unit_test/runner.h
index 2fdfbefa57..5601a8725f 100644
--- a/include/xrpl/beast/unit_test/runner.h
+++ b/include/xrpl/beast/unit_test/runner.h
@@ -231,7 +231,7 @@ template <class>
 void
 runner::testcase(std::string const& name)
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     // Name may not be empty
     BOOST_ASSERT(default_ || !name.empty());
     // Forgot to call pass or fail
@@ -247,7 +247,7 @@ template <class>
 void
 runner::pass()
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     if (default_)
         testcase("");
     on_pass();
@@ -258,7 +258,7 @@ template <class>
 void
 runner::fail(std::string const& reason)
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     if (default_)
         testcase("");
     on_fail(reason);
@@ -270,7 +270,7 @@ template <class>
 void
 runner::log(std::string const& s)
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     if (default_)
         testcase("");
     on_log(s);
diff --git a/include/xrpl/beast/unit_test/suite.h b/include/xrpl/beast/unit_test/suite.h
index a7b9d3bacb..c6967ecfe3 100644
--- a/include/xrpl/beast/unit_test/suite.h
+++ b/include/xrpl/beast/unit_test/suite.h
@@ -37,7 +37,7 @@ make_reason(String const& reason, char const* file, int line)
 
 class Thread;
 
-enum abort_t { no_abort_on_fail, abort_on_fail };
+enum class abort_t { no_abort_on_fail, abort_on_fail };
 
 /** A testsuite class.
 
@@ -127,7 +127,7 @@ private:
             @param abort Determines if suite continues running after a failure.
         */
         void
-        operator()(std::string const& name, abort_t abort = no_abort_on_fail);
+        operator()(std::string const& name, abort_t abort = abort_t::no_abort_on_fail);
 
         scoped_testcase
         operator()(abort_t abort);
@@ -363,14 +363,14 @@ public:
 inline void
 suite::testcase_t::operator()(std::string const& name, abort_t abort)
 {
-    suite_.abort_ = abort == abort_on_fail;
+    suite_.abort_ = abort == abort_t::abort_on_fail;
     suite_.runner_->testcase(name);
 }
 
 inline suite::scoped_testcase
 suite::testcase_t::operator()(abort_t abort)
 {
-    suite_.abort_ = abort == abort_on_fail;
+    suite_.abort_ = abort == abort_t::abort_on_fail;
     return {suite_, ss_};
 }
 
diff --git a/include/xrpl/beast/utility/Journal.h b/include/xrpl/beast/utility/Journal.h
index a056ce8d79..45b7b671cb 100644
--- a/include/xrpl/beast/utility/Journal.h
+++ b/include/xrpl/beast/utility/Journal.h
@@ -9,6 +9,8 @@ namespace beast {
 /** A namespace for easy access to logging severity values. */
 namespace severities {
 /** Severity level / threshold of a Journal message. */
+// Hundreds of usages via logging macros
+// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
 enum Severity {
     kAll = 0,
 
diff --git a/include/xrpl/core/ClosureCounter.h b/include/xrpl/core/ClosureCounter.h
index bcdfa7d673..76e52cb3cd 100644
--- a/include/xrpl/core/ClosureCounter.h
+++ b/include/xrpl/core/ClosureCounter.h
@@ -56,7 +56,7 @@ private:
         // a lock.  This removes a small timing window that occurs if the
         // waiting thread is handling a spurious wakeup when closureCount_
         // drops to zero.
-        std::lock_guard const lock{mutex_};
+        std::scoped_lock const lock{mutex_};
 
         // Update closureCount_.  Notify if stopping and closureCount_ == 0.
         if ((--closureCount_ == 0) && waitForClosures_)
@@ -170,7 +170,7 @@ public:
     {
         std::optional<Substitute<Closure>> ret;
 
-        std::lock_guard const lock{mutex_};
+        std::scoped_lock const lock{mutex_};
         if (!waitForClosures_)
             ret.emplace(*this, std::forward<Closure>(closure));
 
@@ -193,7 +193,7 @@ public:
     bool
     joined() const
     {
-        std::lock_guard const lock{mutex_};
+        std::scoped_lock const lock{mutex_};
         return waitForClosures_;
     }
 };
diff --git a/include/xrpl/core/Coro.ipp b/include/xrpl/core/Coro.ipp
index 38d921a658..2343f805a5 100644
--- a/include/xrpl/core/Coro.ipp
+++ b/include/xrpl/core/Coro.ipp
@@ -34,7 +34,7 @@ inline void
 JobQueue::Coro::yield() const
 {
     {
-        std::lock_guard lock(jq_.m_mutex);
+        std::scoped_lock lock(jq_.m_mutex);
         ++jq_.nSuspend_;
     }
     (*yield_)();
@@ -44,7 +44,7 @@ inline bool
 JobQueue::Coro::post()
 {
     {
-        std::lock_guard lk(mutex_run_);
+        std::scoped_lock lk(mutex_run_);
         running_ = true;
     }
 
@@ -55,7 +55,7 @@ JobQueue::Coro::post()
     }
 
     // The coroutine will not run.  Clean up running_.
-    std::lock_guard lk(mutex_run_);
+    std::scoped_lock lk(mutex_run_);
     running_ = false;
     cv_.notify_all();
     return false;
@@ -65,16 +65,16 @@ inline void
 JobQueue::Coro::resume()
 {
     {
-        std::lock_guard lk(mutex_run_);
+        std::scoped_lock lk(mutex_run_);
         running_ = true;
     }
     {
-        std::lock_guard lk(jq_.m_mutex);
+        std::scoped_lock lk(jq_.m_mutex);
         --jq_.nSuspend_;
     }
     auto saved = detail::getLocalValues().release();
     detail::getLocalValues().reset(&lvs_);
-    std::lock_guard lock(mutex_);
+    std::scoped_lock lock(mutex_);
     // A late resume() can arrive after the coroutine has already completed.
     // This is an expected (if rare) outcome of the race condition documented
     // in JobQueue.h:354-377 where post() schedules a resume job before the
@@ -89,7 +89,7 @@ JobQueue::Coro::resume()
     }
     detail::getLocalValues().release();
     detail::getLocalValues().reset(saved);
-    std::lock_guard lk(mutex_run_);
+    std::scoped_lock lk(mutex_run_);
     running_ = false;
     cv_.notify_all();
 }
@@ -113,7 +113,7 @@ JobQueue::Coro::expectEarlyExit()
         //
         // That said, since we're outside the Coro's stack, we need to
         // decrement the nSuspend that the Coro's call to yield caused.
-        std::lock_guard lock(jq_.m_mutex);
+        std::scoped_lock lock(jq_.m_mutex);
         --jq_.nSuspend_;
 #ifndef NDEBUG
         finished_ = true;
diff --git a/include/xrpl/core/Job.h b/include/xrpl/core/Job.h
index 9954fc4ba4..2fe5ab263c 100644
--- a/include/xrpl/core/Job.h
+++ b/include/xrpl/core/Job.h
@@ -11,6 +11,8 @@ namespace xrpl {
 // Note that this queue should only be used for CPU-bound jobs
 // It is primarily intended for signature checking
 
+// Protocol-wide
+// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
 enum JobType {
     // Special type indicating an invalid job - will go away soon.
     jtINVALID = -1,
diff --git a/include/xrpl/core/PeerReservationTable.h b/include/xrpl/core/PeerReservationTable.h
index 0d107e879c..80ad7196c3 100644
--- a/include/xrpl/core/PeerReservationTable.h
+++ b/include/xrpl/core/PeerReservationTable.h
@@ -67,7 +67,7 @@ public:
     bool
     contains(PublicKey const& nodeId)
     {
-        std::lock_guard const lock(this->mutex_);
+        std::scoped_lock const lock(this->mutex_);
         return table_.contains({.nodeId = nodeId, .description = {}});
     }
 
diff --git a/include/xrpl/core/detail/semaphore.h b/include/xrpl/core/detail/semaphore.h
index b3bee00588..38b7329ab1 100644
--- a/include/xrpl/core/detail/semaphore.h
+++ b/include/xrpl/core/detail/semaphore.h
@@ -55,7 +55,7 @@ public:
     void
     notify()
     {
-        std::lock_guard const lock{m_mutex};
+        std::scoped_lock const lock{m_mutex};
         ++m_count;
         m_cond.notify_one();
     }
@@ -76,7 +76,7 @@ public:
     bool
     try_wait()
     {
-        std::lock_guard lock{m_mutex};
+        std::scoped_lock lock{m_mutex};
         if (m_count == 0)
             return false;
         --m_count;
diff --git a/include/xrpl/json/Writer.h b/include/xrpl/json/Writer.h
index e348e57825..34c4e8458a 100644
--- a/include/xrpl/json/Writer.h
+++ b/include/xrpl/json/Writer.h
@@ -107,7 +107,7 @@ namespace Json {
 class Writer
 {
 public:
-    enum CollectionType { array, object };
+    enum class CollectionType { array, object };
 
     explicit Writer(Output const& output);
     Writer(Writer&&) noexcept;
diff --git a/include/xrpl/json/json_reader.h b/include/xrpl/json/json_reader.h
index d53569fb33..543f0cfb9c 100644
--- a/include/xrpl/json/json_reader.h
+++ b/include/xrpl/json/json_reader.h
@@ -70,6 +70,8 @@ public:
     static constexpr unsigned nest_limit{25};
 
 private:
+    // 53 files, protocol-wide
+    // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
     enum TokenType {
         tokenEndOfStream = 0,
         tokenObjectBegin,
diff --git a/include/xrpl/json/json_value.h b/include/xrpl/json/json_value.h
index 83b5142b27..def2696c5c 100644
--- a/include/xrpl/json/json_value.h
+++ b/include/xrpl/json/json_value.h
@@ -15,6 +15,8 @@ namespace Json {
 
 /** \brief Type of the value held by a Value object.
  */
+// Used throughout JSON layer
+// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
 enum ValueType {
     nullValue = 0,  ///< 'null' value
     intValue,       ///< signed integer value
@@ -147,6 +149,8 @@ private:
     class CZString
     {
     public:
+        // Stored as int field, implicit conversion
+        // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
         enum DuplicationPolicy { noDuplication = 0, duplicate, duplicateOnCopy };
         CZString(int index);
         CZString(char const* cstr, DuplicationPolicy allocate);
@@ -471,6 +475,8 @@ operator>=(Value const& x, Value const& y)
 class ValueAllocator
 {
 public:
+    // Need to be named before converting
+    // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
     enum { unknown = (unsigned)-1 };
 
     virtual ~ValueAllocator() = default;
diff --git a/include/xrpl/ledger/ApplyView.h b/include/xrpl/ledger/ApplyView.h
index bd38b57a58..0aea9813b9 100644
--- a/include/xrpl/ledger/ApplyView.h
+++ b/include/xrpl/ledger/ApplyView.h
@@ -7,6 +7,8 @@
 
 namespace xrpl {
 
+// Bitwise flag enum with existing operator overloads
+// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
 enum ApplyFlags : std::uint32_t {
     tapNONE = 0x00,
 
diff --git a/include/xrpl/ledger/PendingSaves.h b/include/xrpl/ledger/PendingSaves.h
index ff70d48bb9..a18292df68 100644
--- a/include/xrpl/ledger/PendingSaves.h
+++ b/include/xrpl/ledger/PendingSaves.h
@@ -31,7 +31,7 @@ public:
     bool
     startWork(LedgerIndex seq)
     {
-        std::lock_guard const lock(mutex_);
+        std::scoped_lock const lock(mutex_);
 
         auto it = map_.find(seq);
 
@@ -54,7 +54,7 @@ public:
     void
     finishWork(LedgerIndex seq)
     {
-        std::lock_guard const lock(mutex_);
+        std::scoped_lock const lock(mutex_);
 
         map_.erase(seq);
         await_.notify_all();
@@ -64,7 +64,7 @@ public:
     bool
     pending(LedgerIndex seq)
     {
-        std::lock_guard const lock(mutex_);
+        std::scoped_lock const lock(mutex_);
         return map_.contains(seq);
     }
 
@@ -117,7 +117,7 @@ public:
     std::map<LedgerIndex, bool>
     getSnapshot() const
     {
-        std::lock_guard const lock(mutex_);
+        std::scoped_lock const lock(mutex_);
 
         return map_;
     }
diff --git a/include/xrpl/ledger/helpers/AMMHelpers.h b/include/xrpl/ledger/helpers/AMMHelpers.h
index d261f9e018..9258d58fb6 100644
--- a/include/xrpl/ledger/helpers/AMMHelpers.h
+++ b/include/xrpl/ledger/helpers/AMMHelpers.h
@@ -28,7 +28,7 @@ reduceOffer(auto const& amount)
     static Number const reducedOfferPct(9999, -4);
 
     // Make sure the result is always less than amount or zero.
-    NumberRoundModeGuard const mg(Number::towards_zero);
+    NumberRoundModeGuard const mg(Number::rounding_mode::towards_zero);
     return amount * reducedOfferPct;
 }
 
@@ -180,7 +180,7 @@ getAMMOfferStartWithTakerGets(
     if (targetQuality.rate() == beast::zero)
         return std::nullopt;
 
-    NumberRoundModeGuard const mg(Number::to_nearest);
+    NumberRoundModeGuard const mg(Number::rounding_mode::to_nearest);
     auto const f = feeMult(tfee);
     auto const a = 1;
     auto const b = pool.in * (1 - 1 / f) / targetQuality.rate() - 2 * pool.out;
@@ -202,7 +202,7 @@ getAMMOfferStartWithTakerGets(
         // Round downward to minimize the offer and to maximize the quality.
         // This has the most impact when takerGets is XRP.
         auto const takerGets =
-            toAmount<TOut>(getAsset(pool.out), nTakerGetsProposed, Number::downward);
+            toAmount<TOut>(getAsset(pool.out), nTakerGetsProposed, Number::rounding_mode::downward);
         return TAmounts<TIn, TOut>{swapAssetOut(pool, takerGets, tfee), takerGets};
     };
 
@@ -247,7 +247,7 @@ getAMMOfferStartWithTakerPays(
     if (targetQuality.rate() == beast::zero)
         return std::nullopt;
 
-    NumberRoundModeGuard const mg(Number::to_nearest);
+    NumberRoundModeGuard const mg(Number::rounding_mode::to_nearest);
     auto const f = feeMult(tfee);
     auto const& a = f;
     auto const b = pool.in * (1 + f);
@@ -269,7 +269,7 @@ getAMMOfferStartWithTakerPays(
         // Round downward to minimize the offer and to maximize the quality.
         // This has the most impact when takerPays is XRP.
         auto const takerPays =
-            toAmount<TIn>(getAsset(pool.in), nTakerPaysProposed, Number::downward);
+            toAmount<TIn>(getAsset(pool.in), nTakerPaysProposed, Number::rounding_mode::downward);
         return TAmounts<TIn, TOut>{takerPays, swapAssetIn(pool, takerPays, tfee)};
     };
 
@@ -341,7 +341,8 @@ changeSpotPriceQuality(
                                 << " " << to_string(pool.out) << " " << quality << " " << tfee;
                 return std::nullopt;
             }
-            auto const takerPays = toAmount<TIn>(getAsset(pool.in), nTakerPays, Number::upward);
+            auto const takerPays =
+                toAmount<TIn>(getAsset(pool.in), nTakerPays, Number::rounding_mode::upward);
             // should not fail
             if (auto amounts = TAmounts<TIn, TOut>{takerPays, swapAssetIn(pool, takerPays, tfee)};
                 Quality{amounts} < quality &&
@@ -447,32 +448,32 @@ swapAssetIn(TAmounts<TIn, TOut> const& pool, TIn const& assetIn, std::uint16_t t
         // fee
         saveNumberRoundMode const _{Number::getround()};
 
-        Number::setround(Number::upward);
+        Number::setround(Number::rounding_mode::upward);
         auto const numerator = pool.in * pool.out;
         auto const fee = getFee(tfee);
 
-        Number::setround(Number::downward);
+        Number::setround(Number::rounding_mode::downward);
         auto const denom = pool.in + assetIn * (1 - fee);
 
         if (denom.signum() <= 0)
             return toAmount<TOut>(getAsset(pool.out), 0);
 
-        Number::setround(Number::upward);
+        Number::setround(Number::rounding_mode::upward);
         auto const ratio = numerator / denom;
 
-        Number::setround(Number::downward);
+        Number::setround(Number::rounding_mode::downward);
         auto const swapOut = pool.out - ratio;
 
         if (swapOut.signum() < 0)
             return toAmount<TOut>(getAsset(pool.out), 0);
 
-        return toAmount<TOut>(getAsset(pool.out), swapOut, Number::downward);
+        return toAmount<TOut>(getAsset(pool.out), swapOut, Number::rounding_mode::downward);
     }
 
     return toAmount<TOut>(
         getAsset(pool.out),
         pool.out - (pool.in * pool.out) / (pool.in + assetIn * feeMult(tfee)),
-        Number::downward);
+        Number::rounding_mode::downward);
 }
 
 /** Swap assetOut out of the pool and swap in a proportional amount
@@ -509,36 +510,36 @@ swapAssetOut(TAmounts<TIn, TOut> const& pool, TOut const& assetOut, std::uint16_
 
         saveNumberRoundMode const _{Number::getround()};
 
-        Number::setround(Number::upward);
+        Number::setround(Number::rounding_mode::upward);
         auto const numerator = pool.in * pool.out;
 
-        Number::setround(Number::downward);
+        Number::setround(Number::rounding_mode::downward);
         auto const denom = pool.out - assetOut;
         if (denom.signum() <= 0)
         {
             return toMaxAmount<TIn>(getAsset(pool.in));
         }
 
-        Number::setround(Number::upward);
+        Number::setround(Number::rounding_mode::upward);
         auto const ratio = numerator / denom;
         auto const numerator2 = ratio - pool.in;
         auto const fee = getFee(tfee);
 
-        Number::setround(Number::downward);
+        Number::setround(Number::rounding_mode::downward);
         auto const feeMult = 1 - fee;
 
-        Number::setround(Number::upward);
+        Number::setround(Number::rounding_mode::upward);
         auto const swapIn = numerator2 / feeMult;
         if (swapIn.signum() < 0)
             return toAmount<TIn>(getAsset(pool.in), 0);
 
-        return toAmount<TIn>(getAsset(pool.in), swapIn, Number::upward);
+        return toAmount<TIn>(getAsset(pool.in), swapIn, Number::rounding_mode::upward);
     }
 
     return toAmount<TIn>(
         getAsset(pool.in),
         ((pool.in * pool.out) / (pool.out - assetOut) - pool.in) / feeMult(tfee),
-        Number::upward);
+        Number::rounding_mode::upward);
 }
 
 /** Return square of n.
@@ -597,7 +598,8 @@ getLPTokenRounding(IsDeposit isDeposit)
 {
     // Minimize on deposit, maximize on withdraw to ensure
     // AMM invariant sqrt(poolAsset1 * poolAsset2) >= LPTokensBalance
-    return isDeposit == IsDeposit::Yes ? Number::downward : Number::upward;
+    return isDeposit == IsDeposit::Yes ? Number::rounding_mode::downward
+                                       : Number::rounding_mode::upward;
 }
 
 inline Number::rounding_mode
@@ -605,7 +607,8 @@ getAssetRounding(IsDeposit isDeposit)
 {
     // Maximize on deposit, minimize on withdraw to ensure
     // AMM invariant sqrt(poolAsset1 * poolAsset2) >= LPTokensBalance
-    return isDeposit == IsDeposit::Yes ? Number::upward : Number::downward;
+    return isDeposit == IsDeposit::Yes ? Number::rounding_mode::upward
+                                       : Number::rounding_mode::downward;
 }
 
 }  // namespace detail
diff --git a/include/xrpl/ledger/helpers/LendingHelpers.h b/include/xrpl/ledger/helpers/LendingHelpers.h
index 23b87de654..e1d8626b7c 100644
--- a/include/xrpl/ledger/helpers/LendingHelpers.h
+++ b/include/xrpl/ledger/helpers/LendingHelpers.h
@@ -19,7 +19,7 @@ loanPeriodicRate(TenthBips32 interestRate, std::uint32_t paymentInterval);
 inline Number
 roundPeriodicPayment(Asset const& asset, Number const& periodicPayment, std::int32_t scale)
 {
-    return roundToAsset(asset, periodicPayment, scale, Number::upward);
+    return roundToAsset(asset, periodicPayment, scale, Number::rounding_mode::upward);
 }
 
 /* Represents the breakdown of amounts to be paid and changes applied to the
diff --git a/include/xrpl/ledger/helpers/TokenHelpers.h b/include/xrpl/ledger/helpers/TokenHelpers.h
index 703a7d0ed8..b797cd966c 100644
--- a/include/xrpl/ledger/helpers/TokenHelpers.h
+++ b/include/xrpl/ledger/helpers/TokenHelpers.h
@@ -21,13 +21,13 @@ namespace xrpl {
 //------------------------------------------------------------------------------
 
 /** Controls the treatment of frozen account balances */
-enum FreezeHandling { fhIGNORE_FREEZE, fhZERO_IF_FROZEN };
+enum class FreezeHandling { fhIGNORE_FREEZE, fhZERO_IF_FROZEN };
 
 /** Controls the treatment of unauthorized MPT balances */
-enum AuthHandling { ahIGNORE_AUTH, ahZERO_IF_UNAUTHORIZED };
+enum class AuthHandling { ahIGNORE_AUTH, ahZERO_IF_UNAUTHORIZED };
 
 /** Controls whether to include the account's full spendable balance */
-enum SpendableHandling { shSIMPLE_BALANCE, shFULL_BALANCE };
+enum class SpendableHandling { shSIMPLE_BALANCE, shFULL_BALANCE };
 
 enum class WaiveTransferFee : bool { No = false, Yes };
 
@@ -135,7 +135,7 @@ accountHolds(
     AccountID const& issuer,
     FreezeHandling zeroIfFrozen,
     beast::Journal j,
-    SpendableHandling includeFullBalance = shSIMPLE_BALANCE);
+    SpendableHandling includeFullBalance = SpendableHandling::shSIMPLE_BALANCE);
 
 [[nodiscard]] STAmount
 accountHolds(
@@ -144,7 +144,7 @@ accountHolds(
     Issue const& issue,
     FreezeHandling zeroIfFrozen,
     beast::Journal j,
-    SpendableHandling includeFullBalance = shSIMPLE_BALANCE);
+    SpendableHandling includeFullBalance = SpendableHandling::shSIMPLE_BALANCE);
 
 [[nodiscard]] STAmount
 accountHolds(
@@ -154,7 +154,7 @@ accountHolds(
     FreezeHandling zeroIfFrozen,
     AuthHandling zeroIfUnauthorized,
     beast::Journal j,
-    SpendableHandling includeFullBalance = shSIMPLE_BALANCE);
+    SpendableHandling includeFullBalance = SpendableHandling::shSIMPLE_BALANCE);
 
 [[nodiscard]] STAmount
 accountHolds(
@@ -164,7 +164,7 @@ accountHolds(
     FreezeHandling zeroIfFrozen,
     AuthHandling zeroIfUnauthorized,
     beast::Journal j,
-    SpendableHandling includeFullBalance = shSIMPLE_BALANCE);
+    SpendableHandling includeFullBalance = SpendableHandling::shSIMPLE_BALANCE);
 
 // Returns the amount an account can spend of the currency type saDefault, or
 // returns saDefault if this account is the issuer of the currency in
diff --git a/include/xrpl/nodestore/NodeObject.h b/include/xrpl/nodestore/NodeObject.h
index 6397ea2e4e..8759f244d2 100644
--- a/include/xrpl/nodestore/NodeObject.h
+++ b/include/xrpl/nodestore/NodeObject.h
@@ -9,7 +9,7 @@
 namespace xrpl {
 
 /** The types of node objects. */
-enum NodeObjectType : std::uint32_t {
+enum class NodeObjectType : std::uint32_t {
     hotUNKNOWN = 0,
     hotLEDGER = 1,
     hotACCOUNT_NODE = 3,
diff --git a/include/xrpl/nodestore/Types.h b/include/xrpl/nodestore/Types.h
index 851cbcfb8b..cc7d345067 100644
--- a/include/xrpl/nodestore/Types.h
+++ b/include/xrpl/nodestore/Types.h
@@ -6,6 +6,8 @@
 
 namespace xrpl::NodeStore {
 
+// Need to be named before converting
+// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
 enum {
     // This is only used to pre-allocate the array for
     // batch objects and does not affect the amount written.
@@ -20,7 +22,7 @@ enum {
 };
 
 /** Return codes from Backend operations. */
-enum Status {
+enum class Status {
     ok = 0,
     notFound = 1,
     dataCorrupt = 2,
diff --git a/include/xrpl/nodestore/detail/codec.h b/include/xrpl/nodestore/detail/codec.h
index c159558f83..e127062b80 100644
--- a/include/xrpl/nodestore/detail/codec.h
+++ b/include/xrpl/nodestore/detail/codec.h
@@ -127,7 +127,7 @@ nodeobject_decompress(void const* in, std::size_t in_size, BufferFactory&& bf)
             ostream os(out, result.second);
             write<std::uint32_t>(os, 0);
             write<std::uint32_t>(os, 0);
-            write<std::uint8_t>(os, hotUNKNOWN);
+            write<std::uint8_t>(os, static_cast<std::uint8_t>(NodeObjectType::hotUNKNOWN));
             write<std::uint32_t>(os, static_cast<std::uint32_t>(HashPrefix::innerNode));
             if (mask == 0)
                 Throw<std::runtime_error>("nodeobject codec v1: empty inner node");
@@ -173,7 +173,7 @@ nodeobject_decompress(void const* in, std::size_t in_size, BufferFactory&& bf)
             ostream os(out, result.second);
             write<std::uint32_t>(os, 0);
             write<std::uint32_t>(os, 0);
-            write<std::uint8_t>(os, hotUNKNOWN);
+            write<std::uint8_t>(os, static_cast<std::uint8_t>(NodeObjectType::hotUNKNOWN));
             write<std::uint32_t>(os, static_cast<std::uint32_t>(HashPrefix::innerNode));
             write(os, is(512), 512);
             break;
@@ -307,7 +307,7 @@ filter_inner(void* in, std::size_t in_size)
             ostream os(in, 9);
             write<std::uint32_t>(os, 0);
             write<std::uint32_t>(os, 0);
-            write<std::uint8_t>(os, hotUNKNOWN);
+            write<std::uint8_t>(os, static_cast<std::uint8_t>(NodeObjectType::hotUNKNOWN));
         }
     }
 }
diff --git a/include/xrpl/protocol/ErrorCodes.h b/include/xrpl/protocol/ErrorCodes.h
index 2f16415bdf..ed7f898312 100644
--- a/include/xrpl/protocol/ErrorCodes.h
+++ b/include/xrpl/protocol/ErrorCodes.h
@@ -17,6 +17,8 @@ namespace xrpl {
 //
 // Please only append to this table. Do not "fill-in" gaps and do not re-use
 // or repurpose error code values.
+// Protocol-wide, 50+ files
+// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
 enum error_code_i {
     // -1 represents codes not listed in this enumeration
     rpcUNKNOWN = -1,
@@ -148,6 +150,8 @@ enum error_code_i {
 
     These values need to remain stable.
 */
+// Protocol-wide, 50+ files
+// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
 enum warning_code_i {
     warnRPC_UNSUPPORTED_MAJORITY = 1001,
     warnRPC_AMENDMENT_BLOCKED = 1002,
diff --git a/include/xrpl/protocol/LedgerFormats.h b/include/xrpl/protocol/LedgerFormats.h
index 66040ebe2c..78b0e751e9 100644
--- a/include/xrpl/protocol/LedgerFormats.h
+++ b/include/xrpl/protocol/LedgerFormats.h
@@ -29,6 +29,8 @@ namespace xrpl {
 
     @ingroup protocol
 */
+// Protocol-critical, hundreds of usages
+// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
 enum LedgerEntryType : std::uint16_t {
 
 #pragma push_macro("LEDGER_ENTRY")
@@ -218,6 +220,8 @@ enum LedgerEntryType : std::uint16_t {
 #define TO_VALUE(name, value) name = (value),
 #define NULL_NAME(name, values) values
 #define NULL_OUTPUT(name, value)
+// Bitwise flag enum
+// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
 enum LedgerSpecificFlags : std::uint32_t { XMACRO(NULL_NAME, TO_VALUE, NULL_OUTPUT) };
 
 // Create getter functions for each set of flags using Meyer's singleton pattern.
diff --git a/include/xrpl/protocol/MultiApiJson.h b/include/xrpl/protocol/MultiApiJson.h
index 6a86aa35b8..6b0c799a56 100644
--- a/include/xrpl/protocol/MultiApiJson.h
+++ b/include/xrpl/protocol/MultiApiJson.h
@@ -66,8 +66,7 @@ struct MultiApiJson
             a[key] = v;
     }
 
-    // Intentionally not using class enum here, MultivarJson is scope enough
-    enum IsMemberResult : int { none = 0, some, all };
+    enum class IsMemberResult : int { none = 0, some, all };
 
     [[nodiscard]] IsMemberResult
     isMember(char const* key) const
@@ -80,8 +79,8 @@ struct MultiApiJson
         }
 
         if (count == 0)
-            return none;
-        return count < size ? some : all;
+            return IsMemberResult::none;
+        return count < size ? IsMemberResult::some : IsMemberResult::all;
     }
 
     static constexpr struct visitor_t final
diff --git a/include/xrpl/protocol/Permissions.h b/include/xrpl/protocol/Permissions.h
index 4d26ba7cf8..3ce8918a16 100644
--- a/include/xrpl/protocol/Permissions.h
+++ b/include/xrpl/protocol/Permissions.h
@@ -16,6 +16,8 @@ namespace xrpl {
  * conflicts with TxType, the GranularPermissionType is always set to a value
  * greater than the maximum value of uint16.
  */
+// Macro-generated, complex
+// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
 enum GranularPermissionType : std::uint32_t {
 #pragma push_macro("PERMISSION")
 #undef PERMISSION
@@ -28,6 +30,9 @@ enum GranularPermissionType : std::uint32_t {
 #pragma pop_macro("PERMISSION")
 };
 
+// Injected bare enumerators (xrpl::delegable / xrpl::notDelegable) are required by preprocessor
+// tricks in tests and macro-generated code; enum class would break that.
+// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
 enum Delegation { delegable, notDelegable };
 
 class Permission
diff --git a/include/xrpl/protocol/SField.h b/include/xrpl/protocol/SField.h
index 7e42b9ec62..784de5511e 100644
--- a/include/xrpl/protocol/SField.h
+++ b/include/xrpl/protocol/SField.h
@@ -87,6 +87,8 @@ class STCurrency;
 #define TO_ENUM(name, value) name = (value),
 #define TO_MAP(name, value) {#name, value},
 
+// Protocol infrastructure, 39+ files
+// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
 enum SerializedTypeID { XMACRO(TO_ENUM) };
 
 static std::map<std::string, int> const sTypeMap = {XMACRO(TO_MAP)};
@@ -125,6 +127,8 @@ field_code(int id, int index)
 class SField
 {
 public:
+    // Need to be named before converting
+    // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
     enum {
         sMD_Never = 0x00,
         sMD_ChangeOrig = 0x01,     // original value when it changes
diff --git a/include/xrpl/protocol/SOTemplate.h b/include/xrpl/protocol/SOTemplate.h
index ca09fc3d71..3bfe07d049 100644
--- a/include/xrpl/protocol/SOTemplate.h
+++ b/include/xrpl/protocol/SOTemplate.h
@@ -11,6 +11,8 @@
 namespace xrpl {
 
 /** Kind of element in each entry of an SOTemplate. */
+// 2026 usages, 129 files
+// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
 enum SOEStyle {
     soeINVALID = -1,
     soeREQUIRED = 0,  // required
@@ -20,7 +22,8 @@ enum SOEStyle {
                       // constructed with STObject::makeInnerObject()
 };
 
-/** Amount fields that can support MPT */
+// Part of a Python-parsed DSL (transactions.macro); bare enumerator names required by the parser
+// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
 enum SOETxMPTIssue { soeMPTNone, soeMPTSupported, soeMPTNotSupported };
 
 //------------------------------------------------------------------------------
diff --git a/include/xrpl/protocol/STAmount.h b/include/xrpl/protocol/STAmount.h
index 06471df5c9..f681f811b7 100644
--- a/include/xrpl/protocol/STAmount.h
+++ b/include/xrpl/protocol/STAmount.h
@@ -319,7 +319,7 @@ STAmount::STAmount(
     : STBase(name), mAsset(asset), mValue(mantissa), mOffset(exponent), mIsNegative(negative)
 {
     // mValue is uint64, but needs to fit in the range of int64
-    if (Number::getMantissaScale() == MantissaRange::small)
+    if (Number::getMantissaScale() == MantissaRange::mantissa_scale::small)
     {
         XRPL_ASSERT(
             mValue <= std::numeric_limits<std::int64_t>::max(),
diff --git a/include/xrpl/protocol/STBase.h b/include/xrpl/protocol/STBase.h
index 0beefe45f6..7ebf22fe8f 100644
--- a/include/xrpl/protocol/STBase.h
+++ b/include/xrpl/protocol/STBase.h
@@ -18,6 +18,8 @@ struct JsonOptions
     using underlying_t = unsigned int;
     underlying_t value;
 
+    // Bitwise flags with operator~
+    // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
     enum values : underlying_t {
         // clang-format off
         none                        = 0b0000'0000,
diff --git a/include/xrpl/protocol/STObject.h b/include/xrpl/protocol/STObject.h
index d27112e17c..187bde6dae 100644
--- a/include/xrpl/protocol/STObject.h
+++ b/include/xrpl/protocol/STObject.h
@@ -413,9 +413,9 @@ public:
     class FieldErr;
 
 private:
-    enum WhichFields : bool {
+    enum class WhichFields : bool {
         // These values are carefully chosen to do the right thing if passed
-        // to SField::shouldInclude (bool)
+        // to SField::shouldInclude (bool) via static_cast<bool>
         omitSigningFields = false,
         withAllFields = true
     };
@@ -987,7 +987,7 @@ STObject::isFree() const
 inline void
 STObject::addWithoutSigningFields(Serializer& s) const
 {
-    add(s, omitSigningFields);
+    add(s, WhichFields::omitSigningFields);
 }
 
 // VFALCO NOTE does this return an expensive copy of an object with a
@@ -997,7 +997,7 @@ inline Serializer
 STObject::getSerializer() const
 {
     Serializer s;
-    add(s, withAllFields);
+    add(s, WhichFields::withAllFields);
     return s;
 }
 
diff --git a/include/xrpl/protocol/STPathSet.h b/include/xrpl/protocol/STPathSet.h
index 38f4668b5d..ce9a73523c 100644
--- a/include/xrpl/protocol/STPathSet.h
+++ b/include/xrpl/protocol/STPathSet.h
@@ -25,6 +25,8 @@ class STPathElement final : public CountedObject<STPathElement>
     std::size_t hash_value_;
 
 public:
+    // Bitwise values (typeCurrency | typeMPT)
+    // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
     enum Type {
         typeNone = 0x00,
         typeAccount = 0x01,   // Rippling through an account (vs taking an offer).
diff --git a/include/xrpl/protocol/SeqProxy.h b/include/xrpl/protocol/SeqProxy.h
index 86742bacc1..820004681d 100644
--- a/include/xrpl/protocol/SeqProxy.h
+++ b/include/xrpl/protocol/SeqProxy.h
@@ -35,7 +35,7 @@ namespace xrpl {
 class SeqProxy
 {
 public:
-    enum Type : std::uint8_t { seq = 0, ticket };
+    enum class Type : std::uint8_t { seq = 0, ticket };
 
 private:
     std::uint32_t value_;
@@ -67,13 +67,13 @@ public:
     [[nodiscard]] constexpr bool
     isSeq() const
     {
-        return type_ == seq;
+        return type_ == Type::seq;
     }
 
     [[nodiscard]] constexpr bool
     isTicket() const
     {
-        return type_ == ticket;
+        return type_ == Type::ticket;
     }
 
     // Occasionally it is convenient to be able to increase the value_
diff --git a/include/xrpl/protocol/TER.h b/include/xrpl/protocol/TER.h
index ef9fac6dc5..8e1bc6aac7 100644
--- a/include/xrpl/protocol/TER.h
+++ b/include/xrpl/protocol/TER.h
@@ -19,6 +19,8 @@ using TERUnderlyingType = int;
 
 //------------------------------------------------------------------------------
 
+// Protocol-critical, mixed with custom TER wrapper type, hundreds of usages
+// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
 enum TELcodes : TERUnderlyingType {
     // Note: Range is stable.
     // Exact numbers are used in ripple-binary-codec:
@@ -50,6 +52,8 @@ enum TELcodes : TERUnderlyingType {
 
 //------------------------------------------------------------------------------
 
+// Protocol-critical, mixed with custom TER wrapper type, hundreds of usages
+// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
 enum TEMcodes : TERUnderlyingType {
     // Note: Range is stable.
     // Exact numbers are used in ripple-binary-codec:
@@ -126,6 +130,8 @@ enum TEMcodes : TERUnderlyingType {
 
 //------------------------------------------------------------------------------
 
+// Protocol-critical, mixed with custom TER wrapper type, hundreds of usages
+// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
 enum TEFcodes : TERUnderlyingType {
     // Note: Range is stable.
     // Exact numbers are used in ripple-binary-codec:
@@ -170,6 +176,8 @@ enum TEFcodes : TERUnderlyingType {
 
 //------------------------------------------------------------------------------
 
+// Protocol-critical, mixed with custom TER wrapper type, hundreds of usages
+// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
 enum TERcodes : TERUnderlyingType {
     // Note: Range is stable.
     // Exact numbers are used in ripple-binary-codec:
@@ -215,6 +223,8 @@ enum TERcodes : TERUnderlyingType {
 
 //------------------------------------------------------------------------------
 
+// Protocol-critical, mixed with custom TER wrapper type, hundreds of usages
+// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
 enum TEScodes : TERUnderlyingType {
     // Note: Exact number must stay stable.  This code is stored by value
     // in metadata for historic transactions.
@@ -230,6 +240,8 @@ enum TEScodes : TERUnderlyingType {
 
 //------------------------------------------------------------------------------
 
+// Protocol-critical, mixed with custom TER wrapper type, hundreds of usages
+// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
 enum TECcodes : TERUnderlyingType {
     // Note: Exact numbers must stay stable.  These codes are stored by
     // value in metadata for historic transactions.
diff --git a/include/xrpl/protocol/TxFormats.h b/include/xrpl/protocol/TxFormats.h
index 563a28f39f..235fb7b16e 100644
--- a/include/xrpl/protocol/TxFormats.h
+++ b/include/xrpl/protocol/TxFormats.h
@@ -35,6 +35,8 @@ namespace xrpl {
     @ingroup protocol
 */
 // clang-format off
+// Protocol-critical, hundreds of usages
+// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
 enum TxType : std::uint16_t
 {
 
diff --git a/include/xrpl/protocol/detail/features.macro b/include/xrpl/protocol/detail/features.macro
index d3a8ca5e22..92d73a8441 100644
--- a/include/xrpl/protocol/detail/features.macro
+++ b/include/xrpl/protocol/detail/features.macro
@@ -16,6 +16,7 @@
 // Keep it sorted in reverse chronological order.
 
 XRPL_FEATURE(Sponsor,                     Supported::no,  VoteBehavior::DefaultNo)
+XRPL_FIX    (Cleanup3_2_0,                Supported::no, VoteBehavior::DefaultNo)
 XRPL_FEATURE(MPTokensV2,                  Supported::no, VoteBehavior::DefaultNo)
 XRPL_FIX    (Security3_1_3,               Supported::no, VoteBehavior::DefaultNo)
 XRPL_FIX    (PermissionedDomainInvariant, Supported::yes, VoteBehavior::DefaultNo)
diff --git a/include/xrpl/protocol/detail/ledger_entries.macro b/include/xrpl/protocol/detail/ledger_entries.macro
index 85b86e3c10..f94b899c2b 100644
--- a/include/xrpl/protocol/detail/ledger_entries.macro
+++ b/include/xrpl/protocol/detail/ledger_entries.macro
@@ -471,6 +471,7 @@ LEDGER_ENTRY(ltDELEGATE, 0x0083, Delegate, delegate, ({
     {sfAuthorize,            soeREQUIRED},
     {sfPermissions,          soeREQUIRED},
     {sfOwnerNode,            soeREQUIRED},
+    {sfDestinationNode,      soeOPTIONAL},
     {sfPreviousTxnID,        soeREQUIRED},
     {sfPreviousTxnLgrSeq,    soeREQUIRED},
 }))
diff --git a/include/xrpl/protocol_autogen/LedgerEntryBase.h b/include/xrpl/protocol_autogen/LedgerEntryBase.h
index 0c5b367391..ad513992c7 100644
--- a/include/xrpl/protocol_autogen/LedgerEntryBase.h
+++ b/include/xrpl/protocol_autogen/LedgerEntryBase.h
@@ -130,6 +130,19 @@ public:
         return sle_->at(sfFlags);
     }
 
+    /**
+     * @brief Check if a specific flag is set.
+     *
+     * @param f The flag bitmask to check
+     * @return true if all bits in f are set in the flags field
+     */
+    [[nodiscard]]
+    bool
+    isFlag(std::uint32_t f) const
+    {
+        return sle_->isFlag(f);
+    }
+
     /**
      * @brief Get the underlying SLE object.
      *
diff --git a/include/xrpl/protocol_autogen/ledger_entries/Delegate.h b/include/xrpl/protocol_autogen/ledger_entries/Delegate.h
index 4d937eb99a..e2660632cd 100644
--- a/include/xrpl/protocol_autogen/ledger_entries/Delegate.h
+++ b/include/xrpl/protocol_autogen/ledger_entries/Delegate.h
@@ -90,6 +90,30 @@ public:
         return this->sle_->at(sfOwnerNode);
     }
 
+    /**
+     * @brief Get sfDestinationNode (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT64::type::value_type>
+    getDestinationNode() const
+    {
+        if (hasDestinationNode())
+            return this->sle_->at(sfDestinationNode);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfDestinationNode is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasDestinationNode() const
+    {
+        return this->sle_->isFieldPresent(sfDestinationNode);
+    }
+
     /**
      * @brief Get sfPreviousTxnID (soeREQUIRED)
      * @return The field value.
@@ -203,6 +227,17 @@ public:
         return *this;
     }
 
+    /**
+     * @brief Set sfDestinationNode (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    DelegateBuilder&
+    setDestinationNode(std::decay_t<typename SF_UINT64::type::value_type> const& value)
+    {
+        object_[sfDestinationNode] = value;
+        return *this;
+    }
+
     /**
      * @brief Set sfPreviousTxnID (soeREQUIRED)
      * @return Reference to this builder for method chaining.
diff --git a/include/xrpl/resource/Disposition.h b/include/xrpl/resource/Disposition.h
index 22830ad470..59a1c3840a 100644
--- a/include/xrpl/resource/Disposition.h
+++ b/include/xrpl/resource/Disposition.h
@@ -3,7 +3,7 @@
 namespace xrpl::Resource {
 
 /** The disposition of a consumer after applying a load charge. */
-enum Disposition {
+enum class Disposition {
     /** No action required. */
     ok
 
diff --git a/include/xrpl/resource/detail/Entry.h b/include/xrpl/resource/detail/Entry.h
index 89f27b2672..2cbf06d5c3 100644
--- a/include/xrpl/resource/detail/Entry.h
+++ b/include/xrpl/resource/detail/Entry.h
@@ -39,7 +39,7 @@ struct Entry : public beast::List<Entry>::Node
     [[nodiscard]] bool
     isUnlimited() const
     {
-        return key->kind == kindUnlimited;
+        return key->kind == Kind::kindUnlimited;
     }
 
     // Balance including remote contributions
diff --git a/include/xrpl/resource/detail/Kind.h b/include/xrpl/resource/detail/Kind.h
index 74115ba7f1..5cbddce6bb 100644
--- a/include/xrpl/resource/detail/Kind.h
+++ b/include/xrpl/resource/detail/Kind.h
@@ -10,6 +10,6 @@ namespace xrpl::Resource {
  *                subjected to administrative restrictions, such as
  *                use of some RPC commands like "stop".
  */
-enum Kind { kindInbound, kindOutbound, kindUnlimited };
+enum class Kind { kindInbound, kindOutbound, kindUnlimited };
 
 }  // namespace xrpl::Resource
diff --git a/include/xrpl/resource/detail/Logic.h b/include/xrpl/resource/detail/Logic.h
index b775f0a965..3102a1f119 100644
--- a/include/xrpl/resource/detail/Logic.h
+++ b/include/xrpl/resource/detail/Logic.h
@@ -92,11 +92,11 @@ public:
         Entry* entry(nullptr);
 
         {
-            std::lock_guard const _(lock_);
+            std::scoped_lock const _(lock_);
             auto [resultIt, resultInserted] = table_.emplace(
                 std::piecewise_construct,
-                std::make_tuple(kindInbound, address.at_port(0)),  // Key
-                std::make_tuple(m_clock.now()));                   // Entry
+                std::make_tuple(Kind::kindInbound, address.at_port(0)),  // Key
+                std::make_tuple(m_clock.now()));                         // Entry
 
             entry = &resultIt->second;
             entry->key = &resultIt->first;
@@ -122,11 +122,11 @@ public:
         Entry* entry(nullptr);
 
         {
-            std::lock_guard const _(lock_);
+            std::scoped_lock const _(lock_);
             auto [resultIt, resultInserted] = table_.emplace(
                 std::piecewise_construct,
-                std::make_tuple(kindOutbound, address),  // Key
-                std::make_tuple(m_clock.now()));         // Entry
+                std::make_tuple(Kind::kindOutbound, address),  // Key
+                std::make_tuple(m_clock.now()));               // Entry
 
             entry = &resultIt->second;
             entry->key = &resultIt->first;
@@ -155,11 +155,11 @@ public:
         Entry* entry(nullptr);
 
         {
-            std::lock_guard const _(lock_);
+            std::scoped_lock const _(lock_);
             auto [resultIt, resultInserted] = table_.emplace(
                 std::piecewise_construct,
-                std::make_tuple(kindUnlimited, address.at_port(1)),  // Key
-                std::make_tuple(m_clock.now()));                     // Entry
+                std::make_tuple(Kind::kindUnlimited, address.at_port(1)),  // Key
+                std::make_tuple(m_clock.now()));                           // Entry
 
             entry = &resultIt->second;
             entry->key = &resultIt->first;
@@ -190,7 +190,7 @@ public:
         clock_type::time_point const now(m_clock.now());
 
         Json::Value ret(Json::objectValue);
-        std::lock_guard const _(lock_);
+        std::scoped_lock const _(lock_);
 
         for (auto& inboundEntry : inbound_)
         {
@@ -235,7 +235,7 @@ public:
         clock_type::time_point const now(m_clock.now());
 
         Gossip gossip;
-        std::lock_guard const _(lock_);
+        std::scoped_lock const _(lock_);
 
         gossip.items.reserve(inbound_.size());
 
@@ -260,7 +260,7 @@ public:
     {
         auto const elapsed = m_clock.now();
         {
-            std::lock_guard const _(lock_);
+            std::scoped_lock const _(lock_);
             auto [resultIt, resultInserted] = importTable_.emplace(
                 std::piecewise_construct,
                 std::make_tuple(origin),                                     // Key
@@ -317,7 +317,7 @@ public:
     void
     periodicActivity()
     {
-        std::lock_guard const _(lock_);
+        std::scoped_lock const _(lock_);
 
         auto const elapsed = m_clock.now();
 
@@ -375,7 +375,7 @@ public:
     void
     erase(Table::iterator iter)
     {
-        std::lock_guard const _(lock_);
+        std::scoped_lock const _(lock_);
         Entry& entry(iter->second);
         XRPL_ASSERT(entry.refcount == 0, "xrpl::Resource::Logic::erase : entry not used");
         inactive_.erase(inactive_.iterator_to(entry));
@@ -385,27 +385,27 @@ public:
     void
     acquire(Entry& entry)
     {
-        std::lock_guard const _(lock_);
+        std::scoped_lock const _(lock_);
         ++entry.refcount;
     }
 
     void
     release(Entry& entry)
     {
-        std::lock_guard const _(lock_);
+        std::scoped_lock const _(lock_);
         if (--entry.refcount == 0)
         {
             JLOG(m_journal.debug()) << "Inactive " << entry;
 
             switch (entry.key->kind)
             {
-                case kindInbound:
+                case Kind::kindInbound:
                     inbound_.erase(inbound_.iterator_to(entry));
                     break;
-                case kindOutbound:
+                case Kind::kindOutbound:
                     outbound_.erase(outbound_.iterator_to(entry));
                     break;
-                case kindUnlimited:
+                case Kind::kindUnlimited:
                     admin_.erase(admin_.iterator_to(entry));
                     break;
                 default:
@@ -443,7 +443,7 @@ public:
         if (!context.empty())
             context = " (" + context + ")";
 
-        std::lock_guard const _(lock_);
+        std::scoped_lock const _(lock_);
         clock_type::time_point const now(m_clock.now());
         int const balance(entry.add(fee.cost(), now));
         JLOG(getStream(fee.cost(), m_journal)) << "Charging " << entry << " for " << fee << context;
@@ -456,7 +456,7 @@ public:
         if (entry.isUnlimited())
             return false;
 
-        std::lock_guard const _(lock_);
+        std::scoped_lock const _(lock_);
         bool notify(false);
         auto const elapsed = m_clock.now();
         if (entry.balance(m_clock.now()) >= warningThreshold && elapsed != entry.lastWarningTime)
@@ -479,7 +479,7 @@ public:
         if (entry.isUnlimited())
             return false;
 
-        std::lock_guard const _(lock_);
+        std::scoped_lock const _(lock_);
         bool drop(false);
         clock_type::time_point const now(m_clock.now());
         int const balance(entry.balance(now));
@@ -501,7 +501,7 @@ public:
     int
     balance(Entry& entry)
     {
-        std::lock_guard const _(lock_);
+        std::scoped_lock const _(lock_);
         return entry.balance(m_clock.now());
     }
 
@@ -530,7 +530,7 @@ public:
     {
         clock_type::time_point const now(m_clock.now());
 
-        std::lock_guard const _(lock_);
+        std::scoped_lock const _(lock_);
 
         {
             beast::PropertyStream::Set s("inbound", map);
diff --git a/include/xrpl/resource/detail/Tuning.h b/include/xrpl/resource/detail/Tuning.h
index 1c903d8cd4..d5e872d16c 100644
--- a/include/xrpl/resource/detail/Tuning.h
+++ b/include/xrpl/resource/detail/Tuning.h
@@ -5,6 +5,8 @@
 namespace xrpl::Resource {
 
 /** Tunable constants. */
+// Need to be named before converting
+// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
 enum {
     // Balance at which a warning is issued
     warningThreshold = 5000
diff --git a/include/xrpl/server/LoadFeeTrack.h b/include/xrpl/server/LoadFeeTrack.h
index 6b9e96241c..e54ea4d280 100644
--- a/include/xrpl/server/LoadFeeTrack.h
+++ b/include/xrpl/server/LoadFeeTrack.h
@@ -35,28 +35,28 @@ public:
     setRemoteFee(std::uint32_t f)
     {
         JLOG(j_.trace()) << "setRemoteFee: " << f;
-        std::lock_guard const sl(lock_);
+        std::scoped_lock const sl(lock_);
         remoteTxnLoadFee_ = f;
     }
 
     std::uint32_t
     getRemoteFee() const
     {
-        std::lock_guard const sl(lock_);
+        std::scoped_lock const sl(lock_);
         return remoteTxnLoadFee_;
     }
 
     std::uint32_t
     getLocalFee() const
     {
-        std::lock_guard const sl(lock_);
+        std::scoped_lock const sl(lock_);
         return localTxnLoadFee_;
     }
 
     std::uint32_t
     getClusterFee() const
     {
-        std::lock_guard const sl(lock_);
+        std::scoped_lock const sl(lock_);
         return clusterTxnLoadFee_;
     }
 
@@ -69,14 +69,14 @@ public:
     std::uint32_t
     getLoadFactor() const
     {
-        std::lock_guard const sl(lock_);
+        std::scoped_lock const sl(lock_);
         return std::max({clusterTxnLoadFee_, localTxnLoadFee_, remoteTxnLoadFee_});
     }
 
     std::pair<std::uint32_t, std::uint32_t>
     getScalingFactors() const
     {
-        std::lock_guard const sl(lock_);
+        std::scoped_lock const sl(lock_);
 
         return std::make_pair(
             std::max(localTxnLoadFee_, remoteTxnLoadFee_),
@@ -87,7 +87,7 @@ public:
     setClusterFee(std::uint32_t fee)
     {
         JLOG(j_.trace()) << "setClusterFee: " << fee;
-        std::lock_guard const sl(lock_);
+        std::scoped_lock const sl(lock_);
         clusterTxnLoadFee_ = fee;
     }
 
@@ -99,14 +99,14 @@ public:
     bool
     isLoadedLocal() const
     {
-        std::lock_guard const sl(lock_);
+        std::scoped_lock const sl(lock_);
         return (raiseCount_ != 0) || (localTxnLoadFee_ != lftNormalFee);
     }
 
     bool
     isLoadedCluster() const
     {
-        std::lock_guard const sl(lock_);
+        std::scoped_lock const sl(lock_);
         return (raiseCount_ != 0) || (localTxnLoadFee_ != lftNormalFee) ||
             (clusterTxnLoadFee_ != lftNormalFee);
     }
diff --git a/include/xrpl/server/detail/BaseHTTPPeer.h b/include/xrpl/server/detail/BaseHTTPPeer.h
index a0f8e1f318..31820402ab 100644
--- a/include/xrpl/server/detail/BaseHTTPPeer.h
+++ b/include/xrpl/server/detail/BaseHTTPPeer.h
@@ -38,6 +38,8 @@ protected:
     using endpoint_type = boost::asio::ip::tcp::endpoint;
     using yield_context = boost::asio::yield_context;
 
+    // Need to be named before converting
+    // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
     enum {
         // Size of our read/write buffer
         bufferSize = 4 * 1024,
@@ -303,7 +305,7 @@ BaseHTTPPeer<Handler, Impl>::on_write(error_code const& ec, std::size_t bytes_tr
         return fail(ec, "write");
     bytes_out_ += bytes_transferred;
     {
-        std::lock_guard const lock(mutex_);
+        std::scoped_lock const lock(mutex_);
         wq2_.clear();
         wq2_.reserve(wq_.size());
         std::swap(wq2_, wq_);
@@ -395,7 +397,7 @@ BaseHTTPPeer<Handler, Impl>::write(void const* buf, std::size_t bytes)
     if (bytes == 0)
         return;
     if ([&] {
-            std::lock_guard const lock(mutex_);
+            std::scoped_lock const lock(mutex_);
             wq_.emplace_back(buf, bytes);
             return wq_.size() == 1 && wq2_.size() == 0;
         }())
@@ -449,7 +451,7 @@ BaseHTTPPeer<Handler, Impl>::complete()
     complete_ = true;
 
     {
-        std::lock_guard const lock(mutex_);
+        std::scoped_lock const lock(mutex_);
         if (!wq_.empty() && !wq2_.empty())
             return;
     }
@@ -484,7 +486,7 @@ BaseHTTPPeer<Handler, Impl>::close(bool graceful)
     {
         graceful_ = true;
         {
-            std::lock_guard const lock(mutex_);
+            std::scoped_lock const lock(mutex_);
             if (!wq_.empty() || !wq2_.empty())
                 return;
         }
diff --git a/include/xrpl/server/detail/ServerImpl.h b/include/xrpl/server/detail/ServerImpl.h
index 14d2b56fe4..2c3a8330e1 100644
--- a/include/xrpl/server/detail/ServerImpl.h
+++ b/include/xrpl/server/detail/ServerImpl.h
@@ -62,6 +62,8 @@ class ServerImpl : public Server
 private:
     using clock_type = std::chrono::system_clock;
 
+    // Need to be named before converting
+    // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
     enum { historySize = 100 };
 
     Handler& handler_;
diff --git a/include/xrpl/server/detail/io_list.h b/include/xrpl/server/detail/io_list.h
index 8c25a89f79..67e04d04b6 100644
--- a/include/xrpl/server/detail/io_list.h
+++ b/include/xrpl/server/detail/io_list.h
@@ -165,7 +165,7 @@ io_list::work::destroy()
         return;
     std::function<void(void)> f;
     {
-        std::lock_guard const lock(ios_->m_);
+        std::scoped_lock const lock(ios_->m_);
         ios_->map_.erase(this);
         if (--ios_->n_ == 0 && ios_->closed_)
         {
@@ -195,7 +195,7 @@ io_list::emplace(Args&&... args)
     auto sp = std::make_shared<T>(std::forward<Args>(args)...);
     decltype(sp) dead;
 
-    std::lock_guard const lock(m_);
+    std::scoped_lock const lock(m_);
     if (!closed_)
     {
         ++n_;
diff --git a/include/xrpl/shamap/FullBelowCache.h b/include/xrpl/shamap/FullBelowCache.h
index 6a6da1463a..e17a640672 100644
--- a/include/xrpl/shamap/FullBelowCache.h
+++ b/include/xrpl/shamap/FullBelowCache.h
@@ -22,6 +22,8 @@ private:
     using CacheType = KeyCache;
 
 public:
+    // Need to be named before converting
+    // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
     enum { defaultCacheTargetSize = 0 };
 
     using key_type = uint256;
diff --git a/include/xrpl/tx/Transactor.h b/include/xrpl/tx/Transactor.h
index cecc7485a8..b53c6c3fd0 100644
--- a/include/xrpl/tx/Transactor.h
+++ b/include/xrpl/tx/Transactor.h
@@ -138,6 +138,8 @@ public:
     Transactor(Transactor const&) = delete;
     Transactor&
     operator=(Transactor const&) = delete;
+    // 68 transactor subclass files
+    // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
     enum ConsequencesFactoryType { Normal, Blocker, Custom };
 
     /** Process the transaction. */
diff --git a/include/xrpl/tx/applySteps.h b/include/xrpl/tx/applySteps.h
index 4f857bb7c1..dc4140956c 100644
--- a/include/xrpl/tx/applySteps.h
+++ b/include/xrpl/tx/applySteps.h
@@ -39,7 +39,7 @@ class TxConsequences
 public:
     /// Describes how the transaction affects subsequent
     /// transactions
-    enum Category {
+    enum class Category {
         /// Moves currency around, creates offers, etc.
         normal = 0,
         /// Affects the ability of subsequent transactions
diff --git a/include/xrpl/tx/invariants/InvariantCheckPrivilege.h b/include/xrpl/tx/invariants/InvariantCheckPrivilege.h
index 684e40c8cf..44131167b6 100644
--- a/include/xrpl/tx/invariants/InvariantCheckPrivilege.h
+++ b/include/xrpl/tx/invariants/InvariantCheckPrivilege.h
@@ -25,6 +25,8 @@ not have the relevant amendments enabled_. It's intentionally a pain in the neck
 so that bad code gets caught and fixed as early as possible.
 */
 
+// Bitwise flags, 86 files
+// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
 enum Privilege {
     noPriv = 0x0000,              // The transaction can not do any of the enumerated operations
     createAcct = 0x0001,          // The transaction can create a new ACCOUNT_ROOT object.
diff --git a/include/xrpl/tx/invariants/MPTInvariant.h b/include/xrpl/tx/invariants/MPTInvariant.h
index e3aa06016a..7f405814e7 100644
--- a/include/xrpl/tx/invariants/MPTInvariant.h
+++ b/include/xrpl/tx/invariants/MPTInvariant.h
@@ -35,10 +35,10 @@ public:
  */
 class ValidMPTPayment
 {
-    enum Order { Before = 0, After = 1 };
+    enum class Order { Before = 0, After = 1 };
     struct MPTData
     {
-        std::array<std::int64_t, After + 1> outstanding{};
+        std::array<std::int64_t, 2> outstanding{};
         // sum (MPT after - MPT before)
         std::int64_t mptAmount{0};
     };
diff --git a/include/xrpl/tx/paths/detail/Steps.h b/include/xrpl/tx/paths/detail/Steps.h
index b4d9d6e0b4..9b37f06ca9 100644
--- a/include/xrpl/tx/paths/detail/Steps.h
+++ b/include/xrpl/tx/paths/detail/Steps.h
@@ -21,7 +21,7 @@ class AMMContext;
 enum class DebtDirection { issues, redeems };
 enum class QualityDirection { in, out };
 enum class StrandDirection { forward, reverse };
-enum OfferCrossing { no = 0, yes = 1, sell = 2 };
+enum class OfferCrossing { no = 0, yes = 1, sell = 2 };
 
 inline bool
 redeems(DebtDirection dir)
diff --git a/include/xrpl/tx/paths/detail/StrandFlow.h b/include/xrpl/tx/paths/detail/StrandFlow.h
index ee23de27b3..03ec9cc871 100644
--- a/include/xrpl/tx/paths/detail/StrandFlow.h
+++ b/include/xrpl/tx/paths/detail/StrandFlow.h
@@ -665,7 +665,7 @@ flow(
             // the previous strand execution failed. It has to be reset
             // since this strand might not have AMM liquidity.
             ammContext.clear();
-            if (offerCrossing && limitQuality)
+            if (offerCrossing != OfferCrossing::no && limitQuality)
             {
                 auto const strandQ = qualityUpperBound(sb, *strand);
                 if (!strandQ || *strandQ < *limitQuality)
@@ -797,7 +797,8 @@ flow(
             // fixFillOrKill amendment:
             //   That case is handled here if tfSell is also not set; i.e,
             //   case 1.
-            if (!offerCrossing || (fillOrKillEnabled && offerCrossing != OfferCrossing::sell))
+            if (offerCrossing == OfferCrossing::no ||
+                (fillOrKillEnabled && offerCrossing != OfferCrossing::sell))
                 return {tecPATH_PARTIAL, actualIn, actualOut, std::move(ofrsToRmOnFail)};
         }
         else if (actualOut == beast::zero)
@@ -805,7 +806,7 @@ flow(
             return {tecPATH_DRY, std::move(ofrsToRmOnFail)};
         }
     }
-    if (offerCrossing &&
+    if (offerCrossing != OfferCrossing::no &&
         (!partialPayment && (!fillOrKillEnabled || offerCrossing == OfferCrossing::sell)))
     {
         // If we're offer crossing and partialPayment is *not* true, then
diff --git a/include/xrpl/tx/transactors/account/SignerListSet.h b/include/xrpl/tx/transactors/account/SignerListSet.h
index 1f1a68ccc8..12419076e3 100644
--- a/include/xrpl/tx/transactors/account/SignerListSet.h
+++ b/include/xrpl/tx/transactors/account/SignerListSet.h
@@ -18,8 +18,8 @@ class SignerListSet : public Transactor
 {
 private:
     // Values determined during preCompute for use later.
-    enum Operation { unknown, set, destroy };
-    Operation do_{unknown};
+    enum class Operation { unknown, set, destroy };
+    Operation do_{Operation::unknown};
     std::uint32_t quorum_{0};
     std::vector<SignerEntries::SignerEntry> signers_;
 
diff --git a/include/xrpl/tx/transactors/delegate/DelegateSet.h b/include/xrpl/tx/transactors/delegate/DelegateSet.h
index 25cb21e9b5..eaa22532ae 100644
--- a/include/xrpl/tx/transactors/delegate/DelegateSet.h
+++ b/include/xrpl/tx/transactors/delegate/DelegateSet.h
@@ -38,11 +38,7 @@ public:
 
     // Interface used by AccountDelete
     static TER
-    deleteDelegate(
-        ApplyView& view,
-        std::shared_ptr<SLE> const& sle,
-        AccountID const& account,
-        beast::Journal j);
+    deleteDelegate(ApplyView& view, std::shared_ptr<SLE> const& sle, beast::Journal j);
 };
 
 }  // namespace xrpl
diff --git a/include/xrpl/tx/transactors/system/LedgerStateFix.h b/include/xrpl/tx/transactors/system/LedgerStateFix.h
index a236a52c74..da3cb33398 100644
--- a/include/xrpl/tx/transactors/system/LedgerStateFix.h
+++ b/include/xrpl/tx/transactors/system/LedgerStateFix.h
@@ -7,7 +7,7 @@ namespace xrpl {
 class LedgerStateFix : public Transactor
 {
 public:
-    enum FixType : std::uint16_t {
+    enum class FixType : std::uint16_t {
         nfTokenPageLink = 1,
     };
 
diff --git a/src/libxrpl/basics/Log.cpp b/src/libxrpl/basics/Log.cpp
index e855e1006b..eb93feaa3e 100644
--- a/src/libxrpl/basics/Log.cpp
+++ b/src/libxrpl/basics/Log.cpp
@@ -120,7 +120,7 @@ Logs::open(boost::filesystem::path const& pathToLogFile)
 beast::Journal::Sink&
 Logs::get(std::string const& name)
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     auto const result = sinks_.emplace(name, makeSink(name, thresh_));
     return *result.first->second;
 }
@@ -146,7 +146,7 @@ Logs::threshold() const
 void
 Logs::threshold(beast::severities::Severity thresh)
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     thresh_ = thresh;
     for (auto& sink : sinks_)
         sink.second->threshold(thresh);
@@ -156,7 +156,7 @@ std::vector<std::pair<std::string, std::string>>
 Logs::partition_severities() const
 {
     std::vector<std::pair<std::string, std::string>> list;
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     list.reserve(sinks_.size());
     for (auto const& [name, sink] : sinks_)
         list.emplace_back(name, toString(fromSeverity(sink->threshold())));
@@ -172,7 +172,7 @@ Logs::write(
 {
     std::string s;
     format(s, text, level, partition);
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     file_.writeln(s);
     if (!silent_)
         std::cerr << s << '\n';
@@ -184,7 +184,7 @@ Logs::write(
 std::string
 Logs::rotate()
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     bool const wasOpened = file_.closeAndReopen();
     if (wasOpened)
         return "The log file was closed and reopened.";
@@ -412,7 +412,7 @@ public:
     std::unique_ptr<beast::Journal::Sink>
     set(std::unique_ptr<beast::Journal::Sink> sink)
     {
-        std::lock_guard const _(m_);
+        std::scoped_lock const _(m_);
 
         using std::swap;
         swap(holder_, sink);
@@ -432,7 +432,7 @@ public:
     beast::Journal::Sink&
     get()
     {
-        std::lock_guard const _(m_);
+        std::scoped_lock const _(m_);
         return sink_.get();
     }
 };
diff --git a/src/libxrpl/basics/Number.cpp b/src/libxrpl/basics/Number.cpp
index 3b2b8670cb..ba444b77e0 100644
--- a/src/libxrpl/basics/Number.cpp
+++ b/src/libxrpl/basics/Number.cpp
@@ -27,7 +27,7 @@ using int128_t = __int128_t;
 
 namespace xrpl {
 
-thread_local Number::rounding_mode Number::mode_ = Number::to_nearest;
+thread_local Number::rounding_mode Number::mode_ = Number::rounding_mode::to_nearest;
 thread_local std::reference_wrapper<MantissaRange const> Number::range_ = largeRange;
 
 Number::rounding_mode
@@ -51,9 +51,10 @@ Number::getMantissaScale()
 void
 Number::setMantissaScale(MantissaRange::mantissa_scale scale)
 {
-    if (scale != MantissaRange::small && scale != MantissaRange::large)
+    if (scale != MantissaRange::mantissa_scale::small &&
+        scale != MantissaRange::mantissa_scale::large)
         LogicError("Unknown mantissa scale");
-    range_ = scale == MantissaRange::small ? smallRange : largeRange;
+    range_ = scale == MantissaRange::mantissa_scale::small ? smallRange : largeRange;
 }
 
 // Guard
@@ -176,10 +177,10 @@ Number::Guard::round() const noexcept
 {
     auto mode = Number::getround();
 
-    if (mode == towards_zero)
+    if (mode == rounding_mode::towards_zero)
         return -1;
 
-    if (mode == downward)
+    if (mode == rounding_mode::downward)
     {
         if (sbit_)
         {
@@ -189,7 +190,7 @@ Number::Guard::round() const noexcept
         return -1;
     }
 
-    if (mode == upward)
+    if (mode == rounding_mode::upward)
     {
         if (sbit_)
             return -1;
@@ -729,7 +730,7 @@ Number::operator/=(Number const& y)
     // f can be up to 10^(38-19) = 10^19 safely
     static_assert(smallRange.log == 15);
     static_assert(largeRange.log == 18);
-    bool const small = Number::getMantissaScale() == MantissaRange::small;
+    bool const small = Number::getMantissaScale() == MantissaRange::mantissa_scale::small;
     uint128_t const f = small ? 100'000'000'000'000'000 : 10'000'000'000'000'000'000ULL;
     XRPL_ASSERT_PARTS(f >= minMantissa * 10, "Number::operator/=", "factor expected size");
 
diff --git a/src/libxrpl/basics/ResolverAsio.cpp b/src/libxrpl/basics/ResolverAsio.cpp
index fc71666768..0443aa3502 100644
--- a/src/libxrpl/basics/ResolverAsio.cpp
+++ b/src/libxrpl/basics/ResolverAsio.cpp
@@ -177,7 +177,7 @@ public:
         if (m_stopped.exchange(false))
         {
             {
-                std::lock_guard const lk{m_mut};
+                std::scoped_lock const lk{m_mut};
                 m_asyncHandlersCompleted = false;
             }
             addReference();
diff --git a/src/libxrpl/beast/clock/basic_seconds_clock.cpp b/src/libxrpl/beast/clock/basic_seconds_clock.cpp
index 2b7ce57742..dc8f785974 100644
--- a/src/libxrpl/beast/clock/basic_seconds_clock.cpp
+++ b/src/libxrpl/beast/clock/basic_seconds_clock.cpp
@@ -42,7 +42,7 @@ seconds_clock_thread::~seconds_clock_thread()
     XRPL_ASSERT(
         thread_.joinable(), "beast::seconds_clock_thread::~seconds_clock_thread : thread joinable");
     {
-        std::lock_guard const lock(mut_);
+        std::scoped_lock const lock(mut_);
         stop_ = true;
     }  // publish stop_ asap so if waiting thread times-out, it will see it
     cv_.notify_one();
diff --git a/src/libxrpl/beast/insight/StatsDCollector.cpp b/src/libxrpl/beast/insight/StatsDCollector.cpp
index d11e85830f..a83a11d7d6 100644
--- a/src/libxrpl/beast/insight/StatsDCollector.cpp
+++ b/src/libxrpl/beast/insight/StatsDCollector.cpp
@@ -204,6 +204,8 @@ class StatsDCollectorImp : public StatsDCollector,
                            public std::enable_shared_from_this<StatsDCollectorImp>
 {
 private:
+    // Need to be named before converting
+    // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
     enum {
         // max_packet_size = 484
         max_packet_size = 1472
@@ -293,14 +295,14 @@ public:
     void
     add(StatsDMetricBase& metric)
     {
-        std::lock_guard const _(metricsLock_);
+        std::scoped_lock const _(metricsLock_);
         metrics_.push_back(metric);
     }
 
     void
     remove(StatsDMetricBase& metric)
     {
-        std::lock_guard const _(metricsLock_);
+        std::scoped_lock const _(metricsLock_);
         metrics_.erase(metrics_.iterator_to(metric));
     }
 
@@ -444,7 +446,7 @@ public:
             return;
         }
 
-        std::lock_guard const _(metricsLock_);
+        std::scoped_lock const _(metricsLock_);
 
         for (auto& m : metrics_)
             m.do_process();
diff --git a/src/libxrpl/beast/utility/beast_PropertyStream.cpp b/src/libxrpl/beast/utility/beast_PropertyStream.cpp
index ddfe075132..62c192bf64 100644
--- a/src/libxrpl/beast/utility/beast_PropertyStream.cpp
+++ b/src/libxrpl/beast/utility/beast_PropertyStream.cpp
@@ -158,7 +158,7 @@ PropertyStream::Source::Source(std::string name) : m_name(std::move(name)), item
 
 PropertyStream::Source::~Source()
 {
-    std::lock_guard const _(lock_);
+    std::scoped_lock const _(lock_);
     if (parent_ != nullptr)
         parent_->remove(*this);
     removeAll();
@@ -173,9 +173,7 @@ PropertyStream::Source::name() const
 void
 PropertyStream::Source::add(Source& source)
 {
-    std::lock(lock_, source.lock_);
-    std::lock_guard const lk1(lock_, std::adopt_lock);
-    std::lock_guard const lk2(source.lock_, std::adopt_lock);
+    std::scoped_lock const lock(lock_, source.lock_);
 
     XRPL_ASSERT(
         source.parent_ == nullptr, "beast::PropertyStream::Source::add : null source parent");
@@ -186,9 +184,7 @@ PropertyStream::Source::add(Source& source)
 void
 PropertyStream::Source::remove(Source& child)
 {
-    std::lock(lock_, child.lock_);
-    std::lock_guard const lk1(lock_, std::adopt_lock);
-    std::lock_guard const lk2(child.lock_, std::adopt_lock);
+    std::scoped_lock const lock(lock_, child.lock_);
 
     XRPL_ASSERT(
         child.parent_ == this, "beast::PropertyStream::Source::remove : child parent match");
@@ -199,10 +195,10 @@ PropertyStream::Source::remove(Source& child)
 void
 PropertyStream::Source::removeAll()
 {
-    std::lock_guard const _(lock_);
+    std::scoped_lock const _(lock_);
     for (auto iter = children_.begin(); iter != children_.end();)
     {
-        std::lock_guard const _cl((*iter)->lock_);
+        std::scoped_lock const _cl((*iter)->lock_);
         remove(*(*iter));
     }
 }
@@ -222,7 +218,7 @@ PropertyStream::Source::write(PropertyStream& stream)
     Map map(m_name, stream);
     onWrite(map);
 
-    std::lock_guard const _(lock_);
+    std::scoped_lock const _(lock_);
 
     for (auto& child : children_)
         child.source().write(stream);
@@ -324,7 +320,7 @@ PropertyStream::Source::find_one_deep(std::string const& name)
     if (found != nullptr)
         return found;
 
-    std::lock_guard const _(lock_);
+    std::scoped_lock const _(lock_);
     for (auto& s : children_)
     {
         found = s.source().find_one_deep(name);
@@ -355,7 +351,7 @@ PropertyStream::Source::find_path(std::string path)
 PropertyStream::Source*
 PropertyStream::Source::find_one(std::string const& name)
 {
-    std::lock_guard const _(lock_);
+    std::scoped_lock const _(lock_);
     for (auto& s : children_)
     {
         if (s.source().m_name == name)
diff --git a/src/libxrpl/core/HashRouter.cpp b/src/libxrpl/core/HashRouter.cpp
index 4175d83340..ecc2aa9f14 100644
--- a/src/libxrpl/core/HashRouter.cpp
+++ b/src/libxrpl/core/HashRouter.cpp
@@ -34,7 +34,7 @@ HashRouter::emplace(uint256 const& key) -> std::pair<Entry&, bool>
 void
 HashRouter::addSuppression(uint256 const& key)
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
 
     emplace(key);
 }
@@ -48,7 +48,7 @@ HashRouter::addSuppressionPeer(uint256 const& key, PeerShortID peer)
 std::pair<bool, std::optional<Stopwatch::time_point>>
 HashRouter::addSuppressionPeerWithStatus(uint256 const& key, PeerShortID peer)
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
 
     auto result = emplace(key);
     result.first.addPeer(peer);
@@ -58,7 +58,7 @@ HashRouter::addSuppressionPeerWithStatus(uint256 const& key, PeerShortID peer)
 bool
 HashRouter::addSuppressionPeer(uint256 const& key, PeerShortID peer, HashRouterFlags& flags)
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
 
     auto [s, created] = emplace(key);
     s.addPeer(peer);
@@ -73,7 +73,7 @@ HashRouter::shouldProcess(
     HashRouterFlags& flags,
     std::chrono::seconds tx_interval)
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
 
     auto result = emplace(key);
     auto& s = result.first;
@@ -85,7 +85,7 @@ HashRouter::shouldProcess(
 HashRouterFlags
 HashRouter::getFlags(uint256 const& key)
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
 
     return emplace(key).first.getFlags();
 }
@@ -95,7 +95,7 @@ HashRouter::setFlags(uint256 const& key, HashRouterFlags flags)
 {
     XRPL_ASSERT(static_cast<bool>(flags), "xrpl::HashRouter::setFlags : valid input");
 
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
 
     auto& s = emplace(key).first;
 
@@ -109,7 +109,7 @@ HashRouter::setFlags(uint256 const& key, HashRouterFlags flags)
 auto
 HashRouter::shouldRelay(uint256 const& key) -> std::optional<std::set<PeerShortID>>
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
 
     auto& s = emplace(key).first;
 
diff --git a/src/libxrpl/core/detail/JobQueue.cpp b/src/libxrpl/core/detail/JobQueue.cpp
index d55160f285..9e6756e0c0 100644
--- a/src/libxrpl/core/detail/JobQueue.cpp
+++ b/src/libxrpl/core/detail/JobQueue.cpp
@@ -39,7 +39,7 @@ JobQueue::JobQueue(
     job_count = m_collector->make_gauge("job_count");
 
     {
-        std::lock_guard const lock(m_mutex);
+        std::scoped_lock const lock(m_mutex);
 
         for (auto const& x : JobTypes::instance())
         {
@@ -65,7 +65,7 @@ JobQueue::~JobQueue()
 void
 JobQueue::collect()
 {
-    std::lock_guard const lock(m_mutex);
+    std::scoped_lock const lock(m_mutex);
     job_count = m_jobSet.size();
 }
 
@@ -91,7 +91,7 @@ JobQueue::addRefCountedJob(JobType type, std::string const& name, JobFunction co
         "requires no threads");
 
     {
-        std::lock_guard const lock(m_mutex);
+        std::scoped_lock const lock(m_mutex);
         auto result = m_jobSet.emplace(type, name, ++m_lastJob, data.load(), func);
         auto const& job = *result.first;
 
@@ -119,7 +119,7 @@ JobQueue::addRefCountedJob(JobType type, std::string const& name, JobFunction co
 int
 JobQueue::getJobCount(JobType t) const
 {
-    std::lock_guard const lock(m_mutex);
+    std::scoped_lock const lock(m_mutex);
 
     JobDataMap::const_iterator const c = m_jobData.find(t);
 
@@ -129,7 +129,7 @@ JobQueue::getJobCount(JobType t) const
 int
 JobQueue::getJobCountTotal(JobType t) const
 {
-    std::lock_guard const lock(m_mutex);
+    std::scoped_lock const lock(m_mutex);
 
     JobDataMap::const_iterator const c = m_jobData.find(t);
 
@@ -142,7 +142,7 @@ JobQueue::getJobCountGE(JobType t) const
     // return the number of jobs at this priority level or greater
     int ret = 0;
 
-    std::lock_guard const lock(m_mutex);
+    std::scoped_lock const lock(m_mutex);
 
     for (auto const& x : m_jobData)
     {
@@ -192,7 +192,7 @@ JobQueue::getJson(int c)
 
     Json::Value priorities = Json::arrayValue;
 
-    std::lock_guard const lock(m_mutex);
+    std::scoped_lock const lock(m_mutex);
 
     for (auto& x : m_jobData)
     {
@@ -349,7 +349,7 @@ JobQueue::processTask(int instance)
         {
             Job job;
             {
-                std::lock_guard const lock(m_mutex);
+                std::scoped_lock const lock(m_mutex);
                 getNextJob(job);
                 ++m_processCount;
             }
@@ -376,7 +376,7 @@ JobQueue::processTask(int instance)
     }
 
     {
-        std::lock_guard const lock(m_mutex);
+        std::scoped_lock const lock(m_mutex);
         // Job should be destroyed before stopping
         // otherwise destructors with side effects can access
         // parent objects that are already destroyed.
diff --git a/src/libxrpl/core/detail/LoadMonitor.cpp b/src/libxrpl/core/detail/LoadMonitor.cpp
index 2cf4e1f6ea..aea535fb81 100644
--- a/src/libxrpl/core/detail/LoadMonitor.cpp
+++ b/src/libxrpl/core/detail/LoadMonitor.cpp
@@ -108,7 +108,7 @@ LoadMonitor::addLoadSample(LoadEvent const& s)
 void
 LoadMonitor::addSamples(int count, std::chrono::milliseconds latency)
 {
-    std::lock_guard const sl(mutex_);
+    std::scoped_lock const sl(mutex_);
 
     update();
     mCounts += count;
@@ -140,7 +140,7 @@ LoadMonitor::isOverTarget(std::chrono::milliseconds avg, std::chrono::millisecon
 bool
 LoadMonitor::isOver()
 {
-    std::lock_guard const sl(mutex_);
+    std::scoped_lock const sl(mutex_);
 
     update();
 
@@ -157,7 +157,7 @@ LoadMonitor::getStats()
     using namespace std::chrono_literals;
     Stats stats;
 
-    std::lock_guard const sl(mutex_);
+    std::scoped_lock const sl(mutex_);
 
     update();
 
diff --git a/src/libxrpl/core/detail/Workers.cpp b/src/libxrpl/core/detail/Workers.cpp
index e7d63c0900..a6f8885a86 100644
--- a/src/libxrpl/core/detail/Workers.cpp
+++ b/src/libxrpl/core/detail/Workers.cpp
@@ -151,7 +151,7 @@ Workers::Worker::Worker(Workers& workers, std::string threadName, int const inst
 Workers::Worker::~Worker()
 {
     {
-        std::lock_guard const lock{mutex_};
+        std::scoped_lock const lock{mutex_};
         ++wakeCount_;
         shouldExit_ = true;
     }
@@ -163,7 +163,7 @@ Workers::Worker::~Worker()
 void
 Workers::Worker::notify()
 {
-    std::lock_guard const lock{mutex_};
+    std::scoped_lock const lock{mutex_};
     ++wakeCount_;
     wakeup_.notify_one();
 }
@@ -179,7 +179,7 @@ Workers::Worker::run()
         //
         if (++m_workers.m_activeCount == 1)
         {
-            std::lock_guard const lk{m_workers.m_mut};
+            std::scoped_lock const lk{m_workers.m_mut};
             m_workers.m_allPaused = false;
         }
 
@@ -226,7 +226,7 @@ Workers::Worker::run()
             // the predicate evaluation and the actual sleep.
             if (--m_workers.m_runningTaskCount == 0)
             {
-                std::lock_guard const lk{m_workers.m_mut};
+                std::scoped_lock const lk{m_workers.m_mut};
                 m_workers.m_cv.notify_all();
             }
         }
@@ -242,7 +242,7 @@ Workers::Worker::run()
         //
         if (--m_workers.m_activeCount == 0)
         {
-            std::lock_guard const lk{m_workers.m_mut};
+            std::scoped_lock const lk{m_workers.m_mut};
             m_workers.m_allPaused = true;
             m_workers.m_cv.notify_all();
         }
diff --git a/src/libxrpl/crypto/csprng.cpp b/src/libxrpl/crypto/csprng.cpp
index dc16c9ac64..7aef9b2831 100644
--- a/src/libxrpl/crypto/csprng.cpp
+++ b/src/libxrpl/crypto/csprng.cpp
@@ -43,7 +43,7 @@ csprng_engine::mix_entropy(void* buffer, std::size_t count)
             e = rd();
     }
 
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
 
     // We add data to the pool, but we conservatively assume that
     // it contributes no actual entropy.
@@ -60,7 +60,7 @@ csprng_engine::operator()(void* ptr, std::size_t count)
     // with thread support, so we don't need to grab a mutex.
     // https://mta.openssl.org/pipermail/openssl-users/2020-November/013146.html
 #if (OPENSSL_VERSION_NUMBER < 0x10100000L) || !defined(OPENSSL_THREADS)
-    std::lock_guard lock(mutex_);
+    std::scoped_lock lock(mutex_);
 #endif
 
     auto const result = RAND_bytes(reinterpret_cast<unsigned char*>(ptr), count);
diff --git a/src/libxrpl/json/Output.cpp b/src/libxrpl/json/Output.cpp
index e588d21d3c..31d74db7e0 100644
--- a/src/libxrpl/json/Output.cpp
+++ b/src/libxrpl/json/Output.cpp
@@ -45,7 +45,7 @@ outputJson(Json::Value const& value, Writer& writer)
         }
 
         case Json::arrayValue: {
-            writer.startRoot(Writer::array);
+            writer.startRoot(Writer::CollectionType::array);
             for (auto const& i : value)
             {
                 writer.rawAppend();
@@ -56,7 +56,7 @@ outputJson(Json::Value const& value, Writer& writer)
         }
 
         case Json::objectValue: {
-            writer.startRoot(Writer::object);
+            writer.startRoot(Writer::CollectionType::object);
             auto members = value.getMemberNames();
             for (auto const& tag : members)
             {
diff --git a/src/libxrpl/json/Writer.cpp b/src/libxrpl/json/Writer.cpp
index b4a85e0170..188f0749f0 100644
--- a/src/libxrpl/json/Writer.cpp
+++ b/src/libxrpl/json/Writer.cpp
@@ -81,7 +81,7 @@ public:
     void
     start(CollectionType ct)
     {
-        char const ch = (ct == array) ? openBracket : openBrace;
+        char const ch = (ct == CollectionType::array) ? openBracket : openBrace;
         output({&ch, 1});
         stack_.emplace(Collection{.type = ct});
     }
@@ -134,7 +134,9 @@ public:
         auto t = stack_.top().type;
         if (t != type)
         {
-            check(false, "Not an " + ((type == array ? "array: " : "object: ") + message));
+            check(
+                false,
+                "Not an " + ((type == CollectionType::array ? "array: " : "object: ") + message));
         }
         if (stack_.top().isFirst)
         {
@@ -171,7 +173,7 @@ public:
     {
         check(!empty(), "Empty stack in finish()");
 
-        auto isArray = stack_.top().type == array;
+        auto isArray = stack_.top().type == CollectionType::array;
         auto ch = isArray ? closeBracket : closeBrace;
         output_({&ch, 1});
         stack_.pop();
@@ -301,7 +303,7 @@ Writer::finishAll()
 void
 Writer::rawAppend()
 {
-    impl_->nextCollectionEntry(array, "append");
+    impl_->nextCollectionEntry(CollectionType::array, "append");
 }
 
 void
@@ -309,7 +311,7 @@ Writer::rawSet(std::string const& tag)
 {
     check(!tag.empty(), "Tag can't be empty");
 
-    impl_->nextCollectionEntry(object, "set");
+    impl_->nextCollectionEntry(CollectionType::object, "set");
     impl_->writeObjectTag(tag);
 }
 
@@ -322,14 +324,14 @@ Writer::startRoot(CollectionType type)
 void
 Writer::startAppend(CollectionType type)
 {
-    impl_->nextCollectionEntry(array, "startAppend");
+    impl_->nextCollectionEntry(CollectionType::array, "startAppend");
     impl_->start(type);
 }
 
 void
 Writer::startSet(CollectionType type, std::string const& key)
 {
-    impl_->nextCollectionEntry(object, "startSet");
+    impl_->nextCollectionEntry(CollectionType::object, "startSet");
     impl_->writeObjectTag(key);
     impl_->start(type);
 }
diff --git a/src/libxrpl/ledger/AcceptedLedgerTx.cpp b/src/libxrpl/ledger/AcceptedLedgerTx.cpp
index e609f5bdc8..21baa24323 100644
--- a/src/libxrpl/ledger/AcceptedLedgerTx.cpp
+++ b/src/libxrpl/ledger/AcceptedLedgerTx.cpp
@@ -62,8 +62,8 @@ AcceptedLedgerTx::AcceptedLedgerTx(
                 *ledger,
                 account,
                 amount,
-                fhIGNORE_FREEZE,
-                ahIGNORE_AUTH,
+                FreezeHandling::fhIGNORE_FREEZE,
+                AuthHandling::ahIGNORE_AUTH,
                 beast::Journal{beast::Journal::getNullSink()});
             mJson[jss::transaction][jss::owner_funds] = ownerFunds.getText();
         }
diff --git a/src/libxrpl/ledger/BookListeners.cpp b/src/libxrpl/ledger/BookListeners.cpp
index 36d02427bc..d922dc3a67 100644
--- a/src/libxrpl/ledger/BookListeners.cpp
+++ b/src/libxrpl/ledger/BookListeners.cpp
@@ -13,21 +13,21 @@ namespace xrpl {
 void
 BookListeners::addSubscriber(InfoSub::ref sub)
 {
-    std::lock_guard const sl(mLock);
+    std::scoped_lock const sl(mLock);
     mListeners[sub->getSeq()] = sub;
 }
 
 void
 BookListeners::removeSubscriber(std::uint64_t seq)
 {
-    std::lock_guard const sl(mLock);
+    std::scoped_lock const sl(mLock);
     mListeners.erase(seq);
 }
 
 void
 BookListeners::publish(MultiApiJson const& jvObj, hash_set<std::uint64_t>& havePublished)
 {
-    std::lock_guard const sl(mLock);
+    std::scoped_lock const sl(mLock);
     auto it = mListeners.cbegin();
 
     while (it != mListeners.cend())
diff --git a/src/libxrpl/ledger/CachedView.cpp b/src/libxrpl/ledger/CachedView.cpp
index 6bbe2d828b..bb7ff97153 100644
--- a/src/libxrpl/ledger/CachedView.cpp
+++ b/src/libxrpl/ledger/CachedView.cpp
@@ -30,7 +30,7 @@ CachedViewImpl::read(Keylet const& k) const
 
     auto const digest = [&]() -> std::optional<uint256> {
         {
-            std::lock_guard const lock(mutex_);
+            std::scoped_lock const lock(mutex_);
             auto const iter = map_.find(k.key);
             if (iter != map_.end())
             {
@@ -66,7 +66,7 @@ CachedViewImpl::read(Keylet const& k) const
         // Avoid acquiring this lock unless necessary. It is only necessary if
         // the key was not found in the map_. The lock is needed to add the key
         // and digest.
-        std::lock_guard const lock(mutex_);
+        std::scoped_lock const lock(mutex_);
         map_.emplace(k.key, *digest);
     }
     if (!sle || !k.check(*sle))
diff --git a/src/libxrpl/ledger/Ledger.cpp b/src/libxrpl/ledger/Ledger.cpp
index 18db482538..729f1ebce9 100644
--- a/src/libxrpl/ledger/Ledger.cpp
+++ b/src/libxrpl/ledger/Ledger.cpp
@@ -204,7 +204,7 @@ Ledger::Ledger(
         rawInsert(sle);
     }
 
-    stateMap_.flushDirty(hotACCOUNT_NODE);
+    stateMap_.flushDirty(NodeObjectType::hotACCOUNT_NODE);
     setImmutable();
 }
 
diff --git a/src/libxrpl/ledger/helpers/AMMHelpers.cpp b/src/libxrpl/ledger/helpers/AMMHelpers.cpp
index 94ca2469f7..cc91dcaaf4 100644
--- a/src/libxrpl/ledger/helpers/AMMHelpers.cpp
+++ b/src/libxrpl/ledger/helpers/AMMHelpers.cpp
@@ -46,7 +46,8 @@ STAmount
 ammLPTokens(STAmount const& asset1, STAmount const& asset2, Asset const& lptIssue)
 {
     // AMM invariant: sqrt(asset1 * asset2) >= LPTokensBalance
-    auto const rounding = isFeatureEnabled(fixAMMv1_3) ? Number::downward : Number::getround();
+    auto const rounding =
+        isFeatureEnabled(fixAMMv1_3) ? Number::rounding_mode::downward : Number::getround();
     NumberRoundModeGuard const g(rounding);
     auto const tokens = root2(asset1 * asset2);
     return toSTAmount(lptIssue, tokens);
@@ -77,7 +78,7 @@ lpTokensOut(
 
     // minimize tokens out
     auto const frac = (r - c) / (1 + c);
-    return multiply(lptAMMBalance, frac, Number::downward);
+    return multiply(lptAMMBalance, frac, Number::rounding_mode::downward);
 }
 
 /* Equation 4 solves equation 3 for b:
@@ -113,7 +114,7 @@ ammAssetIn(
 
     // maximize deposit
     auto const frac = solveQuadraticEq(a, b, c);
-    return multiply(asset1Balance, frac, Number::upward);
+    return multiply(asset1Balance, frac, Number::rounding_mode::upward);
 }
 
 /* Equation 7:
@@ -138,7 +139,7 @@ lpTokensIn(
 
     // maximize tokens in
     auto const frac = (c - root2(c * c - 4 * fr)) / 2;
-    return multiply(lptAMMBalance, frac, Number::upward);
+    return multiply(lptAMMBalance, frac, Number::rounding_mode::upward);
 }
 
 /* Equation 8 solves equation 7 for b:
@@ -168,7 +169,7 @@ ammAssetOut(
 
     // minimize withdraw
     auto const frac = (t1 * t1 - t1 * (2 - f)) / (t1 * f - 1);
-    return multiply(assetBalance, frac, Number::downward);
+    return multiply(assetBalance, frac, Number::rounding_mode::downward);
 }
 
 Number
diff --git a/src/libxrpl/ledger/helpers/LendingHelpers.cpp b/src/libxrpl/ledger/helpers/LendingHelpers.cpp
index caccca752d..a263791e39 100644
--- a/src/libxrpl/ledger/helpers/LendingHelpers.cpp
+++ b/src/libxrpl/ledger/helpers/LendingHelpers.cpp
@@ -93,8 +93,8 @@ loanPeriodicRate(TenthBips32 interestRate, std::uint32_t paymentInterval)
 bool
 isRounded(Asset const& asset, Number const& value, std::int32_t scale)
 {
-    return roundToAsset(asset, value, scale, Number::downward) ==
-        roundToAsset(asset, value, scale, Number::upward);
+    return roundToAsset(asset, value, scale, Number::rounding_mode::downward) ==
+        roundToAsset(asset, value, scale, Number::rounding_mode::upward);
 }
 
 namespace detail {
@@ -458,7 +458,11 @@ tryOverpayment(
     // preserved rounding errors. This ensures the loan's tracked state remains
     // consistent with its payment history.
     auto const principalOutstanding = std::clamp(
-        roundToAsset(asset, newTheoreticalState.principalOutstanding, loanScale, Number::upward),
+        roundToAsset(
+            asset,
+            newTheoreticalState.principalOutstanding,
+            loanScale,
+            Number::rounding_mode::upward),
         numZero,
         roundedOldState.principalOutstanding);
     auto const totalValueOutstanding = std::clamp(
@@ -466,7 +470,7 @@ tryOverpayment(
             asset,
             principalOutstanding + newTheoreticalState.interestOutstanding(),
             loanScale,
-            Number::upward),
+            Number::rounding_mode::upward),
         numZero,
         roundedOldState.valueOutstanding);
     auto const managementFeeOutstanding = std::clamp(
@@ -836,7 +840,8 @@ computeFullPayment(
     // Split the full payment interest into net interest (to vault) and
     // management fee (to broker), applying proper rounding.
     auto const [roundedFullInterest, roundedFullManagementFee] = [&]() {
-        auto const interest = roundToAsset(asset, fullPaymentInterest, loanScale, Number::downward);
+        auto const interest =
+            roundToAsset(asset, fullPaymentInterest, loanScale, Number::rounding_mode::downward);
         return computeInterestAndFeeParts(asset, interest, managementFeeRate, loanScale);
     }();
 
@@ -1286,7 +1291,7 @@ checkLoanGuards(
     // loan can't be amortized in the specified number of payments, raise an
     // error
     {
-        NumberRoundModeGuard const mg(Number::upward);
+        NumberRoundModeGuard const mg(Number::rounding_mode::upward);
 
         if (std::int64_t const computedPayments{
                 properties.loanState.valueOutstanding / roundedPayment};
@@ -1465,7 +1470,8 @@ computeManagementFee(
     TenthBips32 managementFeeRate,
     std::int32_t scale)
 {
-    return roundToAsset(asset, tenthBipsOfValue(value, managementFeeRate), scale, Number::downward);
+    return roundToAsset(
+        asset, tenthBipsOfValue(value, managementFeeRate), scale, Number::rounding_mode::downward);
 }
 
 /*
@@ -1519,7 +1525,8 @@ computeLoanProperties(
 
     auto const [totalValueOutstanding, loanScale] = [&]() {
         // only round up if there should be interest
-        NumberRoundModeGuard const mg(periodicRate == 0 ? Number::to_nearest : Number::upward);
+        NumberRoundModeGuard const mg(
+            periodicRate == 0 ? Number::rounding_mode::to_nearest : Number::rounding_mode::upward);
         // Use STAmount's internal rounding instead of roundToAsset, because
         // we're going to use this result to determine the scale for all the
         // other rounding.
@@ -1548,7 +1555,7 @@ computeLoanProperties(
     // validate that the principal fits in it, so to allow this function to
     // succeed, round it here, and let the caller do the validation.
     auto const roundedPrincipalOutstanding =
-        roundToAsset(asset, principalOutstanding, loanScale, Number::to_nearest);
+        roundToAsset(asset, principalOutstanding, loanScale, Number::rounding_mode::to_nearest);
 
     // Equation (31) from XLS-66 spec, Section A-2 Equation Glossary
     auto const totalInterestOutstanding = totalValueOutstanding - roundedPrincipalOutstanding;
diff --git a/src/libxrpl/ledger/helpers/TokenHelpers.cpp b/src/libxrpl/ledger/helpers/TokenHelpers.cpp
index 436542f9b3..ec56717f61 100644
--- a/src/libxrpl/ledger/helpers/TokenHelpers.cpp
+++ b/src/libxrpl/ledger/helpers/TokenHelpers.cpp
@@ -162,7 +162,7 @@ getLineIfUsable(
         return nullptr;
     }
 
-    if (zeroIfFrozen == fhZERO_IF_FROZEN)
+    if (zeroIfFrozen == FreezeHandling::fhZERO_IF_FROZEN)
     {
         if (isFrozen(view, account, currency, issuer) ||
             isDeepFrozen(view, account, currency, issuer))
@@ -249,7 +249,7 @@ accountHolds(
         return {xrpLiquid(view, account, 0, j)};
     }
 
-    bool const returnSpendable = (includeFullBalance == shFULL_BALANCE);
+    bool const returnSpendable = (includeFullBalance == SpendableHandling::shFULL_BALANCE);
     if (returnSpendable && account == issuer)
     {
         // If the account is the issuer, then their limit is effectively
@@ -287,7 +287,7 @@ accountHolds(
     beast::Journal j,
     SpendableHandling includeFullBalance)
 {
-    bool const returnSpendable = (includeFullBalance == shFULL_BALANCE);
+    bool const returnSpendable = (includeFullBalance == SpendableHandling::shFULL_BALANCE);
     STAmount amount{mptIssue};
     auto const& issuer = mptIssue.getIssuer();
     bool const mptokensV2 = view.rules().enabled(featureMPTokensV2);
@@ -314,7 +314,7 @@ accountHolds(
     {
         amount.clear(mptIssue);
     }
-    else if (zeroIfFrozen == fhZERO_IF_FROZEN && isFrozen(view, account, mptIssue))
+    else if (zeroIfFrozen == FreezeHandling::fhZERO_IF_FROZEN && isFrozen(view, account, mptIssue))
     {
         amount.clear(mptIssue);
     }
@@ -324,14 +324,14 @@ accountHolds(
 
         // Only if auth check is needed, as it needs to do an additional read
         // operation. Note featureSingleAssetVault will affect error codes.
-        if (zeroIfUnauthorized == ahZERO_IF_UNAUTHORIZED &&
+        if (zeroIfUnauthorized == AuthHandling::ahZERO_IF_UNAUTHORIZED &&
             view.rules().enabled(featureSingleAssetVault))
         {
             if (auto const err = requireAuth(view, mptIssue, account, AuthType::StrongAuth);
                 !isTesSuccess(err))
                 amount.clear(mptIssue);
         }
-        else if (zeroIfUnauthorized == ahZERO_IF_UNAUTHORIZED)
+        else if (zeroIfUnauthorized == AuthHandling::ahZERO_IF_UNAUTHORIZED)
         {
             auto const sleIssuance = view.read(keylet::mptIssuance(mptIssue.getMptID()));
 
@@ -398,7 +398,13 @@ accountFunds(
         [&](Issue const&) { return accountFunds(view, id, saDefault, freezeHandling, j); },
         [&](MPTIssue const&) {
             return accountHolds(
-                view, id, saDefault.asset(), freezeHandling, authHandling, j, shFULL_BALANCE);
+                view,
+                id,
+                saDefault.asset(),
+                freezeHandling,
+                authHandling,
+                j,
+                SpendableHandling::shFULL_BALANCE);
         });
 }
 
diff --git a/src/libxrpl/nodestore/BatchWriter.cpp b/src/libxrpl/nodestore/BatchWriter.cpp
index 9da6f504a9..b05c80ff00 100644
--- a/src/libxrpl/nodestore/BatchWriter.cpp
+++ b/src/libxrpl/nodestore/BatchWriter.cpp
@@ -47,7 +47,7 @@ BatchWriter::store(std::shared_ptr<NodeObject> const& object)
 int
 BatchWriter::getWriteLoad()
 {
-    std::lock_guard const sl(mWriteMutex);
+    std::scoped_lock const sl(mWriteMutex);
 
     return std::max(mWriteLoad, static_cast<int>(mWriteSet.size()));
 }
@@ -68,7 +68,7 @@ BatchWriter::writeBatch()
         set.reserve(batchWritePreallocationSize);
 
         {
-            std::lock_guard const sl(mWriteMutex);
+            std::scoped_lock const sl(mWriteMutex);
 
             mWriteSet.swap(set);
             XRPL_ASSERT(
diff --git a/src/libxrpl/nodestore/Database.cpp b/src/libxrpl/nodestore/Database.cpp
index ee8d2f56aa..fa69cba517 100644
--- a/src/libxrpl/nodestore/Database.cpp
+++ b/src/libxrpl/nodestore/Database.cpp
@@ -143,7 +143,7 @@ void
 Database::stop()
 {
     {
-        std::lock_guard const lock(readLock_);
+        std::scoped_lock const lock(readLock_);
 
         if (!readStopping_.exchange(true, std::memory_order_relaxed))
         {
@@ -179,7 +179,7 @@ Database::asyncFetch(
     std::uint32_t ledgerSeq,
     std::function<void(std::shared_ptr<NodeObject> const&)>&& cb)
 {
-    std::lock_guard const lock(readLock_);
+    std::scoped_lock const lock(readLock_);
 
     if (!isStopping())
     {
diff --git a/src/libxrpl/nodestore/DatabaseNodeImp.cpp b/src/libxrpl/nodestore/DatabaseNodeImp.cpp
index 7722f711bb..1bb5f32308 100644
--- a/src/libxrpl/nodestore/DatabaseNodeImp.cpp
+++ b/src/libxrpl/nodestore/DatabaseNodeImp.cpp
@@ -48,7 +48,7 @@ DatabaseNodeImp::fetchNodeObject(
     bool duplicate)
 {
     std::shared_ptr<NodeObject> nodeObject = nullptr;
-    Status status = ok;
+    Status status = Status::ok;
 
     try
     {
@@ -63,15 +63,15 @@ DatabaseNodeImp::fetchNodeObject(
 
     switch (status)
     {
-        case ok:
-        case notFound:
+        case Status::ok:
+        case Status::notFound:
             break;
-        case dataCorrupt:
+        case Status::dataCorrupt:
             JLOG(j_.fatal()) << "fetchNodeObject " << hash << ": nodestore data is corrupted";
             break;
         default:
             JLOG(j_.warn()) << "fetchNodeObject " << hash << ": backend returns unknown result "
-                            << status;
+                            << static_cast<int>(status);
             break;
     }
 
diff --git a/src/libxrpl/nodestore/DatabaseRotatingImp.cpp b/src/libxrpl/nodestore/DatabaseRotatingImp.cpp
index ef7431f5a3..de34af7773 100644
--- a/src/libxrpl/nodestore/DatabaseRotatingImp.cpp
+++ b/src/libxrpl/nodestore/DatabaseRotatingImp.cpp
@@ -53,7 +53,7 @@ DatabaseRotatingImp::rotate(
     // deleted.
     std::shared_ptr<NodeStore::Backend> oldArchiveBackend;
     {
-        std::lock_guard const lock(mutex_);
+        std::scoped_lock const lock(mutex_);
 
         archiveBackend_->setDeletePath();
         oldArchiveBackend = std::move(archiveBackend_);
@@ -70,14 +70,14 @@ DatabaseRotatingImp::rotate(
 std::string
 DatabaseRotatingImp::getName() const
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     return writableBackend_->getName();
 }
 
 std::int32_t
 DatabaseRotatingImp::getWriteLoad() const
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     return writableBackend_->getWriteLoad();
 }
 
@@ -85,7 +85,7 @@ void
 DatabaseRotatingImp::importDatabase(Database& source)
 {
     auto const backend = [&] {
-        std::lock_guard const lock(mutex_);
+        std::scoped_lock const lock(mutex_);
         return writableBackend_;
     }();
 
@@ -95,7 +95,7 @@ DatabaseRotatingImp::importDatabase(Database& source)
 void
 DatabaseRotatingImp::sync()
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     writableBackend_->sync();
 }
 
@@ -105,7 +105,7 @@ DatabaseRotatingImp::store(NodeObjectType type, Blob&& data, uint256 const& hash
     auto nObj = NodeObject::createObject(type, std::move(data), hash);
 
     auto const backend = [&] {
-        std::lock_guard const lock(mutex_);
+        std::scoped_lock const lock(mutex_);
         return writableBackend_;
     }();
 
@@ -121,7 +121,7 @@ DatabaseRotatingImp::fetchNodeObject(
     bool duplicate)
 {
     auto fetch = [&](std::shared_ptr<Backend> const& backend) {
-        Status status = ok;
+        Status status = Status::ok;
         std::shared_ptr<NodeObject> nodeObject;
         try
         {
@@ -135,14 +135,14 @@ DatabaseRotatingImp::fetchNodeObject(
 
         switch (status)
         {
-            case ok:
-            case notFound:
+            case Status::ok:
+            case Status::notFound:
                 break;
-            case dataCorrupt:
+            case Status::dataCorrupt:
                 JLOG(j_.fatal()) << "Corrupt NodeObject #" << hash;
                 break;
             default:
-                JLOG(j_.warn()) << "Unknown status=" << status;
+                JLOG(j_.warn()) << "Unknown status=" << static_cast<int>(status);
                 break;
         }
 
@@ -153,7 +153,7 @@ DatabaseRotatingImp::fetchNodeObject(
     std::shared_ptr<NodeObject> nodeObject;
 
     auto [writable, archive] = [&] {
-        std::lock_guard const lock(mutex_);
+        std::scoped_lock const lock(mutex_);
         return std::make_pair(writableBackend_, archiveBackend_);
     }();
 
@@ -167,7 +167,7 @@ DatabaseRotatingImp::fetchNodeObject(
         {
             {
                 // Refresh the writable backend pointer
-                std::lock_guard const lock(mutex_);
+                std::scoped_lock const lock(mutex_);
                 writable = writableBackend_;
             }
 
@@ -187,7 +187,7 @@ void
 DatabaseRotatingImp::for_each(std::function<void(std::shared_ptr<NodeObject>)> f)
 {
     auto [writable, archive] = [&] {
-        std::lock_guard const lock(mutex_);
+        std::scoped_lock const lock(mutex_);
         return std::make_pair(writableBackend_, archiveBackend_);
     }();
 
diff --git a/src/libxrpl/nodestore/DecodedBlob.cpp b/src/libxrpl/nodestore/DecodedBlob.cpp
index 1d60f2af86..437aef24da 100644
--- a/src/libxrpl/nodestore/DecodedBlob.cpp
+++ b/src/libxrpl/nodestore/DecodedBlob.cpp
@@ -25,7 +25,7 @@ DecodedBlob::DecodedBlob(void const* key, void const* value, int valueBytes)
 
     m_success = false;
     m_key = key;
-    m_objectType = hotUNKNOWN;
+    m_objectType = NodeObjectType::hotUNKNOWN;
     m_objectData = nullptr;
     m_dataBytes = std::max(0, valueBytes - 9);
 
@@ -46,10 +46,10 @@ DecodedBlob::DecodedBlob(void const* key, void const* value, int valueBytes)
             default:
                 break;
 
-            case hotUNKNOWN:
-            case hotLEDGER:
-            case hotACCOUNT_NODE:
-            case hotTRANSACTION_NODE:
+            case NodeObjectType::hotUNKNOWN:
+            case NodeObjectType::hotLEDGER:
+            case NodeObjectType::hotACCOUNT_NODE:
+            case NodeObjectType::hotTRANSACTION_NODE:
                 m_success = true;
                 break;
         }
diff --git a/src/libxrpl/nodestore/ManagerImp.cpp b/src/libxrpl/nodestore/ManagerImp.cpp
index 40a48f0875..1420bf3997 100644
--- a/src/libxrpl/nodestore/ManagerImp.cpp
+++ b/src/libxrpl/nodestore/ManagerImp.cpp
@@ -96,14 +96,14 @@ ManagerImp::make_Database(
 void
 ManagerImp::insert(Factory& factory)
 {
-    std::lock_guard const _(mutex_);
+    std::scoped_lock const _(mutex_);
     list_.push_back(&factory);
 }
 
 void
 ManagerImp::erase(Factory& factory)
 {
-    std::lock_guard const _(mutex_);
+    std::scoped_lock const _(mutex_);
     auto const iter =
         std::ranges::find_if(list_, [&factory](Factory* other) { return other == &factory; });
     XRPL_ASSERT(iter != list_.end(), "xrpl::NodeStore::ManagerImp::erase : valid input");
@@ -113,7 +113,7 @@ ManagerImp::erase(Factory& factory)
 Factory*
 ManagerImp::find(std::string const& name)
 {
-    std::lock_guard const _(mutex_);
+    std::scoped_lock const _(mutex_);
     auto const iter = std::ranges::find_if(
         list_, [&name](Factory* other) { return boost::iequals(name, other->getName()); });
     if (iter == list_.end())
diff --git a/src/libxrpl/nodestore/backend/MemoryFactory.cpp b/src/libxrpl/nodestore/backend/MemoryFactory.cpp
index abf25013ce..ef07ebe957 100644
--- a/src/libxrpl/nodestore/backend/MemoryFactory.cpp
+++ b/src/libxrpl/nodestore/backend/MemoryFactory.cpp
@@ -59,7 +59,7 @@ public:
     MemoryDB&
     open(std::string const& path)
     {
-        std::lock_guard const _(mutex_);
+        std::scoped_lock const _(mutex_);
         auto const result =
             map_.emplace(std::piecewise_construct, std::make_tuple(path), std::make_tuple());
         MemoryDB& db = result.first->second;
@@ -134,16 +134,16 @@ public:
     {
         XRPL_ASSERT(db_, "xrpl::NodeStore::MemoryBackend::fetch : non-null database");
 
-        std::lock_guard const _(db_->mutex);
+        std::scoped_lock const _(db_->mutex);
 
         Map::iterator const iter = db_->table.find(hash);
         if (iter == db_->table.end())
         {
             pObject->reset();
-            return notFound;
+            return Status::notFound;
         }
         *pObject = iter->second;
-        return ok;
+        return Status::ok;
     }
 
     std::pair<std::vector<std::shared_ptr<NodeObject>>, Status>
@@ -155,7 +155,7 @@ public:
         {
             std::shared_ptr<NodeObject> nObj;
             Status const status = fetch(h, &nObj);
-            if (status != ok)
+            if (status != Status::ok)
             {
                 results.push_back({});
             }
@@ -165,14 +165,14 @@ public:
             }
         }
 
-        return {results, ok};
+        return {results, Status::ok};
     }
 
     void
     store(std::shared_ptr<NodeObject> const& object) override
     {
         XRPL_ASSERT(db_, "xrpl::NodeStore::MemoryBackend::store : non-null database");
-        std::lock_guard const _(db_->mutex);
+        std::scoped_lock const _(db_->mutex);
         db_->table.emplace(object->getHash(), object);
     }
 
diff --git a/src/libxrpl/nodestore/backend/NuDBFactory.cpp b/src/libxrpl/nodestore/backend/NuDBFactory.cpp
index 86540016da..18fe3c572e 100644
--- a/src/libxrpl/nodestore/backend/NuDBFactory.cpp
+++ b/src/libxrpl/nodestore/backend/NuDBFactory.cpp
@@ -207,7 +207,7 @@ public:
     Status
     fetch(uint256 const& hash, std::shared_ptr<NodeObject>* pno) override
     {
-        Status status = ok;
+        Status status = Status::ok;
         pno->reset();
         nudb::error_code ec;
         db_.fetch(
@@ -218,15 +218,15 @@ public:
                 DecodedBlob decoded(hash.data(), result.first, result.second);
                 if (!decoded.wasOk())
                 {
-                    status = dataCorrupt;
+                    status = Status::dataCorrupt;
                     return;
                 }
                 *pno = decoded.createObject();
-                status = ok;
+                status = Status::ok;
             },
             ec);
         if (ec == nudb::error::key_not_found)
-            return notFound;
+            return Status::notFound;
         if (ec)
             Throw<nudb::system_error>(ec);
         return status;
@@ -241,7 +241,7 @@ public:
         {
             std::shared_ptr<NodeObject> nObj;
             Status const status = fetch(h, &nObj);
-            if (status != ok)
+            if (status != Status::ok)
             {
                 results.push_back({});
             }
@@ -251,7 +251,7 @@ public:
             }
         }
 
-        return {results, ok};
+        return {results, Status::ok};
     }
 
     void
diff --git a/src/libxrpl/nodestore/backend/NullFactory.cpp b/src/libxrpl/nodestore/backend/NullFactory.cpp
index 02e6ca4dda..917ee3d8d0 100644
--- a/src/libxrpl/nodestore/backend/NullFactory.cpp
+++ b/src/libxrpl/nodestore/backend/NullFactory.cpp
@@ -49,7 +49,7 @@ public:
     Status
     fetch(uint256 const&, std::shared_ptr<NodeObject>*) override
     {
-        return notFound;
+        return Status::notFound;
     }
 
     std::pair<std::vector<std::shared_ptr<NodeObject>>, Status>
diff --git a/src/libxrpl/nodestore/backend/RocksDBFactory.cpp b/src/libxrpl/nodestore/backend/RocksDBFactory.cpp
index 86dff9240d..be2506ec6f 100644
--- a/src/libxrpl/nodestore/backend/RocksDBFactory.cpp
+++ b/src/libxrpl/nodestore/backend/RocksDBFactory.cpp
@@ -285,7 +285,7 @@ public:
         XRPL_ASSERT(m_db, "xrpl::NodeStore::RocksDBBackend::fetch : non-null database");
         pObject->reset();
 
-        Status status(ok);
+        Status status(Status::ok);
 
         rocksdb::ReadOptions const options;
         rocksdb::Slice const slice(std::bit_cast<char const*>(hash.data()), m_keyBytes);
@@ -306,22 +306,23 @@ public:
             {
                 // Decoding failed, probably corrupted!
                 //
-                status = dataCorrupt;
+                status = Status::dataCorrupt;
             }
         }
         else
         {
             if (getStatus.IsCorruption())
             {
-                status = dataCorrupt;
+                status = Status::dataCorrupt;
             }
             else if (getStatus.IsNotFound())
             {
-                status = notFound;
+                status = Status::notFound;
             }
             else
             {
-                status = Status(customCode + unsafe_cast<int>(getStatus.code()));
+                status = static_cast<Status>(
+                    static_cast<int>(Status::customCode) + unsafe_cast<int>(getStatus.code()));
 
                 JLOG(m_journal.error()) << getStatus.ToString();
             }
@@ -339,7 +340,7 @@ public:
         {
             std::shared_ptr<NodeObject> nObj;
             Status const status = fetch(h, &nObj);
-            if (status != ok)
+            if (status != Status::ok)
             {
                 results.push_back({});
             }
@@ -349,7 +350,7 @@ public:
             }
         }
 
-        return {results, ok};
+        return {results, Status::ok};
     }
 
     void
diff --git a/src/libxrpl/protocol/AccountID.cpp b/src/libxrpl/protocol/AccountID.cpp
index a89dc8fd11..ffebde2c1a 100644
--- a/src/libxrpl/protocol/AccountID.cpp
+++ b/src/libxrpl/protocol/AccountID.cpp
@@ -56,7 +56,7 @@ public:
         packed_spinlock sl(locks_, index % 64);
 
         {
-            std::lock_guard const lock(sl);
+            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:
@@ -69,7 +69,7 @@ public:
         XRPL_ASSERT(ret.size() <= 38, "xrpl::detail::AccountIdCache : maximum result size");
 
         {
-            std::lock_guard const lock(sl);
+            std::scoped_lock const lock(sl);
             cache_[index].id = id;
             std::strcpy(cache_[index].encoding, ret.c_str());
         }
diff --git a/src/libxrpl/protocol/Rules.cpp b/src/libxrpl/protocol/Rules.cpp
index 7a8d0144bb..3e4649a27f 100644
--- a/src/libxrpl/protocol/Rules.cpp
+++ b/src/libxrpl/protocol/Rules.cpp
@@ -40,7 +40,9 @@ setCurrentTransactionRules(std::optional<Rules> r)
     // the value is needed. That could get expensive fast.
     bool const enableLargeNumbers =
         !r || (r->enabled(featureSingleAssetVault) || r->enabled(featureLendingProtocol));
-    Number::setMantissaScale(enableLargeNumbers ? MantissaRange::large : MantissaRange::small);
+    Number::setMantissaScale(
+        enableLargeNumbers ? MantissaRange::mantissa_scale::large
+                           : MantissaRange::mantissa_scale::small);
 
     *getCurrentTransactionRulesRef() = std::move(r);
 }
diff --git a/src/libxrpl/protocol/STAmount.cpp b/src/libxrpl/protocol/STAmount.cpp
index 89992b823c..654bcf1be4 100644
--- a/src/libxrpl/protocol/STAmount.cpp
+++ b/src/libxrpl/protocol/STAmount.cpp
@@ -1612,7 +1612,7 @@ mulRoundImpl(STAmount const& v1, STAmount const& v2, Asset const& asset, bool ro
     STAmount result = [&]() {
         // If appropriate, tell Number to round down.  This gives the desired
         // result from STAmount::canonicalize.
-        MightSaveRound const savedRound(Number::towards_zero);
+        MightSaveRound const savedRound(Number::rounding_mode::towards_zero);
         return STAmount(asset, amount, offset, resultNegative);
     }();
 
diff --git a/src/libxrpl/protocol/STNumber.cpp b/src/libxrpl/protocol/STNumber.cpp
index 25aa9eaa05..d506751f86 100644
--- a/src/libxrpl/protocol/STNumber.cpp
+++ b/src/libxrpl/protocol/STNumber.cpp
@@ -95,7 +95,7 @@ STNumber::add(Serializer& s) const
             // Json. Regardless, the only time we should be serializing an
             // STNumber is when the scale is large.
             XRPL_ASSERT_PARTS(
-                Number::getMantissaScale() == MantissaRange::large,
+                Number::getMantissaScale() == MantissaRange::mantissa_scale::large,
                 "xrpl::STNumber::add",
                 "STNumber only used with large mantissa scale");
 #endif
diff --git a/src/libxrpl/protocol/STObject.cpp b/src/libxrpl/protocol/STObject.cpp
index baece3ca56..9f032a0962 100644
--- a/src/libxrpl/protocol/STObject.cpp
+++ b/src/libxrpl/protocol/STObject.cpp
@@ -119,7 +119,7 @@ STObject::isDefault() const
 void
 STObject::add(Serializer& s) const
 {
-    add(s, withAllFields);  // just inner elements
+    add(s, WhichFields::withAllFields);  // just inner elements
 }
 
 STObject&
@@ -258,7 +258,7 @@ STObject::set(SerialIter& sit, int depth)
 
     // We want to ensure that the deserialized object does not contain any
     // duplicate fields. This is a key invariant:
-    auto const sf = getSortedFields(*this, withAllFields);
+    auto const sf = getSortedFields(*this, WhichFields::withAllFields);
 
     auto const dup = std::ranges::adjacent_find(sf, [](STBase const* lhs, STBase const* rhs) {
         return lhs->getFName() == rhs->getFName();
@@ -353,8 +353,8 @@ STObject::isEquivalent(STBase const& t) const
             });
     }
 
-    auto const sf1 = getSortedFields(*this, withAllFields);
-    auto const sf2 = getSortedFields(*v, withAllFields);
+    auto const sf1 = getSortedFields(*this, WhichFields::withAllFields);
+    auto const sf2 = getSortedFields(*v, WhichFields::withAllFields);
 
     return std::ranges::equal(sf1, sf2, [](STBase const* st1, STBase const* st2) {
         return (st1->getSType() == st2->getSType()) && st1->isEquivalent(*st2);
@@ -366,7 +366,7 @@ STObject::getHash(HashPrefix prefix) const
 {
     Serializer s;
     s.add32(prefix);
-    add(s, withAllFields);
+    add(s, WhichFields::withAllFields);
     return s.getSHA512Half();
 }
 
@@ -375,7 +375,7 @@ STObject::getSigningHash(HashPrefix prefix) const
 {
     Serializer s;
     s.add32(prefix);
-    add(s, omitSigningFields);
+    add(s, WhichFields::omitSigningFields);
     return s.getSHA512Half();
 }
 
diff --git a/src/libxrpl/protocol/STTx.cpp b/src/libxrpl/protocol/STTx.cpp
index 4f992432d8..fbec49a4e4 100644
--- a/src/libxrpl/protocol/STTx.cpp
+++ b/src/libxrpl/protocol/STTx.cpp
@@ -203,7 +203,7 @@ STTx::getSeqProxy() const
         return SeqProxy::sequence(seq);
     }
 
-    return SeqProxy{SeqProxy::ticket, *ticketSeq};
+    return SeqProxy{SeqProxy::Type::ticket, *ticketSeq};
 }
 
 std::uint32_t
diff --git a/src/libxrpl/rdb/DatabaseCon.cpp b/src/libxrpl/rdb/DatabaseCon.cpp
index 5f4594b630..cc7692de78 100644
--- a/src/libxrpl/rdb/DatabaseCon.cpp
+++ b/src/libxrpl/rdb/DatabaseCon.cpp
@@ -30,7 +30,7 @@ public:
     std::shared_ptr<Checkpointer>
     fromId(std::uintptr_t id)
     {
-        std::lock_guard const l{mutex_};
+        std::scoped_lock const l{mutex_};
         auto it = checkpointers_.find(id);
         if (it != checkpointers_.end())
             return it->second;
@@ -40,7 +40,7 @@ public:
     void
     erase(std::uintptr_t id)
     {
-        std::lock_guard const lock{mutex_};
+        std::scoped_lock const lock{mutex_};
         checkpointers_.erase(id);
     }
 
@@ -50,7 +50,7 @@ public:
         JobQueue& jobQueue,
         ServiceRegistry& registry)
     {
-        std::lock_guard const lock{mutex_};
+        std::scoped_lock const lock{mutex_};
         auto const id = nextId_++;
         auto const r = makeCheckpointer(id, session, jobQueue, registry);
         checkpointers_[id] = r;
diff --git a/src/libxrpl/rdb/SociDB.cpp b/src/libxrpl/rdb/SociDB.cpp
index c6e40ae90b..1d69f1c984 100644
--- a/src/libxrpl/rdb/SociDB.cpp
+++ b/src/libxrpl/rdb/SociDB.cpp
@@ -238,7 +238,7 @@ public:
     schedule() override
     {
         {
-            std::lock_guard const lock(mutex_);
+            std::scoped_lock const lock(mutex_);
             if (running_)
                 return;
             running_ = true;
@@ -258,7 +258,7 @@ public:
                         self->checkpoint();
                 }))
         {
-            std::lock_guard const lock(mutex_);
+            std::scoped_lock const lock(mutex_);
             running_ = false;
         }
     }
@@ -286,7 +286,7 @@ public:
             JLOG(j_.trace()) << "WAL(" << fname << "): frames=" << log << ", written=" << ckpt;
         }
 
-        std::lock_guard const lock(mutex_);
+        std::scoped_lock const lock(mutex_);
         running_ = false;
     }
 
diff --git a/src/libxrpl/resource/Consumer.cpp b/src/libxrpl/resource/Consumer.cpp
index 3d03fa05db..c57344bd8f 100644
--- a/src/libxrpl/resource/Consumer.cpp
+++ b/src/libxrpl/resource/Consumer.cpp
@@ -78,7 +78,7 @@ Consumer::isUnlimited() const
 Disposition
 Consumer::disposition() const
 {
-    Disposition d = ok;
+    Disposition d = Disposition::ok;
     if ((m_logic != nullptr) && (m_entry != nullptr))
         d = m_logic->charge(*m_entry, Charge(0));
 
@@ -88,7 +88,7 @@ Consumer::disposition() const
 Disposition
 Consumer::charge(Charge const& what, std::string const& context)
 {
-    Disposition d = ok;
+    Disposition d = Disposition::ok;
 
     if ((m_logic != nullptr) && (m_entry != nullptr) && !m_entry->isUnlimited())
         d = m_logic->charge(*m_entry, what, context);
diff --git a/src/libxrpl/resource/ResourceManager.cpp b/src/libxrpl/resource/ResourceManager.cpp
index 6652c1a66b..e3f0ae8583 100644
--- a/src/libxrpl/resource/ResourceManager.cpp
+++ b/src/libxrpl/resource/ResourceManager.cpp
@@ -50,7 +50,7 @@ public:
     ~ManagerImp() override
     {
         {
-            std::lock_guard const lock(mutex_);
+            std::scoped_lock const lock(mutex_);
             stop_ = true;
             cond_.notify_one();
         }
diff --git a/src/libxrpl/server/InfoSub.cpp b/src/libxrpl/server/InfoSub.cpp
index 30686dfe7e..c426d44646 100644
--- a/src/libxrpl/server/InfoSub.cpp
+++ b/src/libxrpl/server/InfoSub.cpp
@@ -73,7 +73,7 @@ InfoSub::onSendEmpty()
 void
 InfoSub::insertSubAccountInfo(AccountID const& account, bool rt)
 {
-    std::lock_guard const sl(mLock);
+    std::scoped_lock const sl(mLock);
 
     if (rt)
     {
@@ -88,7 +88,7 @@ InfoSub::insertSubAccountInfo(AccountID const& account, bool rt)
 void
 InfoSub::deleteSubAccountInfo(AccountID const& account, bool rt)
 {
-    std::lock_guard const sl(mLock);
+    std::scoped_lock const sl(mLock);
 
     if (rt)
     {
@@ -103,14 +103,14 @@ InfoSub::deleteSubAccountInfo(AccountID const& account, bool rt)
 bool
 InfoSub::insertSubAccountHistory(AccountID const& account)
 {
-    std::lock_guard const sl(mLock);
+    std::scoped_lock const sl(mLock);
     return accountHistorySubscriptions_.insert(account).second;
 }
 
 void
 InfoSub::deleteSubAccountHistory(AccountID const& account)
 {
-    std::lock_guard const sl(mLock);
+    std::scoped_lock const sl(mLock);
     accountHistorySubscriptions_.erase(account);
 }
 
diff --git a/src/libxrpl/server/LoadFeeTrack.cpp b/src/libxrpl/server/LoadFeeTrack.cpp
index 53fbb8cb84..2fa7e1beba 100644
--- a/src/libxrpl/server/LoadFeeTrack.cpp
+++ b/src/libxrpl/server/LoadFeeTrack.cpp
@@ -16,7 +16,7 @@ namespace xrpl {
 bool
 LoadFeeTrack::raiseLocalFee()
 {
-    std::lock_guard const sl(lock_);
+    std::scoped_lock const sl(lock_);
 
     if (++raiseCount_ < 2)
         return false;
@@ -41,7 +41,7 @@ LoadFeeTrack::raiseLocalFee()
 bool
 LoadFeeTrack::lowerLocalFee()
 {
-    std::lock_guard const sl(lock_);
+    std::scoped_lock const sl(lock_);
     std::uint32_t const origFee = localTxnLoadFee_;
     raiseCount_ = 0;
 
diff --git a/src/libxrpl/shamap/SHAMap.cpp b/src/libxrpl/shamap/SHAMap.cpp
index b638efc383..837724babe 100644
--- a/src/libxrpl/shamap/SHAMap.cpp
+++ b/src/libxrpl/shamap/SHAMap.cpp
@@ -975,7 +975,7 @@ int
 SHAMap::unshare()
 {
     // Don't share nodes with parent map
-    return walkSubTree(false, hotUNKNOWN);
+    return walkSubTree(false, NodeObjectType::hotUNKNOWN);
 }
 
 int
diff --git a/src/libxrpl/shamap/SHAMapDelta.cpp b/src/libxrpl/shamap/SHAMapDelta.cpp
index d8162710be..e80f28d25f 100644
--- a/src/libxrpl/shamap/SHAMapDelta.cpp
+++ b/src/libxrpl/shamap/SHAMapDelta.cpp
@@ -344,7 +344,7 @@ SHAMap::walkMapParallel(std::vector<SHAMapMissingNode>& missingNodes, int maxMis
                             }
                             else
                             {
-                                std::lock_guard const l{m};
+                                std::scoped_lock const l{m};
                                 missingNodes.emplace_back(type_, node->getChildHash(i));
                                 if (--maxMissing <= 0)
                                     return;
@@ -354,7 +354,7 @@ SHAMap::walkMapParallel(std::vector<SHAMapMissingNode>& missingNodes, int maxMis
                 }
                 catch (SHAMapMissingNode const& e)
                 {
-                    std::lock_guard const l(m);
+                    std::scoped_lock const l(m);
                     exceptions.push_back(e);
                 }
             },
@@ -364,7 +364,7 @@ SHAMap::walkMapParallel(std::vector<SHAMapMissingNode>& missingNodes, int maxMis
     for (std::thread& worker : workers)
         worker.join();
 
-    std::lock_guard const l(m);
+    std::scoped_lock const l(m);
     if (exceptions.empty())
         return true;
     std::stringstream ss;
diff --git a/src/libxrpl/shamap/SHAMapInnerNode.cpp b/src/libxrpl/shamap/SHAMapInnerNode.cpp
index d3324e91d0..38300beadb 100644
--- a/src/libxrpl/shamap/SHAMapInnerNode.cpp
+++ b/src/libxrpl/shamap/SHAMapInnerNode.cpp
@@ -99,7 +99,7 @@ SHAMapInnerNode::clone(std::uint32_t cowid) const
     }
 
     spinlock sl(lock_);
-    std::lock_guard const lock(sl);
+    std::scoped_lock const lock(sl);
 
     if (thisIsSparse)
     {
@@ -333,7 +333,7 @@ SHAMapInnerNode::getChildPointer(int branch)
         *getChildIndex(branch);  // NOLINT(bugprone-unchecked-optional-access) assert above
 
     packed_spinlock sl(lock_, index);
-    std::lock_guard const lock(sl);
+    std::scoped_lock const lock(sl);
     return hashesAndChildren_.getChildren()[index].get();
 }
 
@@ -349,7 +349,7 @@ SHAMapInnerNode::getChild(int branch)
         *getChildIndex(branch);  // NOLINT(bugprone-unchecked-optional-access) assert above
 
     packed_spinlock sl(lock_, index);
-    std::lock_guard const lock(sl);
+    std::scoped_lock const lock(sl);
     return hashesAndChildren_.getChildren()[index];
 }
 
@@ -383,7 +383,7 @@ SHAMapInnerNode::canonicalizeChild(int branch, intr_ptr::SharedPtr<SHAMapTreeNod
         "hash do match");
 
     packed_spinlock sl(lock_, childIndex);
-    std::lock_guard const lock(sl);
+    std::scoped_lock const lock(sl);
 
     if (children[childIndex])
     {
diff --git a/src/libxrpl/shamap/SHAMapNodeID.cpp b/src/libxrpl/shamap/SHAMapNodeID.cpp
index c2d93f20ee..6116a997b6 100644
--- a/src/libxrpl/shamap/SHAMapNodeID.cpp
+++ b/src/libxrpl/shamap/SHAMapNodeID.cpp
@@ -16,6 +16,8 @@ namespace xrpl {
 static uint256 const&
 depthMask(unsigned int depth)
 {
+    // Need to be named before converting
+    // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
     enum { mask_size = 65 };
 
     struct masks_t
diff --git a/src/libxrpl/tx/applySteps.cpp b/src/libxrpl/tx/applySteps.cpp
index 40d87d4890..5ae51066e7 100644
--- a/src/libxrpl/tx/applySteps.cpp
+++ b/src/libxrpl/tx/applySteps.cpp
@@ -84,7 +84,7 @@ with_txn_type(Rules const& rules, TxType txnType, F&& f)
     else
     {
         // Without those features enabled, always use the old number rules.
-        mantissaScaleGuard.emplace(MantissaRange::small);
+        mantissaScaleGuard.emplace(MantissaRange::mantissa_scale::small);
     }
 
     switch (txnType)
@@ -130,7 +130,7 @@ template <class T>
 TxConsequences
 consequences_helper(PreflightContext const& ctx)
 {
-    return TxConsequences(ctx.tx, TxConsequences::blocker);
+    return TxConsequences(ctx.tx, TxConsequences::Category::blocker);
 };
 
 // For Transactor::Custom
@@ -282,7 +282,7 @@ TxConsequences::TxConsequences(STTx const& tx)
 
 TxConsequences::TxConsequences(STTx const& tx, Category category) : TxConsequences(tx)
 {
-    isBlocker_ = (category == blocker);
+    isBlocker_ = (category == Category::blocker);
 }
 
 TxConsequences::TxConsequences(STTx const& tx, XRPAmount potentialSpend) : TxConsequences(tx)
diff --git a/src/libxrpl/tx/invariants/AMMInvariant.cpp b/src/libxrpl/tx/invariants/AMMInvariant.cpp
index 30be382c91..af60f3fc55 100644
--- a/src/libxrpl/tx/invariants/AMMInvariant.cpp
+++ b/src/libxrpl/tx/invariants/AMMInvariant.cpp
@@ -146,8 +146,8 @@ ValidAMM::finalizeCreate(
             *ammAccount_,
             tx[sfAmount].asset(),
             tx[sfAmount2].asset(),
-            fhIGNORE_FREEZE,
-            ahIGNORE_AUTH,
+            FreezeHandling::fhIGNORE_FREEZE,
+            AuthHandling::ahIGNORE_AUTH,
             j);
         // Create invariant:
         // sqrt(amount * amount2) == LPTokens
@@ -210,7 +210,13 @@ ValidAMM::generalInvariant(
     // NOLINTBEGIN(bugprone-unchecked-optional-access) ammAccount_ and lptAMMBalanceAfter_ set
     // together in visitEntry; callers only invoke this inside else-of-if(!ammAccount_)
     auto const [amount, amount2] = ammPoolHolds(
-        view, *ammAccount_, tx[sfAsset], tx[sfAsset2], fhIGNORE_FREEZE, ahIGNORE_AUTH, j);
+        view,
+        *ammAccount_,
+        tx[sfAsset],
+        tx[sfAsset2],
+        FreezeHandling::fhIGNORE_FREEZE,
+        AuthHandling::ahIGNORE_AUTH,
+        j);
     // Deposit and Withdrawal invariant:
     // sqrt(amount * amount2) >= LPTokens
     // all balances are greater than zero
diff --git a/src/libxrpl/tx/invariants/InvariantCheck.cpp b/src/libxrpl/tx/invariants/InvariantCheck.cpp
index 99ab38f643..862580c989 100644
--- a/src/libxrpl/tx/invariants/InvariantCheck.cpp
+++ b/src/libxrpl/tx/invariants/InvariantCheck.cpp
@@ -826,10 +826,17 @@ ValidClawback::finalize(
             AccountID const& holder = amount.getIssuer();
             STAmount const holderBalance = amount.asset().visit(
                 [&](Issue const& issue) {
-                    return accountHolds(view, holder, issue.currency, issuer, fhIGNORE_FREEZE, j);
+                    return accountHolds(
+                        view, holder, issue.currency, issuer, FreezeHandling::fhIGNORE_FREEZE, j);
                 },
                 [&](MPTIssue const& issue) {
-                    return accountHolds(view, issuer, issue, fhIGNORE_FREEZE, ahIGNORE_AUTH, j);
+                    return accountHolds(
+                        view,
+                        issuer,
+                        issue,
+                        FreezeHandling::fhIGNORE_FREEZE,
+                        AuthHandling::ahIGNORE_AUTH,
+                        j);
                 });
 
             if (holderBalance.signum() < 0)
diff --git a/src/libxrpl/tx/invariants/MPTInvariant.cpp b/src/libxrpl/tx/invariants/MPTInvariant.cpp
index e010b79b87..97db4aa385 100644
--- a/src/libxrpl/tx/invariants/MPTInvariant.cpp
+++ b/src/libxrpl/tx/invariants/MPTInvariant.cpp
@@ -18,6 +18,7 @@
 #include <xrpl/protocol/XRPAmount.h>
 #include <xrpl/tx/invariants/InvariantCheckPrivilege.h>
 
+#include <cstddef>
 #include <cstdint>
 #include <memory>
 
@@ -303,7 +304,7 @@ ValidMPTPayment::visitEntry(
                 overflow_ = true;
                 return false;
             }
-            data_[makeKey(sle)].outstanding[order] = outstanding;
+            data_[makeKey(sle)].outstanding[static_cast<std::size_t>(order)] = outstanding;
         }
         else if (type == ltMPTOKEN)
         {
@@ -317,7 +318,7 @@ ValidMPTPayment::visitEntry(
             }
             auto const res = static_cast<std::int64_t>(mptAmt + lockedAmt);
             // subtract before from after
-            if (order == Before)
+            if (order == Order::Before)
             {
                 data_[makeKey(sle)].mptAmount -= res;
             }
@@ -329,7 +330,7 @@ ValidMPTPayment::visitEntry(
         return true;
     };
 
-    if (before && !update(*before, Before))
+    if (before && !update(*before, Order::Before))
         return;
 
     if (after)
@@ -338,7 +339,7 @@ ValidMPTPayment::visitEntry(
         {
             overflow_ = (*after)[sfOutstandingAmount] > maxMPTAmount(*after);
         }
-        if (!update(*after, After))
+        if (!update(*after, Order::After))
             return;
     }
 }
@@ -364,15 +365,17 @@ ValidMPTPayment::finalize(
         for (auto const& [id, data] : data_)
         {
             (void)id;
+            constexpr auto iBefore = static_cast<std::size_t>(Order::Before);
+            constexpr auto iAfter = static_cast<std::size_t>(Order::After);
             bool const addOverflows =
-                (data.mptAmount > 0 && data.outstanding[Before] > (signedMax - data.mptAmount)) ||
-                (data.mptAmount < 0 && data.outstanding[Before] < (-signedMax - data.mptAmount));
+                (data.mptAmount > 0 && data.outstanding[iBefore] > (signedMax - data.mptAmount)) ||
+                (data.mptAmount < 0 && data.outstanding[iBefore] < (-signedMax - data.mptAmount));
             if (addOverflows ||
-                data.outstanding[After] != (data.outstanding[Before] + data.mptAmount))
+                data.outstanding[iAfter] != (data.outstanding[iBefore] + data.mptAmount))
             {
                 JLOG(j.fatal()) << "Invariant failed: invalid OutstandingAmount balance "
-                                << data.outstanding[Before] << " " << data.outstanding[After] << " "
-                                << data.mptAmount;
+                                << data.outstanding[iBefore] << " " << data.outstanding[iAfter]
+                                << " " << data.mptAmount;
                 return !enforce;
             }
         }
diff --git a/src/libxrpl/tx/paths/BookStep.cpp b/src/libxrpl/tx/paths/BookStep.cpp
index 239e8831c5..ce3df04e5c 100644
--- a/src/libxrpl/tx/paths/BookStep.cpp
+++ b/src/libxrpl/tx/paths/BookStep.cpp
@@ -1493,7 +1493,7 @@ make_BookStepHelper(StrandContext const& ctx, Asset const& in, Asset const& out)
 {
     TER ter = tefINTERNAL;
     std::unique_ptr<Step> r;
-    if (ctx.offerCrossing)
+    if (ctx.offerCrossing != OfferCrossing::no)
     {
         auto offerCrossingStep = std::make_unique<BookOfferCrossingStep<TIn, TOut>>(ctx, in, out);
         ter = offerCrossingStep->check(ctx);
diff --git a/src/libxrpl/tx/paths/DirectStep.cpp b/src/libxrpl/tx/paths/DirectStep.cpp
index a6f74c9c9f..c2ad818b73 100644
--- a/src/libxrpl/tx/paths/DirectStep.cpp
+++ b/src/libxrpl/tx/paths/DirectStep.cpp
@@ -479,8 +479,8 @@ template <class TDerived>
 std::pair<IOUAmount, DebtDirection>
 DirectStepI<TDerived>::maxPaymentFlow(ReadView const& sb) const
 {
-    auto const srcOwed =
-        toAmount<IOUAmount>(accountHolds(sb, src_, currency_, dst_, fhIGNORE_FREEZE, j_));
+    auto const srcOwed = toAmount<IOUAmount>(
+        accountHolds(sb, src_, currency_, dst_, FreezeHandling::fhIGNORE_FREEZE, j_));
 
     if (srcOwed.signum() > 0)
         return {srcOwed, DebtDirection::redeems};
@@ -496,7 +496,8 @@ DirectStepI<TDerived>::debtDirection(ReadView const& sb, StrandDirection dir) co
     if (dir == StrandDirection::forward && cache_)
         return cache_->srcDebtDir;
 
-    auto const srcOwed = accountHolds(sb, src_, currency_, dst_, fhIGNORE_FREEZE, j_);
+    auto const srcOwed =
+        accountHolds(sb, src_, currency_, dst_, FreezeHandling::fhIGNORE_FREEZE, j_);
     return srcOwed.signum() > 0 ? DebtDirection::redeems : DebtDirection::issues;
 }
 
@@ -930,7 +931,7 @@ make_DirectStepI(
 {
     TER ter = tefINTERNAL;
     std::unique_ptr<Step> r;
-    if (ctx.offerCrossing != 0u)
+    if (ctx.offerCrossing != OfferCrossing::no)
     {
         auto offerCrossingStep = std::make_unique<DirectIOfferCrossingStep>(ctx, src, dst, c);
         ter = offerCrossingStep->check(ctx);
diff --git a/src/libxrpl/tx/paths/MPTEndpointStep.cpp b/src/libxrpl/tx/paths/MPTEndpointStep.cpp
index 171f5b873f..da672d3c4c 100644
--- a/src/libxrpl/tx/paths/MPTEndpointStep.cpp
+++ b/src/libxrpl/tx/paths/MPTEndpointStep.cpp
@@ -382,8 +382,13 @@ MPTEndpointPaymentStep::check(StrandContext const& ctx, std::shared_ptr<const SL
 
     if (prevStep_ == nullptr)
     {
-        auto const owed =
-            accountFunds(ctx.view, src_, mptIssue_, fhIGNORE_FREEZE, ahIGNORE_AUTH, j_);
+        auto const owed = accountFunds(
+            ctx.view,
+            src_,
+            mptIssue_,
+            FreezeHandling::fhIGNORE_FREEZE,
+            AuthHandling::ahIGNORE_AUTH,
+            j_);
         // Already at MaximumAmount
         if (owed <= beast::zero)
             return tecPATH_DRY;
@@ -425,7 +430,8 @@ template <class TDerived>
 std::pair<MPTAmount, DebtDirection>
 MPTEndpointStep<TDerived>::maxPaymentFlow(ReadView const& sb) const
 {
-    auto const maxFlow = accountFunds(sb, src_, mptIssue_, fhIGNORE_FREEZE, ahIGNORE_AUTH, j_);
+    auto const maxFlow = accountFunds(
+        sb, src_, mptIssue_, FreezeHandling::fhIGNORE_FREEZE, AuthHandling::ahIGNORE_AUTH, j_);
 
     // From a holder to an issuer
     if (src_ != mptIssue_.getIssuer())
diff --git a/src/libxrpl/tx/paths/OfferStream.cpp b/src/libxrpl/tx/paths/OfferStream.cpp
index c2f2fed25b..67f9a294b7 100644
--- a/src/libxrpl/tx/paths/OfferStream.cpp
+++ b/src/libxrpl/tx/paths/OfferStream.cpp
@@ -266,8 +266,8 @@ TOfferStreamBase<TIn, TOut>::step()
             offer_.owner(),
             amount.out,
             offer_.assetOut(),
-            fhZERO_IF_FROZEN,
-            ahZERO_IF_UNAUTHORIZED,
+            FreezeHandling::fhZERO_IF_FROZEN,
+            AuthHandling::ahZERO_IF_UNAUTHORIZED,
             j_);
 
         // Check for unfunded offer
@@ -281,8 +281,8 @@ TOfferStreamBase<TIn, TOut>::step()
                 offer_.owner(),
                 amount.out,
                 offer_.assetOut(),
-                fhZERO_IF_FROZEN,
-                ahZERO_IF_UNAUTHORIZED,
+                FreezeHandling::fhZERO_IF_FROZEN,
+                AuthHandling::ahZERO_IF_UNAUTHORIZED,
                 j_);
 
             if (original_funds == *ownerFunds_)
@@ -306,8 +306,8 @@ TOfferStreamBase<TIn, TOut>::step()
                 offer_.owner(),
                 amount.out,
                 offer_.assetOut(),
-                fhZERO_IF_FROZEN,
-                ahZERO_IF_UNAUTHORIZED,
+                FreezeHandling::fhZERO_IF_FROZEN,
+                AuthHandling::ahZERO_IF_UNAUTHORIZED,
                 j_);
 
             if (original_funds == *ownerFunds_)
diff --git a/src/libxrpl/tx/paths/XRPEndpointStep.cpp b/src/libxrpl/tx/paths/XRPEndpointStep.cpp
index 95228ed158..2310f72f34 100644
--- a/src/libxrpl/tx/paths/XRPEndpointStep.cpp
+++ b/src/libxrpl/tx/paths/XRPEndpointStep.cpp
@@ -396,7 +396,7 @@ make_XRPEndpointStep(StrandContext const& ctx, AccountID const& acc)
 {
     TER ter = tefINTERNAL;
     std::unique_ptr<Step> r;
-    if (ctx.offerCrossing != 0u)
+    if (ctx.offerCrossing != OfferCrossing::no)
     {
         auto offerCrossingStep = std::make_unique<XRPEndpointOfferCrossingStep>(ctx, acc);
         ter = offerCrossingStep->check(ctx);
diff --git a/src/libxrpl/tx/transactors/account/AccountDelete.cpp b/src/libxrpl/tx/transactors/account/AccountDelete.cpp
index 77164afa0c..13cb05a02d 100644
--- a/src/libxrpl/tx/transactors/account/AccountDelete.cpp
+++ b/src/libxrpl/tx/transactors/account/AccountDelete.cpp
@@ -178,12 +178,12 @@ TER
 removeDelegateFromLedger(
     ServiceRegistry&,
     ApplyView& view,
-    AccountID const& account,
-    uint256 const& delIndex,
+    AccountID const&,
+    uint256 const&,
     std::shared_ptr<SLE> const& sleDel,
     beast::Journal j)
 {
-    return DelegateSet::deleteDelegate(view, sleDel, account, j);
+    return DelegateSet::deleteDelegate(view, sleDel, j);
 }
 
 // Return nullptr if the LedgerEntryType represents an obligation that can't
diff --git a/src/libxrpl/tx/transactors/account/AccountSet.cpp b/src/libxrpl/tx/transactors/account/AccountSet.cpp
index a892bd045c..e8555ecc04 100644
--- a/src/libxrpl/tx/transactors/account/AccountSet.cpp
+++ b/src/libxrpl/tx/transactors/account/AccountSet.cpp
@@ -39,19 +39,19 @@ AccountSet::makeTxConsequences(PreflightContext const& ctx)
     auto getTxConsequencesCategory = [](STTx const& tx) {
         if (std::uint32_t const uTxFlags = tx.getFlags();
             uTxFlags & (tfRequireAuth | tfOptionalAuth))
-            return TxConsequences::blocker;
+            return TxConsequences::Category::blocker;
 
         if (auto const uSetFlag = tx[~sfSetFlag]; uSetFlag &&
             (*uSetFlag == asfRequireAuth || *uSetFlag == asfDisableMaster ||
              *uSetFlag == asfAccountTxnID))
-            return TxConsequences::blocker;
+            return TxConsequences::Category::blocker;
 
         if (auto const uClearFlag = tx[~sfClearFlag]; uClearFlag &&
             (*uClearFlag == asfRequireAuth || *uClearFlag == asfDisableMaster ||
              *uClearFlag == asfAccountTxnID))
-            return TxConsequences::blocker;
+            return TxConsequences::Category::blocker;
 
-        return TxConsequences::normal;
+        return TxConsequences::Category::normal;
     };
 
     return TxConsequences{ctx.tx, getTxConsequencesCategory(ctx.tx)};
diff --git a/src/libxrpl/tx/transactors/account/SignerListSet.cpp b/src/libxrpl/tx/transactors/account/SignerListSet.cpp
index f74ed8aff3..9cf316d023 100644
--- a/src/libxrpl/tx/transactors/account/SignerListSet.cpp
+++ b/src/libxrpl/tx/transactors/account/SignerListSet.cpp
@@ -48,7 +48,7 @@ SignerListSet::determineOperation(STTx const& tx, ApplyFlags flags, beast::Journ
     // the list.  A zero quorum means we're destroying the list.
     auto const quorum = tx[sfSignerQuorum];
     std::vector<SignerEntries::SignerEntry> sign;
-    Operation op = unknown;
+    Operation op = Operation::unknown;
 
     bool const hasSignerEntries(tx.isFieldPresent(sfSignerEntries));
     if ((quorum != 0u) && hasSignerEntries)
@@ -62,11 +62,11 @@ SignerListSet::determineOperation(STTx const& tx, ApplyFlags flags, beast::Journ
 
         // Save deserialized list for later.
         sign = std::move(*signers);
-        op = set;
+        op = Operation::set;
     }
     else if ((quorum == 0) && !hasSignerEntries)
     {
-        op = destroy;
+        op = Operation::destroy;
     }
 
     return std::make_tuple(tesSUCCESS, quorum, sign, op);
@@ -87,14 +87,14 @@ SignerListSet::preflight(PreflightContext const& ctx)
     if (!isTesSuccess(std::get<0>(result)))
         return std::get<0>(result);
 
-    if (std::get<3>(result) == unknown)
+    if (std::get<3>(result) == Operation::unknown)
     {
         // Neither a set nor a destroy.  Malformed.
         JLOG(ctx.j.trace()) << "Malformed transaction: Invalid signer set list format.";
         return temMALFORMED;
     }
 
-    if (std::get<3>(result) == set)
+    if (std::get<3>(result) == Operation::set)
     {
         // Validate our settings.
         auto const account = ctx.tx.getAccountID(sfAccount);
@@ -115,10 +115,10 @@ SignerListSet::doApply()
     // Perform the operation preCompute() decided on.
     switch (do_)
     {
-        case set:
+        case Operation::set:
             return replaceSignerList();
 
-        case destroy:
+        case Operation::destroy:
             return destroySignerList();
 
         default:
@@ -139,7 +139,7 @@ SignerListSet::preCompute()
         isTesSuccess(std::get<0>(result)),
         "xrpl::SignerListSet::preCompute : result is tesSUCCESS");
     XRPL_ASSERT(
-        std::get<3>(result) != unknown,
+        std::get<3>(result) != Operation::unknown,
         "xrpl::SignerListSet::preCompute : result is known operation");
 
     quorum_ = std::get<1>(result);
diff --git a/src/libxrpl/tx/transactors/check/CheckCash.cpp b/src/libxrpl/tx/transactors/check/CheckCash.cpp
index 7865a64f2d..050525d39b 100644
--- a/src/libxrpl/tx/transactors/check/CheckCash.cpp
+++ b/src/libxrpl/tx/transactors/check/CheckCash.cpp
@@ -164,8 +164,8 @@ CheckCash::preclaim(PreclaimContext const& ctx)
                 ctx.view,
                 sleCheck->at(sfAccount),
                 value,
-                fhZERO_IF_FROZEN,
-                ahZERO_IF_UNAUTHORIZED,
+                FreezeHandling::fhZERO_IF_FROZEN,
+                AuthHandling::ahZERO_IF_UNAUTHORIZED,
                 ctx.j)};
 
             // Note that src will have one reserve's worth of additional XRP
diff --git a/src/libxrpl/tx/transactors/delegate/DelegateSet.cpp b/src/libxrpl/tx/transactors/delegate/DelegateSet.cpp
index d5fe2cdc8b..1eb7e56085 100644
--- a/src/libxrpl/tx/transactors/delegate/DelegateSet.cpp
+++ b/src/libxrpl/tx/transactors/delegate/DelegateSet.cpp
@@ -7,7 +7,6 @@
 #include <xrpl/ledger/helpers/AccountRootHelpers.h>
 #include <xrpl/ledger/helpers/DirectoryHelpers.h>
 #include <xrpl/ledger/helpers/SponsorHelpers.h>
-#include <xrpl/protocol/AccountID.h>
 #include <xrpl/protocol/Indexes.h>
 #include <xrpl/protocol/Protocol.h>
 #include <xrpl/protocol/SField.h>
@@ -85,7 +84,7 @@ DelegateSet::doApply()
         if (permissions.empty())
         {
             // if permissions array is empty, delete the ledger object.
-            return deleteDelegate(view(), sle, account_, j_);
+            return deleteDelegate(view(), sle, j_);
         }
 
         sle->setFieldArray(sfPermissions, permissions);
@@ -108,6 +107,8 @@ DelegateSet::doApply()
     sle->setAccountID(sfAuthorize, authAccount);
 
     sle->setFieldArray(sfPermissions, permissions);
+
+    // Add to delegating account's owner directory
     auto const page =
         ctx_.view().dirInsert(keylet::ownerDir(account_), delegateKey, describeOwnerDir(account_));
 
@@ -115,6 +116,17 @@ DelegateSet::doApply()
         return tecDIR_FULL;  // LCOV_EXCL_LINE
 
     (*sle)[sfOwnerNode] = *page;
+
+    // Add to authorized account's owner directory so the object can be found
+    // and cleaned up when the authorized account is deleted.
+    auto const destPage = ctx_.view().dirInsert(
+        keylet::ownerDir(authAccount), delegateKey, describeOwnerDir(authAccount));
+
+    if (!destPage)
+        return tecDIR_FULL;  // LCOV_EXCL_LINE
+
+    (*sle)[sfDestinationNode] = *destPage;
+
     ctx_.view().insert(sle);
     adjustOwnerCount(ctx_.view(), sleOwner, sponsor, 1, ctx_.journal);
     addSponsorToLedgerEntry(sle, sponsor);
@@ -123,16 +135,16 @@ DelegateSet::doApply()
 }
 
 TER
-DelegateSet::deleteDelegate(
-    ApplyView& view,
-    std::shared_ptr<SLE> const& sle,
-    AccountID const& account,
-    beast::Journal j)
+DelegateSet::deleteDelegate(ApplyView& view, std::shared_ptr<SLE> const& sle, beast::Journal j)
 {
     if (!sle)
         return tecINTERNAL;  // LCOV_EXCL_LINE
 
-    if (!view.dirRemove(keylet::ownerDir(account), (*sle)[sfOwnerNode], sle->key(), false))
+    auto const delegator = (*sle)[sfAccount];
+    auto const delegatee = (*sle)[sfAuthorize];
+
+    // Remove from delegating account's owner directory
+    if (!view.dirRemove(keylet::ownerDir(delegator), (*sle)[sfOwnerNode], sle->key(), false))
     {
         // LCOV_EXCL_START
         JLOG(j.fatal()) << "Unable to delete Delegate from owner.";
@@ -140,7 +152,20 @@ DelegateSet::deleteDelegate(
         // LCOV_EXCL_STOP
     }
 
-    auto const sleOwner = view.peek(keylet::account(account));
+    // Remove from authorized account's owner directory, if present
+    if (auto const optPage = (*sle)[~sfDestinationNode])
+    {
+        if (!view.dirRemove(keylet::ownerDir(delegatee), *optPage, sle->key(), false))
+        {
+            // LCOV_EXCL_START
+            JLOG(j.fatal()) << "Unable to delete Delegate from authorized account.";
+            return tefBAD_LEDGER;
+            // LCOV_EXCL_STOP
+        }
+    }
+
+    // Only the delegating account's owner count was incremented on creation
+    auto const sleOwner = view.peek(keylet::account(delegator));
     if (!sleOwner)
         return tecINTERNAL;  // LCOV_EXCL_LINE
 
diff --git a/src/libxrpl/tx/transactors/dex/OfferCreate.cpp b/src/libxrpl/tx/transactors/dex/OfferCreate.cpp
index 6fbfc0c15f..ab75cac38f 100644
--- a/src/libxrpl/tx/transactors/dex/OfferCreate.cpp
+++ b/src/libxrpl/tx/transactors/dex/OfferCreate.cpp
@@ -193,8 +193,13 @@ OfferCreate::preclaim(PreclaimContext const& ctx)
 
     // Allow unfunded MPT for issuer (OutstandingAmount >= MaximumAmount)
     if ((!saTakerGets.holds<MPTIssue>() || saTakerGets.getIssuer() != id) &&
-        accountFunds(ctx.view, id, saTakerGets, fhZERO_IF_FROZEN, ahZERO_IF_UNAUTHORIZED, viewJ) <=
-            beast::zero)
+        accountFunds(
+            ctx.view,
+            id,
+            saTakerGets,
+            FreezeHandling::fhZERO_IF_FROZEN,
+            AuthHandling::ahZERO_IF_UNAUTHORIZED,
+            viewJ) <= beast::zero)
     {
         JLOG(ctx.j.debug()) << "delay: Offers must be at least partially funded.";
         return tecUNFUNDED_OFFER;
@@ -339,7 +344,12 @@ OfferCreate::flowCross(
         // cause a user's available balance to go to 0 (by causing it to dip
         // below the reserve) so we check this case again.
         STAmount const inStartBalance = accountFunds(
-            psb, account_, takerAmount.in, fhZERO_IF_FROZEN, ahZERO_IF_UNAUTHORIZED, j_);
+            psb,
+            account_,
+            takerAmount.in,
+            FreezeHandling::fhZERO_IF_FROZEN,
+            AuthHandling::ahZERO_IF_UNAUTHORIZED,
+            j_);
         // Allow unfunded MPT issuer
         auto const disallowUnfunded =
             !inStartBalance.holds<MPTIssue>() || inStartBalance.getIssuer() != account_;
@@ -449,7 +459,12 @@ OfferCreate::flowCross(
         if (isTesSuccess(result.result()))
         {
             STAmount const takerInBalance = accountFunds(
-                psb, account_, takerAmount.in, fhZERO_IF_FROZEN, ahZERO_IF_UNAUTHORIZED, j_);
+                psb,
+                account_,
+                takerAmount.in,
+                FreezeHandling::fhZERO_IF_FROZEN,
+                AuthHandling::ahZERO_IF_UNAUTHORIZED,
+                j_);
 
             if (disallowUnfunded && takerInBalance <= beast::zero)
             {
diff --git a/src/libxrpl/tx/transactors/escrow/EscrowCreate.cpp b/src/libxrpl/tx/transactors/escrow/EscrowCreate.cpp
index 73da485e49..d2b50e3768 100644
--- a/src/libxrpl/tx/transactors/escrow/EscrowCreate.cpp
+++ b/src/libxrpl/tx/transactors/escrow/EscrowCreate.cpp
@@ -229,8 +229,8 @@ escrowCreatePreclaimHelper<Issue>(
     if (isFrozen(ctx.view, dest, issue))
         return tecFROZEN;
 
-    STAmount const spendableAmount =
-        accountHolds(ctx.view, account, issue.currency, issuer, fhIGNORE_FREEZE, ctx.j);
+    STAmount const spendableAmount = accountHolds(
+        ctx.view, account, issue.currency, issuer, FreezeHandling::fhIGNORE_FREEZE, ctx.j);
 
     // If the balance is less than or equal to 0, return tecINSUFFICIENT_FUNDS
     if (spendableAmount <= beast::zero)
@@ -306,7 +306,12 @@ escrowCreatePreclaimHelper<MPTIssue>(
         return ter;
 
     STAmount const spendableAmount = accountHolds(
-        ctx.view, account, amount.get<MPTIssue>(), fhIGNORE_FREEZE, ahIGNORE_AUTH, ctx.j);
+        ctx.view,
+        account,
+        amount.get<MPTIssue>(),
+        FreezeHandling::fhIGNORE_FREEZE,
+        AuthHandling::ahIGNORE_AUTH,
+        ctx.j);
 
     // If the balance is less than or equal to 0, return tecINSUFFICIENT_FUNDS
     if (spendableAmount <= beast::zero)
diff --git a/src/libxrpl/tx/transactors/lending/LoanBrokerCoverClawback.cpp b/src/libxrpl/tx/transactors/lending/LoanBrokerCoverClawback.cpp
index fb071f4c90..d229f132bc 100644
--- a/src/libxrpl/tx/transactors/lending/LoanBrokerCoverClawback.cpp
+++ b/src/libxrpl/tx/transactors/lending/LoanBrokerCoverClawback.cpp
@@ -164,11 +164,11 @@ determineClawAmount(
 {
     auto const maxClawAmount = [&]() {
         // Always round the minimum required up
-        NumberRoundModeGuard const mg1(Number::upward);
+        NumberRoundModeGuard const mg1(Number::rounding_mode::upward);
         auto const minRequiredCover =
             tenthBipsOfValue(sleBroker[sfDebtTotal], TenthBips32(sleBroker[sfCoverRateMinimum]));
         // The subtraction probably won't round, but round down if it does.
-        NumberRoundModeGuard const mg2(Number::downward);
+        NumberRoundModeGuard const mg2(Number::rounding_mode::downward);
         return sleBroker[sfCoverAvailable] - minRequiredCover;
     }();
     if (maxClawAmount <= beast::zero)
@@ -295,8 +295,12 @@ LoanBrokerCoverClawback::preclaim(PreclaimContext const& ctx)
     // balance is actually there. It should always match `sfCoverAvailable`, so
     // if there isn't, this is an internal error.
     if (accountHolds(
-            ctx.view, brokerPseudoAccountID, vaultAsset, fhIGNORE_FREEZE, ahIGNORE_AUTH, ctx.j) <
-        clawAmount)
+            ctx.view,
+            brokerPseudoAccountID,
+            vaultAsset,
+            FreezeHandling::fhIGNORE_FREEZE,
+            AuthHandling::ahIGNORE_AUTH,
+            ctx.j) < clawAmount)
         return tecINTERNAL;  // tecINSUFFICIENT_FUNDS; LCOV_EXCL_LINE
 
     // Check if the vault asset issuer has the correct flags
diff --git a/src/libxrpl/tx/transactors/lending/LoanBrokerCoverWithdraw.cpp b/src/libxrpl/tx/transactors/lending/LoanBrokerCoverWithdraw.cpp
index 7061ec99c3..06f2e518ab 100644
--- a/src/libxrpl/tx/transactors/lending/LoanBrokerCoverWithdraw.cpp
+++ b/src/libxrpl/tx/transactors/lending/LoanBrokerCoverWithdraw.cpp
@@ -133,7 +133,7 @@ LoanBrokerCoverWithdraw::preclaim(PreclaimContext const& ctx)
     auto const minimumCover = [&]() {
         // Always round the minimum required up.
         // Applies to `tenthBipsOfValue` as well as `roundToAsset`.
-        NumberRoundModeGuard const mg(Number::upward);
+        NumberRoundModeGuard const mg(Number::rounding_mode::upward);
         return roundToAsset(
             vaultAsset,
             tenthBipsOfValue(currentDebtTotal, TenthBips32(sleBroker->at(sfCoverRateMinimum))),
diff --git a/src/libxrpl/tx/transactors/lending/LoanBrokerDelete.cpp b/src/libxrpl/tx/transactors/lending/LoanBrokerDelete.cpp
index 68ef2f4652..ef7e99c355 100644
--- a/src/libxrpl/tx/transactors/lending/LoanBrokerDelete.cpp
+++ b/src/libxrpl/tx/transactors/lending/LoanBrokerDelete.cpp
@@ -82,7 +82,8 @@ LoanBrokerDelete::preclaim(PreclaimContext const& ctx)
         // Delete. This check is purely defensive.
         auto const scale = getAssetsTotalScale(vault);
 
-        auto const rounded = roundToAsset(asset, debtTotal, scale, Number::towards_zero);
+        auto const rounded =
+            roundToAsset(asset, debtTotal, scale, Number::rounding_mode::towards_zero);
 
         if (rounded != beast::zero)
         {
diff --git a/src/libxrpl/tx/transactors/lending/LoanDelete.cpp b/src/libxrpl/tx/transactors/lending/LoanDelete.cpp
index 363f5cb12a..0a90b0f5fc 100644
--- a/src/libxrpl/tx/transactors/lending/LoanDelete.cpp
+++ b/src/libxrpl/tx/transactors/lending/LoanDelete.cpp
@@ -123,7 +123,7 @@ LoanDelete::doApply()
                     vaultSle->at(sfAsset),
                     debtTotalProxy,
                     getAssetsTotalScale(vaultSle),
-                    Number::towards_zero) == beast::zero,
+                    Number::rounding_mode::towards_zero) == beast::zero,
                 "xrpl::LoanDelete::doApply",
                 "last loan, remaining debt rounds to zero");
             debtTotalProxy = 0;
diff --git a/src/libxrpl/tx/transactors/lending/LoanManage.cpp b/src/libxrpl/tx/transactors/lending/LoanManage.cpp
index dc1a4a979b..1baca9a052 100644
--- a/src/libxrpl/tx/transactors/lending/LoanManage.cpp
+++ b/src/libxrpl/tx/transactors/lending/LoanManage.cpp
@@ -167,7 +167,7 @@ LoanManage::defaultLoan(
     TenthBips32 const coverRateLiquidation{brokerSle->at(sfCoverRateLiquidation)};
     auto const defaultCovered = [&]() {
         // Always round the minimum required up.
-        NumberRoundModeGuard const mg(Number::upward);
+        NumberRoundModeGuard const mg(Number::rounding_mode::upward);
         auto const minimumCover = tenthBipsOfValue(brokerDebtTotalProxy.value(), coverRateMinimum);
         // Round the liquidation amount up, too
         auto const covered = roundToAsset(
@@ -206,8 +206,8 @@ LoanManage::defaultLoan(
             // LCOV_EXCL_STOP
         }
 
-        auto const vaultDefaultRounded =
-            roundToAsset(vaultAsset, vaultDefaultAmount, vaultScale, Number::downward);
+        auto const vaultDefaultRounded = roundToAsset(
+            vaultAsset, vaultDefaultAmount, vaultScale, Number::rounding_mode::downward);
         vaultTotalProxy -= vaultDefaultRounded;
         // Increase the Asset Available of the Vault by liquidated First-Loss
         // Capital and any unclaimed funds amount:
diff --git a/src/libxrpl/tx/transactors/lending/LoanPay.cpp b/src/libxrpl/tx/transactors/lending/LoanPay.cpp
index 2e826991f5..25eabe40ad 100644
--- a/src/libxrpl/tx/transactors/lending/LoanPay.cpp
+++ b/src/libxrpl/tx/transactors/lending/LoanPay.cpp
@@ -138,12 +138,14 @@ LoanPay::calculateBaseFee(ReadView const& view, STTx const& tx)
 
     // If making an overpayment, count it as a full payment because it will do
     // about the same amount of work, if not more.
-    NumberRoundModeGuard const mg(tx.isFlag(tfLoanOverpayment) ? Number::upward : Number::downward);
+    NumberRoundModeGuard const mg(
+        tx.isFlag(tfLoanOverpayment) ? Number::rounding_mode::upward
+                                     : Number::rounding_mode::downward);
     // Estimate how many payments will be made
     Number const numPaymentEstimate = static_cast<std::int64_t>(amount / regularPayment);
 
     // Charge one base fee per paymentsPerFeeIncrement payments, rounding up.
-    Number::setround(Number::upward);
+    Number::setround(Number::rounding_mode::upward);
     auto const feeIncrements = std::max(
         std::int64_t(1),
         static_cast<std::int64_t>(numPaymentEstimate / loanPaymentsPerFeeIncrement));
@@ -240,8 +242,8 @@ LoanPay::preclaim(PreclaimContext const& ctx)
             ctx.view,
             account,
             asset,
-            fhZERO_IF_FROZEN,
-            ahZERO_IF_UNAUTHORIZED,
+            FreezeHandling::fhZERO_IF_FROZEN,
+            AuthHandling::ahZERO_IF_UNAUTHORIZED,
             ctx.j,
             SpendableHandling::shFULL_BALANCE);
         balance < amount)
@@ -298,7 +300,7 @@ LoanPay::doApply()
         // Round the minimum required cover up to be conservative. This ensures
         // CoverAvailable never drops below the theoretical minimum, protecting
         // the broker's solvency.
-        NumberRoundModeGuard const mg(Number::upward);
+        NumberRoundModeGuard const mg(Number::rounding_mode::upward);
         return coverAvailableProxy >=
             roundToAsset(
                    asset, tenthBipsOfValue(debtTotalProxy.value(), coverRateMinimum), loanScale) &&
@@ -404,7 +406,7 @@ LoanPay::doApply()
 
     auto const totalPaidToVaultRaw = paymentParts->principalPaid + paymentParts->interestPaid;
     auto const totalPaidToVaultRounded =
-        roundToAsset(asset, totalPaidToVaultRaw, vaultScale, Number::downward);
+        roundToAsset(asset, totalPaidToVaultRaw, vaultScale, Number::rounding_mode::downward);
     XRPL_ASSERT_PARTS(
         !asset.integral() || totalPaidToVaultRaw == totalPaidToVaultRounded,
         "xrpl::LoanPay::doApply",
@@ -511,8 +513,8 @@ LoanPay::doApply()
         view,
         account_,
         asset,
-        fhIGNORE_FREEZE,
-        ahIGNORE_AUTH,
+        FreezeHandling::fhIGNORE_FREEZE,
+        AuthHandling::ahIGNORE_AUTH,
         j_,
         SpendableHandling::shFULL_BALANCE);
     auto const vaultBalanceBefore = account_ == vaultPseudoAccount
@@ -521,8 +523,8 @@ LoanPay::doApply()
               view,
               vaultPseudoAccount,
               asset,
-              fhIGNORE_FREEZE,
-              ahIGNORE_AUTH,
+              FreezeHandling::fhIGNORE_FREEZE,
+              AuthHandling::ahIGNORE_AUTH,
               j_,
               SpendableHandling::shFULL_BALANCE);
     auto const brokerBalanceBefore = account_ == brokerPayee
@@ -531,8 +533,8 @@ LoanPay::doApply()
               view,
               brokerPayee,
               asset,
-              fhIGNORE_FREEZE,
-              ahIGNORE_AUTH,
+              FreezeHandling::fhIGNORE_FREEZE,
+              AuthHandling::ahIGNORE_AUTH,
               j_,
               SpendableHandling::shFULL_BALANCE);
 #endif
@@ -589,8 +591,8 @@ LoanPay::doApply()
         view,
         account_,
         asset,
-        fhIGNORE_FREEZE,
-        ahIGNORE_AUTH,
+        FreezeHandling::fhIGNORE_FREEZE,
+        AuthHandling::ahIGNORE_AUTH,
         j_,
         SpendableHandling::shFULL_BALANCE);
     auto const vaultBalanceAfter = account_ == vaultPseudoAccount
@@ -599,8 +601,8 @@ LoanPay::doApply()
               view,
               vaultPseudoAccount,
               asset,
-              fhIGNORE_FREEZE,
-              ahIGNORE_AUTH,
+              FreezeHandling::fhIGNORE_FREEZE,
+              AuthHandling::ahIGNORE_AUTH,
               j_,
               SpendableHandling::shFULL_BALANCE);
     auto const brokerBalanceAfter = account_ == brokerPayee
@@ -609,8 +611,8 @@ LoanPay::doApply()
               view,
               brokerPayee,
               asset,
-              fhIGNORE_FREEZE,
-              ahIGNORE_AUTH,
+              FreezeHandling::fhIGNORE_FREEZE,
+              AuthHandling::ahIGNORE_AUTH,
               j_,
               SpendableHandling::shFULL_BALANCE);
 
diff --git a/src/libxrpl/tx/transactors/lending/LoanSet.cpp b/src/libxrpl/tx/transactors/lending/LoanSet.cpp
index 3618abe714..b997ce47f6 100644
--- a/src/libxrpl/tx/transactors/lending/LoanSet.cpp
+++ b/src/libxrpl/tx/transactors/lending/LoanSet.cpp
@@ -496,7 +496,7 @@ LoanSet::doApply()
         // Round the minimum required cover up to be conservative. This ensures
         // CoverAvailable never drops below the theoretical minimum, protecting
         // the broker's solvency.
-        NumberRoundModeGuard const mg(Number::upward);
+        NumberRoundModeGuard const mg(Number::rounding_mode::upward);
         if (brokerSle->at(sfCoverAvailable) < tenthBipsOfValue(newDebtTotal, coverRateMinimum))
         {
             JLOG(j_.warn()) << "Insufficient first-loss capital to cover the loan.";
diff --git a/src/libxrpl/tx/transactors/nft/NFTokenAcceptOffer.cpp b/src/libxrpl/tx/transactors/nft/NFTokenAcceptOffer.cpp
index c8e6b7972b..2bbae0f84e 100644
--- a/src/libxrpl/tx/transactors/nft/NFTokenAcceptOffer.cpp
+++ b/src/libxrpl/tx/transactors/nft/NFTokenAcceptOffer.cpp
@@ -191,7 +191,8 @@ NFTokenAcceptOffer::preclaim(PreclaimContext const& ctx)
         // own currency
         auto const needed = bo->at(sfAmount);
 
-        if (accountFunds(ctx.view, (*bo)[sfOwner], needed, fhZERO_IF_FROZEN, ctx.j) < needed)
+        if (accountFunds(
+                ctx.view, (*bo)[sfOwner], needed, FreezeHandling::fhZERO_IF_FROZEN, ctx.j) < needed)
             return tecINSUFFICIENT_FUNDS;
 
         // Check that the account accepting the buy offer (he's selling the NFT)
@@ -259,7 +260,9 @@ NFTokenAcceptOffer::preclaim(PreclaimContext const& ctx)
             // mode, because then we are confirming that the broker can
             // cover what the buyer will pay, which doesn't make sense, causes
             // an unnecessary tec, and is also resolved with this amendment.
-            if (accountFunds(ctx.view, ctx.tx[sfAccount], needed, fhZERO_IF_FROZEN, ctx.j) < needed)
+            if (accountFunds(
+                    ctx.view, ctx.tx[sfAccount], needed, FreezeHandling::fhZERO_IF_FROZEN, ctx.j) <
+                needed)
                 return tecINSUFFICIENT_FUNDS;
         }
 
@@ -347,9 +350,9 @@ NFTokenAcceptOffer::pay(AccountID const& from, AccountID const& to, STAmount con
     // just confirm that the end state is OK.
     if (!isTesSuccess(result))
         return result;
-    if (accountFunds(view(), from, amount, fhZERO_IF_FROZEN, j_).signum() < 0)
+    if (accountFunds(view(), from, amount, FreezeHandling::fhZERO_IF_FROZEN, j_).signum() < 0)
         return tecINSUFFICIENT_FUNDS;
-    if (accountFunds(view(), to, amount, fhZERO_IF_FROZEN, j_).signum() < 0)
+    if (accountFunds(view(), to, amount, FreezeHandling::fhZERO_IF_FROZEN, j_).signum() < 0)
         return tecINSUFFICIENT_FUNDS;
     return tesSUCCESS;
 }
diff --git a/src/libxrpl/tx/transactors/system/LedgerStateFix.cpp b/src/libxrpl/tx/transactors/system/LedgerStateFix.cpp
index 27cbad2e88..07ec677288 100644
--- a/src/libxrpl/tx/transactors/system/LedgerStateFix.cpp
+++ b/src/libxrpl/tx/transactors/system/LedgerStateFix.cpp
@@ -19,7 +19,7 @@ namespace xrpl {
 NotTEC
 LedgerStateFix::preflight(PreflightContext const& ctx)
 {
-    switch (ctx.tx[sfLedgerFixType])
+    switch (static_cast<FixType>(ctx.tx[sfLedgerFixType]))
     {
         case FixType::nfTokenPageLink:
             if (!ctx.tx.isFieldPresent(sfOwner))
@@ -44,7 +44,7 @@ LedgerStateFix::calculateBaseFee(ReadView const& view, STTx const& tx)
 TER
 LedgerStateFix::preclaim(PreclaimContext const& ctx)
 {
-    if (ctx.tx[sfLedgerFixType] == FixType::nfTokenPageLink)
+    if (static_cast<FixType>(ctx.tx[sfLedgerFixType]) == FixType::nfTokenPageLink)
     {
         AccountID const owner{ctx.tx[sfOwner]};
         if (!ctx.view.read(keylet::account(owner)))
@@ -60,7 +60,7 @@ LedgerStateFix::preclaim(PreclaimContext const& ctx)
 TER
 LedgerStateFix::doApply()
 {
-    if (ctx_.tx[sfLedgerFixType] == FixType::nfTokenPageLink)
+    if (static_cast<FixType>(ctx_.tx[sfLedgerFixType]) == FixType::nfTokenPageLink)
     {
         if (!nft::repairNFTokenDirectoryLinks(view(), ctx_.tx[sfOwner]))
             return tecFAILED_PROCESSING;
diff --git a/src/libxrpl/tx/transactors/token/Clawback.cpp b/src/libxrpl/tx/transactors/token/Clawback.cpp
index c9e6d32f6c..ff20bd82c3 100644
--- a/src/libxrpl/tx/transactors/token/Clawback.cpp
+++ b/src/libxrpl/tx/transactors/token/Clawback.cpp
@@ -138,8 +138,12 @@ preclaimHelper<Issue>(
     // the available balance of a trustline is prone to new changes (eg.
     // XLS-34). So we must use `accountHolds`.
     if (accountHolds(
-            ctx.view, holder, clawAmount.get<Issue>().currency, issuer, fhIGNORE_FREEZE, ctx.j) <=
-        beast::zero)
+            ctx.view,
+            holder,
+            clawAmount.get<Issue>().currency,
+            issuer,
+            FreezeHandling::fhIGNORE_FREEZE,
+            ctx.j) <= beast::zero)
         return tecINSUFFICIENT_FUNDS;
 
     return tesSUCCESS;
@@ -169,8 +173,12 @@ preclaimHelper<MPTIssue>(
         return tecOBJECT_NOT_FOUND;
 
     if (accountHolds(
-            ctx.view, holder, clawAmount.get<MPTIssue>(), fhIGNORE_FREEZE, ahIGNORE_AUTH, ctx.j) <=
-        beast::zero)
+            ctx.view,
+            holder,
+            clawAmount.get<MPTIssue>(),
+            FreezeHandling::fhIGNORE_FREEZE,
+            AuthHandling::ahIGNORE_AUTH,
+            ctx.j) <= beast::zero)
         return tecINSUFFICIENT_FUNDS;
 
     return tesSUCCESS;
@@ -229,7 +237,7 @@ applyHelper<Issue>(ApplyContext& ctx)
         holder,
         clawAmount.get<Issue>().currency,
         clawAmount.getIssuer(),
-        fhIGNORE_FREEZE,
+        FreezeHandling::fhIGNORE_FREEZE,
         ctx.journal);
 
     return directSendNoFee(
@@ -249,8 +257,8 @@ applyHelper<MPTIssue>(ApplyContext& ctx)
         ctx.view(),
         holder,
         clawAmount.get<MPTIssue>(),
-        fhIGNORE_FREEZE,
-        ahIGNORE_AUTH,
+        FreezeHandling::fhIGNORE_FREEZE,
+        AuthHandling::ahIGNORE_AUTH,
         ctx.journal);
 
     return directSendNoFee(
diff --git a/src/test/app/AMMExtended_test.cpp b/src/test/app/AMMExtended_test.cpp
index d8cdf1ae12..6047880e72 100644
--- a/src/test/app/AMMExtended_test.cpp
+++ b/src/test/app/AMMExtended_test.cpp
@@ -69,7 +69,7 @@ namespace xrpl::test {
 struct AMMExtended_test : public jtx::AMMTest
 {
     // Use small Number mantissas for the life of this test.
-    NumberMantissaScaleGuard const sg_{xrpl::MantissaRange::small};
+    NumberMantissaScaleGuard const sg_{xrpl::MantissaRange::mantissa_scale::small};
 
 private:
     void
diff --git a/src/test/app/AMM_test.cpp b/src/test/app/AMM_test.cpp
index d2d7fbf2c7..d79bd667dd 100644
--- a/src/test/app/AMM_test.cpp
+++ b/src/test/app/AMM_test.cpp
@@ -73,7 +73,7 @@ namespace xrpl::test {
 struct AMM_test : public jtx::AMMTest
 {
     // Use small Number mantissas for the life of this test.
-    NumberMantissaScaleGuard const sg_{xrpl::MantissaRange::small};
+    NumberMantissaScaleGuard const sg_{xrpl::MantissaRange::mantissa_scale::small};
 
 private:
     static FeatureBitset
@@ -5802,7 +5802,7 @@ private:
         Env const env(*this, features, std::make_unique<CaptureLogs>(&logs));
         auto rules = env.current()->rules();
         CurrentTransactionRulesGuard const rg(rules);
-        NumberMantissaScaleGuard const sg(MantissaRange::small);
+        NumberMantissaScaleGuard const sg(MantissaRange::mantissa_scale::small);
 
         for (auto const& t : tests)
         {
@@ -6792,8 +6792,9 @@ private:
     {
         auto const [amount, amount2, lptBalance] = amm.balances(GBP, EUR);
 
-        NumberMantissaScaleGuard const sg(MantissaRange::small);
-        NumberRoundModeGuard const g(env.enabled(fixAMMv1_3) ? Number::upward : Number::getround());
+        NumberMantissaScaleGuard const sg(MantissaRange::mantissa_scale::small);
+        NumberRoundModeGuard const g(
+            env.enabled(fixAMMv1_3) ? Number::rounding_mode::upward : Number::getround());
         auto const res = root2(amount * amount2);
 
         if (shouldFail)
diff --git a/src/test/app/Delegate_test.cpp b/src/test/app/Delegate_test.cpp
index a632391d6f..feca3a41c8 100644
--- a/src/test/app/Delegate_test.cpp
+++ b/src/test/app/Delegate_test.cpp
@@ -28,6 +28,7 @@
 #include <xrpl/basics/strHex.h>
 #include <xrpl/beast/unit_test/suite.h>
 #include <xrpl/json/json_value.h>
+#include <xrpl/ledger/Dir.h>
 #include <xrpl/ledger/helpers/AccountRootHelpers.h>
 #include <xrpl/ledger/helpers/DelegateHelpers.h>
 #include <xrpl/protocol/Feature.h>
@@ -42,6 +43,7 @@
 #include <xrpl/protocol/TxFlags.h>
 #include <xrpl/protocol/jss.h>
 
+#include <algorithm>
 #include <cstddef>
 #include <cstdint>
 #include <memory>
@@ -585,32 +587,179 @@ class Delegate_test : public beast::unit_test::suite
         testcase("test deleting account");
         using namespace jtx;
 
-        Env env(*this);
-        Account const alice{"alice"};
-        Account const bob{"bob"};
-        env.fund(XRP(100000), alice, bob);
-        env.close();
-
-        env(delegate::set(alice, bob, {"Payment"}));
-        env.close();
-        BEAST_EXPECT(env.closed()->exists(keylet::delegate(alice.id(), bob.id())));
-
-        for (std::uint32_t i = 0; i < 256; ++i)
+        // Delegator (alice) deletes account: Delegate object is cleaned up from
+        // both alice's and bob's owner directories.
+        {
+            Env env(*this);
+            Account const alice{"alice"};
+            Account const bob{"bob"};
+            Account const carol{"carol"};
+            env.fund(XRP(100000), alice, bob, carol);
             env.close();
 
-        auto const aliceBalance = env.balance(alice);
-        auto const bobBalance = env.balance(bob);
+            env(delegate::set(alice, bob, {"Payment"}));
+            env.close();
 
-        // alice deletes account, this will remove the Delegate object
-        auto const deleteFee = drops(env.current()->fees().increment);
-        env(acctdelete(alice, bob), fee(deleteFee));
-        env.close();
+            auto const delegateKey = keylet::delegate(alice.id(), bob.id());
+            BEAST_EXPECT(env.closed()->exists(delegateKey));
 
-        BEAST_EXPECT(!env.closed()->exists(keylet::account(alice.id())));
-        BEAST_EXPECT(!env.closed()->exists(keylet::ownerDir(alice.id())));
-        BEAST_EXPECT(env.balance(bob) == bobBalance + aliceBalance - deleteFee);
+            auto hasKey = [](xrpl::Dir const& dir, uint256 const& key) {
+                return std::any_of(  // NOLINT(modernize-use-ranges)
+                    dir.begin(), dir.end(), [&](auto const& sle) { return sle->key() == key; });
+            };
 
-        BEAST_EXPECT(!env.closed()->exists(keylet::delegate(alice.id(), bob.id())));
+            // Delegate object should appear in both alice's and bob's directories
+            BEAST_EXPECT(
+                hasKey(xrpl::Dir(*env.closed(), keylet::ownerDir(alice.id())), delegateKey.key));
+            BEAST_EXPECT(
+                hasKey(xrpl::Dir(*env.closed(), keylet::ownerDir(bob.id())), delegateKey.key));
+
+            for (std::uint32_t i = 0; i < 256; ++i)
+                env.close();
+
+            auto const aliceBalance = env.balance(alice);
+            auto const carolBalance = env.balance(carol);
+
+            // alice deletes account, this will remove the Delegate object from
+            // both alice's and bob's owner directories
+            auto const deleteFee = drops(env.current()->fees().increment);
+            env(acctdelete(alice, carol), fee(deleteFee));
+            env.close();
+
+            BEAST_EXPECT(!env.closed()->exists(keylet::account(alice.id())));
+            BEAST_EXPECT(!env.closed()->exists(keylet::ownerDir(alice.id())));
+            BEAST_EXPECT(!env.closed()->exists(delegateKey));
+            // bob's directory should no longer reference the Delegate object
+            BEAST_EXPECT(
+                !hasKey(xrpl::Dir(*env.closed(), keylet::ownerDir(bob.id())), delegateKey.key));
+            BEAST_EXPECT(env.balance(carol) == carolBalance + aliceBalance - deleteFee);
+        }
+
+        // Delegatee (bob) deletes account: Delegate object is cleaned up from
+        // both alice's and bob's owner directories, freeing alice's reserve so
+        // she can subsequently delete her own account.
+        {
+            Env env(*this);
+            Account const alice{"alice"};
+            Account const bob{"bob"};
+            Account const carol{"carol"};
+            env.fund(XRP(100000), alice, bob, carol);
+            env.close();
+
+            env(delegate::set(alice, bob, {"Payment"}));
+            env.close();
+
+            auto const delegateKey = keylet::delegate(alice.id(), bob.id());
+            BEAST_EXPECT(env.closed()->exists(delegateKey));
+
+            auto hasKey = [](xrpl::Dir const& dir, uint256 const& key) {
+                return std::any_of(  // NOLINT(modernize-use-ranges)
+                    dir.begin(), dir.end(), [&](auto const& sle) { return sle->key() == key; });
+            };
+
+            BEAST_EXPECT(
+                hasKey(xrpl::Dir(*env.closed(), keylet::ownerDir(alice.id())), delegateKey.key));
+            BEAST_EXPECT(
+                hasKey(xrpl::Dir(*env.closed(), keylet::ownerDir(bob.id())), delegateKey.key));
+
+            // The Delegate entry counts against alice's ownerCount.
+            auto const sleAlice = env.closed()->read(keylet::account(alice.id()));
+            BEAST_EXPECT(sleAlice);
+            BEAST_EXPECT(sleAlice->getFieldU32(sfOwnerCount) == 1);
+
+            for (std::uint32_t i = 0; i < 256; ++i)
+                env.close();
+
+            auto const bobBalance = env.balance(bob);
+            auto const carolBalance = env.balance(carol);
+
+            // bob (the authorized/delegatee account) deletes his account.
+            // This must clean up the Delegate object from both alice's and
+            // bob's owner directories so alice's delegation does not survive
+            // a potential account resurrection.
+            auto const deleteFee = drops(env.current()->fees().increment);
+            env(acctdelete(bob, carol), fee(deleteFee));
+            env.close();
+
+            BEAST_EXPECT(!env.closed()->exists(keylet::account(bob.id())));
+            BEAST_EXPECT(!env.closed()->exists(keylet::ownerDir(bob.id())));
+            BEAST_EXPECT(!env.closed()->exists(delegateKey));
+            // alice's directory should no longer reference the Delegate object
+            BEAST_EXPECT(
+                !hasKey(xrpl::Dir(*env.closed(), keylet::ownerDir(alice.id())), delegateKey.key));
+            BEAST_EXPECT(env.balance(carol) == carolBalance + bobBalance - deleteFee);
+
+            // alice's ownerCount is now 0; she can delete her own account.
+            auto const sleAlice2 = env.closed()->read(keylet::account(alice.id()));
+            BEAST_EXPECT(sleAlice2);
+            BEAST_EXPECT(sleAlice2->getFieldU32(sfOwnerCount) == 0);
+
+            auto const aliceDeleteFee = drops(env.current()->fees().increment);
+            env(acctdelete(alice, carol), fee(aliceDeleteFee));
+            env.close();
+
+            BEAST_EXPECT(!env.closed()->exists(keylet::account(alice.id())));
+        }
+
+        // Multiple delegators -> same delegatee: when the delegatee (bob)
+        // deletes his account, ALL Delegate objects (from alice and carol)
+        // must be cleaned up from every delegator's directory.
+        {
+            Env env(*this);
+            Account const alice{"alice"};
+            Account const bob{"bob"};
+            Account const carol{"carol"};
+            Account const dave{"dave"};
+            env.fund(XRP(100000), alice, bob, carol, dave);
+            env.close();
+
+            // Both alice and carol delegate to bob
+            env(delegate::set(alice, bob, {"Payment"}));
+            env(delegate::set(carol, bob, {"EscrowCreate"}));
+            env.close();
+
+            auto const aliceBobKey = keylet::delegate(alice.id(), bob.id());
+            auto const carolBobKey = keylet::delegate(carol.id(), bob.id());
+
+            auto hasKey = [](xrpl::Dir const& dir, uint256 const& key) {
+                return std::any_of(  // NOLINT(modernize-use-ranges)
+                    dir.begin(), dir.end(), [&](auto const& sle) { return sle->key() == key; });
+            };
+
+            // Both Delegate objects exist and are in bob's directory
+            BEAST_EXPECT(env.closed()->exists(aliceBobKey));
+            BEAST_EXPECT(env.closed()->exists(carolBobKey));
+            BEAST_EXPECT(
+                hasKey(xrpl::Dir(*env.closed(), keylet::ownerDir(bob.id())), aliceBobKey.key));
+            BEAST_EXPECT(
+                hasKey(xrpl::Dir(*env.closed(), keylet::ownerDir(bob.id())), carolBobKey.key));
+
+            for (std::uint32_t i = 0; i < 256; ++i)
+                env.close();
+
+            auto const bobBalance = env.balance(bob);
+            auto const daveBalance = env.balance(dave);
+
+            auto const deleteFee = drops(env.current()->fees().increment);
+            env(acctdelete(bob, dave), fee(deleteFee));
+            env.close();
+
+            // bob's account and directory are gone
+            BEAST_EXPECT(!env.closed()->exists(keylet::account(bob.id())));
+            BEAST_EXPECT(!env.closed()->exists(keylet::ownerDir(bob.id())));
+
+            // Both Delegate objects are erased
+            BEAST_EXPECT(!env.closed()->exists(aliceBobKey));
+            BEAST_EXPECT(!env.closed()->exists(carolBobKey));
+
+            // alice's and carol's directories no longer reference the objects
+            BEAST_EXPECT(
+                !hasKey(xrpl::Dir(*env.closed(), keylet::ownerDir(alice.id())), aliceBobKey.key));
+            BEAST_EXPECT(
+                !hasKey(xrpl::Dir(*env.closed(), keylet::ownerDir(carol.id())), carolBobKey.key));
+
+            BEAST_EXPECT(env.balance(dave) == daveBalance + bobBalance - deleteFee);
+        }
     }
 
     void
@@ -1864,10 +2013,10 @@ class Delegate_test : public beast::unit_test::suite
 #pragma push_macro("TRANSACTION")
 #undef TRANSACTION
 
-#define TRANSACTION(tag, value, name, delegable, ...) \
-    if (delegable == xrpl::delegable)                 \
-    {                                                 \
-        delegableCount++;                             \
+#define TRANSACTION(tag, value, name, txDelegable, ...) \
+    if (txDelegable == xrpl::delegable)                 \
+    {                                                   \
+        delegableCount++;                               \
     }
 
 #include <xrpl/protocol/detail/transactions.macro>
diff --git a/src/test/app/Invariants_test.cpp b/src/test/app/Invariants_test.cpp
index cbad2ce8c0..837c2cd4a7 100644
--- a/src/test/app/Invariants_test.cpp
+++ b/src/test/app/Invariants_test.cpp
@@ -4201,7 +4201,7 @@ class Invariants_test : public beast::unit_test::suite
             std::vector<ValidVault::DeltaInfo> values;
         };
 
-        NumberMantissaScaleGuard const g{MantissaRange::large};
+        NumberMantissaScaleGuard const g{MantissaRange::mantissa_scale::large};
 
         auto makeDelta = [&vaultAsset](Number const& n) -> ValidVault::DeltaInfo {
             return {.delta = n, .scale = scale(n, vaultAsset.raw())};
diff --git a/src/test/app/LedgerHistory_test.cpp b/src/test/app/LedgerHistory_test.cpp
index e78bdc588f..73944b617c 100644
--- a/src/test/app/LedgerHistory_test.cpp
+++ b/src/test/app/LedgerHistory_test.cpp
@@ -65,8 +65,8 @@ public:
         res->updateSkipList();
 
         {
-            res->stateMap().flushDirty(hotACCOUNT_NODE);
-            res->txMap().flushDirty(hotTRANSACTION_NODE);
+            res->stateMap().flushDirty(NodeObjectType::hotACCOUNT_NODE);
+            res->txMap().flushDirty(NodeObjectType::hotTRANSACTION_NODE);
         }
         res->unshare();
 
diff --git a/src/test/app/LoanBroker_test.cpp b/src/test/app/LoanBroker_test.cpp
index 59ae83264e..a6cff0530a 100644
--- a/src/test/app/LoanBroker_test.cpp
+++ b/src/test/app/LoanBroker_test.cpp
@@ -848,7 +848,7 @@ class LoanBroker_test : public beast::unit_test::suite
         BEAST_EXPECT(env.ownerCount(alice) == aliceOriginalCount);
     }
 
-    enum LoanBrokerTest { CoverClawback, CoverDeposit, CoverWithdraw, Delete, Set };
+    enum class LoanBrokerTest { CoverClawback, CoverDeposit, CoverWithdraw, Delete, Set };
 
     void
     testLoanBroker(
@@ -923,7 +923,7 @@ class LoanBroker_test : public beast::unit_test::suite
             env(jv, txflags(tfFullyCanonicalSig), ter(temINVALID));
         };
 
-        if (brokerTest == CoverDeposit)
+        if (brokerTest == LoanBrokerTest::CoverDeposit)
         {
             // preflight: temINVALID (empty/zero broker id)
             testZeroBrokerID([&]() { return coverDeposit(alice, brokerKeylet.key, asset(10)); });
@@ -949,7 +949,7 @@ class LoanBroker_test : public beast::unit_test::suite
         }
         env.close();
 
-        if (brokerTest == CoverWithdraw)
+        if (brokerTest == LoanBrokerTest::CoverWithdraw)
         {
             // preflight: temINVALID (empty/zero broker id)
             testZeroBrokerID([&]() { return coverWithdraw(alice, brokerKeylet.key, asset(10)); });
@@ -1002,7 +1002,7 @@ class LoanBroker_test : public beast::unit_test::suite
                 ter(tecPSEUDO_ACCOUNT));
         }
 
-        if (brokerTest == CoverClawback)
+        if (brokerTest == LoanBrokerTest::CoverClawback)
         {
             // preflight: temINVALID (empty/zero broker id)
             testZeroBrokerID([&]() {
@@ -1039,7 +1039,7 @@ class LoanBroker_test : public beast::unit_test::suite
             env.close();
         }
 
-        if (brokerTest == Delete)
+        if (brokerTest == LoanBrokerTest::Delete)
         {
             Account const borrower{"borrower"};
             env.fund(XRP(1'000), borrower);
@@ -1071,7 +1071,7 @@ class LoanBroker_test : public beast::unit_test::suite
             env(del(alice, brokerKeylet.key));
         }
 
-        if (brokerTest == Set)
+        if (brokerTest == LoanBrokerTest::Set)
         {
             // preflight: temINVALID (empty/zero broker id)
             testZeroBrokerID([&]() {
@@ -1139,7 +1139,7 @@ class LoanBroker_test : public beast::unit_test::suite
 
         // Issue:
         // AllowTrustLineClawback is not set or NoFreeze is set
-        testLoanBroker({}, CoverClawback);
+        testLoanBroker({}, LoanBrokerTest::CoverClawback);
 
         // MPTIssue:
         // MPTCanClawback is not set
@@ -1148,7 +1148,7 @@ class LoanBroker_test : public beast::unit_test::suite
                 MPTTester const mpt({.env = env, .issuer = issuer, .holders = {alice}});
                 return mpt;
             },
-            CoverClawback);
+            LoanBrokerTest::CoverClawback);
     }
 
     void
@@ -1159,7 +1159,7 @@ class LoanBroker_test : public beast::unit_test::suite
 
         // preclaim:
         // tecWRONG_ASSET, tecINSUFFICIENT_FUNDS, frozen asset
-        testLoanBroker({}, CoverDeposit);
+        testLoanBroker({}, LoanBrokerTest::CoverDeposit);
     }
 
     void
@@ -1178,7 +1178,7 @@ class LoanBroker_test : public beast::unit_test::suite
             second+third tecINSUFFICIENT_FUNDS (can this happen)?
         doApply: tecPATH_DRY (can it happen, funds already checked?)
          */
-        testLoanBroker({}, CoverWithdraw);
+        testLoanBroker({}, LoanBrokerTest::CoverWithdraw);
     }
 
     void
@@ -1192,7 +1192,7 @@ class LoanBroker_test : public beast::unit_test::suite
             accountSend failure, removeEmptyHolding failure,
             all tecHAS_OBLIGATIONS (can any of these happen?)
         */
-        testLoanBroker({}, Delete);
+        testLoanBroker({}, LoanBrokerTest::Delete);
     }
 
     void
@@ -1208,7 +1208,7 @@ class LoanBroker_test : public beast::unit_test::suite
             addEmptyHolding failure
             can any of these happen?
         */
-        testLoanBroker({}, Set);
+        testLoanBroker({}, LoanBrokerTest::Set);
     }
 
     void
@@ -1586,7 +1586,7 @@ class LoanBroker_test : public beast::unit_test::suite
         Account const dest("destination");
         auto const token = issuer["IOU"];
 
-        enum TrustState {
+        enum class TrustState {
             RequireAuth,
             ZeroLimit,
             ReachedLimit,
@@ -1602,10 +1602,10 @@ class LoanBroker_test : public beast::unit_test::suite
             auto setTrustLine = [&](Account const& acct, TrustState state) {
                 switch (state)
                 {
-                    case RequireAuth:
+                    case TrustState::RequireAuth:
                         env(trust(issuer, token(0), acct, tfSetfAuth));
                         break;
-                    case ZeroLimit: {
+                    case TrustState::ZeroLimit: {
                         auto jv = trust(acct, token(0));
                         // set QualityIn so that the trustline is not
                         // auto-deleted
@@ -1613,19 +1613,19 @@ class LoanBroker_test : public beast::unit_test::suite
                         env(jv);
                     }
                     break;
-                    case ReachedLimit: {
+                    case TrustState::ReachedLimit: {
                         env(trust(acct, token(1'000)));
                         env(pay(issuer, acct, token(1'000)));
                         env.close();
                     }
                     break;
-                    case NearLimit: {
+                    case TrustState::NearLimit: {
                         env(trust(acct, token(1'000)));
                         env(pay(issuer, acct, token(950)));
                         env.close();
                     }
                     break;
-                    case NoTrustLine:
+                    case TrustState::NoTrustLine:
                         // don't create a trustline
                         break;
                     default:
@@ -1637,12 +1637,12 @@ class LoanBroker_test : public beast::unit_test::suite
             env.fund(XRP(1'000), issuer, broker, dest);
             env.close();
 
-            if (trustState == RequireAuth)
+            if (trustState == TrustState::RequireAuth)
             {
                 env(fset(issuer, asfRequireAuth));
                 env.close();
 
-                setTrustLine(broker, RequireAuth);
+                setTrustLine(broker, TrustState::RequireAuth);
             }
 
             setTrustLine(dest, trustState);
@@ -1684,7 +1684,7 @@ class LoanBroker_test : public beast::unit_test::suite
             env.close();
 
             // Clearing RequireAuth shouldn't change the result
-            if (trustState == RequireAuth)
+            if (trustState == TrustState::RequireAuth)
             {
                 env(fclear(issuer, asfRequireAuth));
                 env.close();
@@ -1697,11 +1697,11 @@ class LoanBroker_test : public beast::unit_test::suite
             }
         };
 
-        test(RequireAuth);
-        test(ZeroLimit);
-        test(ReachedLimit);
-        test(NearLimit);
-        test(NoTrustLine);
+        test(TrustState::RequireAuth);
+        test(TrustState::ZeroLimit);
+        test(TrustState::ReachedLimit);
+        test(TrustState::NearLimit);
+        test(TrustState::NoTrustLine);
     }
 
     void
@@ -1712,24 +1712,24 @@ class LoanBroker_test : public beast::unit_test::suite
         Account const broker("issuer");
         Account const dest("destination");
 
-        enum MPTState {
+        enum class MPTState {
             RequireAuth,
             ReachedMAX,
             NoMPT,
         };
 
-        auto test = [&](MPTState MPTState) {
+        auto test = [&](MPTState mptState) {
             Env env(*this);
 
-            testcase << "RIPD-4274 MPT with state: " << static_cast<int>(MPTState);
+            testcase << "RIPD-4274 MPT with state: " << static_cast<int>(mptState);
 
             env.fund(XRP(1'000), issuer, broker, dest);
             env.close();
 
             auto const maybeToken = [&]() -> std::optional<MPT> {
-                switch (MPTState)
+                switch (mptState)
                 {
-                    case RequireAuth: {
+                    case MPTState::RequireAuth: {
                         auto tester = MPTTester(
                             {.env = env,
                              .issuer = issuer,
@@ -1743,7 +1743,7 @@ class LoanBroker_test : public beast::unit_test::suite
                             {.account = issuer, .holder = dest, .flags = tfMPTUnauthorize});
                         return tester;
                     }
-                    case ReachedMAX: {
+                    case MPTState::ReachedMAX: {
                         auto tester = MPTTester(
                             {.env = env,
                              .issuer = issuer,
@@ -1754,7 +1754,7 @@ class LoanBroker_test : public beast::unit_test::suite
                         BEAST_EXPECT(env.balance(issuer, tester) == tester(-4'000));
                         return tester;
                     }
-                    case NoMPT: {
+                    case MPTState::NoMPT: {
                         return MPTTester(
                             {.env = env,
                              .issuer = issuer,
@@ -1786,7 +1786,7 @@ class LoanBroker_test : public beast::unit_test::suite
                 ter(std::ignore));
 
             // Shouldn't fail if at MaximumAmount since no new tokens are issued
-            TER const err = MPTState == ReachedMAX ? TER(tesSUCCESS) : tecNO_AUTH;
+            TER const err = mptState == MPTState::ReachedMAX ? TER(tesSUCCESS) : tecNO_AUTH;
             BEAST_EXPECT(env.ter() == err);
             env.close();
 
@@ -1812,9 +1812,9 @@ class LoanBroker_test : public beast::unit_test::suite
             env.close();
         };
 
-        test(RequireAuth);
-        test(ReachedMAX);
-        test(NoMPT);
+        test(MPTState::RequireAuth);
+        test(MPTState::ReachedMAX);
+        test(MPTState::NoMPT);
     }
 
     void
diff --git a/src/test/app/Loan_test.cpp b/src/test/app/Loan_test.cpp
index 336482d855..2e5698fa3d 100644
--- a/src/test/app/Loan_test.cpp
+++ b/src/test/app/Loan_test.cpp
@@ -155,7 +155,7 @@ protected:
         [[nodiscard]] Number
         maxCoveredLoanValue(Number const& currentDebt) const
         {
-            NumberRoundModeGuard const mg(Number::downward);
+            NumberRoundModeGuard const mg(Number::rounding_mode::downward);
             auto debtLimit = coverDeposit * tenthBipsPerUnity.value() / coverRateMin.value();
 
             return debtLimit - currentDebt;
@@ -591,7 +591,7 @@ protected:
                  : std::max(broker.vaultScale(env), state.principalOutstanding.exponent())));
         BEAST_EXPECT(state.paymentInterval == 600);
         {
-            NumberRoundModeGuard const mg(Number::upward);
+            NumberRoundModeGuard const mg(Number::rounding_mode::upward);
             BEAST_EXPECT(
                 state.totalValue ==
                 roundToAsset(
@@ -913,8 +913,8 @@ protected:
         }
 
         // Include the service fee
-        STAmount const totalDue =
-            roundToScale(roundedPeriodicPayment + serviceFee, state.loanScale, Number::upward);
+        STAmount const totalDue = roundToScale(
+            roundedPeriodicPayment + serviceFee, state.loanScale, Number::rounding_mode::upward);
 
         auto currentRoundedState = constructLoanState(
             state.totalValue, state.principalOutstanding, state.managementFeeOutstanding);
@@ -2013,7 +2013,7 @@ protected:
                          ? 0
                          : std::max(
                                broker.vaultScale(env), state.principalOutstanding.exponent())));
-                NumberRoundModeGuard const mg(Number::upward);
+                NumberRoundModeGuard const mg(Number::rounding_mode::upward);
                 auto const defaultAmount = roundToAsset(
                     broker.asset,
                     std::min(
@@ -2317,7 +2317,7 @@ protected:
                     // service fee is 2
                     auto const startingPayments = state.paymentRemaining;
                     STAmount const payoffAmount = [&]() {
-                        NumberRoundModeGuard const mg(Number::upward);
+                        NumberRoundModeGuard const mg(Number::rounding_mode::upward);
                         auto const rawPayoff =
                             startingPayments * (state.periodicPayment + broker.asset(2).value());
                         STAmount payoffAmount{broker.asset, rawPayoff};
@@ -2519,21 +2519,25 @@ protected:
                 BEAST_EXPECT(
                     roundedPeriodicPayment ==
                     roundToScale(
-                        broker.asset(Number(8333457002039338267, -17), Number::upward),
+                        broker.asset(
+                            Number(8333457002039338267, -17), Number::rounding_mode::upward),
                         state.loanScale,
-                        Number::upward));
+                        Number::rounding_mode::upward));
                 // 83334570.01162141
                 // Include the service fee
                 STAmount const totalDue = roundToScale(
-                    roundedPeriodicPayment + serviceFee, state.loanScale, Number::upward);
+                    roundedPeriodicPayment + serviceFee,
+                    state.loanScale,
+                    Number::rounding_mode::upward);
                 // Only check the first payment since the rounding
                 // may drift as payments are made
                 BEAST_EXPECT(
                     totalDue ==
                     roundToScale(
-                        broker.asset(Number(8533457002039338267, -17), Number::upward),
+                        broker.asset(
+                            Number(8533457002039338267, -17), Number::rounding_mode::upward),
                         state.loanScale,
-                        Number::upward));
+                        Number::rounding_mode::upward));
 
                 {
                     auto const raw = computeTheoreticalLoanState(
@@ -2561,9 +2565,9 @@ protected:
                 BEAST_EXPECT(
                     transactionAmount ==
                     roundToScale(
-                        broker.asset(Number(9533457002039400, -14), Number::upward),
+                        broker.asset(Number(9533457002039400, -14), Number::rounding_mode::upward),
                         state.loanScale,
-                        Number::upward));
+                        Number::rounding_mode::upward));
 
                 auto const initialState = state;
                 xrpl::detail::PaymentComponents totalPaid{
@@ -2651,11 +2655,16 @@ protected:
                     BEAST_EXPECT(
                         state.paymentRemaining < 12 ||
                         roundToAsset(
-                            broker.asset, deltas.principal, state.loanScale, Number::upward) ==
+                            broker.asset,
+                            deltas.principal,
+                            state.loanScale,
+                            Number::rounding_mode::upward) ==
                             roundToScale(
-                                broker.asset(Number(8333228691531218890, -17), Number::upward),
+                                broker.asset(
+                                    Number(8333228691531218890, -17),
+                                    Number::rounding_mode::upward),
                                 state.loanScale,
-                                Number::upward));
+                                Number::rounding_mode::upward));
                     BEAST_EXPECT(
                         paymentComponents.trackedPrincipalDelta >= beast::zero &&
                         paymentComponents.trackedPrincipalDelta <= state.principalOutstanding);
@@ -5239,7 +5248,7 @@ protected:
 
             // pay all but the last payment
             {
-                NumberRoundModeGuard const mg{Number::upward};
+                NumberRoundModeGuard const mg{Number::rounding_mode::upward};
                 Number const payment = beforeState.periodicPayment * (total - 1);
                 XRPAmount const payFee{baseFee * ((total - 1) / loanPaymentsPerFeeIncrement + 1)};
                 STAmount const paymentAmount =
diff --git a/src/test/app/MPToken_test.cpp b/src/test/app/MPToken_test.cpp
index 6150bdce9a..e9fd448998 100644
--- a/src/test/app/MPToken_test.cpp
+++ b/src/test/app/MPToken_test.cpp
@@ -4191,18 +4191,18 @@ class MPToken_test : public beast::unit_test::suite
 
         // Holders are locked
         {
-            enum LockType { Global, Individual, None };
+            enum class LockType { Global, Individual, None };
             struct TestArg
             {
                 Account src;
                 Account dst;
                 Account offerOwner;
-                LockType srcFlag = None;
-                LockType dstFlag = None;
-                LockType offerFlagBuy = None;
-                LockType offerFlagSell = None;
-                LockType globalFlagBuy = None;
-                LockType globalFlagSell = None;
+                LockType srcFlag = LockType::None;
+                LockType dstFlag = LockType::None;
+                LockType offerFlagBuy = LockType::None;
+                LockType offerFlagSell = LockType::None;
+                LockType globalFlagBuy = LockType::None;
+                LockType globalFlagSell = LockType::None;
                 TER err = tesSUCCESS;
                 std::optional<TER> errIOU = std::nullopt;
             };
@@ -4247,11 +4247,11 @@ class MPToken_test : public beast::unit_test::suite
             };
             auto lock = [&]<typename Token>(
                             Env& env, Account const& account, Token& token, LockType lock) {
-                if (lock == None)
+                if (lock == LockType::None)
                     return;
                 if constexpr (std::is_same_v<Token, IOU>)
                 {
-                    if (lock == Global)
+                    if (lock == LockType::Global)
                     {
                         env(fset(gw, asfGlobalFreeze));
                     }
@@ -4263,7 +4263,7 @@ class MPToken_test : public beast::unit_test::suite
                 }
                 else if constexpr (std::is_same_v<Token, MPTTester>)
                 {
-                    if (lock == Global)
+                    if (lock == LockType::Global)
                     {
                         token.set({.flags = tfMPTLock});
                     }
@@ -4312,33 +4312,33 @@ class MPToken_test : public beast::unit_test::suite
             // clang-format off
             std::vector<TestArg> const tests = {
                     // src, dst, offer's owner are a holder
-                    {.src = alice, .dst = carol, .offerOwner = bob, .srcFlag = Individual, .err = tecPATH_DRY},
+                    {.src = alice, .dst = carol, .offerOwner = bob, .srcFlag = LockType::Individual, .err = tecPATH_DRY},
                     // dst can receive IOU even if the account is frozen
-                    {.src = alice, .dst = carol, .offerOwner = bob, .dstFlag = Individual, .err = tecPATH_DRY, .errIOU = tesSUCCESS},
-                    {.src = alice, .dst = carol, .offerOwner = bob, .globalFlagBuy = Global, .err = tecPATH_DRY},
-                    {.src = alice, .dst = carol, .offerOwner = bob, .globalFlagSell = Global, .err = tecPATH_DRY},
+                    {.src = alice, .dst = carol, .offerOwner = bob, .dstFlag = LockType::Individual, .err = tecPATH_DRY, .errIOU = tesSUCCESS},
+                    {.src = alice, .dst = carol, .offerOwner = bob, .globalFlagBuy = LockType::Global, .err = tecPATH_DRY},
+                    {.src = alice, .dst = carol, .offerOwner = bob, .globalFlagSell = LockType::Global, .err = tecPATH_DRY},
                     // offer's owner can receive IOU even if the account is frozen
-                    {.src = alice, .dst = carol, .offerOwner = bob, .offerFlagBuy = Individual, .err =
+                    {.src = alice, .dst = carol, .offerOwner = bob, .offerFlagBuy = LockType::Individual, .err =
                     tecPATH_PARTIAL, .errIOU = tesSUCCESS},
-                    {.src = alice, .dst = carol, .offerOwner = bob, .offerFlagSell = Individual, .err = tecPATH_PARTIAL},
+                    {.src = alice, .dst = carol, .offerOwner = bob, .offerFlagSell = LockType::Individual, .err = tecPATH_PARTIAL},
                     // src, dst are a holder, offer's owner is an issuer
-                    {.src = alice, .dst = carol, .offerOwner = gw, .srcFlag = Individual, .err = tecPATH_DRY},
+                    {.src = alice, .dst = carol, .offerOwner = gw, .srcFlag = LockType::Individual, .err = tecPATH_DRY},
                     // dst can receive IOU even if the account is frozen
-                    {.src = alice, .dst = carol, .offerOwner = gw, .dstFlag = Individual, .err = tecPATH_DRY, .errIOU = tesSUCCESS},
-                    {.src = alice, .dst = carol, .offerOwner = gw, .globalFlagBuy = Global, .err = tecPATH_DRY},
-                    {.src = alice, .dst = carol, .offerOwner = gw, .globalFlagSell = Global, .err = tecPATH_DRY},
+                    {.src = alice, .dst = carol, .offerOwner = gw, .dstFlag = LockType::Individual, .err = tecPATH_DRY, .errIOU = tesSUCCESS},
+                    {.src = alice, .dst = carol, .offerOwner = gw, .globalFlagBuy = LockType::Global, .err = tecPATH_DRY},
+                    {.src = alice, .dst = carol, .offerOwner = gw, .globalFlagSell = LockType::Global, .err = tecPATH_DRY},
                     // src is issuer, dst and offer's owner are a holder
                     // dst can receive IOU even if the account is frozen
-                    {.src = gw, .dst = carol, .offerOwner = bob, .dstFlag = Individual, .err = tecPATH_DRY, .errIOU = tesSUCCESS},
+                    {.src = gw, .dst = carol, .offerOwner = bob, .dstFlag = LockType::Individual, .err = tecPATH_DRY, .errIOU = tesSUCCESS},
                     // offer's owner can receive IOU from an issuer even if takerBuys is frozen, MPT offer is unfunded in this case
-                    {.src = gw, .dst = carol, .offerOwner = bob, .offerFlagBuy = Individual, .err = tecPATH_PARTIAL, .errIOU = tesSUCCESS},
-                    {.src = gw, .dst = carol, .offerOwner = bob, .offerFlagSell = Individual, .err = tecPATH_PARTIAL},
+                    {.src = gw, .dst = carol, .offerOwner = bob, .offerFlagBuy = LockType::Individual, .err = tecPATH_PARTIAL, .errIOU = tesSUCCESS},
+                    {.src = gw, .dst = carol, .offerOwner = bob, .offerFlagSell = LockType::Individual, .err = tecPATH_PARTIAL},
                     // dst is issuer, src and offer's owner are a holder
-                    {.src = alice, .dst = gw, .offerOwner = bob, .srcFlag = Individual, .err = tecPATH_DRY},
+                    {.src = alice, .dst = gw, .offerOwner = bob, .srcFlag = LockType::Individual, .err = tecPATH_DRY},
                     // offer's owner can receive IOU even if the account is frozen
-                    {.src = alice, .dst = gw, .offerOwner = bob, .offerFlagBuy = Individual, .err = tecPATH_PARTIAL,
+                    {.src = alice, .dst = gw, .offerOwner = bob, .offerFlagBuy = LockType::Individual, .err = tecPATH_PARTIAL,
                      .errIOU = tesSUCCESS},
-                    {.src = alice, .dst = gw, .offerOwner = bob, .offerFlagSell = Individual, .err = tecPATH_PARTIAL},
+                    {.src = alice, .dst = gw, .offerOwner = bob, .offerFlagSell = LockType::Individual, .err = tecPATH_PARTIAL},
             };
             // clang-format on
 
diff --git a/src/test/app/NFTokenBurn_test.cpp b/src/test/app/NFTokenBurn_test.cpp
index 08d7b4305e..efb255ea2d 100644
--- a/src/test/app/NFTokenBurn_test.cpp
+++ b/src/test/app/NFTokenBurn_test.cpp
@@ -88,7 +88,7 @@ class NFTokenBurn_test : public beast::unit_test::suite
     //
     // It uses the ledger RPC command to show the NFT pages in the ledger.
     // This parameter controls how noisy the output is.
-    enum Volume : bool {
+    enum class Volume : bool {
         quiet = false,
         noisy = true,
     };
@@ -123,7 +123,7 @@ class NFTokenBurn_test : public beast::unit_test::suite
                     std::cout << tokenCount << " NFtokens in page "
                               << state[i][jss::index].asString() << std::endl;
 
-                    if (vol == noisy)
+                    if (vol == Volume::noisy)
                     {
                         std::cout << state[i].toStyledString() << std::endl;
                     }
diff --git a/src/test/app/NFTokenDir_test.cpp b/src/test/app/NFTokenDir_test.cpp
index 5764e87f76..a1527e8601 100644
--- a/src/test/app/NFTokenDir_test.cpp
+++ b/src/test/app/NFTokenDir_test.cpp
@@ -42,7 +42,7 @@ class NFTokenDir_test : public beast::unit_test::suite
     //
     // It uses the ledger RPC command to show the NFT pages in the ledger.
     // This parameter controls how noisy the output is.
-    enum Volume : bool {
+    enum class Volume : bool {
         quiet = false,
         noisy = true,
     };
@@ -77,7 +77,7 @@ class NFTokenDir_test : public beast::unit_test::suite
                     std::cout << tokenCount << " NFtokens in page "
                               << state[i][jss::index].asString() << std::endl;
 
-                    if (vol == noisy)
+                    if (vol == Volume::noisy)
                     {
                         std::cout << state[i].toStyledString() << std::endl;
                     }
@@ -190,7 +190,7 @@ class NFTokenDir_test : public beast::unit_test::suite
             for (std::string_view const seed : seeds)
             {
                 Account const& account =
-                    accounts.emplace_back(Account::base58Seed, std::string(seed));
+                    accounts.emplace_back(Account::AcctStringType::base58Seed, std::string(seed));
                 env.fund(XRP(10000), account);
 
                 // Do not close the ledger inside the loop.  If accounts are
@@ -394,7 +394,7 @@ class NFTokenDir_test : public beast::unit_test::suite
             for (std::string_view const seed : seeds)
             {
                 Account const& account =
-                    accounts.emplace_back(Account::base58Seed, std::string(seed));
+                    accounts.emplace_back(Account::AcctStringType::base58Seed, std::string(seed));
                 env.fund(XRP(10000), account);
 
                 // Do not close the ledger inside the loop.  If accounts are
@@ -624,7 +624,8 @@ class NFTokenDir_test : public beast::unit_test::suite
         accounts.reserve(seeds.size());
         for (std::string_view const seed : seeds)
         {
-            Account const& account = accounts.emplace_back(Account::base58Seed, std::string(seed));
+            Account const& account =
+                accounts.emplace_back(Account::AcctStringType::base58Seed, std::string(seed));
             env.fund(XRP(10000), account);
 
             // Do not close the ledger inside the loop.  If accounts are
@@ -787,7 +788,8 @@ class NFTokenDir_test : public beast::unit_test::suite
         accounts.reserve(seeds.size());
         for (std::string_view const seed : seeds)
         {
-            Account const& account = accounts.emplace_back(Account::base58Seed, std::string(seed));
+            Account const& account =
+                accounts.emplace_back(Account::AcctStringType::base58Seed, std::string(seed));
             env.fund(XRP(10000), account);
 
             // Do not close the ledger inside the loop.  If accounts are
diff --git a/src/test/app/OfferMPT_test.cpp b/src/test/app/OfferMPT_test.cpp
index 49558d91cf..b576f7b968 100644
--- a/src/test/app/OfferMPT_test.cpp
+++ b/src/test/app/OfferMPT_test.cpp
@@ -2013,7 +2013,7 @@ public:
         auto const f = env.current()->fees().base;
 
         // To keep things simple all offers are 1 : 1 for XRP : USD.
-        enum preAuthType { noPreAuth, acctPreAuth };
+        enum class preAuthType { noPreAuth, acctPreAuth };
         struct TestData
         {
             std::string account;      // Account operated on
@@ -2032,37 +2032,37 @@ public:
         // clang-format off
         TestData const tests[]{
             // acct                     fundXrp        bookAmt   preTrust  offerAmt                   tec     spentXrp       balanceUSD offers  owners scale
-            {.account="ann",             .fundXrp=reserve(env, 0) + 0 * f,    .bookAmount=1,   .preAuth=noPreAuth, .offerAmount=1000,      .tec=tecUNFUNDED_OFFER,               .spentXrp=f, .balanceUsd=USD(      0),    .offers=0, .owners=0},  // Account is at the reserve, and will dip below once fees are subtracted.
-            {.account="bev",             .fundXrp=reserve(env, 0) + 1 * f,    .bookAmount=1,   .preAuth=noPreAuth, .offerAmount=1000,      .tec=tecUNFUNDED_OFFER,               .spentXrp=f, .balanceUsd=USD(      0),    .offers=0, .owners=0},  // Account has just enough for the reserve and the fee.
-            {.account="cam",             .fundXrp=reserve(env, 0) + 2 * f,    .bookAmount=0,   .preAuth=noPreAuth, .offerAmount=1000, .tec=tecINSUF_RESERVE_OFFER,               .spentXrp=f, .balanceUsd=USD(      0),    .offers=0, .owners=0},  // Account has enough for the reserve, the fee and the offer, and a bit more, but not enough for the reserve after the offer is placed.
-            {.account="deb",             .fundXrp=reserve(env, 0) + 2 * f,    .bookAmount=1,   .preAuth=noPreAuth, .offerAmount=1000,             .tec=tesSUCCESS,           .spentXrp=2 * f, .balanceUsd=USD(      1),    .offers=0, .owners=1, .scale=100000},  // Account has enough to buy a little USD then the offer runs dry.
-            {.account="eve",             .fundXrp=reserve(env, 1) + 0 * f,    .bookAmount=0,   .preAuth=noPreAuth, .offerAmount=1000,             .tec=tesSUCCESS,               .spentXrp=f, .balanceUsd=USD(      0),    .offers=1, .owners=1},  // No offer to cross
-            {.account="flo",             .fundXrp=reserve(env, 1) + 0 * f,    .bookAmount=1,   .preAuth=noPreAuth, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP(   1)   + f, .balanceUsd=USD(      1),    .offers=0, .owners=1},
-            {.account="gay",             .fundXrp=reserve(env, 1) + 1 * f, .bookAmount=1000,   .preAuth=noPreAuth, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP(  50)   + f, .balanceUsd=USD(     50),    .offers=0, .owners=1},
-            {.account="hye", .fundXrp=XRP(1000)                   + 1 * f, .bookAmount=1000,   .preAuth=noPreAuth, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP( 800)   + f, .balanceUsd=USD(    800),    .offers=0, .owners=1},
-            {.account="ivy", .fundXrp=XRP(   1) + reserve(env, 1) + 1 * f,    .bookAmount=1,   .preAuth=noPreAuth, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP(   1)   + f, .balanceUsd=USD(      1),    .offers=0, .owners=1},
-            {.account="joy", .fundXrp=XRP(   1) + reserve(env, 2) + 1 * f,    .bookAmount=1,   .preAuth=noPreAuth, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP(   1)   + f, .balanceUsd=USD(      1),    .offers=1, .owners=2},
-            {.account="kim", .fundXrp=XRP( 900) + reserve(env, 2) + 1 * f,  .bookAmount=999,   .preAuth=noPreAuth, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP( 999)   + f, .balanceUsd=USD(    999),    .offers=0, .owners=1},
-            {.account="liz", .fundXrp=XRP( 998) + reserve(env, 0) + 1 * f,  .bookAmount=999,   .preAuth=noPreAuth, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP( 998)   + f, .balanceUsd=USD(    998),    .offers=0, .owners=1},
-            {.account="meg", .fundXrp=XRP( 998) + reserve(env, 1) + 1 * f,  .bookAmount=999,   .preAuth=noPreAuth, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP( 999)   + f, .balanceUsd=USD(    999),    .offers=0, .owners=1},
-            {.account="nia", .fundXrp=XRP( 998) + reserve(env, 2) + 1 * f,  .bookAmount=999,   .preAuth=noPreAuth, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP( 999)   + f, .balanceUsd=USD(    999),    .offers=1, .owners=2},
-            {.account="ova", .fundXrp=XRP( 999) + reserve(env, 0) + 1 * f, .bookAmount=1000,   .preAuth=noPreAuth, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP( 999)   + f, .balanceUsd=USD(    999),    .offers=0, .owners=1},
-            {.account="pam", .fundXrp=XRP( 999) + reserve(env, 1) + 1 * f, .bookAmount=1000,   .preAuth=noPreAuth, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP(1000)   + f, .balanceUsd=USD(   1000),    .offers=0, .owners=1},
-            {.account="rae", .fundXrp=XRP( 999) + reserve(env, 2) + 1 * f, .bookAmount=1000,   .preAuth=noPreAuth, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP(1000)   + f, .balanceUsd=USD(   1000),    .offers=0, .owners=1},
-            {.account="sue", .fundXrp=XRP(1000) + reserve(env, 2) + 1 * f,    .bookAmount=0,   .preAuth=noPreAuth, .offerAmount=1000,             .tec=tesSUCCESS,               .spentXrp=f, .balanceUsd=USD(      0),    .offers=1, .owners=1},
+            {.account="ann",             .fundXrp=reserve(env, 0) + 0 * f,    .bookAmount=1,   .preAuth=preAuthType::noPreAuth, .offerAmount=1000,      .tec=tecUNFUNDED_OFFER,               .spentXrp=f, .balanceUsd=USD(      0),    .offers=0, .owners=0},  // Account is at the reserve, and will dip below once fees are subtracted.
+            {.account="bev",             .fundXrp=reserve(env, 0) + 1 * f,    .bookAmount=1,   .preAuth=preAuthType::noPreAuth, .offerAmount=1000,      .tec=tecUNFUNDED_OFFER,               .spentXrp=f, .balanceUsd=USD(      0),    .offers=0, .owners=0},  // Account has just enough for the reserve and the fee.
+            {.account="cam",             .fundXrp=reserve(env, 0) + 2 * f,    .bookAmount=0,   .preAuth=preAuthType::noPreAuth, .offerAmount=1000, .tec=tecINSUF_RESERVE_OFFER,               .spentXrp=f, .balanceUsd=USD(      0),    .offers=0, .owners=0},  // Account has enough for the reserve, the fee and the offer, and a bit more, but not enough for the reserve after the offer is placed.
+            {.account="deb",             .fundXrp=reserve(env, 0) + 2 * f,    .bookAmount=1,   .preAuth=preAuthType::noPreAuth, .offerAmount=1000,             .tec=tesSUCCESS,           .spentXrp=2 * f, .balanceUsd=USD(      1),    .offers=0, .owners=1, .scale=100000},  // Account has enough to buy a little USD then the offer runs dry.
+            {.account="eve",             .fundXrp=reserve(env, 1) + 0 * f,    .bookAmount=0,   .preAuth=preAuthType::noPreAuth, .offerAmount=1000,             .tec=tesSUCCESS,               .spentXrp=f, .balanceUsd=USD(      0),    .offers=1, .owners=1},  // No offer to cross
+            {.account="flo",             .fundXrp=reserve(env, 1) + 0 * f,    .bookAmount=1,   .preAuth=preAuthType::noPreAuth, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP(   1)   + f, .balanceUsd=USD(      1),    .offers=0, .owners=1},
+            {.account="gay",             .fundXrp=reserve(env, 1) + 1 * f, .bookAmount=1000,   .preAuth=preAuthType::noPreAuth, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP(  50)   + f, .balanceUsd=USD(     50),    .offers=0, .owners=1},
+            {.account="hye", .fundXrp=XRP(1000)                   + 1 * f, .bookAmount=1000,   .preAuth=preAuthType::noPreAuth, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP( 800)   + f, .balanceUsd=USD(    800),    .offers=0, .owners=1},
+            {.account="ivy", .fundXrp=XRP(   1) + reserve(env, 1) + 1 * f,    .bookAmount=1,   .preAuth=preAuthType::noPreAuth, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP(   1)   + f, .balanceUsd=USD(      1),    .offers=0, .owners=1},
+            {.account="joy", .fundXrp=XRP(   1) + reserve(env, 2) + 1 * f,    .bookAmount=1,   .preAuth=preAuthType::noPreAuth, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP(   1)   + f, .balanceUsd=USD(      1),    .offers=1, .owners=2},
+            {.account="kim", .fundXrp=XRP( 900) + reserve(env, 2) + 1 * f,  .bookAmount=999,   .preAuth=preAuthType::noPreAuth, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP( 999)   + f, .balanceUsd=USD(    999),    .offers=0, .owners=1},
+            {.account="liz", .fundXrp=XRP( 998) + reserve(env, 0) + 1 * f,  .bookAmount=999,   .preAuth=preAuthType::noPreAuth, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP( 998)   + f, .balanceUsd=USD(    998),    .offers=0, .owners=1},
+            {.account="meg", .fundXrp=XRP( 998) + reserve(env, 1) + 1 * f,  .bookAmount=999,   .preAuth=preAuthType::noPreAuth, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP( 999)   + f, .balanceUsd=USD(    999),    .offers=0, .owners=1},
+            {.account="nia", .fundXrp=XRP( 998) + reserve(env, 2) + 1 * f,  .bookAmount=999,   .preAuth=preAuthType::noPreAuth, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP( 999)   + f, .balanceUsd=USD(    999),    .offers=1, .owners=2},
+            {.account="ova", .fundXrp=XRP( 999) + reserve(env, 0) + 1 * f, .bookAmount=1000,   .preAuth=preAuthType::noPreAuth, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP( 999)   + f, .balanceUsd=USD(    999),    .offers=0, .owners=1},
+            {.account="pam", .fundXrp=XRP( 999) + reserve(env, 1) + 1 * f, .bookAmount=1000,   .preAuth=preAuthType::noPreAuth, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP(1000)   + f, .balanceUsd=USD(   1000),    .offers=0, .owners=1},
+            {.account="rae", .fundXrp=XRP( 999) + reserve(env, 2) + 1 * f, .bookAmount=1000,   .preAuth=preAuthType::noPreAuth, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP(1000)   + f, .balanceUsd=USD(   1000),    .offers=0, .owners=1},
+            {.account="sue", .fundXrp=XRP(1000) + reserve(env, 2) + 1 * f,    .bookAmount=0,   .preAuth=preAuthType::noPreAuth, .offerAmount=1000,             .tec=tesSUCCESS,               .spentXrp=f, .balanceUsd=USD(      0),    .offers=1, .owners=1},
             //---------------- Pre-created MPT ---------------------
             // Unlike from IOU, an issuer can't pre-create MPToken for an account (see similar tests in Offer_test.cpp)
-            {.account="ned",             .fundXrp=reserve(env, 1) + 0 * f,    .bookAmount=1, .preAuth=acctPreAuth, .offerAmount=1000,      .tec=tecUNFUNDED_OFFER,           .spentXrp=2 * f, .balanceUsd=USD(      0),    .offers=0, .owners=1},
-            {.account="ole",             .fundXrp=reserve(env, 1) + 1 * f,    .bookAmount=1, .preAuth=acctPreAuth, .offerAmount=1000,      .tec=tecUNFUNDED_OFFER,           .spentXrp=2 * f, .balanceUsd=USD(      0),    .offers=0, .owners=1},
-            {.account="pat",             .fundXrp=reserve(env, 1) + 2 * f,    .bookAmount=0, .preAuth=acctPreAuth, .offerAmount=1000,      .tec=tecUNFUNDED_OFFER,           .spentXrp=2 * f, .balanceUsd=USD(      0),    .offers=0, .owners=1},
-            {.account="quy",             .fundXrp=reserve(env, 1) + 2 * f,    .bookAmount=1, .preAuth=acctPreAuth, .offerAmount=1000,      .tec=tecUNFUNDED_OFFER,           .spentXrp=2 * f, .balanceUsd=USD(      0),    .offers=0, .owners=1},
-            {.account="ron",             .fundXrp=reserve(env, 1) + 3 * f,    .bookAmount=0, .preAuth=acctPreAuth, .offerAmount=1000, .tec=tecINSUF_RESERVE_OFFER,           .spentXrp=2 * f, .balanceUsd=USD(      0),    .offers=0, .owners=1},
-            {.account="syd",             .fundXrp=reserve(env, 1) + 3 * f,    .bookAmount=1, .preAuth=acctPreAuth, .offerAmount=1000,             .tec=tesSUCCESS,           .spentXrp=3 * f, .balanceUsd=USD(      1),    .offers=0, .owners=1, .scale=100000},
-            {.account="ted", .fundXrp=XRP(  20) + reserve(env, 1) + 2 * f, .bookAmount=1000, .preAuth=acctPreAuth, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP(20) + 2 * f, .balanceUsd=USD(     20),    .offers=0, .owners=1},
-            {.account="uli",             .fundXrp=reserve(env, 2) + 0 * f,    .bookAmount=0, .preAuth=acctPreAuth, .offerAmount=1000, .tec=tecINSUF_RESERVE_OFFER,           .spentXrp=2 * f, .balanceUsd=USD(      0),    .offers=0, .owners=1},
-            {.account="vic",             .fundXrp=reserve(env, 2) + 0 * f,    .bookAmount=1, .preAuth=acctPreAuth, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP( 1) + 2 * f, .balanceUsd=USD(      1),    .offers=0, .owners=1},
-            {.account="wes",             .fundXrp=reserve(env, 2) + 1 * f,    .bookAmount=0, .preAuth=acctPreAuth, .offerAmount=1000,             .tec=tesSUCCESS,           .spentXrp=2 * f, .balanceUsd=USD(      0),    .offers=1, .owners=2},
-            {.account="xan",             .fundXrp=reserve(env, 2) + 1 * f,    .bookAmount=1, .preAuth=acctPreAuth, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP( 1) + 2 * f, .balanceUsd=USD(      1),    .offers=1, .owners=2},
+            {.account="ned",             .fundXrp=reserve(env, 1) + 0 * f,    .bookAmount=1, .preAuth=preAuthType::acctPreAuth, .offerAmount=1000,      .tec=tecUNFUNDED_OFFER,           .spentXrp=2 * f, .balanceUsd=USD(      0),    .offers=0, .owners=1},
+            {.account="ole",             .fundXrp=reserve(env, 1) + 1 * f,    .bookAmount=1, .preAuth=preAuthType::acctPreAuth, .offerAmount=1000,      .tec=tecUNFUNDED_OFFER,           .spentXrp=2 * f, .balanceUsd=USD(      0),    .offers=0, .owners=1},
+            {.account="pat",             .fundXrp=reserve(env, 1) + 2 * f,    .bookAmount=0, .preAuth=preAuthType::acctPreAuth, .offerAmount=1000,      .tec=tecUNFUNDED_OFFER,           .spentXrp=2 * f, .balanceUsd=USD(      0),    .offers=0, .owners=1},
+            {.account="quy",             .fundXrp=reserve(env, 1) + 2 * f,    .bookAmount=1, .preAuth=preAuthType::acctPreAuth, .offerAmount=1000,      .tec=tecUNFUNDED_OFFER,           .spentXrp=2 * f, .balanceUsd=USD(      0),    .offers=0, .owners=1},
+            {.account="ron",             .fundXrp=reserve(env, 1) + 3 * f,    .bookAmount=0, .preAuth=preAuthType::acctPreAuth, .offerAmount=1000, .tec=tecINSUF_RESERVE_OFFER,           .spentXrp=2 * f, .balanceUsd=USD(      0),    .offers=0, .owners=1},
+            {.account="syd",             .fundXrp=reserve(env, 1) + 3 * f,    .bookAmount=1, .preAuth=preAuthType::acctPreAuth, .offerAmount=1000,             .tec=tesSUCCESS,           .spentXrp=3 * f, .balanceUsd=USD(      1),    .offers=0, .owners=1, .scale=100000},
+            {.account="ted", .fundXrp=XRP(  20) + reserve(env, 1) + 2 * f, .bookAmount=1000, .preAuth=preAuthType::acctPreAuth, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP(20) + 2 * f, .balanceUsd=USD(     20),    .offers=0, .owners=1},
+            {.account="uli",             .fundXrp=reserve(env, 2) + 0 * f,    .bookAmount=0, .preAuth=preAuthType::acctPreAuth, .offerAmount=1000, .tec=tecINSUF_RESERVE_OFFER,           .spentXrp=2 * f, .balanceUsd=USD(      0),    .offers=0, .owners=1},
+            {.account="vic",             .fundXrp=reserve(env, 2) + 0 * f,    .bookAmount=1, .preAuth=preAuthType::acctPreAuth, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP( 1) + 2 * f, .balanceUsd=USD(      1),    .offers=0, .owners=1},
+            {.account="wes",             .fundXrp=reserve(env, 2) + 1 * f,    .bookAmount=0, .preAuth=preAuthType::acctPreAuth, .offerAmount=1000,             .tec=tesSUCCESS,           .spentXrp=2 * f, .balanceUsd=USD(      0),    .offers=1, .owners=2},
+            {.account="xan",             .fundXrp=reserve(env, 2) + 1 * f,    .bookAmount=1, .preAuth=preAuthType::acctPreAuth, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP( 1) + 2 * f, .balanceUsd=USD(      1),    .offers=1, .owners=2},
         };
         // clang-format on
 
@@ -2085,7 +2085,7 @@ public:
             // Optionally pre-authorize MPT for acct.
             // Note this is not really part of the test, so we expect there
             // to be enough XRP reserve for acct to create the trust line.
-            if (t.preAuth == acctPreAuth)
+            if (t.preAuth == preAuthType::acctPreAuth)
                 MUSD.authorize({.account = acct});
             env.close();
 
@@ -2120,7 +2120,7 @@ public:
                 BEAST_EXPECT(acctOffer[sfTakerPays] == USD(leftover));
             }
 
-            if (t.preAuth == noPreAuth)
+            if (t.preAuth == preAuthType::noPreAuth)
             {
                 if (t.balanceUsd.value().signum() != 0)
                 {
diff --git a/src/test/app/Offer_test.cpp b/src/test/app/Offer_test.cpp
index 117826f603..2b048716b7 100644
--- a/src/test/app/Offer_test.cpp
+++ b/src/test/app/Offer_test.cpp
@@ -2229,7 +2229,7 @@ public:
         auto const f = env.current()->fees().base;
 
         // To keep things simple all offers are 1 : 1 for XRP : USD.
-        enum preTrustType { noPreTrust, gwPreTrust, acctPreTrust };
+        enum class preTrustType { noPreTrust, gwPreTrust, acctPreTrust };
         struct TestData
         {
             std::string account;      // Account operated on
@@ -2247,45 +2247,45 @@ public:
         // clang-format off
         TestData const tests[]{
             // acct                     fundXrp        bookAmt   preTrust  offerAmount                   tec     spentXrp       balanceUSD offers  owners
-            {.account="ann",             .fundXrp=reserve(env, 0) + 0 * f,    .bookAmount=1,   .preTrust=noPreTrust, .offerAmount=1000,      .tec=tecUNFUNDED_OFFER,               .spentXrp=f, .balanceUsd=USD(      0),    .offers=0, .owners=0},  // Account is at the reserve, and will dip below once fees are subtracted.
-            {.account="bev",             .fundXrp=reserve(env, 0) + 1 * f,    .bookAmount=1,   .preTrust=noPreTrust, .offerAmount=1000,      .tec=tecUNFUNDED_OFFER,               .spentXrp=f, .balanceUsd=USD(      0),    .offers=0, .owners=0},  // Account has just enough for the reserve and the fee.
-            {.account="cam",             .fundXrp=reserve(env, 0) + 2 * f,    .bookAmount=0,   .preTrust=noPreTrust, .offerAmount=1000, .tec=tecINSUF_RESERVE_OFFER,               .spentXrp=f, .balanceUsd=USD(      0),    .offers=0, .owners=0},  // Account has enough for the reserve, the fee and the offer, and a bit more, but not enough for the reserve after the offer is placed.
-            {.account="deb", .fundXrp=drops(10) + reserve(env, 0) + 1 * f,    .bookAmount=1,   .preTrust=noPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=drops(10)   + f, .balanceUsd=USD(0.00001),    .offers=0, .owners=1},  // Account has enough to buy a little USD then the offer runs dry.
-            {.account="eve",             .fundXrp=reserve(env, 1) + 0 * f,    .bookAmount=0,   .preTrust=noPreTrust, .offerAmount=1000,             .tec=tesSUCCESS,               .spentXrp=f, .balanceUsd=USD(      0),    .offers=1, .owners=1},  // No offer to cross
-            {.account="flo",             .fundXrp=reserve(env, 1) + 0 * f,    .bookAmount=1,   .preTrust=noPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP(   1)   + f, .balanceUsd=USD(      1),    .offers=0, .owners=1},
-            {.account="gay",             .fundXrp=reserve(env, 1) + 1 * f, .bookAmount=1000,   .preTrust=noPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP(  50)   + f, .balanceUsd=USD(     50),    .offers=0, .owners=1},
-            {.account="hye", .fundXrp=XRP(1000)                   + 1 * f, .bookAmount=1000,   .preTrust=noPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP( 800)   + f, .balanceUsd=USD(    800),    .offers=0, .owners=1},
-            {.account="ivy", .fundXrp=XRP(   1) + reserve(env, 1) + 1 * f,    .bookAmount=1,   .preTrust=noPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP(   1)   + f, .balanceUsd=USD(      1),    .offers=0, .owners=1},
-            {.account="joy", .fundXrp=XRP(   1) + reserve(env, 2) + 1 * f,    .bookAmount=1,   .preTrust=noPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP(   1)   + f, .balanceUsd=USD(      1),    .offers=1, .owners=2},
-            {.account="kim", .fundXrp=XRP( 900) + reserve(env, 2) + 1 * f,  .bookAmount=999,   .preTrust=noPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP( 999)   + f, .balanceUsd=USD(    999),    .offers=0, .owners=1},
-            {.account="liz", .fundXrp=XRP( 998) + reserve(env, 0) + 1 * f,  .bookAmount=999,   .preTrust=noPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP( 998)   + f, .balanceUsd=USD(    998),    .offers=0, .owners=1},
-            {.account="meg", .fundXrp=XRP( 998) + reserve(env, 1) + 1 * f,  .bookAmount=999,   .preTrust=noPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP( 999)   + f, .balanceUsd=USD(    999),    .offers=0, .owners=1},
-            {.account="nia", .fundXrp=XRP( 998) + reserve(env, 2) + 1 * f,  .bookAmount=999,   .preTrust=noPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP( 999)   + f, .balanceUsd=USD(    999),    .offers=1, .owners=2},
-            {.account="ova", .fundXrp=XRP( 999) + reserve(env, 0) + 1 * f, .bookAmount=1000,   .preTrust=noPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP( 999)   + f, .balanceUsd=USD(    999),    .offers=0, .owners=1},
-            {.account="pam", .fundXrp=XRP( 999) + reserve(env, 1) + 1 * f, .bookAmount=1000,   .preTrust=noPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP(1000)   + f, .balanceUsd=USD(   1000),    .offers=0, .owners=1},
-            {.account="rae", .fundXrp=XRP( 999) + reserve(env, 2) + 1 * f, .bookAmount=1000,   .preTrust=noPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP(1000)   + f, .balanceUsd=USD(   1000),    .offers=0, .owners=1},
-            {.account="sue", .fundXrp=XRP(1000) + reserve(env, 2) + 1 * f,    .bookAmount=0,   .preTrust=noPreTrust, .offerAmount=1000,             .tec=tesSUCCESS,               .spentXrp=f, .balanceUsd=USD(      0),    .offers=1, .owners=1},
+            {.account="ann",             .fundXrp=reserve(env, 0) + 0 * f,    .bookAmount=1,   .preTrust=preTrustType::noPreTrust, .offerAmount=1000,      .tec=tecUNFUNDED_OFFER,               .spentXrp=f, .balanceUsd=USD(      0),    .offers=0, .owners=0},  // Account is at the reserve, and will dip below once fees are subtracted.
+            {.account="bev",             .fundXrp=reserve(env, 0) + 1 * f,    .bookAmount=1,   .preTrust=preTrustType::noPreTrust, .offerAmount=1000,      .tec=tecUNFUNDED_OFFER,               .spentXrp=f, .balanceUsd=USD(      0),    .offers=0, .owners=0},  // Account has just enough for the reserve and the fee.
+            {.account="cam",             .fundXrp=reserve(env, 0) + 2 * f,    .bookAmount=0,   .preTrust=preTrustType::noPreTrust, .offerAmount=1000, .tec=tecINSUF_RESERVE_OFFER,               .spentXrp=f, .balanceUsd=USD(      0),    .offers=0, .owners=0},  // Account has enough for the reserve, the fee and the offer, and a bit more, but not enough for the reserve after the offer is placed.
+            {.account="deb", .fundXrp=drops(10) + reserve(env, 0) + 1 * f,    .bookAmount=1,   .preTrust=preTrustType::noPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=drops(10)   + f, .balanceUsd=USD(0.00001),    .offers=0, .owners=1},  // Account has enough to buy a little USD then the offer runs dry.
+            {.account="eve",             .fundXrp=reserve(env, 1) + 0 * f,    .bookAmount=0,   .preTrust=preTrustType::noPreTrust, .offerAmount=1000,             .tec=tesSUCCESS,               .spentXrp=f, .balanceUsd=USD(      0),    .offers=1, .owners=1},  // No offer to cross
+            {.account="flo",             .fundXrp=reserve(env, 1) + 0 * f,    .bookAmount=1,   .preTrust=preTrustType::noPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP(   1)   + f, .balanceUsd=USD(      1),    .offers=0, .owners=1},
+            {.account="gay",             .fundXrp=reserve(env, 1) + 1 * f, .bookAmount=1000,   .preTrust=preTrustType::noPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP(  50)   + f, .balanceUsd=USD(     50),    .offers=0, .owners=1},
+            {.account="hye", .fundXrp=XRP(1000)                   + 1 * f, .bookAmount=1000,   .preTrust=preTrustType::noPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP( 800)   + f, .balanceUsd=USD(    800),    .offers=0, .owners=1},
+            {.account="ivy", .fundXrp=XRP(   1) + reserve(env, 1) + 1 * f,    .bookAmount=1,   .preTrust=preTrustType::noPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP(   1)   + f, .balanceUsd=USD(      1),    .offers=0, .owners=1},
+            {.account="joy", .fundXrp=XRP(   1) + reserve(env, 2) + 1 * f,    .bookAmount=1,   .preTrust=preTrustType::noPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP(   1)   + f, .balanceUsd=USD(      1),    .offers=1, .owners=2},
+            {.account="kim", .fundXrp=XRP( 900) + reserve(env, 2) + 1 * f,  .bookAmount=999,   .preTrust=preTrustType::noPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP( 999)   + f, .balanceUsd=USD(    999),    .offers=0, .owners=1},
+            {.account="liz", .fundXrp=XRP( 998) + reserve(env, 0) + 1 * f,  .bookAmount=999,   .preTrust=preTrustType::noPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP( 998)   + f, .balanceUsd=USD(    998),    .offers=0, .owners=1},
+            {.account="meg", .fundXrp=XRP( 998) + reserve(env, 1) + 1 * f,  .bookAmount=999,   .preTrust=preTrustType::noPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP( 999)   + f, .balanceUsd=USD(    999),    .offers=0, .owners=1},
+            {.account="nia", .fundXrp=XRP( 998) + reserve(env, 2) + 1 * f,  .bookAmount=999,   .preTrust=preTrustType::noPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP( 999)   + f, .balanceUsd=USD(    999),    .offers=1, .owners=2},
+            {.account="ova", .fundXrp=XRP( 999) + reserve(env, 0) + 1 * f, .bookAmount=1000,   .preTrust=preTrustType::noPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP( 999)   + f, .balanceUsd=USD(    999),    .offers=0, .owners=1},
+            {.account="pam", .fundXrp=XRP( 999) + reserve(env, 1) + 1 * f, .bookAmount=1000,   .preTrust=preTrustType::noPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP(1000)   + f, .balanceUsd=USD(   1000),    .offers=0, .owners=1},
+            {.account="rae", .fundXrp=XRP( 999) + reserve(env, 2) + 1 * f, .bookAmount=1000,   .preTrust=preTrustType::noPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP(1000)   + f, .balanceUsd=USD(   1000),    .offers=0, .owners=1},
+            {.account="sue", .fundXrp=XRP(1000) + reserve(env, 2) + 1 * f,    .bookAmount=0,   .preTrust=preTrustType::noPreTrust, .offerAmount=1000,             .tec=tesSUCCESS,               .spentXrp=f, .balanceUsd=USD(      0),    .offers=1, .owners=1},
             //---------------- Pre-established trust lines ---------------------
-            {.account="abe",             .fundXrp=reserve(env, 0) + 0 * f,    .bookAmount=1,   .preTrust=gwPreTrust, .offerAmount=1000,      .tec=tecUNFUNDED_OFFER,               .spentXrp=f, .balanceUsd=USD(      0),    .offers=0, .owners=0},
-            {.account="bud",             .fundXrp=reserve(env, 0) + 1 * f,    .bookAmount=1,   .preTrust=gwPreTrust, .offerAmount=1000,      .tec=tecUNFUNDED_OFFER,               .spentXrp=f, .balanceUsd=USD(      0),    .offers=0, .owners=0},
-            {.account="che",             .fundXrp=reserve(env, 0) + 2 * f,    .bookAmount=0,   .preTrust=gwPreTrust, .offerAmount=1000, .tec=tecINSUF_RESERVE_OFFER,               .spentXrp=f, .balanceUsd=USD(      0),    .offers=0, .owners=0},
-            {.account="dan", .fundXrp=drops(10) + reserve(env, 0) + 1 * f,    .bookAmount=1,   .preTrust=gwPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=drops(10)   + f, .balanceUsd=USD(0.00001),    .offers=0, .owners=0},
-            {.account="eli", .fundXrp=XRP(  20) + reserve(env, 0) + 1 * f, .bookAmount=1000,   .preTrust=gwPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP(20) + 1 * f, .balanceUsd=USD(     20),    .offers=0, .owners=0},
-            {.account="fyn",             .fundXrp=reserve(env, 1) + 0 * f,    .bookAmount=0,   .preTrust=gwPreTrust, .offerAmount=1000,             .tec=tesSUCCESS,               .spentXrp=f, .balanceUsd=USD(      0),    .offers=1, .owners=1},
-            {.account="gar",             .fundXrp=reserve(env, 1) + 0 * f,    .bookAmount=1,   .preTrust=gwPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP( 1) +     f, .balanceUsd=USD(      1),    .offers=1, .owners=1},
-            {.account="hal",             .fundXrp=reserve(env, 1) + 1 * f,    .bookAmount=1,   .preTrust=gwPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP( 1) +     f, .balanceUsd=USD(      1),    .offers=1, .owners=1},
+            {.account="abe",             .fundXrp=reserve(env, 0) + 0 * f,    .bookAmount=1,   .preTrust=preTrustType::gwPreTrust, .offerAmount=1000,      .tec=tecUNFUNDED_OFFER,               .spentXrp=f, .balanceUsd=USD(      0),    .offers=0, .owners=0},
+            {.account="bud",             .fundXrp=reserve(env, 0) + 1 * f,    .bookAmount=1,   .preTrust=preTrustType::gwPreTrust, .offerAmount=1000,      .tec=tecUNFUNDED_OFFER,               .spentXrp=f, .balanceUsd=USD(      0),    .offers=0, .owners=0},
+            {.account="che",             .fundXrp=reserve(env, 0) + 2 * f,    .bookAmount=0,   .preTrust=preTrustType::gwPreTrust, .offerAmount=1000, .tec=tecINSUF_RESERVE_OFFER,               .spentXrp=f, .balanceUsd=USD(      0),    .offers=0, .owners=0},
+            {.account="dan", .fundXrp=drops(10) + reserve(env, 0) + 1 * f,    .bookAmount=1,   .preTrust=preTrustType::gwPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=drops(10)   + f, .balanceUsd=USD(0.00001),    .offers=0, .owners=0},
+            {.account="eli", .fundXrp=XRP(  20) + reserve(env, 0) + 1 * f, .bookAmount=1000,   .preTrust=preTrustType::gwPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP(20) + 1 * f, .balanceUsd=USD(     20),    .offers=0, .owners=0},
+            {.account="fyn",             .fundXrp=reserve(env, 1) + 0 * f,    .bookAmount=0,   .preTrust=preTrustType::gwPreTrust, .offerAmount=1000,             .tec=tesSUCCESS,               .spentXrp=f, .balanceUsd=USD(      0),    .offers=1, .owners=1},
+            {.account="gar",             .fundXrp=reserve(env, 1) + 0 * f,    .bookAmount=1,   .preTrust=preTrustType::gwPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP( 1) +     f, .balanceUsd=USD(      1),    .offers=1, .owners=1},
+            {.account="hal",             .fundXrp=reserve(env, 1) + 1 * f,    .bookAmount=1,   .preTrust=preTrustType::gwPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP( 1) +     f, .balanceUsd=USD(      1),    .offers=1, .owners=1},
 
-            {.account="ned",             .fundXrp=reserve(env, 1) + 0 * f,    .bookAmount=1, .preTrust=acctPreTrust, .offerAmount=1000,      .tec=tecUNFUNDED_OFFER,           .spentXrp=2 * f, .balanceUsd=USD(      0),    .offers=0, .owners=1},
-            {.account="ole",             .fundXrp=reserve(env, 1) + 1 * f,    .bookAmount=1, .preTrust=acctPreTrust, .offerAmount=1000,      .tec=tecUNFUNDED_OFFER,           .spentXrp=2 * f, .balanceUsd=USD(      0),    .offers=0, .owners=1},
-            {.account="pat",             .fundXrp=reserve(env, 1) + 2 * f,    .bookAmount=0, .preTrust=acctPreTrust, .offerAmount=1000,      .tec=tecUNFUNDED_OFFER,           .spentXrp=2 * f, .balanceUsd=USD(      0),    .offers=0, .owners=1},
-            {.account="quy",             .fundXrp=reserve(env, 1) + 2 * f,    .bookAmount=1, .preTrust=acctPreTrust, .offerAmount=1000,      .tec=tecUNFUNDED_OFFER,           .spentXrp=2 * f, .balanceUsd=USD(      0),    .offers=0, .owners=1},
-            {.account="ron",             .fundXrp=reserve(env, 1) + 3 * f,    .bookAmount=0, .preTrust=acctPreTrust, .offerAmount=1000, .tec=tecINSUF_RESERVE_OFFER,           .spentXrp=2 * f, .balanceUsd=USD(      0),    .offers=0, .owners=1},
-            {.account="syd", .fundXrp=drops(10) + reserve(env, 1) + 2 * f,    .bookAmount=1, .preTrust=acctPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=drops(10) + 2 * f, .balanceUsd=USD(0.00001),    .offers=0, .owners=1},
-            {.account="ted", .fundXrp=XRP(  20) + reserve(env, 1) + 2 * f, .bookAmount=1000, .preTrust=acctPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP(20) + 2 * f, .balanceUsd=USD(     20),    .offers=0, .owners=1},
-            {.account="uli",             .fundXrp=reserve(env, 2) + 0 * f,    .bookAmount=0, .preTrust=acctPreTrust, .offerAmount=1000, .tec=tecINSUF_RESERVE_OFFER,           .spentXrp=2 * f, .balanceUsd=USD(      0),    .offers=0, .owners=1},
-            {.account="vic",             .fundXrp=reserve(env, 2) + 0 * f,    .bookAmount=1, .preTrust=acctPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP( 1) + 2 * f, .balanceUsd=USD(      1),    .offers=0, .owners=1},
-            {.account="wes",             .fundXrp=reserve(env, 2) + 1 * f,    .bookAmount=0, .preTrust=acctPreTrust, .offerAmount=1000,             .tec=tesSUCCESS,           .spentXrp=2 * f, .balanceUsd=USD(      0),    .offers=1, .owners=2},
-            {.account="xan",             .fundXrp=reserve(env, 2) + 1 * f,    .bookAmount=1, .preTrust=acctPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP( 1) + 2 * f, .balanceUsd=USD(      1),    .offers=1, .owners=2},
+            {.account="ned",             .fundXrp=reserve(env, 1) + 0 * f,    .bookAmount=1, .preTrust=preTrustType::acctPreTrust, .offerAmount=1000,      .tec=tecUNFUNDED_OFFER,           .spentXrp=2 * f, .balanceUsd=USD(      0),    .offers=0, .owners=1},
+            {.account="ole",             .fundXrp=reserve(env, 1) + 1 * f,    .bookAmount=1, .preTrust=preTrustType::acctPreTrust, .offerAmount=1000,      .tec=tecUNFUNDED_OFFER,           .spentXrp=2 * f, .balanceUsd=USD(      0),    .offers=0, .owners=1},
+            {.account="pat",             .fundXrp=reserve(env, 1) + 2 * f,    .bookAmount=0, .preTrust=preTrustType::acctPreTrust, .offerAmount=1000,      .tec=tecUNFUNDED_OFFER,           .spentXrp=2 * f, .balanceUsd=USD(      0),    .offers=0, .owners=1},
+            {.account="quy",             .fundXrp=reserve(env, 1) + 2 * f,    .bookAmount=1, .preTrust=preTrustType::acctPreTrust, .offerAmount=1000,      .tec=tecUNFUNDED_OFFER,           .spentXrp=2 * f, .balanceUsd=USD(      0),    .offers=0, .owners=1},
+            {.account="ron",             .fundXrp=reserve(env, 1) + 3 * f,    .bookAmount=0, .preTrust=preTrustType::acctPreTrust, .offerAmount=1000, .tec=tecINSUF_RESERVE_OFFER,           .spentXrp=2 * f, .balanceUsd=USD(      0),    .offers=0, .owners=1},
+            {.account="syd", .fundXrp=drops(10) + reserve(env, 1) + 2 * f,    .bookAmount=1, .preTrust=preTrustType::acctPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=drops(10) + 2 * f, .balanceUsd=USD(0.00001),    .offers=0, .owners=1},
+            {.account="ted", .fundXrp=XRP(  20) + reserve(env, 1) + 2 * f, .bookAmount=1000, .preTrust=preTrustType::acctPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP(20) + 2 * f, .balanceUsd=USD(     20),    .offers=0, .owners=1},
+            {.account="uli",             .fundXrp=reserve(env, 2) + 0 * f,    .bookAmount=0, .preTrust=preTrustType::acctPreTrust, .offerAmount=1000, .tec=tecINSUF_RESERVE_OFFER,           .spentXrp=2 * f, .balanceUsd=USD(      0),    .offers=0, .owners=1},
+            {.account="vic",             .fundXrp=reserve(env, 2) + 0 * f,    .bookAmount=1, .preTrust=preTrustType::acctPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP( 1) + 2 * f, .balanceUsd=USD(      1),    .offers=0, .owners=1},
+            {.account="wes",             .fundXrp=reserve(env, 2) + 1 * f,    .bookAmount=0, .preTrust=preTrustType::acctPreTrust, .offerAmount=1000,             .tec=tesSUCCESS,           .spentXrp=2 * f, .balanceUsd=USD(      0),    .offers=1, .owners=2},
+            {.account="xan",             .fundXrp=reserve(env, 2) + 1 * f,    .bookAmount=1, .preTrust=preTrustType::acctPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP( 1) + 2 * f, .balanceUsd=USD(      1),    .offers=1, .owners=2},
         };
         // clang-format on
 
@@ -2306,14 +2306,14 @@ public:
             std::uint32_t const gwOfferSeq = env.seq(gw) - 1;
 
             // Optionally pre-establish a trustline between gw and acct.
-            if (t.preTrust == gwPreTrust)
+            if (t.preTrust == preTrustType::gwPreTrust)
                 env(trust(gw, acct["USD"](1)));
             env.close();
 
             // Optionally pre-establish a trustline between acct and gw.
             // Note this is not really part of the test, so we expect there
             // to be enough XRP reserve for acct to create the trust line.
-            if (t.preTrust == acctPreTrust)
+            if (t.preTrust == preTrustType::acctPreTrust)
                 env(trust(acct, USD(1)));
             env.close();
 
@@ -2341,7 +2341,7 @@ public:
                 BEAST_EXPECT(acctOffer[sfTakerPays] == USD(leftover));
             }
 
-            if (t.preTrust == noPreTrust)
+            if (t.preTrust == preTrustType::noPreTrust)
             {
                 if (t.balanceUsd.value().signum() != 0)
                 {
@@ -2676,7 +2676,7 @@ public:
         auto const f = env.current()->fees().base;
 
         // To keep things simple all offers are 1 : 1 for XRP : USD.
-        enum preTrustType { noPreTrust, gwPreTrust, acctPreTrust };
+        enum class preTrustType { noPreTrust, gwPreTrust, acctPreTrust };
         struct TestData
         {
             std::string account;  // Account operated on
diff --git a/src/test/app/Path_test.cpp b/src/test/app/Path_test.cpp
index 505d052faa..e6d27de415 100644
--- a/src/test/app/Path_test.cpp
+++ b/src/test/app/Path_test.cpp
@@ -132,7 +132,7 @@ public:
         void
         signal()
         {
-            std::lock_guard const lk(mutex_);
+            std::scoped_lock const lk(mutex_);
             signaled_ = true;
             cv_.notify_all();
         }
diff --git a/src/test/app/PayChan_test.cpp b/src/test/app/PayChan_test.cpp
index 1f4376a656..f69187c50f 100644
--- a/src/test/app/PayChan_test.cpp
+++ b/src/test/app/PayChan_test.cpp
@@ -1019,7 +1019,8 @@ struct PayChan_test : public beast::unit_test::suite
             auto testInvalidAccountParam = [&](auto const& param) {
                 Json::Value params;
                 params[jss::account] = param;
-                auto jrr = env.rpc("json", "account_channels", to_string(params))[jss::result];
+                auto const jrr =
+                    env.rpc("json", "account_channels", to_string(params))[jss::result];
                 BEAST_EXPECT(jrr[jss::error] == "invalidParams");
                 BEAST_EXPECT(jrr[jss::error_message] == "Invalid field 'account'.");
             };
@@ -1031,6 +1032,25 @@ struct PayChan_test : public beast::unit_test::suite
             testInvalidAccountParam(Json::Value(Json::objectValue));
             testInvalidAccountParam(Json::Value(Json::arrayValue));
         }
+        {
+            // test destination_account non-string
+            auto testInvalidDestAccountParam = [&](auto const& param) {
+                Json::Value params;
+                params[jss::account] = alice.human();
+                params[jss::destination_account] = param;
+                auto const jrr =
+                    env.rpc("json", "account_channels", to_string(params))[jss::result];
+                BEAST_EXPECT(jrr[jss::error] == "invalidParams");
+                BEAST_EXPECT(jrr[jss::error_message] == "Invalid field 'destination_account'.");
+            };
+
+            testInvalidDestAccountParam(1);
+            testInvalidDestAccountParam(1.1);
+            testInvalidDestAccountParam(true);
+            testInvalidDestAccountParam(Json::Value(Json::nullValue));
+            testInvalidDestAccountParam(Json::Value(Json::objectValue));
+            testInvalidDestAccountParam(Json::Value(Json::arrayValue));
+        }
         {
             auto const r = env.rpc("account_channels", alice.human(), bob.human());
             BEAST_EXPECT(r[jss::result][jss::channels].size() == 1);
diff --git a/src/test/app/XChain_test.cpp b/src/test/app/XChain_test.cpp
index de5ddbf891..a79d793c06 100644
--- a/src/test/app/XChain_test.cpp
+++ b/src/test/app/XChain_test.cpp
@@ -4026,7 +4026,7 @@ private:
         ChainStateTrack b_;
     };
 
-    enum SmState {
+    enum class SmState {
         st_initial,
         st_claim_id_created,
         st_attesting,
@@ -4035,8 +4035,6 @@ private:
         st_closed,
     };
 
-    enum Act_Flags { af_a2b = 1 << 0 };
-
     // --------------------------------------------------
     template <class T>
     class SmBase
@@ -4170,7 +4168,7 @@ private:
                 st.spend(dstDoor(), reward, num_attestors);
                 st.transfer(dstDoor(), cr.to, cr.amt);
                 st.env.env_.memoize(cr.to);
-                sm_state = st_completed;
+                sm_state = SmState::st_completed;
             };
 
             counters.create_callbacks[cr.claim_id - 1] = std::move(complete_cb);
@@ -4181,12 +4179,12 @@ private:
         {
             switch (sm_state)
             {
-                case st_initial:
+                case SmState::st_initial:
                     cr.claim_id = issue_account_create();
-                    sm_state = st_attesting;
+                    sm_state = SmState::st_attesting;
                     break;
 
-                case st_attesting:
+                case SmState::st_attesting:
                     attest(time, rnd);
                     break;
 
@@ -4194,14 +4192,14 @@ private:
                     assert(0);
                     break;
 
-                case st_completed:
+                case SmState::st_completed:
                     break;  // will get this once
             }
             return sm_state;
         }
 
     private:
-        SmState sm_state{st_initial};
+        SmState sm_state{SmState::st_initial};
         AccountCreate cr;
     };
 
@@ -4330,35 +4328,36 @@ private:
         {
             switch (sm_state)
             {
-                case st_initial:
+                case SmState::st_initial:
                     xfer.claim_id = create_claim_id();
-                    sm_state = st_claim_id_created;
+                    sm_state = SmState::st_claim_id_created;
                     break;
 
-                case st_claim_id_created:
+                case SmState::st_claim_id_created:
                     commit();
-                    sm_state = st_attesting;
+                    sm_state = SmState::st_attesting;
                     break;
 
-                case st_attesting:
+                case SmState::st_attesting:
                     if (attest(time, rnd))
                     {
-                        sm_state = xfer.with_claim == WithClaim::yes ? st_attested : st_completed;
+                        sm_state = xfer.with_claim == WithClaim::yes ? SmState::st_attested
+                                                                     : SmState::st_completed;
                     }
                     else
                     {
-                        sm_state = st_attesting;
+                        sm_state = SmState::st_attesting;
                     }
                     break;
 
-                case st_attested:
+                case SmState::st_attested:
                     assert(xfer.with_claim == WithClaim::yes);
                     claim();
-                    sm_state = st_completed;
+                    sm_state = SmState::st_completed;
                     break;
 
                 default:
-                case st_completed:
+                case SmState::st_completed:
                     assert(0);  // should have been removed
                     break;
             }
@@ -4367,7 +4366,7 @@ private:
 
     private:
         Transfer xfer;
-        SmState sm_state{st_initial};
+        SmState sm_state{SmState::st_initial};
     };
 
     // --------------------------------------------------
@@ -4414,7 +4413,7 @@ public:
                     return sm.advance(time, rnd);
                 };
                 auto& [t, sm] = *it;
-                if (t <= time && std::visit(vis, sm) == st_completed)
+                if (t <= time && std::visit(vis, sm) == SmState::st_completed)
                 {
                     it = sm_.erase(it);
                 }
diff --git a/src/test/basics/IOUAmount_test.cpp b/src/test/basics/IOUAmount_test.cpp
index 95362c7545..5c01445e31 100644
--- a/src/test/basics/IOUAmount_test.cpp
+++ b/src/test/basics/IOUAmount_test.cpp
@@ -156,7 +156,8 @@ public:
             BEAST_EXPECTS(result == expected, ss.str());
         };
 
-        for (auto const mantissaSize : {MantissaRange::small, MantissaRange::large})
+        for (auto const mantissaSize :
+             {MantissaRange::mantissa_scale::small, MantissaRange::mantissa_scale::large})
         {
             NumberMantissaScaleGuard const mg(mantissaSize);
 
diff --git a/src/test/basics/Number_test.cpp b/src/test/basics/Number_test.cpp
index cc7ccaa8c2..607ae004b1 100644
--- a/src/test/basics/Number_test.cpp
+++ b/src/test/basics/Number_test.cpp
@@ -75,20 +75,21 @@ public:
 
         test(
             Number{std::numeric_limits<std::int64_t>::min()},
-            scale == MantissaRange::small
+            scale == MantissaRange::mantissa_scale::small
                 ? Number{-9'223'372'036'854'776, 3}
                 : Number{true, 9'223'372'036'854'775'808ULL, 0, Number::normalized{}},
             __LINE__);
         test(
             Number{std::numeric_limits<std::int64_t>::min() + 1},
-            scale == MantissaRange::small ? Number{-9'223'372'036'854'776, 3}
-                                          : Number{-9'223'372'036'854'775'807},
+            scale == MantissaRange::mantissa_scale::small ? Number{-9'223'372'036'854'776, 3}
+                                                          : Number{-9'223'372'036'854'775'807},
             __LINE__);
         test(
             Number{std::numeric_limits<std::int64_t>::max()},
             Number{
-                scale == MantissaRange::small ? 9'223'372'036'854'776
-                                              : std::numeric_limits<std::int64_t>::max(),
+                scale == MantissaRange::mantissa_scale::small
+                    ? 9'223'372'036'854'776
+                    : std::numeric_limits<std::int64_t>::max(),
                 18 - Number::mantissaLog()},
             __LINE__);
         caught = false;
@@ -207,7 +208,7 @@ public:
                 BEAST_EXPECTS(result == z, ss.str());
             }
         };
-        if (scale == MantissaRange::small)
+        if (scale == MantissaRange::mantissa_scale::small)
         {
             test(cSmall);
         }
@@ -303,7 +304,7 @@ public:
                 BEAST_EXPECTS(result == z, ss.str());
             }
         };
-        if (scale == MantissaRange::small)
+        if (scale == MantissaRange::mantissa_scale::small)
         {
             test(cSmall);
         }
@@ -330,7 +331,7 @@ public:
             }
         };
         auto tests = [&](auto const& cSmall, auto const& cLarge) {
-            if (scale == MantissaRange::small)
+            if (scale == MantissaRange::mantissa_scale::small)
             {
                 test(cSmall);
             }
@@ -341,7 +342,7 @@ public:
         };
         auto const maxMantissa = Number::maxMantissa();
 
-        saveNumberRoundMode const save{Number::setround(Number::to_nearest)};
+        saveNumberRoundMode const save{Number::setround(Number::rounding_mode::to_nearest)};
         {
             auto const cSmall = std::to_array<Case>({
                 {Number{7}, Number{8}, Number{56}},
@@ -407,7 +408,7 @@ public:
             });
             tests(cSmall, cLarge);
         }
-        Number::setround(Number::towards_zero);
+        Number::setround(Number::rounding_mode::towards_zero);
         testcase << "test_mul " << to_string(Number::getMantissaScale()) << " towards_zero";
         {
             auto const cSmall = std::to_array<Case>(
@@ -474,7 +475,7 @@ public:
                 });
             tests(cSmall, cLarge);
         }
-        Number::setround(Number::downward);
+        Number::setround(Number::rounding_mode::downward);
         testcase << "test_mul " << to_string(Number::getMantissaScale()) << " downward";
         {
             auto const cSmall = std::to_array<Case>(
@@ -541,7 +542,7 @@ public:
                 });
             tests(cSmall, cLarge);
         }
-        Number::setround(Number::upward);
+        Number::setround(Number::rounding_mode::upward);
         testcase << "test_mul " << to_string(Number::getMantissaScale()) << " upward";
         {
             auto const cSmall = std::to_array<Case>(
@@ -642,7 +643,7 @@ public:
         };
         auto const maxMantissa = Number::maxMantissa();
         auto tests = [&](auto const& cSmall, auto const& cLarge) {
-            if (scale == MantissaRange::small)
+            if (scale == MantissaRange::mantissa_scale::small)
             {
                 test(cSmall);
             }
@@ -651,7 +652,7 @@ public:
                 test(cLarge);
             }
         };
-        saveNumberRoundMode const save{Number::setround(Number::to_nearest)};
+        saveNumberRoundMode const save{Number::setround(Number::rounding_mode::to_nearest)};
         {
             auto const cSmall = std::to_array<Case>(
                 {{Number{1}, Number{2}, Number{5, -1}},
@@ -689,7 +690,7 @@ public:
             tests(cSmall, cLarge);
         }
         testcase << "test_div " << to_string(Number::getMantissaScale()) << " towards_zero";
-        Number::setround(Number::towards_zero);
+        Number::setround(Number::rounding_mode::towards_zero);
         {
             auto const cSmall = std::to_array<Case>(
                 {{Number{1}, Number{2}, Number{5, -1}},
@@ -727,7 +728,7 @@ public:
             tests(cSmall, cLarge);
         }
         testcase << "test_div " << to_string(Number::getMantissaScale()) << " downward";
-        Number::setround(Number::downward);
+        Number::setround(Number::rounding_mode::downward);
         {
             auto const cSmall = std::to_array<Case>(
                 {{Number{1}, Number{2}, Number{5, -1}},
@@ -765,7 +766,7 @@ public:
             tests(cSmall, cLarge);
         }
         testcase << "test_div " << to_string(Number::getMantissaScale()) << " upward";
-        Number::setround(Number::upward);
+        Number::setround(Number::rounding_mode::upward);
         {
             auto const cSmall = std::to_array<Case>(
                 {{Number{1}, Number{2}, Number{5, -1}},
@@ -834,7 +835,7 @@ public:
         /*
         auto tests = [&](auto const& cSmall, auto const& cLarge) {
             test(cSmall);
-            if (scale != MantissaRange::small)
+            if (scale != MantissaRange::mantissa_scale::small)
                 test(cLarge);
         };
         */
@@ -864,9 +865,9 @@ public:
              Number{false, 55'108'98747006743627, -14, Number::normalized{}}},
         });
         test(cSmall);
-        if (Number::getMantissaScale() != MantissaRange::small)
+        if (Number::getMantissaScale() != MantissaRange::mantissa_scale::small)
         {
-            NumberRoundModeGuard const mg(Number::towards_zero);
+            NumberRoundModeGuard const mg(Number::rounding_mode::towards_zero);
             test(cLarge);
         }
         bool caught = false;
@@ -1027,7 +1028,7 @@ public:
     {
         testcase << "test_to_integer " << to_string(Number::getMantissaScale());
         using Case = std::tuple<Number, std::int64_t>;
-        saveNumberRoundMode const save{Number::setround(Number::to_nearest)};
+        saveNumberRoundMode const save{Number::setround(Number::rounding_mode::to_nearest)};
         {
             Case const c[]{
                 {Number{0}, 0},
@@ -1064,8 +1065,8 @@ public:
                 BEAST_EXPECT(j == y);
             }
         }
-        auto prev_mode = Number::setround(Number::towards_zero);
-        BEAST_EXPECT(prev_mode == Number::to_nearest);
+        auto prev_mode = Number::setround(Number::rounding_mode::towards_zero);
+        BEAST_EXPECT(prev_mode == Number::rounding_mode::to_nearest);
         {
             Case const c[]{
                 {Number{0}, 0},
@@ -1102,8 +1103,8 @@ public:
                 BEAST_EXPECT(j == y);
             }
         }
-        prev_mode = Number::setround(Number::downward);
-        BEAST_EXPECT(prev_mode == Number::towards_zero);
+        prev_mode = Number::setround(Number::rounding_mode::downward);
+        BEAST_EXPECT(prev_mode == Number::rounding_mode::towards_zero);
         {
             Case const c[]{
                 {Number{0}, 0},
@@ -1140,8 +1141,8 @@ public:
                 BEAST_EXPECT(j == y);
             }
         }
-        prev_mode = Number::setround(Number::upward);
-        BEAST_EXPECT(prev_mode == Number::downward);
+        prev_mode = Number::setround(Number::rounding_mode::upward);
+        BEAST_EXPECT(prev_mode == Number::rounding_mode::downward);
         {
             Case const c[]{
                 {Number{0}, 0},
@@ -1236,13 +1237,13 @@ public:
 
         switch (scale)
         {
-            case MantissaRange::small:
+            case MantissaRange::mantissa_scale::small:
 
                 test(Number::min(), "1e-32753");
                 test(Number::max(), "9999999999999999e32768");
                 test(Number::lowest(), "-9999999999999999e32768");
                 {
-                    NumberRoundModeGuard const mg(Number::towards_zero);
+                    NumberRoundModeGuard const mg(Number::rounding_mode::towards_zero);
 
                     auto const maxMantissa = Number::maxMantissa();
                     BEAST_EXPECT(maxMantissa == 9'999'999'999'999'999);
@@ -1265,14 +1266,14 @@ public:
                         "9223372036854775e3");
                 }
                 break;
-            case MantissaRange::large:
+            case MantissaRange::mantissa_scale::large:
                 // Test the edges
                 // ((exponent < -(28)) || (exponent > -(8)))))
                 test(Number::min(), "1e-32750");
                 test(Number::max(), "9223372036854775807e32768");
                 test(Number::lowest(), "-9223372036854775807e32768");
                 {
-                    NumberRoundModeGuard const mg(Number::towards_zero);
+                    NumberRoundModeGuard const mg(Number::rounding_mode::towards_zero);
 
                     auto const maxMantissa = Number::maxMantissa();
                     BEAST_EXPECT(maxMantissa == 9'999'999'999'999'999'999ULL);
@@ -1348,19 +1349,19 @@ public:
         NumberSO const stNumberSO{true};
         Issue const issue;
         Number const n{7'518'783'80596, -5};
-        saveNumberRoundMode const save{Number::setround(Number::to_nearest)};
+        saveNumberRoundMode const save{Number::setround(Number::rounding_mode::to_nearest)};
         auto res2 = STAmount{issue, n};
         BEAST_EXPECT(res2 == STAmount{7518784});
 
-        Number::setround(Number::towards_zero);
+        Number::setround(Number::rounding_mode::towards_zero);
         res2 = STAmount{issue, n};
         BEAST_EXPECT(res2 == STAmount{7518783});
 
-        Number::setround(Number::downward);
+        Number::setround(Number::rounding_mode::downward);
         res2 = STAmount{issue, n};
         BEAST_EXPECT(res2 == STAmount{7518783});
 
-        Number::setround(Number::upward);
+        Number::setround(Number::rounding_mode::upward);
         res2 = STAmount{issue, n};
         BEAST_EXPECT(res2 == STAmount{7518784});
     }
@@ -1400,87 +1401,87 @@ public:
         std::map<Number, NumberRoundings> const expected{
             // Positive numbers
             {Number{13, -1},
-             {{Number::to_nearest, 1},
-              {Number::towards_zero, 1},
-              {Number::downward, 1},
-              {Number::upward, 2}}},
+             {{Number::rounding_mode::to_nearest, 1},
+              {Number::rounding_mode::towards_zero, 1},
+              {Number::rounding_mode::downward, 1},
+              {Number::rounding_mode::upward, 2}}},
             {Number{23, -1},
-             {{Number::to_nearest, 2},
-              {Number::towards_zero, 2},
-              {Number::downward, 2},
-              {Number::upward, 3}}},
+             {{Number::rounding_mode::to_nearest, 2},
+              {Number::rounding_mode::towards_zero, 2},
+              {Number::rounding_mode::downward, 2},
+              {Number::rounding_mode::upward, 3}}},
             {Number{15, -1},
-             {{Number::to_nearest, 2},
-              {Number::towards_zero, 1},
-              {Number::downward, 1},
-              {Number::upward, 2}}},
+             {{Number::rounding_mode::to_nearest, 2},
+              {Number::rounding_mode::towards_zero, 1},
+              {Number::rounding_mode::downward, 1},
+              {Number::rounding_mode::upward, 2}}},
             {Number{25, -1},
-             {{Number::to_nearest, 2},
-              {Number::towards_zero, 2},
-              {Number::downward, 2},
-              {Number::upward, 3}}},
+             {{Number::rounding_mode::to_nearest, 2},
+              {Number::rounding_mode::towards_zero, 2},
+              {Number::rounding_mode::downward, 2},
+              {Number::rounding_mode::upward, 3}}},
             {Number{152, -2},
-             {{Number::to_nearest, 2},
-              {Number::towards_zero, 1},
-              {Number::downward, 1},
-              {Number::upward, 2}}},
+             {{Number::rounding_mode::to_nearest, 2},
+              {Number::rounding_mode::towards_zero, 1},
+              {Number::rounding_mode::downward, 1},
+              {Number::rounding_mode::upward, 2}}},
             {Number{252, -2},
-             {{Number::to_nearest, 3},
-              {Number::towards_zero, 2},
-              {Number::downward, 2},
-              {Number::upward, 3}}},
+             {{Number::rounding_mode::to_nearest, 3},
+              {Number::rounding_mode::towards_zero, 2},
+              {Number::rounding_mode::downward, 2},
+              {Number::rounding_mode::upward, 3}}},
             {Number{17, -1},
-             {{Number::to_nearest, 2},
-              {Number::towards_zero, 1},
-              {Number::downward, 1},
-              {Number::upward, 2}}},
+             {{Number::rounding_mode::to_nearest, 2},
+              {Number::rounding_mode::towards_zero, 1},
+              {Number::rounding_mode::downward, 1},
+              {Number::rounding_mode::upward, 2}}},
             {Number{27, -1},
-             {{Number::to_nearest, 3},
-              {Number::towards_zero, 2},
-              {Number::downward, 2},
-              {Number::upward, 3}}},
+             {{Number::rounding_mode::to_nearest, 3},
+              {Number::rounding_mode::towards_zero, 2},
+              {Number::rounding_mode::downward, 2},
+              {Number::rounding_mode::upward, 3}}},
 
             // Negative numbers
             {Number{-13, -1},
-             {{Number::to_nearest, -1},
-              {Number::towards_zero, -1},
-              {Number::downward, -2},
-              {Number::upward, -1}}},
+             {{Number::rounding_mode::to_nearest, -1},
+              {Number::rounding_mode::towards_zero, -1},
+              {Number::rounding_mode::downward, -2},
+              {Number::rounding_mode::upward, -1}}},
             {Number{-23, -1},
-             {{Number::to_nearest, -2},
-              {Number::towards_zero, -2},
-              {Number::downward, -3},
-              {Number::upward, -2}}},
+             {{Number::rounding_mode::to_nearest, -2},
+              {Number::rounding_mode::towards_zero, -2},
+              {Number::rounding_mode::downward, -3},
+              {Number::rounding_mode::upward, -2}}},
             {Number{-15, -1},
-             {{Number::to_nearest, -2},
-              {Number::towards_zero, -1},
-              {Number::downward, -2},
-              {Number::upward, -1}}},
+             {{Number::rounding_mode::to_nearest, -2},
+              {Number::rounding_mode::towards_zero, -1},
+              {Number::rounding_mode::downward, -2},
+              {Number::rounding_mode::upward, -1}}},
             {Number{-25, -1},
-             {{Number::to_nearest, -2},
-              {Number::towards_zero, -2},
-              {Number::downward, -3},
-              {Number::upward, -2}}},
+             {{Number::rounding_mode::to_nearest, -2},
+              {Number::rounding_mode::towards_zero, -2},
+              {Number::rounding_mode::downward, -3},
+              {Number::rounding_mode::upward, -2}}},
             {Number{-152, -2},
-             {{Number::to_nearest, -2},
-              {Number::towards_zero, -1},
-              {Number::downward, -2},
-              {Number::upward, -1}}},
+             {{Number::rounding_mode::to_nearest, -2},
+              {Number::rounding_mode::towards_zero, -1},
+              {Number::rounding_mode::downward, -2},
+              {Number::rounding_mode::upward, -1}}},
             {Number{-252, -2},
-             {{Number::to_nearest, -3},
-              {Number::towards_zero, -2},
-              {Number::downward, -3},
-              {Number::upward, -2}}},
+             {{Number::rounding_mode::to_nearest, -3},
+              {Number::rounding_mode::towards_zero, -2},
+              {Number::rounding_mode::downward, -3},
+              {Number::rounding_mode::upward, -2}}},
             {Number{-17, -1},
-             {{Number::to_nearest, -2},
-              {Number::towards_zero, -1},
-              {Number::downward, -2},
-              {Number::upward, -1}}},
+             {{Number::rounding_mode::to_nearest, -2},
+              {Number::rounding_mode::towards_zero, -1},
+              {Number::rounding_mode::downward, -2},
+              {Number::rounding_mode::upward, -1}}},
             {Number{-27, -1},
-             {{Number::to_nearest, -3},
-              {Number::towards_zero, -2},
-              {Number::downward, -3},
-              {Number::upward, -2}}},
+             {{Number::rounding_mode::to_nearest, -3},
+              {Number::rounding_mode::towards_zero, -2},
+              {Number::rounding_mode::downward, -3},
+              {Number::rounding_mode::upward, -2}}},
         };
 
         for (auto const& [num, roundings] : expected)
@@ -1491,8 +1492,8 @@ public:
                 auto const res = static_cast<std::int64_t>(num);
                 BEAST_EXPECTS(
                     res == val,
-                    to_string(num) + " with mode " + std::to_string(mode) + " expected " +
-                        std::to_string(val) + " got " + std::to_string(res));
+                    to_string(num) + " with mode " + std::to_string(static_cast<int>(mode)) +
+                        " expected " + std::to_string(val) + " got " + std::to_string(res));
             }
         }
     }
@@ -1508,7 +1509,7 @@ public:
         Number const ten{10};
         BEAST_EXPECT(ten.exponent() <= 0);
 
-        if (scale == MantissaRange::small)
+        if (scale == MantissaRange::mantissa_scale::small)
         {
             BEAST_EXPECT(std::numeric_limits<std::int64_t>::max() > INITIAL_XRP.drops());
             BEAST_EXPECT(Number::maxMantissa() < INITIAL_XRP.drops());
@@ -1537,7 +1538,7 @@ public:
             // 85'070'591'730'234'615'847'396'907'784'232'501'249 - 38 digits
             BEAST_EXPECT((power(maxInt64, 2) == Number{85'070'591'730'234'615'85, 19}));
 
-            NumberRoundModeGuard const mg(Number::towards_zero);
+            NumberRoundModeGuard const mg(Number::rounding_mode::towards_zero);
 
             auto const maxMantissa = Number::maxMantissa();
             Number const max = Number{false, maxMantissa, 0, Number::normalized{}};
@@ -1553,7 +1554,8 @@ public:
     void
     run() override
     {
-        for (auto const scale : {MantissaRange::small, MantissaRange::large})
+        for (auto const scale :
+             {MantissaRange::mantissa_scale::small, MantissaRange::mantissa_scale::large})
         {
             NumberMantissaScaleGuard const sg(scale);
             testZero();
diff --git a/src/test/beast/beast_io_latency_probe_test.cpp b/src/test/beast/beast_io_latency_probe_test.cpp
index dfd20eced0..206fdfc8b1 100644
--- a/src/test/beast/beast_io_latency_probe_test.cpp
+++ b/src/test/beast/beast_io_latency_probe_test.cpp
@@ -66,7 +66,7 @@ class io_latency_probe_test : public beast::unit_test::suite, public beast::test
                         wait_err = ec;
                     auto const end{MeasureClock::now()};
                     elapsed_times_.emplace_back(end - start);
-                    std::lock_guard const lk{mtx};
+                    std::scoped_lock const lk{mtx};
                     done = true;
                     cv.notify_one();
                 });
diff --git a/src/test/consensus/NegativeUNL_test.cpp b/src/test/consensus/NegativeUNL_test.cpp
index a3987e8136..bb1bcb0c0f 100644
--- a/src/test/consensus/NegativeUNL_test.cpp
+++ b/src/test/consensus/NegativeUNL_test.cpp
@@ -738,9 +738,9 @@ class NegativeUNLVoteInternal_test : public beast::unit_test::suite
         PublicKey const toReEnableKey(derivePublicKey(KeyType::ed25519, randomSecretKey()));
         LedgerIndex const seq(1234);
         BEAST_EXPECT(countTx(txSet) == 0);
-        vote.addTx(seq, toDisableKey, NegativeUNLVote::ToDisable, txSet);
+        vote.addTx(seq, toDisableKey, NegativeUNLVote::NegativeUNLModify::ToDisable, txSet);
         BEAST_EXPECT(countTx(txSet) == 1);
-        vote.addTx(seq, toReEnableKey, NegativeUNLVote::ToReEnable, txSet);
+        vote.addTx(seq, toReEnableKey, NegativeUNLVote::NegativeUNLModify::ToReEnable, txSet);
         BEAST_EXPECT(countTx(txSet) == 2);
         // content of a tx is implicitly tested after applied to a ledger
         // in later test cases
diff --git a/src/test/core/Coroutine_test.cpp b/src/test/core/Coroutine_test.cpp
index 38bafe08fd..9696451f6a 100644
--- a/src/test/core/Coroutine_test.cpp
+++ b/src/test/core/Coroutine_test.cpp
@@ -43,7 +43,7 @@ public:
         void
         signal()
         {
-            std::lock_guard const lk(mutex_);
+            std::scoped_lock const lk(mutex_);
             signaled_ = true;
             cv_.notify_all();
         }
diff --git a/src/test/core/Workers_test.cpp b/src/test/core/Workers_test.cpp
index a5b579e810..e8a9f21816 100644
--- a/src/test/core/Workers_test.cpp
+++ b/src/test/core/Workers_test.cpp
@@ -89,7 +89,7 @@ public:
         void
         processTask(int instance) override
         {
-            std::lock_guard const lk{mut};
+            std::scoped_lock const lk{mut};
             if (--count == 0)
                 cv.notify_all();
         }
diff --git a/src/test/jtx/AMMTest.h b/src/test/jtx/AMMTest.h
index 8f46ef6f59..ffb186e0d6 100644
--- a/src/test/jtx/AMMTest.h
+++ b/src/test/jtx/AMMTest.h
@@ -140,7 +140,7 @@ protected:
         void
         signal()
         {
-            std::lock_guard const lk(mutex_);
+            std::scoped_lock const lk(mutex_);
             signaled_ = true;
             cv_.notify_all();
         }
diff --git a/src/test/jtx/Account.h b/src/test/jtx/Account.h
index c702bcffec..a30b974522 100644
--- a/src/test/jtx/Account.h
+++ b/src/test/jtx/Account.h
@@ -52,7 +52,7 @@ public:
      * secret key is unavailable, such as for pseudo-accounts. */
     explicit Account(std::string name, AccountID const& id);
 
-    enum AcctStringType { base58Seed, other };
+    enum class AcctStringType { base58Seed, other };
     /** Create an account from a base58 seed string.  Throws on invalid seed. */
     Account(AcctStringType stringType, std::string base58SeedStr);
 
diff --git a/src/test/jtx/CaptureLogs.h b/src/test/jtx/CaptureLogs.h
index 0e9598decd..491a341540 100644
--- a/src/test/jtx/CaptureLogs.h
+++ b/src/test/jtx/CaptureLogs.h
@@ -36,14 +36,14 @@ class CaptureLogs : public Logs
         void
         write(beast::severities::Severity level, std::string const& text) override
         {
-            std::lock_guard const lock(strmMutex_);
+            std::scoped_lock const lock(strmMutex_);
             strm_ << text;
         }
 
         void
         writeAlways(beast::severities::Severity level, std::string const& text) override
         {
-            std::lock_guard const lock(strmMutex_);
+            std::scoped_lock const lock(strmMutex_);
             strm_ << text;
         }
     };
diff --git a/src/test/jtx/TestHelpers.h b/src/test/jtx/TestHelpers.h
index d87d9a4d79..3cb5f0c462 100644
--- a/src/test/jtx/TestHelpers.h
+++ b/src/test/jtx/TestHelpers.h
@@ -476,7 +476,7 @@ public:
     void
     signal()
     {
-        std::lock_guard const lk(mutex_);
+        std::scoped_lock const lk(mutex_);
         signaled_ = true;
         cv_.notify_all();
     }
diff --git a/src/test/jtx/directory.h b/src/test/jtx/directory.h
index 0940c23623..08d8fef73e 100644
--- a/src/test/jtx/directory.h
+++ b/src/test/jtx/directory.h
@@ -12,7 +12,7 @@
 /** Directory operations. */
 namespace xrpl::test::jtx::directory {
 
-enum Error {
+enum class Error {
     DirectoryRootNotFound,
     DirectoryTooSmall,
     DirectoryPageDuplicate,
diff --git a/src/test/jtx/impl/AMMTest.cpp b/src/test/jtx/impl/AMMTest.cpp
index 2ff261afe2..030651b275 100644
--- a/src/test/jtx/impl/AMMTest.cpp
+++ b/src/test/jtx/impl/AMMTest.cpp
@@ -138,7 +138,7 @@ AMMTestBase::testAMM(std::function<void(jtx::AMM&, jtx::Env&)> const& cb, TestAM
     for (auto const& features : arg.features)
     {
         // Use small Number mantissas for the life of this test.
-        NumberMantissaScaleGuard const sg{xrpl::MantissaRange::small};
+        NumberMantissaScaleGuard const sg{xrpl::MantissaRange::mantissa_scale::small};
 
         // For now, just disable SAV entirely, which locks in the small Number
         // mantissas
diff --git a/src/test/jtx/impl/Account.cpp b/src/test/jtx/impl/Account.cpp
index 4e09940487..e93e6c6068 100644
--- a/src/test/jtx/impl/Account.cpp
+++ b/src/test/jtx/impl/Account.cpp
@@ -50,7 +50,7 @@ Account::fromCache(AcctStringType stringType, std::string name, KeyType type)
 
     auto const keys = [stringType, &name, type]() {
         // Special handling for base58Seeds.
-        if (stringType == base58Seed)
+        if (stringType == AcctStringType::base58Seed)
         {
             std::optional<Seed> const seed = parseBase58<Seed>(name);
             if (!seed.has_value())
@@ -68,12 +68,15 @@ Account::fromCache(AcctStringType stringType, std::string name, KeyType type)
 }
 
 Account::Account(std::string name, KeyType type)
-    : Account(fromCache(Account::other, std::move(name), type))
+    : Account(fromCache(Account::AcctStringType::other, std::move(name), type))
 {
 }
 
 Account::Account(AcctStringType stringType, std::string base58SeedStr)
-    : Account(fromCache(Account::base58Seed, std::move(base58SeedStr), KeyType::secp256k1))
+    : Account(fromCache(
+          Account::AcctStringType::base58Seed,
+          std::move(base58SeedStr),
+          KeyType::secp256k1))
 {
 }
 
diff --git a/src/test/jtx/impl/WSClient.cpp b/src/test/jtx/impl/WSClient.cpp
index a7db5e4302..72f9e25b7c 100644
--- a/src/test/jtx/impl/WSClient.cpp
+++ b/src/test/jtx/impl/WSClient.cpp
@@ -304,7 +304,7 @@ private:
         rb_.consume(rb_.size());
         auto m = std::make_shared<msg>(std::move(jv));
         {
-            std::lock_guard const lock(m_);
+            std::scoped_lock const lock(m_);
             msgs_.push_front(m);
             cv_.notify_all();
         }
@@ -318,7 +318,7 @@ private:
     void
     on_read_done()
     {
-        std::lock_guard const lock(m0_);
+        std::scoped_lock const lock(m0_);
         b0_ = true;
         cv0_.notify_all();
     }
diff --git a/src/test/jtx/impl/directory.cpp b/src/test/jtx/impl/directory.cpp
index ac4d81bdfb..0d545bd6f4 100644
--- a/src/test/jtx/impl/directory.cpp
+++ b/src/test/jtx/impl/directory.cpp
@@ -36,7 +36,7 @@ bumpLastPage(
         auto sleRoot = sb.peek(directory);
         if (!sleRoot)
         {
-            res = Unexpected<Error>(DirectoryRootNotFound);
+            res = Unexpected<Error>(Error::DirectoryRootNotFound);
             return false;
         }
 
@@ -44,26 +44,26 @@ bumpLastPage(
         auto const lastIndex = sleRoot->getFieldU64(sfIndexPrevious);
         if (lastIndex == 0)
         {
-            res = Unexpected<Error>(DirectoryTooSmall);
+            res = Unexpected<Error>(Error::DirectoryTooSmall);
             return false;
         }
 
         if (sb.exists(keylet::page(directory, newLastPage)))
         {
-            res = Unexpected<Error>(DirectoryPageDuplicate);
+            res = Unexpected<Error>(Error::DirectoryPageDuplicate);
             return false;
         }
 
         if (lastIndex >= newLastPage)
         {
-            res = Unexpected<Error>(InvalidLastPage);
+            res = Unexpected<Error>(Error::InvalidLastPage);
             return false;
         }
 
         auto slePage = sb.peek(keylet::page(directory, lastIndex));
         if (!slePage)
         {
-            res = Unexpected<Error>(DirectoryPageNotFound);
+            res = Unexpected<Error>(Error::DirectoryPageNotFound);
             return false;
         }
 
@@ -94,7 +94,7 @@ bumpLastPage(
             auto slePrev = sb.peek(keylet::page(directory, *prevIndex));
             if (!slePrev)
             {
-                res = Unexpected<Error>(DirectoryPageNotFound);
+                res = Unexpected<Error>(Error::DirectoryPageNotFound);
                 return false;
             }
             slePrev->setFieldU64(sfIndexNext, newLastPage);
@@ -109,7 +109,7 @@ bumpLastPage(
             {
                 if (!adjust(sb, key, newLastPage))
                 {
-                    res = Unexpected<Error>(AdjustmentError);
+                    res = Unexpected<Error>(Error::AdjustmentError);
                     return false;
                 }
             }
diff --git a/src/test/jtx/impl/ledgerStateFixes.cpp b/src/test/jtx/impl/ledgerStateFixes.cpp
index 99cd03cbb6..bc19915957 100644
--- a/src/test/jtx/impl/ledgerStateFixes.cpp
+++ b/src/test/jtx/impl/ledgerStateFixes.cpp
@@ -6,6 +6,8 @@
 #include <xrpl/protocol/jss.h>
 #include <xrpl/tx/transactors/system/LedgerStateFix.h>
 
+#include <cstdint>
+
 namespace xrpl::test::jtx::ledgerStateFix {
 
 // Fix NFTokenPage links on owner's account.  acct pays fee.
@@ -14,7 +16,8 @@ nftPageLinks(jtx::Account const& acct, jtx::Account const& owner)
 {
     Json::Value jv;
     jv[sfAccount.jsonName] = acct.human();
-    jv[sfLedgerFixType.jsonName] = LedgerStateFix::nfTokenPageLink;
+    jv[sfLedgerFixType.jsonName] =
+        static_cast<std::uint16_t>(LedgerStateFix::FixType::nfTokenPageLink);
     jv[sfOwner.jsonName] = owner.human();
     jv[sfTransactionType.jsonName] = jss::LedgerStateFix;
     return jv;
diff --git a/src/test/ledger/PaymentSandbox_test.cpp b/src/test/ledger/PaymentSandbox_test.cpp
index b78f3eb42a..f28d8a7d19 100644
--- a/src/test/ledger/PaymentSandbox_test.cpp
+++ b/src/test/ledger/PaymentSandbox_test.cpp
@@ -127,21 +127,23 @@ class PaymentSandbox_test : public beast::unit_test::suite
             ApplyViewImpl av(&*env.current(), tapNONE);
 
             auto const iss = USD_gw1;
-            auto const startingAmount =
-                accountHolds(av, alice, iss.currency, iss.account, fhIGNORE_FREEZE, j);
+            auto const startingAmount = accountHolds(
+                av, alice, iss.currency, iss.account, FreezeHandling::fhIGNORE_FREEZE, j);
             {
                 auto r = accountSend(av, gw1, alice, toCredit, j);
                 BEAST_EXPECT(isTesSuccess(r));
             }
             BEAST_EXPECT(
-                accountHolds(av, alice, iss.currency, iss.account, fhIGNORE_FREEZE, j) ==
+                accountHolds(
+                    av, alice, iss.currency, iss.account, FreezeHandling::fhIGNORE_FREEZE, j) ==
                 startingAmount + toCredit);
             {
                 auto r = accountSend(av, alice, gw1, toDebit, j);
                 BEAST_EXPECT(isTesSuccess(r));
             }
             BEAST_EXPECT(
-                accountHolds(av, alice, iss.currency, iss.account, fhIGNORE_FREEZE, j) ==
+                accountHolds(
+                    av, alice, iss.currency, iss.account, FreezeHandling::fhIGNORE_FREEZE, j) ==
                 startingAmount + toCredit - toDebit);
         }
 
@@ -150,17 +152,19 @@ class PaymentSandbox_test : public beast::unit_test::suite
             ApplyViewImpl av(&*env.current(), tapNONE);
 
             auto const iss = USD_gw1;
-            auto const startingAmount =
-                accountHolds(av, alice, iss.currency, iss.account, fhIGNORE_FREEZE, j);
+            auto const startingAmount = accountHolds(
+                av, alice, iss.currency, iss.account, FreezeHandling::fhIGNORE_FREEZE, j);
 
             directSendNoFee(av, gw1, alice, toCredit, true, j);
             BEAST_EXPECT(
-                accountHolds(av, alice, iss.currency, iss.account, fhIGNORE_FREEZE, j) ==
+                accountHolds(
+                    av, alice, iss.currency, iss.account, FreezeHandling::fhIGNORE_FREEZE, j) ==
                 startingAmount + toCredit);
 
             directSendNoFee(av, alice, gw1, toDebit, true, j);
             BEAST_EXPECT(
-                accountHolds(av, alice, iss.currency, iss.account, fhIGNORE_FREEZE, j) ==
+                accountHolds(
+                    av, alice, iss.currency, iss.account, FreezeHandling::fhIGNORE_FREEZE, j) ==
                 startingAmount + toCredit - toDebit);
         }
 
@@ -170,15 +174,16 @@ class PaymentSandbox_test : public beast::unit_test::suite
             PaymentSandbox pv(&av);
 
             auto const iss = USD_gw1;
-            auto const startingAmount =
-                accountHolds(pv, alice, iss.currency, iss.account, fhIGNORE_FREEZE, j);
+            auto const startingAmount = accountHolds(
+                pv, alice, iss.currency, iss.account, FreezeHandling::fhIGNORE_FREEZE, j);
 
             {
                 auto r = accountSend(pv, gw1, alice, toCredit, j);
                 BEAST_EXPECT(isTesSuccess(r));
             }
             BEAST_EXPECT(
-                accountHolds(pv, alice, iss.currency, iss.account, fhIGNORE_FREEZE, j) ==
+                accountHolds(
+                    pv, alice, iss.currency, iss.account, FreezeHandling::fhIGNORE_FREEZE, j) ==
                 startingAmount);
 
             {
@@ -186,7 +191,8 @@ class PaymentSandbox_test : public beast::unit_test::suite
                 BEAST_EXPECT(isTesSuccess(r));
             }
             BEAST_EXPECT(
-                accountHolds(pv, alice, iss.currency, iss.account, fhIGNORE_FREEZE, j) ==
+                accountHolds(
+                    pv, alice, iss.currency, iss.account, FreezeHandling::fhIGNORE_FREEZE, j) ==
                 startingAmount - toDebit);
         }
 
@@ -196,12 +202,13 @@ class PaymentSandbox_test : public beast::unit_test::suite
             PaymentSandbox pv(&av);
 
             auto const iss = USD_gw1;
-            auto const startingAmount =
-                accountHolds(pv, alice, iss.currency, iss.account, fhIGNORE_FREEZE, j);
+            auto const startingAmount = accountHolds(
+                pv, alice, iss.currency, iss.account, FreezeHandling::fhIGNORE_FREEZE, j);
 
             directSendNoFee(pv, gw1, alice, toCredit, true, j);
             BEAST_EXPECT(
-                accountHolds(pv, alice, iss.currency, iss.account, fhIGNORE_FREEZE, j) ==
+                accountHolds(
+                    pv, alice, iss.currency, iss.account, FreezeHandling::fhIGNORE_FREEZE, j) ==
                 startingAmount);
         }
 
@@ -211,12 +218,13 @@ class PaymentSandbox_test : public beast::unit_test::suite
             PaymentSandbox pv(&av);
 
             auto const iss = USD_gw1;
-            auto const startingAmount =
-                accountHolds(pv, alice, iss.currency, iss.account, fhIGNORE_FREEZE, j);
+            auto const startingAmount = accountHolds(
+                pv, alice, iss.currency, iss.account, FreezeHandling::fhIGNORE_FREEZE, j);
 
             BEAST_EXPECT(redeemIOU(pv, alice, toDebit, iss, j) == tesSUCCESS);
             BEAST_EXPECT(
-                accountHolds(pv, alice, iss.currency, iss.account, fhIGNORE_FREEZE, j) ==
+                accountHolds(
+                    pv, alice, iss.currency, iss.account, FreezeHandling::fhIGNORE_FREEZE, j) ==
                 startingAmount - toDebit);
         }
 
@@ -226,12 +234,13 @@ class PaymentSandbox_test : public beast::unit_test::suite
             PaymentSandbox pv(&av);
 
             auto const iss = USD_gw1;
-            auto const startingAmount =
-                accountHolds(pv, alice, iss.currency, iss.account, fhIGNORE_FREEZE, j);
+            auto const startingAmount = accountHolds(
+                pv, alice, iss.currency, iss.account, FreezeHandling::fhIGNORE_FREEZE, j);
 
             BEAST_EXPECT(issueIOU(pv, alice, toCredit, iss, j) == tesSUCCESS);
             BEAST_EXPECT(
-                accountHolds(pv, alice, iss.currency, iss.account, fhIGNORE_FREEZE, j) ==
+                accountHolds(
+                    pv, alice, iss.currency, iss.account, FreezeHandling::fhIGNORE_FREEZE, j) ==
                 startingAmount);
         }
 
@@ -241,29 +250,40 @@ class PaymentSandbox_test : public beast::unit_test::suite
             PaymentSandbox pv(&av);
 
             auto const iss = USD_gw1;
-            auto const startingAmount =
-                accountHolds(pv, alice, iss.currency, iss.account, fhIGNORE_FREEZE, j);
+            auto const startingAmount = accountHolds(
+                pv, alice, iss.currency, iss.account, FreezeHandling::fhIGNORE_FREEZE, j);
 
             {
                 auto r = accountSend(pv, gw1, alice, toCredit, j);
                 BEAST_EXPECT(isTesSuccess(r));
             }
             BEAST_EXPECT(
-                accountHolds(pv, alice, iss.currency, iss.account, fhIGNORE_FREEZE, j) ==
+                accountHolds(
+                    pv, alice, iss.currency, iss.account, FreezeHandling::fhIGNORE_FREEZE, j) ==
                 startingAmount);
 
             {
                 PaymentSandbox pv2(&pv);
                 BEAST_EXPECT(
-                    accountHolds(pv2, alice, iss.currency, iss.account, fhIGNORE_FREEZE, j) ==
-                    startingAmount);
+                    accountHolds(
+                        pv2,
+                        alice,
+                        iss.currency,
+                        iss.account,
+                        FreezeHandling::fhIGNORE_FREEZE,
+                        j) == startingAmount);
                 {
                     auto r = accountSend(pv2, gw1, alice, toCredit, j);
                     BEAST_EXPECT(isTesSuccess(r));
                 }
                 BEAST_EXPECT(
-                    accountHolds(pv2, alice, iss.currency, iss.account, fhIGNORE_FREEZE, j) ==
-                    startingAmount);
+                    accountHolds(
+                        pv2,
+                        alice,
+                        iss.currency,
+                        iss.account,
+                        FreezeHandling::fhIGNORE_FREEZE,
+                        j) == startingAmount);
             }
 
             {
@@ -271,7 +291,8 @@ class PaymentSandbox_test : public beast::unit_test::suite
                 BEAST_EXPECT(isTesSuccess(r));
             }
             BEAST_EXPECT(
-                accountHolds(pv, alice, iss.currency, iss.account, fhIGNORE_FREEZE, j) ==
+                accountHolds(
+                    pv, alice, iss.currency, iss.account, FreezeHandling::fhIGNORE_FREEZE, j) ==
                 startingAmount - toDebit);
         }
     }
@@ -313,8 +334,8 @@ class PaymentSandbox_test : public beast::unit_test::suite
 
         auto accountFundsXRP =
             [](ReadView const& view, AccountID const& id, beast::Journal j) -> XRPAmount {
-            return toAmount<XRPAmount>(
-                accountHolds(view, id, xrpCurrency(), xrpAccount(), fhZERO_IF_FROZEN, j));
+            return toAmount<XRPAmount>(accountHolds(
+                view, id, xrpCurrency(), xrpAccount(), FreezeHandling::fhZERO_IF_FROZEN, j));
         };
 
         auto reserve = [](jtx::Env& env, std::uint32_t count) -> XRPAmount {
diff --git a/src/test/ledger/View_test.cpp b/src/test/ledger/View_test.cpp
index cf2e478889..e0d757c0d3 100644
--- a/src/test/ledger/View_test.cpp
+++ b/src/test/ledger/View_test.cpp
@@ -787,7 +787,12 @@ class View_test : public beast::unit_test::suite
             BEAST_EXPECT(
                 USD(0) ==
                 accountHolds(
-                    *env.closed(), alice, USD.currency, gw, fhZERO_IF_FROZEN, env.journal));
+                    *env.closed(),
+                    alice,
+                    USD.currency,
+                    gw,
+                    FreezeHandling::fhZERO_IF_FROZEN,
+                    env.journal));
 
             // Thaw gw and try again.
             env(fclear(gw, asfGlobalFreeze));
@@ -806,14 +811,26 @@ class View_test : public beast::unit_test::suite
             // Bob's balance should be zero if frozen.
             BEAST_EXPECT(
                 USD(0) ==
-                accountHolds(*env.closed(), bob, USD.currency, gw, fhZERO_IF_FROZEN, env.journal));
+                accountHolds(
+                    *env.closed(),
+                    bob,
+                    USD.currency,
+                    gw,
+                    FreezeHandling::fhZERO_IF_FROZEN,
+                    env.journal));
 
             // gw thaws bob's trust line.  bob gets his money back.
             env(trust(gw, USD(100), bob, tfClearFreeze));
             env.close();
             BEAST_EXPECT(
                 USD(50) ==
-                accountHolds(*env.closed(), bob, USD.currency, gw, fhZERO_IF_FROZEN, env.journal));
+                accountHolds(
+                    *env.closed(),
+                    bob,
+                    USD.currency,
+                    gw,
+                    FreezeHandling::fhZERO_IF_FROZEN,
+                    env.journal));
         }
         {
             // accountHolds().
@@ -824,17 +841,32 @@ class View_test : public beast::unit_test::suite
             BEAST_EXPECT(
                 EUR(0) ==
                 accountHolds(
-                    *env.closed(), carol, EUR.currency, gw, fhZERO_IF_FROZEN, env.journal));
+                    *env.closed(),
+                    carol,
+                    EUR.currency,
+                    gw,
+                    FreezeHandling::fhZERO_IF_FROZEN,
+                    env.journal));
 
             // But carol does have USD.
             BEAST_EXPECT(
                 USD(50) ==
                 accountHolds(
-                    *env.closed(), carol, USD.currency, gw, fhZERO_IF_FROZEN, env.journal));
+                    *env.closed(),
+                    carol,
+                    USD.currency,
+                    gw,
+                    FreezeHandling::fhZERO_IF_FROZEN,
+                    env.journal));
 
             // carol's XRP balance should be her holdings minus her reserve.
             auto const carolsXRP = accountHolds(
-                *env.closed(), carol, xrpCurrency(), xrpAccount(), fhZERO_IF_FROZEN, env.journal);
+                *env.closed(),
+                carol,
+                xrpCurrency(),
+                xrpAccount(),
+                FreezeHandling::fhZERO_IF_FROZEN,
+                env.journal);
             // carol's XRP balance:              10000
             // base reserve:                      -200
             // 1 trust line times its reserve: 1 * -50
@@ -851,28 +883,35 @@ class View_test : public beast::unit_test::suite
             BEAST_EXPECT(
                 XRP(0) ==
                 accountHolds(
-                    *env.closed(), carol, xrpCurrency(), gw, fhZERO_IF_FROZEN, env.journal));
+                    *env.closed(),
+                    carol,
+                    xrpCurrency(),
+                    gw,
+                    FreezeHandling::fhZERO_IF_FROZEN,
+                    env.journal));
         }
         {
             // accountFunds().
             // Gateways have whatever funds they claim to have.
-            auto const gwUSD =
-                accountFunds(*env.closed(), gw, USD(314159), fhZERO_IF_FROZEN, env.journal);
+            auto const gwUSD = accountFunds(
+                *env.closed(), gw, USD(314159), FreezeHandling::fhZERO_IF_FROZEN, env.journal);
             BEAST_EXPECT(gwUSD == USD(314159));
 
             // carol has funds from the gateway.
-            auto carolsUSD =
-                accountFunds(*env.closed(), carol, USD(0), fhZERO_IF_FROZEN, env.journal);
+            auto carolsUSD = accountFunds(
+                *env.closed(), carol, USD(0), FreezeHandling::fhZERO_IF_FROZEN, env.journal);
             BEAST_EXPECT(carolsUSD == USD(50));
 
             // If carol's funds are frozen she has no funds...
             env(fset(gw, asfGlobalFreeze));
             env.close();
-            carolsUSD = accountFunds(*env.closed(), carol, USD(0), fhZERO_IF_FROZEN, env.journal);
+            carolsUSD = accountFunds(
+                *env.closed(), carol, USD(0), FreezeHandling::fhZERO_IF_FROZEN, env.journal);
             BEAST_EXPECT(carolsUSD == USD(0));
 
             // ... unless the query ignores the FROZEN state.
-            carolsUSD = accountFunds(*env.closed(), carol, USD(0), fhIGNORE_FREEZE, env.journal);
+            carolsUSD = accountFunds(
+                *env.closed(), carol, USD(0), FreezeHandling::fhIGNORE_FREEZE, env.journal);
             BEAST_EXPECT(carolsUSD == USD(50));
 
             // Just to be tidy, thaw gw.
diff --git a/src/test/nodestore/TestBase.h b/src/test/nodestore/TestBase.h
index e527942629..8ea32517d5 100644
--- a/src/test/nodestore/TestBase.h
+++ b/src/test/nodestore/TestBase.h
@@ -67,16 +67,16 @@ public:
                 switch (rand_int(rng, 3))
                 {
                     case 0:
-                        return hotLEDGER;
+                        return NodeObjectType::hotLEDGER;
                     case 1:
-                        return hotACCOUNT_NODE;
+                        return NodeObjectType::hotACCOUNT_NODE;
                     case 2:
-                        return hotTRANSACTION_NODE;
+                        return NodeObjectType::hotTRANSACTION_NODE;
                     case 3:
-                        return hotUNKNOWN;
+                        return NodeObjectType::hotUNKNOWN;
                     default:
                         // will never happen, but make static analysis tool happy.
-                        return hotUNKNOWN;
+                        return NodeObjectType::hotUNKNOWN;
                 }
             }();
 
@@ -140,9 +140,9 @@ public:
 
             Status const status = backend.fetch(batch[i]->getHash(), &object);
 
-            BEAST_EXPECT(status == ok);
+            BEAST_EXPECT(status == Status::ok);
 
-            if (status == ok)
+            if (status == Status::ok)
             {
                 BEAST_EXPECT(object != nullptr);
 
@@ -160,7 +160,7 @@ public:
 
             Status const status = backend.fetch(batch[i]->getHash(), &object);
 
-            BEAST_EXPECT(status == notFound);
+            BEAST_EXPECT(status == Status::notFound);
         }
     }
 
diff --git a/src/test/nodestore/Timing_test.cpp b/src/test/nodestore/Timing_test.cpp
index cc9881dbac..1145bc80f4 100644
--- a/src/test/nodestore/Timing_test.cpp
+++ b/src/test/nodestore/Timing_test.cpp
@@ -77,6 +77,8 @@ rngcpy(void* buffer, std::size_t bytes, Generator& g)
 class Sequence
 {
 private:
+    // Need to be named before converting
+    // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
     enum { minLedger = 1, maxLedger = 1000000, minSize = 250, maxSize = 1250 };
 
     beast::xor_shift_engine gen_;
@@ -135,6 +137,8 @@ public:
 class Timing_test : public beast::unit_test::suite
 {
 public:
+    // Need to be named before converting
+    // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
     enum {
         // percent of fetches for missing nodes
         missingNodePercent = 20
@@ -678,7 +682,7 @@ public:
     void
     run() override
     {
-        testcase("Timing", beast::unit_test::abort_on_fail);
+        testcase("Timing", beast::unit_test::abort_t::abort_on_fail);
 
         /*  Parameters:
 
diff --git a/src/test/nodestore/import_test.cpp b/src/test/nodestore/import_test.cpp
index 1341b98894..359f27ef7d 100644
--- a/src/test/nodestore/import_test.cpp
+++ b/src/test/nodestore/import_test.cpp
@@ -288,7 +288,7 @@ public:
     void
     run() override
     {
-        testcase(beast::unit_test::abort_on_fail) << arg();
+        testcase(beast::unit_test::abort_t::abort_on_fail) << arg();
 
         using namespace nudb;
         using namespace nudb::detail;
diff --git a/src/test/overlay/TMGetObjectByHash_test.cpp b/src/test/overlay/TMGetObjectByHash_test.cpp
index c1db5262d0..e42d4ffe75 100644
--- a/src/test/overlay/TMGetObjectByHash_test.cpp
+++ b/src/test/overlay/TMGetObjectByHash_test.cpp
@@ -158,7 +158,8 @@ class TMGetObjectByHash_test : public beast::unit_test::suite
             hashes.push_back(hash);
 
             Blob data(100, static_cast<unsigned char>(i % 256));
-            nodeStore.store(hotLEDGER, std::move(data), hash, nodeStore.earliestLedgerSeq());
+            nodeStore.store(
+                NodeObjectType::hotLEDGER, std::move(data), hash, nodeStore.earliestLedgerSeq());
         }
 
         // Create a request with more objects than hardMaxReplyNodes
diff --git a/src/test/overlay/reduce_relay_test.cpp b/src/test/overlay/reduce_relay_test.cpp
index 21f3482ab5..1a650655f2 100644
--- a/src/test/overlay/reduce_relay_test.cpp
+++ b/src/test/overlay/reduce_relay_test.cpp
@@ -913,8 +913,8 @@ protected:
         return sp->id();
     }
 
-    enum State { On, Off, WaitReset };
-    enum EventType { LinkDown = 0, PeerDisconnected = 1 };
+    enum class State { On, Off, WaitReset };
+    enum class EventType { LinkDown = 0, PeerDisconnected = 1 };
     // Link down or Peer disconnect event
     // TBD - add new peer event
     // TBD - add overlapping type of events at any
@@ -938,7 +938,8 @@ protected:
     void
     random(bool log)
     {
-        std::unordered_map<EventType, Event> events{{LinkDown, {}}, {PeerDisconnected, {}}};
+        std::unordered_map<EventType, Event> events{
+            {EventType::LinkDown, {}}, {EventType::PeerDisconnected, {}}};
         time_point<ManualClock> lastCheck = ManualClock::now();
 
         network_.reset();
diff --git a/src/test/overlay/short_read_test.cpp b/src/test/overlay/short_read_test.cpp
index 02c9312732..42959000a1 100644
--- a/src/test/overlay/short_read_test.cpp
+++ b/src/test/overlay/short_read_test.cpp
@@ -118,14 +118,14 @@ private:
         void
         add(std::shared_ptr<Child> const& child)
         {
-            std::lock_guard const lock(mutex_);
+            std::scoped_lock const lock(mutex_);
             list_.emplace(child.get(), child);
         }
 
         void
         remove(Child* child)
         {
-            std::lock_guard const lock(mutex_);
+            std::scoped_lock const lock(mutex_);
             list_.erase(child);
             if (list_.empty())
                 cond_.notify_one();
@@ -136,7 +136,7 @@ private:
         {
             std::vector<std::shared_ptr<Child>> v;
             {
-                std::lock_guard const lock(mutex_);
+                std::scoped_lock const lock(mutex_);
                 v.reserve(list_.size());
                 if (closed_)
                     return;
diff --git a/src/test/protocol/MultiApiJson_test.cpp b/src/test/protocol/MultiApiJson_test.cpp
index f0cbf805f3..f9f1ff1373 100644
--- a/src/test/protocol/MultiApiJson_test.cpp
+++ b/src/test/protocol/MultiApiJson_test.cpp
@@ -308,15 +308,15 @@ struct MultiApiJson_test : beast::unit_test::suite
             testcase("isMember");
 
             // Well defined behaviour even if we have different types of members
-            BEAST_EXPECT(subject.isMember("foo") == decltype(subject)::none);
+            BEAST_EXPECT(subject.isMember("foo") == decltype(subject)::IsMemberResult::none);
 
             {
                 // All variants have element "One", none have element "Two"
                 MultiApiJson<1, 2> s1{};
                 s1.val[0] = makeJson("One", 12);
                 s1.val[1] = makeJson("One", 42);
-                BEAST_EXPECT(s1.isMember("One") == decltype(s1)::all);
-                BEAST_EXPECT(s1.isMember("Two") == decltype(s1)::none);
+                BEAST_EXPECT(s1.isMember("One") == decltype(s1)::IsMemberResult::all);
+                BEAST_EXPECT(s1.isMember("Two") == decltype(s1)::IsMemberResult::none);
             }
 
             {
@@ -324,8 +324,8 @@ struct MultiApiJson_test : beast::unit_test::suite
                 MultiApiJson<1, 2> s2{};
                 s2.val[0] = makeJson("One", 12);
                 s2.val[1] = makeJson("Two", 42);
-                BEAST_EXPECT(s2.isMember("One") == decltype(s2)::some);
-                BEAST_EXPECT(s2.isMember("Two") == decltype(s2)::some);
+                BEAST_EXPECT(s2.isMember("One") == decltype(s2)::IsMemberResult::some);
+                BEAST_EXPECT(s2.isMember("Two") == decltype(s2)::IsMemberResult::some);
             }
 
             {
@@ -333,8 +333,8 @@ struct MultiApiJson_test : beast::unit_test::suite
                 MultiApiJson<1, 3> s3{};
                 s3.val[0] = makeJson("One", 12);
                 s3.val[1] = makeJson("One", 42);
-                BEAST_EXPECT(s3.isMember("One") == decltype(s3)::some);
-                BEAST_EXPECT(s3.isMember("Two") == decltype(s3)::none);
+                BEAST_EXPECT(s3.isMember("One") == decltype(s3)::IsMemberResult::some);
+                BEAST_EXPECT(s3.isMember("Two") == decltype(s3)::IsMemberResult::none);
             }
         }
 
diff --git a/src/test/protocol/STNumber_test.cpp b/src/test/protocol/STNumber_test.cpp
index 156f5b42aa..e2c1a91e64 100644
--- a/src/test/protocol/STNumber_test.cpp
+++ b/src/test/protocol/STNumber_test.cpp
@@ -101,12 +101,12 @@ struct STNumber_test : public beast::unit_test::suite
             BEAST_EXPECT(numberFromJson(sfNumber, "-0.000e6") == STNumber(sfNumber, 0));
 
             {
-                NumberRoundModeGuard const mg(Number::towards_zero);
+                NumberRoundModeGuard const mg(Number::rounding_mode::towards_zero);
                 // maxint64 9,223,372,036,854,775,807
                 auto const maxInt = std::to_string(std::numeric_limits<std::int64_t>::max());
                 // minint64 -9,223,372,036,854,775,808
                 auto const minInt = std::to_string(std::numeric_limits<std::int64_t>::min());
-                if (Number::getMantissaScale() == MantissaRange::small)
+                if (Number::getMantissaScale() == MantissaRange::mantissa_scale::small)
                 {
                     BEAST_EXPECT(
                         numberFromJson(sfNumber, maxInt) ==
@@ -280,7 +280,8 @@ struct STNumber_test : public beast::unit_test::suite
     {
         static_assert(!std::is_convertible_v<STNumber*, Number*>);
 
-        for (auto const scale : {MantissaRange::small, MantissaRange::large})
+        for (auto const scale :
+             {MantissaRange::mantissa_scale::small, MantissaRange::mantissa_scale::large})
         {
             NumberMantissaScaleGuard const sg(scale);
             testcase << to_string(Number::getMantissaScale());
diff --git a/src/test/protocol/SeqProxy_test.cpp b/src/test/protocol/SeqProxy_test.cpp
index d0764d7399..71b483425b 100644
--- a/src/test/protocol/SeqProxy_test.cpp
+++ b/src/test/protocol/SeqProxy_test.cpp
@@ -14,7 +14,7 @@ struct SeqProxy_test : public beast::unit_test::suite
     static constexpr bool
     expectValues(SeqProxy seqProx, std::uint32_t value, SeqProxy::Type type)
     {
-        bool const expectSeq{type == SeqProxy::seq};
+        bool const expectSeq{type == SeqProxy::Type::seq};
         return (seqProx.value() == value) && (seqProx.isSeq() == expectSeq) &&
             (seqProx.isTicket() == !expectSeq);
     }
@@ -65,8 +65,8 @@ struct SeqProxy_test : public beast::unit_test::suite
         // expected in the wild.  Nevertheless they are tested here.
         // But so are values of 1, which are expected to occur in the wild.
         static constexpr std::uint32_t uintMax{std::numeric_limits<std::uint32_t>::max()};
-        static constexpr SeqProxy::Type seq{SeqProxy::seq};
-        static constexpr SeqProxy::Type ticket{SeqProxy::ticket};
+        static constexpr SeqProxy::Type seq{SeqProxy::Type::seq};
+        static constexpr SeqProxy::Type ticket{SeqProxy::Type::ticket};
 
         static constexpr SeqProxy seqZero{seq, 0};
         static constexpr SeqProxy seqSmall{seq, 1};
diff --git a/src/test/resource/Logic_test.cpp b/src/test/resource/Logic_test.cpp
index f6da313b22..53fb81e436 100644
--- a/src/test/resource/Logic_test.cpp
+++ b/src/test/resource/Logic_test.cpp
@@ -114,7 +114,7 @@ public:
                     return;
                 }
 
-                if (c.charge(fee) == warn)
+                if (c.charge(fee) == Disposition::warn)
                 {
                     if (limited)
                     {
@@ -145,7 +145,7 @@ public:
                     return;
                 }
 
-                if (c.charge(fee) == drop)
+                if (c.charge(fee) == Disposition::drop)
                 {
                     // Disconnect abusive Consumer
                     BEAST_EXPECT(c.disconnect(j) == limited);
@@ -159,7 +159,7 @@ public:
         {
             Consumer const c(logic.newInboundEndpoint(addr));
             logic.periodicActivity();
-            if (c.disposition() != drop)
+            if (c.disposition() != Disposition::drop)
             {
                 if (limited)
                 {
@@ -185,7 +185,7 @@ public:
                 ++logic.clock();
                 logic.periodicActivity();
                 Consumer const c(logic.newInboundEndpoint(addr));
-                if (c.disposition() != drop)
+                if (c.disposition() != Disposition::drop)
                 {
                     readmitted = true;
                     break;
diff --git a/src/test/rpc/AMMInfo_test.cpp b/src/test/rpc/AMMInfo_test.cpp
index 876c9b66f1..726d23db1d 100644
--- a/src/test/rpc/AMMInfo_test.cpp
+++ b/src/test/rpc/AMMInfo_test.cpp
@@ -37,13 +37,13 @@ public:
         using namespace jtx;
 
         Account const bogie("bogie");
-        enum TestAccount { None, Alice, Bogie };
+        enum class TestAccount { None, Alice, Bogie };
         auto accountId = [&](AMM const& ammAlice, TestAccount v) -> std::optional<AccountID> {
-            if (v == Alice)
+            if (v == TestAccount::Alice)
             {
                 return ammAlice.ammAccount();
             }
-            if (v == Bogie)
+            if (v == TestAccount::Bogie)
             {
                 return bogie;
             }
@@ -67,12 +67,12 @@ public:
 
         std::vector<std::tuple<std::optional<Issue>, std::optional<Issue>, TestAccount, bool>> const
             invalidParams = {
-                {xrpIssue(), std::nullopt, None, false},
-                {std::nullopt, USD, None, false},
-                {xrpIssue(), std::nullopt, Alice, false},
-                {std::nullopt, USD, Alice, false},
-                {xrpIssue(), USD, Alice, false},
-                {std::nullopt, std::nullopt, None, true}};
+                {xrpIssue(), std::nullopt, TestAccount::None, false},
+                {std::nullopt, USD, TestAccount::None, false},
+                {xrpIssue(), std::nullopt, TestAccount::Alice, false},
+                {std::nullopt, USD, TestAccount::Alice, false},
+                {xrpIssue(), USD, TestAccount::Alice, false},
+                {std::nullopt, std::nullopt, TestAccount::None, true}};
 
         // Invalid parameters
         testAMM([&](AMM& ammAlice, Env&) {
@@ -129,12 +129,12 @@ public:
 
         std::vector<std::tuple<std::optional<Issue>, std::optional<Issue>, TestAccount, bool>> const
             invalidParamsBadAccount = {
-                {xrpIssue(), std::nullopt, None, false},
-                {std::nullopt, USD, None, false},
-                {xrpIssue(), std::nullopt, Bogie, false},
-                {std::nullopt, USD, Bogie, false},
-                {xrpIssue(), USD, Bogie, false},
-                {std::nullopt, std::nullopt, None, true}};
+                {xrpIssue(), std::nullopt, TestAccount::None, false},
+                {std::nullopt, USD, TestAccount::None, false},
+                {xrpIssue(), std::nullopt, TestAccount::Bogie, false},
+                {std::nullopt, USD, TestAccount::Bogie, false},
+                {xrpIssue(), USD, TestAccount::Bogie, false},
+                {std::nullopt, std::nullopt, TestAccount::None, true}};
 
         // Invalid parameters *and* invalid AMM account, default API version
         testAMM([&](AMM& ammAlice, Env&) {
@@ -165,8 +165,8 @@ public:
                     3);
                 BEAST_EXPECT(
                     jv[jss::error_message] ==
-                    (acct == Bogie ? std::string("Account malformed.")
-                                   : std::string("Invalid parameters.")));
+                    (acct == TestAccount::Bogie ? std::string("Account malformed.")
+                                                : std::string("Invalid parameters.")));
             }
         });
     }
diff --git a/src/test/rpc/GetAggregatePrice_test.cpp b/src/test/rpc/GetAggregatePrice_test.cpp
index f4473c0aa3..ea8c498619 100644
--- a/src/test/rpc/GetAggregatePrice_test.cpp
+++ b/src/test/rpc/GetAggregatePrice_test.cpp
@@ -177,7 +177,8 @@ public:
             auto const all = testable_amendments();
             for (auto const& feats : {all - featureSingleAssetVault - featureLendingProtocol, all})
             {
-                for (auto const mantissaSize : {MantissaRange::small, MantissaRange::large})
+                for (auto const mantissaSize :
+                     {MantissaRange::mantissa_scale::small, MantissaRange::mantissa_scale::large})
                 {
                     // Regardless of the features enabled, RPC is controlled by
                     // the global mantissa size. And since it's a thread-local,
diff --git a/src/test/rpc/LedgerData_test.cpp b/src/test/rpc/LedgerData_test.cpp
index 612899e47d..32d26f770c 100644
--- a/src/test/rpc/LedgerData_test.cpp
+++ b/src/test/rpc/LedgerData_test.cpp
@@ -165,6 +165,16 @@ public:
             BEAST_EXPECT(jrr[jss::status] == "error");
             BEAST_EXPECT(jrr[jss::error_message] == "ledgerNotFound");
         }
+
+        {
+            // binary not a boolean
+            Json::Value jvParams;
+            jvParams[jss::binary] = "true";
+            auto const jrr = env.rpc("json", "ledger_data", to_string(jvParams))[jss::result];
+            BEAST_EXPECT(jrr[jss::error] == "invalidParams");
+            BEAST_EXPECT(jrr[jss::status] == "error");
+            BEAST_EXPECT(jrr[jss::error_message] == "Invalid field 'binary', not boolean.");
+        }
     }
 
     void
diff --git a/src/test/rpc/LedgerRPC_test.cpp b/src/test/rpc/LedgerRPC_test.cpp
index c8c40ce0cc..48fcfd2dec 100644
--- a/src/test/rpc/LedgerRPC_test.cpp
+++ b/src/test/rpc/LedgerRPC_test.cpp
@@ -165,6 +165,23 @@ class LedgerRPC_test : public beast::unit_test::suite
             auto const ret = env.rpc("json", "ledger", "{ \"ledger_index\" : 1000000000000000 }");
             checkErrorValue(ret, "invalidParams", "Invalid parameters.");
         }
+
+        {
+            // test all boolean fields with non-boolean values
+            auto testBooleanField = [&](Json::StaticString const& field) {
+                Json::Value jvParams;
+                jvParams[field] = "blah";
+                auto const jrr = env.rpc("json", "ledger", to_string(jvParams))[jss::result];
+                checkErrorValue(jrr, "invalidParams", "Invalid parameters.");
+            };
+            testBooleanField(jss::full);
+            testBooleanField(jss::accounts);
+            testBooleanField(jss::transactions);
+            testBooleanField(jss::expand);
+            testBooleanField(jss::binary);
+            testBooleanField(jss::owner_funds);
+            testBooleanField(jss::queue);
+        }
     }
 
     void
diff --git a/src/test/rpc/RPCCall_test.cpp b/src/test/rpc/RPCCall_test.cpp
index 3ece97344c..409ba660d8 100644
--- a/src/test/rpc/RPCCall_test.cpp
+++ b/src/test/rpc/RPCCall_test.cpp
@@ -31,7 +31,7 @@ struct RPCCallTestData
     std::vector<char const*> const args;
 
     // If it throws, what does it throw?
-    enum Exception { no_exception = 0, bad_cast };
+    enum class Exception { no_exception = 0, bad_cast };
     Exception const throwsWhat;
 
     // Expected JSON response.
@@ -72,7 +72,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"account_channels: minimal.",
      __LINE__,
      {"account_channels", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_channels",
     "params" : [
@@ -87,7 +87,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {"account_channels",
       "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
       "rD5MbavGfiSC5m7mkxy1FANuT7s3HxqpoF"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_channels",
     "params" : [
@@ -103,7 +103,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {"account_channels",
       "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
       "r9emE59aTWb85t64dAebKrxYMBTpzK5yR7"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_channels",
     "params" : [
@@ -119,7 +119,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {"account_channels",
       "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
       "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_channels",
     "params" : [
@@ -136,7 +136,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
       "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
       "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_channels",
     "params" : [
@@ -154,7 +154,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
       "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
       "90210"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_channels",
     "params" : [
@@ -171,7 +171,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "account_channels",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_channels",
     "params" : [
@@ -189,7 +189,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
       "current",
       "extra"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_channels",
     "params" : [
@@ -206,7 +206,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "account_channels",
          "",  // Note: very few values are detected as bad!
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_channels",
     "params" : [
@@ -223,7 +223,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"account_currencies: minimal 1.",
      __LINE__,
      {"account_currencies", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_currencies",
     "params" : [
@@ -236,7 +236,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"account_currencies: minimal 2.",
      __LINE__,
      {"account_currencies", "racb4o3DrdYxuCfyVa6vsLb7vgju9RFbBr"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_currencies",
     "params" : [
@@ -249,7 +249,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"account_currencies: ledger index.",
      __LINE__,
      {"account_currencies", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "42"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_currencies",
     "params" : [
@@ -263,7 +263,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"account_currencies: validated ledger.",
      __LINE__,
      {"account_currencies", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "validated"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_currencies",
     "params" : [
@@ -277,7 +277,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"account_currencies: current ledger.",
      __LINE__,
      {"account_currencies", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "current"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_currencies",
     "params" : [
@@ -293,7 +293,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "account_currencies",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_currencies",
     "params" : [
@@ -307,7 +307,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"account_currencies: too many arguments.",
      __LINE__,
      {"account_currencies", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "current", "spare1", "spare2"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_currencies",
     "params" : [
@@ -321,7 +321,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"account_currencies: invalid second argument.",
      __LINE__,
      {"account_currencies", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "yup"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_currencies",
     "params" : [
@@ -339,7 +339,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
             "account_currencies",
             "",  // Note: very few values are detected as bad!
         },
-        RPCCallTestData::no_exception,
+        RPCCallTestData::Exception::no_exception,
         R"({
     "method" : "account_currencies",
     "params" : [
@@ -357,7 +357,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"account_info: minimal.",
      __LINE__,
      {"account_info", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_info",
     "params" : [
@@ -370,7 +370,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"account_info: with numeric ledger index.",
      __LINE__,
      {"account_info", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "77777"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_info",
     "params" : [
@@ -384,7 +384,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"account_info: with text ledger index.",
      __LINE__,
      {"account_info", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "closed"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_info",
     "params" : [
@@ -400,7 +400,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {"account_info",
       "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
       "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_info",
     "params" : [
@@ -414,7 +414,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"account_info: with ledger index.",
      __LINE__,
      {"account_info", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "validated"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_info",
     "params" : [
@@ -430,7 +430,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "account_info",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_info",
     "params" : [
@@ -444,7 +444,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"account_info: too many arguments.",
      __LINE__,
      {"account_info", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "current", "extra1", "extra2"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_info",
     "params" : [
@@ -462,7 +462,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
             "account_info",
             "",  // Note: very few values are detected as bad!
         },
-        RPCCallTestData::no_exception,
+        RPCCallTestData::Exception::no_exception,
         R"({
     "method" : "account_info",
     "params" : [
@@ -480,7 +480,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"account_lines: minimal.",
      __LINE__,
      {"account_lines", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_lines",
     "params" : [
@@ -493,7 +493,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"account_lines: peer.",
      __LINE__,
      {"account_lines", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_lines",
     "params" : [
@@ -510,7 +510,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
       "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
       "888888888"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_lines",
     "params" : [
@@ -528,7 +528,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
       "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
       "closed"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_lines",
     "params" : [
@@ -546,7 +546,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
       "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
       "FFFFEEEEDDDDCCCCBBBBAAAA9999888877776666555544443333222211110000"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_lines",
     "params" : [
@@ -563,7 +563,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "account_lines",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_lines",
     "params" : [
@@ -582,7 +582,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
       "12345678",
       "current"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_lines",
     "params" : [
@@ -603,7 +603,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "12345678",
       "current",
       "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_lines",
     "params" : [
@@ -624,7 +624,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "current",
       "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
       "validated"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_lines",
     "params" : [
@@ -642,7 +642,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
             "account_lines",
             "",  // Note: very few values are detected as bad!
         },
-        RPCCallTestData::no_exception,
+        RPCCallTestData::Exception::no_exception,
         R"({
     "method" : "account_lines",
     "params" : [
@@ -662,7 +662,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
             "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
             ""  // Note: very few values are detected as bad!
         },
-        RPCCallTestData::no_exception,
+        RPCCallTestData::Exception::no_exception,
         R"({
     "method" : "account_lines",
     "params" : [
@@ -680,7 +680,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
          "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
          "not_a_ledger"},
-        RPCCallTestData::no_exception,
+        RPCCallTestData::Exception::no_exception,
         R"({
     "method" : "account_lines",
     "params" : [
@@ -699,7 +699,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"account_objects: minimal.",
      __LINE__,
      {"account_objects", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_objects",
     "params" : [
@@ -712,7 +712,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"account_objects: with numeric ledger index.",
      __LINE__,
      {"account_objects", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "77777"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_objects",
     "params" : [
@@ -726,7 +726,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"account_objects: with text ledger index.",
      __LINE__,
      {"account_objects", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "closed"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_objects",
     "params" : [
@@ -742,7 +742,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {"account_objects",
       "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
       "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_objects",
     "params" : [
@@ -756,7 +756,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"account_objects: with ledger index.",
      __LINE__,
      {"account_objects", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "validated"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_objects",
     "params" : [
@@ -772,7 +772,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "account_objects",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_objects",
     "params" : [
@@ -793,7 +793,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "extra1",
          "extra2",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_objects",
     "params" : [
@@ -814,7 +814,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "extra2",
          "extra3",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_objects",
     "params" : [
@@ -835,7 +835,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "extra3",
          "extra4",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_objects",
     "params" : [
@@ -853,7 +853,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
             "account_objects",
             "",  // Note: very few values are detected as bad!
         },
-        RPCCallTestData::no_exception,
+        RPCCallTestData::Exception::no_exception,
         R"({
     "method" : "account_objects",
     "params" : [
@@ -871,7 +871,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
         "account_objects: invalid ledger selection 1.",
         __LINE__,
         {"account_objects", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "no_ledger"},
-        RPCCallTestData::no_exception,
+        RPCCallTestData::Exception::no_exception,
         R"({
     "method" : "account_objects",
     "params" : [
@@ -889,7 +889,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
         "account_objects: invalid ledger selection 2.",
         __LINE__,
         {"account_objects", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "no_ledger"},
-        RPCCallTestData::no_exception,
+        RPCCallTestData::Exception::no_exception,
         R"({
     "method" : "account_objects",
     "params" : [
@@ -907,7 +907,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"account_offers: minimal.",
      __LINE__,
      {"account_offers", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_offers",
     "params" : [
@@ -920,7 +920,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"account_offers: with numeric ledger index.",
      __LINE__,
      {"account_offers", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "987654321"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_offers",
     "params" : [
@@ -934,7 +934,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"account_offers: with text ledger index.",
      __LINE__,
      {"account_offers", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "validated"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_offers",
     "params" : [
@@ -950,7 +950,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {"account_offers",
       "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
       "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_offers",
     "params" : [
@@ -964,7 +964,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"account_offers: with ledger index.",
      __LINE__,
      {"account_offers", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "validated"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_offers",
     "params" : [
@@ -980,7 +980,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "account_offers",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_offers",
     "params" : [
@@ -995,7 +995,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      "account_offers: four arguments.",
      __LINE__,
      {"account_offers", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "current", "extra"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_offers",
     "params" : [
@@ -1015,7 +1015,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "extra2",
          "extra3",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_offers",
     "params" : [
@@ -1033,7 +1033,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
             "account_offers",
             "",  // Note: very few values are detected as bad!
         },
-        RPCCallTestData::no_exception,
+        RPCCallTestData::Exception::no_exception,
         R"({
     "method" : "account_offers",
     "params" : [
@@ -1051,7 +1051,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
         "account_offers: invalid ledger selection 1.",
         __LINE__,
         {"account_offers", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "no_ledger"},
-        RPCCallTestData::no_exception,
+        RPCCallTestData::Exception::no_exception,
         R"({
     "method" : "account_offers",
     "params" : [
@@ -1069,7 +1069,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
         "account_offers: invalid ledger selection 2.",
         __LINE__,
         {"account_offers", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "no_ledger"},
-        RPCCallTestData::no_exception,
+        RPCCallTestData::Exception::no_exception,
         R"({
     "method" : "account_offers",
     "params" : [
@@ -1087,7 +1087,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"account_tx: minimal.",
      __LINE__,
      {"account_tx", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_tx",
     "params" : [
@@ -1100,7 +1100,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"account_tx: ledger_index .",
      __LINE__,
      {"account_tx", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "444"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_tx",
     "params" : [
@@ -1114,7 +1114,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"account_tx: ledger_index plus trailing params.",
      __LINE__,
      {"account_tx", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "707", "descending", "binary", "count"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_tx",
     "params" : [
@@ -1131,7 +1131,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"account_tx: ledger_index_min and _max.",
      __LINE__,
      {"account_tx", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "-1", "-1"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_tx",
     "params" : [
@@ -1152,7 +1152,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "binary",
       "count",
       "descending"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_tx",
     "params" : [
@@ -1170,7 +1170,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"account_tx: ledger_index_min and _max plus limit.",
      __LINE__,
      {"account_tx", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "247", "-1", "300"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_tx",
     "params" : [
@@ -1193,7 +1193,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "count",
       "descending",
       "binary"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_tx",
     "params" : [
@@ -1212,7 +1212,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"account_tx: ledger_index_min and _max plus limit and offset.",
      __LINE__,
      {"account_tx", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "589", "590", "67", "45"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_tx",
     "params" : [
@@ -1236,7 +1236,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "45",
       "descending",
       "count"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_tx",
     "params" : [
@@ -1257,7 +1257,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "account_tx",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_tx",
     "params" : [
@@ -1280,7 +1280,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "descending",
       "count",
       "binary"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_tx",
     "params" : [
@@ -1295,7 +1295,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
         "account_tx: invalid accountID.",
         __LINE__,
         {"account_tx", "rHb9CJAWyB4rj9!VRWn96DkukG4bwdtyTh"},
-        RPCCallTestData::no_exception,
+        RPCCallTestData::Exception::no_exception,
         R"({
     "method" : "account_tx",
     "params" : [
@@ -1312,7 +1312,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
         "account_tx: invalid ledger.",
         __LINE__,
         {"account_tx", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "-478.7"},
-        RPCCallTestData::no_exception,
+        RPCCallTestData::Exception::no_exception,
         R"({
     "method" : "account_tx",
     "params" : [
@@ -1328,7 +1328,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
         "account_tx: max less than min.",
         __LINE__,
         {"account_tx", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "580", "579"},
-        RPCCallTestData::no_exception,
+        RPCCallTestData::Exception::no_exception,
         {
             R"({
     "method" : "account_tx",
@@ -1356,7 +1356,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
         "account_tx: non-integer min.",
         __LINE__,
         {"account_tx", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "Binary", "-1"},
-        RPCCallTestData::bad_cast,
+        RPCCallTestData::Exception::bad_cast,
         R"()",
     },
     {
@@ -1364,7 +1364,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
         "account_tx: non-integer max.",
         __LINE__,
         {"account_tx", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "-1", "counts"},
-        RPCCallTestData::bad_cast,
+        RPCCallTestData::Exception::bad_cast,
         R"()",
     },
     {
@@ -1372,7 +1372,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
         "account_tx: non-integer offset.",
         __LINE__,
         {"account_tx", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "-1", "-1", "decending"},
-        RPCCallTestData::bad_cast,
+        RPCCallTestData::Exception::bad_cast,
         R"()",
     },
     {
@@ -1380,7 +1380,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
         "account_tx: non-integer limit.",
         __LINE__,
         {"account_tx", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "-1", "-1", "300", "false"},
-        RPCCallTestData::bad_cast,
+        RPCCallTestData::Exception::bad_cast,
         R"()",
     },
     {// Note: this really shouldn't throw, but does at the moment.
@@ -1394,7 +1394,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "false",
       "false",
       "false"},
-     RPCCallTestData::bad_cast,
+     RPCCallTestData::Exception::bad_cast,
      R"()"},
 
     // book_offers
@@ -1406,7 +1406,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "USD",
          "EUR",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "book_offers",
     "params" : [
@@ -1428,7 +1428,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "USD/rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
          "EUR/rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "book_offers",
     "params" : [
@@ -1450,7 +1450,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      "book_offers: add issuer.",
      __LINE__,
      {"book_offers", "USD", "EUR", "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "book_offers",
     "params" : [
@@ -1473,7 +1473,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "EUR",
       "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
       "666"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "book_offers",
     "params" : [
@@ -1498,7 +1498,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "EUR/rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
       "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
       "current"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "book_offers",
     "params" : [
@@ -1523,7 +1523,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "EUR/rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
       "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
       "ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "book_offers",
     "params" : [
@@ -1552,7 +1552,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789",
          "200",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "book_offers",
     "params" : [
@@ -1583,7 +1583,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "200",
       "0",
       "MyMarker"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "book_offers",
     "params" : [
@@ -1609,7 +1609,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "book_offers",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "book_offers",
     "params" : [
@@ -1631,7 +1631,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "0",
       "MyMarker",
       "extra"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "book_offers",
     "params" : [
@@ -1650,7 +1650,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "/rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
          "EUR/rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "book_offers",
     "params" : [
@@ -1668,7 +1668,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "USD/rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
          "/rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "book_offers",
     "params" : [
@@ -1682,7 +1682,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"book_offers: invalid issuer.",
      __LINE__,
      {"book_offers", "USD", "EUR", "not_a_valid_issuer"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "book_offers",
     "params" : [
@@ -1705,7 +1705,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "EUR/rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
       "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
       "not_a_ledger"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "book_offers",
     "params" : [
@@ -1734,7 +1734,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789",
          "not_a_number",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "book_offers",
     "params" : [
@@ -1753,7 +1753,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "can_delete",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "can_delete",
     "params" : [
@@ -1768,7 +1768,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "can_delete",
          "4294967295",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "can_delete",
     "params" : [
@@ -1784,7 +1784,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "can_delete",
          "FEDCBA9876543210FEDCBA9876543210FEDCBA9876543210FEDCBA9876543210",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "can_delete",
     "params" : [
@@ -1800,7 +1800,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "can_delete",
          "always",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "can_delete",
     "params" : [
@@ -1816,7 +1816,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "can_delete",
          "never",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "can_delete",
     "params" : [
@@ -1832,7 +1832,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "can_delete",
          "now",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "can_delete",
     "params" : [
@@ -1845,7 +1845,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"can_delete: too many arguments.",
      __LINE__,
      {"can_delete", "always", "never"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "can_delete",
     "params" : [
@@ -1859,7 +1859,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"can_delete: invalid argument.",
      __LINE__,
      {"can_delete", "invalid"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "can_delete",
     "params" : [
@@ -1876,7 +1876,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "can_delete",
          "4294967296",
      },
-     RPCCallTestData::bad_cast,
+     RPCCallTestData::Exception::bad_cast,
      R"()"},
     {// Note: this really shouldn't throw since it's a legitimate ledger hash.
      "can_delete: ledger hash with no alphas.",
@@ -1885,7 +1885,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "can_delete",
          "0123456701234567012345670123456701234567012345670123456701234567",
      },
-     RPCCallTestData::bad_cast,
+     RPCCallTestData::Exception::bad_cast,
      R"()"},
 
     // channel_authorize
@@ -1896,7 +1896,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "secret_can_be_anything",
       "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
       "18446744073709551615"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "channel_authorize",
     "params" : [
@@ -1915,7 +1915,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "secret_can_be_anything",
          "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "channel_authorize",
     "params" : [
@@ -1934,7 +1934,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "2000",
       "whatever",
       "whenever"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "channel_authorize",
     "params" : [
@@ -1952,7 +1952,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
       "2000",
       "whatever"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "channel_authorize",
     "params" : [
@@ -1969,7 +1969,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "secret_can_be_anything",
       "123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
       "2000"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "channel_authorize",
     "params" : [
@@ -1986,7 +1986,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "secret_can_be_anything",
       "10123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
       "2000"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "channel_authorize",
     "params" : [
@@ -2003,7 +2003,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "secret_can_be_anything",
       "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEZ",
       "2000"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "channel_authorize",
     "params" : [
@@ -2020,7 +2020,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "secret_can_be_anything",
       "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
       "-1"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "channel_authorize",
     "params" : [
@@ -2037,7 +2037,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "secret_can_be_anything",
       "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
       "18446744073709551616"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "channel_authorize",
     "params" : [
@@ -2058,7 +2058,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
       "0",
       "DEADBEEF"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "channel_verify",
     "params" : [
@@ -2078,7 +2078,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
       "18446744073709551615",
       "DEADBEEF"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "channel_verify",
     "params" : [
@@ -2096,7 +2096,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {"channel_verify",
       "aB4BXXLuPu8DpVuyq1DBiu3SrPdtK9AYZisKhu8mvkoiUD8J9Gov",
       "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "channel_verify",
     "params" : [
@@ -2115,7 +2115,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "2000",
       "DEADBEEF",
       "Whatever"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "channel_verify",
     "params" : [
@@ -2133,7 +2133,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
       "2000",
       "DEADBEEF"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "channel_verify",
     "params" : [
@@ -2151,7 +2151,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
       "2000",
       "DEADBEEF"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "channel_verify",
     "params" : [
@@ -2169,7 +2169,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "10123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
       "2000",
       "DEADBEEF"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "channel_verify",
     "params" : [
@@ -2187,7 +2187,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
       "2000",
       "DEADBEEF"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "channel_verify",
     "params" : [
@@ -2205,7 +2205,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
       "-1",
       "DEADBEEF"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "channel_verify",
     "params" : [
@@ -2223,7 +2223,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
       "18446744073709551616",
       "DEADBEEF"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "channel_verify",
     "params" : [
@@ -2241,7 +2241,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
       "40000000",
       "ThisIsNotHexadecimal"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "channel_verify",
     "params" : [
@@ -2263,7 +2263,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "connect",
          "ThereIsNoCheckingOnTheIPFormat",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "connect",
     "params" : [
@@ -2276,7 +2276,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"connect: ip and port.",
      __LINE__,
      {"connect", "ThereIsNoCheckingOnTheIPFormat", "6561"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "connect",
     "params" : [
@@ -2292,7 +2292,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "connect",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "connect",
     "params" : [
@@ -2306,7 +2306,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"connect: too many arguments.",
      __LINE__,
      {"connect", "ThereIsNoCheckingOnTheIPFormat", "6561", "extra"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "connect",
     "params" : [
@@ -2325,7 +2325,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "ThereIsNoCheckingOnTheIPFormat",
          "-1",
      },
-     RPCCallTestData::bad_cast,
+     RPCCallTestData::Exception::bad_cast,
      R"()"},
     {// Note: this should return an error but not throw.
      "connect: port too large.",
@@ -2335,7 +2335,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "ThereIsNoCheckingOnTheIPFormat",
          "4294967296",
      },
-     RPCCallTestData::bad_cast,
+     RPCCallTestData::Exception::bad_cast,
      R"()"},
 
     // consensus_info
@@ -2345,7 +2345,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "consensus_info",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "consensus_info",
     "params" : [
@@ -2357,7 +2357,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"consensus_info: too many arguments.",
      __LINE__,
      {"consensus_info", "whatever"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "consensus_info",
     "params" : [
@@ -2378,7 +2378,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "source_account_NotValidated",
          "destination_account_NotValidated",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "deposit_authorized",
     "params" : [
@@ -2395,7 +2395,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "source_account_NotValidated",
       "destination_account_NotValidated",
       "validated"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "deposit_authorized",
     "params" : [
@@ -2421,7 +2421,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "cred6",
       "cred7",
       "cred8"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "deposit_authorized",
     "params" : [
@@ -2440,7 +2440,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "source_account_NotValidated",
       "destination_account_NotValidated",
       "ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "deposit_authorized",
     "params" : [
@@ -2458,7 +2458,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "deposit_authorized",
          "source_account_NotValidated",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "deposit_authorized",
     "params" : [
@@ -2484,7 +2484,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "cred7",
       "cred8",
       "too_much"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "deposit_authorized",
     "params" : [
@@ -2503,7 +2503,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "destination_account_NotValidated",
          "NotALedger",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "deposit_authorized",
     "params" : [
@@ -2523,7 +2523,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "feature",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "feature",
     "params" : [
@@ -2535,7 +2535,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"feature: with name.",
      __LINE__,
      {"feature", "featureNameOrHexIsNotValidated"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "feature",
     "params" : [
@@ -2551,7 +2551,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "FEDCBA9876543210FEDCBA9876543210FEDCBA9876543210FEDCBA9876543210FEDCBA98"
       "76543210",
       "accept"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "feature",
     "params" : [
@@ -2565,7 +2565,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"feature: reject.",
      __LINE__,
      {"feature", "0", "reject"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "feature",
     "params" : [
@@ -2579,7 +2579,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"feature: too many arguments.",
      __LINE__,
      {"feature", "featureNameOrHexIsNotValidated", "accept", "anotherArg"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "feature",
     "params" : [
@@ -2597,7 +2597,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "featureNameOrHexIsNotValidated",
          "veto",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "feature",
     "params" : [
@@ -2616,7 +2616,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "fetch_info",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "fetch_info",
     "params" : [
@@ -2628,7 +2628,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"fetch_info: clear.",
      __LINE__,
      {"fetch_info", "clear"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "fetch_info",
     "params" : [
@@ -2641,7 +2641,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"fetch_info: too many arguments.",
      __LINE__,
      {"fetch_info", "clear", "other"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "fetch_info",
     "params" : [
@@ -2655,7 +2655,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"fetch_info: other trailing argument.",
      __LINE__,
      {"fetch_info", "too"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "fetch_info",
     "params" : [
@@ -2671,7 +2671,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"gateway_balances: minimal.",
      __LINE__,
      {"gateway_balances", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "gateway_balances",
     "params" : [
@@ -2684,7 +2684,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"gateway_balances: with ledger index.",
      __LINE__,
      {"gateway_balances", "890765", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "gateway_balances",
     "params" : [
@@ -2698,7 +2698,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"gateway_balances: with text ledger index.",
      __LINE__,
      {"gateway_balances", "current", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "gateway_balances",
     "params" : [
@@ -2714,7 +2714,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {"gateway_balances",
       "0123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUV",
       "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "gateway_balances",
     "params" : [
@@ -2728,7 +2728,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"gateway_balances: 1 hotwallet.",
      __LINE__,
      {"gateway_balances", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "hotwallet_is_not_validated"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "gateway_balances",
     "params" : [
@@ -2749,7 +2749,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "hotwallet_is_not_validated_2",
          "hotwallet_is_not_validated_3",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "gateway_balances",
     "params" : [
@@ -2770,7 +2770,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "gateway_balances",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "gateway_balances",
     "params" : [
@@ -2784,7 +2784,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"gateway_balances: empty first argument.",
      __LINE__,
      {"gateway_balances", ""},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "gateway_balances",
     "params" : [
@@ -2801,7 +2801,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "gateway_balances",
          "890765",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "gateway_balances",
     "params" : [
@@ -2818,7 +2818,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "gateway_balances",
          "current",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "gateway_balances",
     "params" : [
@@ -2835,7 +2835,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "gateway_balances",
          "0123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUV",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "gateway_balances",
     "params" : [
@@ -2854,7 +2854,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "get_counts",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "get_counts",
     "params" : [
@@ -2866,7 +2866,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"get_counts: with maximum count.",
      __LINE__,
      {"get_counts", "100"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "get_counts",
     "params" : [
@@ -2879,7 +2879,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"get_counts: too many arguments.",
      __LINE__,
      {"get_counts", "100", "whatever"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "get_counts",
     "params" : [
@@ -2896,12 +2896,12 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "get_counts",
          "-1",
      },
-     RPCCallTestData::bad_cast,
+     RPCCallTestData::Exception::bad_cast,
      R"()"},
     {"get_counts: count too large.",
      __LINE__,
      {"get_counts", "4294967296"},
-     RPCCallTestData::bad_cast,
+     RPCCallTestData::Exception::bad_cast,
      R"()"},
 
     // json
@@ -2913,7 +2913,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "command",
          R"({"json_argument":true})",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "command",
     "params" : [
@@ -2931,7 +2931,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "command",
          R"({})",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "command",
     "params" : [
@@ -2944,7 +2944,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"json: too few arguments.",
      __LINE__,
      {"json", "command"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "json",
     "params" : [
@@ -2958,7 +2958,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"json: too many arguments.",
      __LINE__,
      {"json", "command", R"({"json_argument":true})", "extra"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "json",
     "params" : [
@@ -2976,7 +2976,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "command",
          R"(["arg1","arg2"])",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "json",
     "params" : [
@@ -2994,7 +2994,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "command",
          R"({"json_argument":true,})",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "json",
     "params" : [
@@ -3014,7 +3014,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "json2",
          R"({"jsonrpc":"2.0","ripplerpc":"2.0","id":"A1","method":"call_1"})",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "id" : "A1",
     "jsonrpc" : "2.0",
@@ -3042,7 +3042,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
         "params" : [{"inner_arg" : "yup"}]
         })",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "id" : "A1",
     "jsonrpc" : "2.0",
@@ -3067,7 +3067,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "json2",
          R"([{"jsonrpc":"2.0","ripplerpc":"2.0","id":"A1","method":"call_1"}])",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "json2",
     "params" : [
@@ -3094,7 +3094,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
         "params" : [{"inner_arg" : "yup"}]}
         ])",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "json2",
    "params" : [
@@ -3116,7 +3116,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "json2",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "json2",
     "params" : [
@@ -3130,7 +3130,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"json2: too many arguments.",
      __LINE__,
      {"json2", R"({"jsonrpc":"2.0","ripplerpc":"2.0","id":"A1","method":"call_this"})", "extra"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "json2",
     "params" : [
@@ -3147,7 +3147,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "json2",
          R"({"jsonrpc":"2.0","ripplerpc":"2.0","id":"A1","method":"call_1",})",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "id" : "A1",
     "jsonrpc" : "2.0",
@@ -3170,7 +3170,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "json2",
          R"({"ripplerpc":"2.0","id":"A1","method":"call_1"})",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "id" : "A1",
     "method" : "json2",
@@ -3191,7 +3191,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "json2",
          R"({"jsonrpc":"2.1","ripplerpc":"2.0","id":"A1","method":"call_1"})",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "id" : "A1",
     "jsonrpc" : "2.1",
@@ -3214,7 +3214,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "json2",
          R"({"jsonrpc":"2.0","id":"A1","method":"call_1"})",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "id" : "A1",
     "jsonrpc" : "2.0",
@@ -3235,7 +3235,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "json2",
          R"({"jsonrpc":"2.0","ripplerpc":"2.00","id":"A1","method":"call_1"})",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "id" : "A1",
     "jsonrpc" : "2.0",
@@ -3258,7 +3258,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "json2",
          R"({"jsonrpc":"2.0","ripplerpc":"2.0","method":"call_1"})",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "jsonrpc" : "2.0",
     "method" : "json2",
@@ -3279,7 +3279,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "json2",
          R"({"jsonrpc":"2.0","ripplerpc":"2.0","id":"A1"})",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "id" : "A1",
     "jsonrpc" : "2.0",
@@ -3302,7 +3302,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "json2",
          R"([])",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "json2",
     "params" : [
@@ -3319,7 +3319,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "json2",
          R"([{"jsonrpc":"2.0","ripplerpc":"2.0","id":"A1","method":"call_1",[]}])",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "json2",
     "params" : [
@@ -3342,7 +3342,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
             }
         ])",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "json2",
     "params" : [
@@ -3365,7 +3365,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
         "params" : true
         })",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
    "id" : "A1",
    "jsonrpc" : "2.0",
@@ -3388,7 +3388,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ledger: minimal.",
      __LINE__,
      {"ledger"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ledger",
     "params" : [
@@ -3400,7 +3400,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ledger: ledger index.",
      __LINE__,
      {"ledger", "4294967295"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ledger",
     "params" : [
@@ -3413,7 +3413,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ledger: text ledger index.",
      __LINE__,
      {"ledger", "validated"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ledger",
     "params" : [
@@ -3426,7 +3426,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ledger: ledger hash.",
      __LINE__,
      {"ledger", "ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ledger",
     "params" : [
@@ -3439,7 +3439,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ledger: full.",
      __LINE__,
      {"ledger", "current", "full"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ledger",
     "params" : [
@@ -3453,7 +3453,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ledger: tx.",
      __LINE__,
      {"ledger", "closed", "tx"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ledger",
     "params" : [
@@ -3468,7 +3468,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ledger: too many arguments.",
      __LINE__,
      {"ledger", "4294967295", "spare"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ledger",
     "params" : [
@@ -3481,7 +3481,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ledger: ledger index too small.",
      __LINE__,
      {"ledger", "-1"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ledger",
     "params" : [
@@ -3494,7 +3494,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ledger: ledger index too big.",
      __LINE__,
      {"ledger", "4294967296"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ledger",
     "params" : [
@@ -3507,7 +3507,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ledger: invalid ledger text.",
      __LINE__,
      {"ledger", "latest"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ledger",
     "params" : [
@@ -3520,7 +3520,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ledger: unsupported final argument.",
      __LINE__,
      {"ledger", "current", "expand"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ledger",
     "params" : [
@@ -3536,7 +3536,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ledger_closed: minimal.",
      __LINE__,
      {"ledger_closed"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ledger_closed",
     "params" : [
@@ -3548,7 +3548,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ledger_closed: too many arguments.",
      __LINE__,
      {"ledger_closed", "today"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ledger_closed",
     "params" : [
@@ -3565,7 +3565,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ledger_current: minimal.",
      __LINE__,
      {"ledger_current"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ledger_current",
     "params" : [
@@ -3577,7 +3577,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ledger_current: too many arguments.",
      __LINE__,
      {"ledger_current", "today"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ledger_current",
     "params" : [
@@ -3594,7 +3594,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ledger_header: ledger index.",
      __LINE__,
      {"ledger_header", "4294967295"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ledger_header",
     "params" : [
@@ -3607,7 +3607,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ledger_header: ledger hash.",
      __LINE__,
      {"ledger_header", "ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ledger_header",
     "params" : [
@@ -3622,7 +3622,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "ledger_header",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ledger_header",
     "params" : [
@@ -3636,7 +3636,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ledger_header: too many arguments.",
      __LINE__,
      {"ledger_header", "4294967295", "spare"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ledger_header",
     "params" : [
@@ -3650,7 +3650,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ledger_header: text ledger index.",
      __LINE__,
      {"ledger_header", "current"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ledger_header",
     "params" : [
@@ -3663,7 +3663,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ledger_header: ledger index too small.",
      __LINE__,
      {"ledger_header", "-1"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ledger_header",
     "params" : [
@@ -3676,7 +3676,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ledger_header: ledger index too big.",
      __LINE__,
      {"ledger_header", "4294967296"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ledger_header",
     "params" : [
@@ -3692,7 +3692,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ledger_request: ledger index.",
      __LINE__,
      {"ledger_request", "4294967295"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ledger_request",
     "params" : [
@@ -3705,7 +3705,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ledger_request: ledger hash.",
      __LINE__,
      {"ledger_request", "ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ledger_request",
     "params" : [
@@ -3720,7 +3720,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "ledger_request",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ledger_request",
     "params" : [
@@ -3734,7 +3734,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ledger_request: too many arguments.",
      __LINE__,
      {"ledger_request", "4294967295", "spare"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ledger_request",
     "params" : [
@@ -3748,7 +3748,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ledger_request: text ledger index.",
      __LINE__,
      {"ledger_request", "current"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ledger_request",
     "params" : [
@@ -3761,7 +3761,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ledger_request: ledger index too small.",
      __LINE__,
      {"ledger_request", "-1"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ledger_request",
     "params" : [
@@ -3774,7 +3774,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ledger_request: ledger index too big.",
      __LINE__,
      {"ledger_request", "4294967296"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ledger_request",
     "params" : [
@@ -3792,7 +3792,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "log_level",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "log_level",
     "params" : [
@@ -3804,7 +3804,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"log_level: fatal.",
      __LINE__,
      {"log_level", "fatal"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "log_level",
     "params" : [
@@ -3817,7 +3817,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"log_level: error.",
      __LINE__,
      {"log_level", "error"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "log_level",
     "params" : [
@@ -3830,7 +3830,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"log_level: warn.",
      __LINE__,
      {"log_level", "warn"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "log_level",
     "params" : [
@@ -3843,7 +3843,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"log_level: debug.",
      __LINE__,
      {"log_level", "debug"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "log_level",
     "params" : [
@@ -3856,7 +3856,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"log_level: trace.",
      __LINE__,
      {"log_level", "trace"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "log_level",
     "params" : [
@@ -3869,7 +3869,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"log_level: base partition.",
      __LINE__,
      {"log_level", "base", "trace"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "log_level",
     "params" : [
@@ -3883,7 +3883,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"log_level: partition_name.",
      __LINE__,
      {"log_level", "partition_name", "fatal"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "log_level",
     "params" : [
@@ -3897,7 +3897,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"log_level: too many arguments.",
      __LINE__,
      {"log_level", "partition_name", "fatal", "extra"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "log_level",
     "params" : [
@@ -3911,7 +3911,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"log_level: invalid severity.",
      __LINE__,
      {"log_level", "err"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "log_level",
     "params" : [
@@ -3928,7 +3928,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "fatal",
          "partition_name",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "log_level",
     "params" : [
@@ -3947,7 +3947,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "logrotate",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "logrotate",
     "params" : [
@@ -3959,7 +3959,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"logrotate: too many arguments.",
      __LINE__,
      {"logrotate", "extra"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "logrotate",
     "params" : [
@@ -3976,7 +3976,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"owner_info: minimal.",
      __LINE__,
      {"owner_info", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "owner_info",
     "params" : [
@@ -3989,7 +3989,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"owner_info: with numeric ledger index.",
      __LINE__,
      {"owner_info", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "987654321"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "owner_info",
     "params" : [
@@ -4003,7 +4003,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"owner_info: with text ledger index.",
      __LINE__,
      {"owner_info", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "validated"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "owner_info",
     "params" : [
@@ -4019,7 +4019,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {"owner_info",
       "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
       "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "owner_info",
     "params" : [
@@ -4033,7 +4033,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"owner_info: with ledger index.",
      __LINE__,
      {"owner_info", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "validated"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "owner_info",
     "params" : [
@@ -4049,7 +4049,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "owner_info",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "owner_info",
     "params" : [
@@ -4069,7 +4069,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "extra1",
          "extra2",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "owner_info",
     "params" : [
@@ -4087,7 +4087,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
             "owner_info",
             "",  // Note: very few values are detected as bad!
         },
-        RPCCallTestData::no_exception,
+        RPCCallTestData::Exception::no_exception,
         R"({
     "method" : "owner_info",
     "params" : [
@@ -4105,7 +4105,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
         "owner_info: invalid ledger selection.",
         __LINE__,
         {"owner_info", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "no_ledger"},
-        RPCCallTestData::no_exception,
+        RPCCallTestData::Exception::no_exception,
         R"({
     "method" : "owner_info",
     "params" : [
@@ -4123,7 +4123,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
         "owner_info: invalid ledger selection.",
         __LINE__,
         {"owner_info", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "no_ledger"},
-        RPCCallTestData::no_exception,
+        RPCCallTestData::Exception::no_exception,
         R"({
     "method" : "owner_info",
     "params" : [
@@ -4143,7 +4143,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "peers",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "peers",
     "params" : [
@@ -4155,7 +4155,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"peers: too many arguments.",
      __LINE__,
      {"peers", "extra"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "peers",
     "params" : [
@@ -4172,7 +4172,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"peer_reservations_add: minimal.",
      __LINE__,
      {"peer_reservations_add", "public_key_string"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "peer_reservations_add",
     "params" : [
@@ -4185,7 +4185,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"peer_reservations_add: with description.",
      __LINE__,
      {"peer_reservations_add", "public_key_string", "public_key_description"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "peer_reservations_add",
     "params" : [
@@ -4199,7 +4199,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"peer_reservations_add: too few arguments.",
      __LINE__,
      {"peer_reservations_add"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "peer_reservations_add",
     "params" : [
@@ -4213,7 +4213,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"peer_reservations_add: too many arguments.",
      __LINE__,
      {"peer_reservations_add", "public_key_string", "public_key_description", "spare"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "peer_reservations_add",
     "params" : [
@@ -4230,7 +4230,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"peer_reservations_del: minimal.",
      __LINE__,
      {"peer_reservations_del", "public_key_string"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "peer_reservations_del",
     "params" : [
@@ -4243,7 +4243,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"peer_reservations_del: too few arguments.",
      __LINE__,
      {"peer_reservations_del"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "peer_reservations_del",
     "params" : [
@@ -4257,7 +4257,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"peer_reservations_del: too many arguments.",
      __LINE__,
      {"peer_reservations_del", "public_key_string", "public_key_description", "spare"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "peer_reservations_del",
     "params" : [
@@ -4276,7 +4276,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "ping",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ping",
     "params" : [
@@ -4288,7 +4288,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ping: too many arguments.",
      __LINE__,
      {"ping", "extra"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ping",
     "params" : [
@@ -4307,7 +4307,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "print",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "print",
     "params" : [
@@ -4320,7 +4320,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      "print: extra argument.",
      __LINE__,
      {"print", "extra"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "print",
     "params" : [
@@ -4333,7 +4333,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"print: too many arguments.",
      __LINE__,
      {"print", "extra1", "extra2"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "print",
     "params" : [
@@ -4352,7 +4352,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "random",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "random",
     "params" : [
@@ -4364,7 +4364,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"random: too many arguments.",
      __LINE__,
      {"random", "extra"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "random",
     "params" : [
@@ -4384,7 +4384,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "ripple_path_find",
          R"({"json_argument":true})",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ripple_path_find",
     "params" : [
@@ -4397,7 +4397,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ripple_path_find: ledger index.",
      __LINE__,
      {"ripple_path_find", R"({"json_argument":true})", "4294967295"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ripple_path_find",
     "params" : [
@@ -4411,7 +4411,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ripple_path_find: text ledger index.",
      __LINE__,
      {"ripple_path_find", R"({"json_argument":true})", "closed"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ripple_path_find",
     "params" : [
@@ -4427,7 +4427,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {"ripple_path_find",
       R"({"json_argument":true})",
       "0123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUV"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ripple_path_find",
     "params" : [
@@ -4444,7 +4444,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "ripple_path_find",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ripple_path_find",
     "params" : [
@@ -4458,7 +4458,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ripple_path_find: too many arguments.",
      __LINE__,
      {"ripple_path_find", R"({"json_argument":true})", "current", "extra"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ripple_path_find",
     "params" : [
@@ -4475,7 +4475,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "ripple_path_find",
          R"({"json_argument":true,})",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ripple_path_find",
     "params" : [
@@ -4489,7 +4489,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ripple_path_find: ledger index too small.",
      __LINE__,
      {"ripple_path_find", R"({"json_argument":true})", "-1"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ripple_path_find",
     "params" : [
@@ -4503,7 +4503,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ripple_path_find: ledger index too big.",
      __LINE__,
      {"ripple_path_find", R"({"json_argument":true})", "4294967296"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ripple_path_find",
     "params" : [
@@ -4517,7 +4517,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ripple_path_find: invalid text ledger index.",
      __LINE__,
      {"ripple_path_find", R"({"json_argument":true})", "cur"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ripple_path_find",
     "params" : [
@@ -4538,7 +4538,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "my_secret",
          R"({"json_argument":true})",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "sign",
     "params" : [
@@ -4554,7 +4554,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"sign: offline.",
      __LINE__,
      {"sign", "my_secret", R"({"json_argument":true})", "offline"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "sign",
     "params" : [
@@ -4571,7 +4571,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"sign: too few arguments.",
      __LINE__,
      {"sign", "contents_of_blob"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "sign",
     "params" : [
@@ -4585,7 +4585,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"sign: offline flag with signature_target.",
      __LINE__,
      {"sign", "my_secret", R"({"json_argument":true})", "offline", "extra"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
         "method" : "sign",
         "params" : [
@@ -4609,7 +4609,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "offline",
       "CounterpartySignature",
       "extra"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "sign",
     "params" : [
@@ -4627,7 +4627,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "my_secret",
          R"({"json_argument":true,})",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "sign",
     "params" : [
@@ -4641,7 +4641,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"sign: misspelled offline flag interpreted as signature_target.",
      __LINE__,
      {"sign", "my_secret", R"({"json_argument":true})", "offlin"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
         "method" : "sign",
         "params" : [
@@ -4667,7 +4667,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "my_secret",
          R"({"json_argument":true})",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "sign_for",
     "params" : [
@@ -4688,7 +4688,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "my_secret",
       R"({"json_argument":true})",
       "offline"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "sign_for",
     "params" : [
@@ -4710,7 +4710,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
          "my_secret",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "sign_for",
     "params" : [
@@ -4729,7 +4729,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       R"({"json_argument":true})",
       "offline",
       "extra"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "sign_for",
     "params" : [
@@ -4748,7 +4748,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "my_secret",
          R"({"json_argument":true,})",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "sign_for",
     "params" : [
@@ -4766,7 +4766,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "my_secret",
       R"({"json_argument":true})",
       "ofline"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "sign_for",
     "params" : [
@@ -4783,7 +4783,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"submit: blob.",
      __LINE__,
      {"submit", "the blob is unvalidated and may be any length..."},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "submit",
     "params" : [
@@ -4800,7 +4800,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "my_secret",
          R"({"json_argument":true})",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "submit",
     "params" : [
@@ -4818,7 +4818,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "submit",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "submit",
     "params" : [
@@ -4833,7 +4833,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      "submit: four arguments.",
      __LINE__,
      {"submit", "my_secret", R"({"json_argument":true})", "offline"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "submit",
     "params" : [
@@ -4850,7 +4850,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"submit: offline flag with signature_target.",
      __LINE__,
      {"submit", "my_secret", R"({"json_argument":true})", "offline", "extra"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
         "method" : "submit",
         "params" : [
@@ -4874,7 +4874,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "offline",
       "CounterpartySignature",
       "extra"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "submit",
     "params" : [
@@ -4892,7 +4892,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "my_secret",
          R"({"json_argument":true,})",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "submit",
     "params" : [
@@ -4906,7 +4906,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"submit: misspelled offline flag interpreted as signature_target.",
      __LINE__,
      {"submit", "my_secret", R"({"json_argument":true})", "offlne"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
         "method" : "submit",
         "params" : [
@@ -4930,7 +4930,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "submit_multisigned",
          R"({"json_argument":true})",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "submit_multisigned",
     "params" : [
@@ -4947,7 +4947,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "submit_multisigned",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "submit_multisigned",
     "params" : [
@@ -4961,7 +4961,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"submit_multisigned: too many arguments.",
      __LINE__,
      {"submit_multisigned", R"({"json_argument":true})", "extra"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "submit_multisigned",
     "params" : [
@@ -4978,7 +4978,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "submit_multisigned",
          R"({"json_argument":true,})",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "submit_multisigned",
     "params" : [
@@ -4998,7 +4998,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "server_info",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "server_info",
     "params" : [
@@ -5010,7 +5010,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"server_info: counters.",
      __LINE__,
      {"server_info", "counters"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "server_info",
     "params" : [
@@ -5023,7 +5023,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"server_info: too many arguments.",
      __LINE__,
      {"server_info", "counters", "extra"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "server_info",
     "params" : [
@@ -5037,7 +5037,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"server_info: non-counters argument.",
      __LINE__,
      {"server_info", "counter"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "server_info",
     "params" : [
@@ -5054,7 +5054,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "server_state",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "server_state",
     "params" : [
@@ -5066,7 +5066,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"server_state: counters.",
      __LINE__,
      {"server_state", "counters"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "server_state",
     "params" : [
@@ -5079,7 +5079,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"server_state: too many arguments.",
      __LINE__,
      {"server_state", "counters", "extra"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "server_state",
     "params" : [
@@ -5093,7 +5093,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"server_state: non-counters argument.",
      __LINE__,
      {"server_state", "counter"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "server_state",
     "params" : [
@@ -5110,7 +5110,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "stop",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "stop",
     "params" : [
@@ -5122,7 +5122,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"stop: too many arguments.",
      __LINE__,
      {"stop", "extra"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "stop",
     "params" : [
@@ -5141,7 +5141,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {"transaction_entry",
       "0123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUV",
       "4294967295"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "transaction_entry",
     "params" : [
@@ -5157,7 +5157,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {"transaction_entry",
       "0123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUV",
       "current"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "transaction_entry",
     "params" : [
@@ -5173,7 +5173,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {"transaction_entry",
       "0123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUV",
       "VUTSRQPONMLKJIHGFEDCBA9876543210VUTSRQPONMLKJIHGFEDCBA9876543210"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "transaction_entry",
     "params" : [
@@ -5190,7 +5190,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "transaction_entry",
          "0123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUV",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "transaction_entry",
     "params" : [
@@ -5207,7 +5207,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "0123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUV",
       "validated",
       "extra"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "transaction_entry",
     "params" : [
@@ -5225,7 +5225,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUV",
          "validated",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "transaction_entry",
     "params" : [
@@ -5243,7 +5243,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "0123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUVW",
          "validated",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "transaction_entry",
     "params" : [
@@ -5261,7 +5261,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "0123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUV",
          "0",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "transaction_entry",
     "params" : [
@@ -5279,7 +5279,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "0123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUV",
          "4294967296",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "transaction_entry",
     "params" : [
@@ -5297,7 +5297,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "0123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUV",
          "VUTSRQPONMLKJIHGFEDCBA9876543210VUTSRQPONMLKJIHGFEDCBA987654321",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "transaction_entry",
     "params" : [
@@ -5315,7 +5315,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "0123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUV",
          "VUTSRQPONMLKJIHGFEDCBA9876543210VUTSRQPONMLKJIHGFEDCBA9876543210Z",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "transaction_entry",
     "params" : [
@@ -5332,7 +5332,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"tx: ctid. minimal",
      __LINE__,
      {"tx", "FFFFFFFFFFFFFFFF", "1", "2"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "tx",
     "params" : [
@@ -5347,7 +5347,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"tx: ctid. binary",
      __LINE__,
      {"tx", "FFFFFFFFFFFFFFFF", "binary", "1", "2"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "tx",
     "params" : [
@@ -5363,7 +5363,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"tx: minimal.",
      __LINE__,
      {"tx", "transaction_hash_is_not_validated"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "tx",
     "params" : [
@@ -5376,7 +5376,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"tx: binary.",
      __LINE__,
      {"tx", "transaction_hash_is_not_validated", "binary"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "tx",
     "params" : [
@@ -5392,7 +5392,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "tx",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "tx",
     "params" : [
@@ -5406,7 +5406,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"tx: too many arguments.",
      __LINE__,
      {"tx", "transaction_hash_is_not_validated", "binary", "1", "2", "extra"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "tx",
     "params" : [
@@ -5420,7 +5420,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"tx: invalid final argument is apparently ignored.",
      __LINE__,
      {"tx", "transaction_hash_is_not_validated", "bin"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "tx",
     "params" : [
@@ -5436,7 +5436,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"tx_history: minimal.",
      __LINE__,
      {"tx_history", "0"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "tx_history",
     "params" : [
@@ -5451,7 +5451,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "tx_history",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "tx_history",
     "params" : [
@@ -5465,7 +5465,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"tx_history: too many arguments.",
      __LINE__,
      {"tx_history", "0", "1"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "tx_history",
     "params" : [
@@ -5481,7 +5481,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
         "tx_history: start too small.",
         __LINE__,
         {"tx_history", "-1"},
-        RPCCallTestData::bad_cast,
+        RPCCallTestData::Exception::bad_cast,
         R"()",
     },
     {
@@ -5489,7 +5489,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
         "tx_history: start too big.",
         __LINE__,
         {"tx_history", "4294967296"},
-        RPCCallTestData::bad_cast,
+        RPCCallTestData::Exception::bad_cast,
         R"()",
     },
     {
@@ -5497,7 +5497,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
         "tx_history: start not integer.",
         __LINE__,
         {"tx_history", "beginning"},
-        RPCCallTestData::bad_cast,
+        RPCCallTestData::Exception::bad_cast,
         R"()",
     },
 
@@ -5508,7 +5508,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "unl_list",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "unl_list",
     "params" : [
@@ -5520,7 +5520,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"unl_list: too many arguments.",
      __LINE__,
      {"unl_list", "extra"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "unl_list",
     "params" : [
@@ -5539,7 +5539,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "validation_create",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "validation_create",
     "params" : [
@@ -5551,7 +5551,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"validation_create: with secret.",
      __LINE__,
      {"validation_create", "the form of the secret is not validated"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "validation_create",
     "params" : [
@@ -5564,7 +5564,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"validation_create: too many arguments.",
      __LINE__,
      {"validation_create", "the form of the secret is not validated", "extra"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "validation_create",
     "params" : [
@@ -5583,7 +5583,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "version",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "version",
     "params" : [
@@ -5595,7 +5595,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"version: too many arguments.",
      __LINE__,
      {"version", "extra"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "version",
     "params" : [
@@ -5614,7 +5614,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "wallet_propose",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "wallet_propose",
     "params" : [
@@ -5626,7 +5626,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"wallet_propose: with passphrase.",
      __LINE__,
      {"wallet_propose", "the form of the passphrase is not validated"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "wallet_propose",
     "params" : [
@@ -5639,7 +5639,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"wallet_propose: too many arguments.",
      __LINE__,
      {"wallet_propose", "the form of the passphrase is not validated", "extra"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "wallet_propose",
     "params" : [
@@ -5656,7 +5656,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"internal: minimal.",
      __LINE__,
      {"internal", "command_name"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "internal",
     "params" : [
@@ -5670,7 +5670,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"internal: with parameters.",
      __LINE__,
      {"internal", "command_name", "string_arg", "1", "-1", "4294967296", "3.14159"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "internal",
     "params" : [
@@ -5686,7 +5686,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "internal",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "internal",
     "params" : [
@@ -5705,7 +5705,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "path_find",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "path_find",
     "params" : [
@@ -5719,7 +5719,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"path_find: with arguments.",
      __LINE__,
      {"path_find", "string_arg", "1", "-1", "4294967296", "3.14159"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "path_find",
     "params" : [
@@ -5738,7 +5738,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "subscribe",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "subscribe",
     "params" : [
@@ -5752,7 +5752,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"subscribe: with arguments.",
      __LINE__,
      {"subscribe", "string_arg", "1", "-1", "4294967296", "3.14159"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "subscribe",
     "params" : [
@@ -5771,7 +5771,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "unsubscribe",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "unsubscribe",
     "params" : [
@@ -5785,7 +5785,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"unsubscribe: with arguments.",
      __LINE__,
      {"unsubscribe", "string_arg", "1", "-1", "4294967296", "3.14159"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "unsubscribe",
     "params" : [
@@ -5804,7 +5804,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "unknown_command",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "unknown_command",
     "params" : [
@@ -5816,7 +5816,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"unknown_command: with arguments.",
      __LINE__,
      {"unknown_command", "string_arg", "1", "-1", "4294967296", "3.14159"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "unknown_command",
     "params" : [
@@ -5884,7 +5884,7 @@ public:
             }
             catch (std::bad_cast const&)
             {
-                if ((rpcCallTest.throwsWhat == RPCCallTestData::bad_cast) &&
+                if ((rpcCallTest.throwsWhat == RPCCallTestData::Exception::bad_cast) &&
                     (std::strlen(expVersioned) == 0))
                 {
                     pass();
@@ -5913,7 +5913,8 @@ public:
             rmErrorCode(exp);
 
             // Pass if we didn't expect a throw and we got what we expected.
-            if ((rpcCallTest.throwsWhat == RPCCallTestData::no_exception) && (got == exp))
+            if ((rpcCallTest.throwsWhat == RPCCallTestData::Exception::no_exception) &&
+                (got == exp))
             {
                 pass();
             }
diff --git a/src/test/rpc/Roles_test.cpp b/src/test/rpc/Roles_test.cpp
index eaf6143f5d..c2b1d36a0b 100644
--- a/src/test/rpc/Roles_test.cpp
+++ b/src/test/rpc/Roles_test.cpp
@@ -25,6 +25,7 @@ class Roles_test : public beast::unit_test::suite
     void
     testRoles()
     {
+        testcase("Roles");
         using namespace test::jtx;
 
         {
@@ -224,6 +225,21 @@ class Roles_test : public beast::unit_test::suite
             BEAST_EXPECT(rpcRes["role"] == "proxied");
             BEAST_EXPECT(rpcRes["ip"] == "::11:22:33:44:45.55.65.75");
             BEAST_EXPECT(isValidIpAddress(rpcRes["ip"].asString()));
+
+            // Test: "for=" not at the beginning AND no trailing delimiter.
+            // This exercises the fix for the buffer over-read bug where
+            // the remaining length was incorrectly calculated.
+            headers["Forwarded"] = "by=203.0.113.43;for=1.2.3.4";
+            rpcRes = env.rpc(headers, "ping")["result"];
+            BEAST_EXPECT(rpcRes["role"] == "proxied");
+            BEAST_EXPECT(rpcRes["ip"] == "1.2.3.4");
+            BEAST_EXPECT(isValidIpAddress(rpcRes["ip"].asString()));
+
+            headers["Forwarded"] = "proto=https;by=proxy.example.com;for=5.6.7.8";
+            rpcRes = env.rpc(headers, "ping")["result"];
+            BEAST_EXPECT(rpcRes["role"] == "proxied");
+            BEAST_EXPECT(rpcRes["ip"] == "5.6.7.8");
+            BEAST_EXPECT(isValidIpAddress(rpcRes["ip"].asString()));
         }
 
         {
@@ -252,6 +268,7 @@ class Roles_test : public beast::unit_test::suite
     testInvalidIpAddresses()
     {
         using namespace test::jtx;
+        testcase("Invalid IP addresses");
 
         {
             Env env(*this);
diff --git a/src/test/rpc/Submit_test.cpp b/src/test/rpc/Submit_test.cpp
new file mode 100644
index 0000000000..ea5ef145c4
--- /dev/null
+++ b/src/test/rpc/Submit_test.cpp
@@ -0,0 +1,98 @@
+#include <test/jtx/Account.h>
+#include <test/jtx/Env.h>
+#include <test/jtx/JTx.h>
+#include <test/jtx/amount.h>
+#include <test/jtx/pay.h>
+
+#include <xrpl/basics/strHex.h>
+#include <xrpl/beast/unit_test/suite.h>
+#include <xrpl/json/json_value.h>
+#include <xrpl/json/to_string.h>
+#include <xrpl/protocol/Seed.h>
+#include <xrpl/protocol/jss.h>
+
+namespace xrpl::test {
+
+class Submit_test : public beast::unit_test::suite
+{
+public:
+    void
+    testFailHardValidation()
+    {
+        testcase("fail_hard parameter validation");
+        using namespace jtx;
+        Env env(*this);
+        Account const alice{"alice"};
+        Account const bob{"bob"};
+        env.fund(XRP(10000), alice, bob);
+        env.close();
+
+        // Lambda to test invalid fail_hard parameter types
+        auto testInvalidFailHard = [&](auto const& param) {
+            // Test with tx_blob path
+            {
+                JTx const jt = env.jt(pay(alice, bob, XRP(1)));
+                auto const txBlob = strHex(jt.stx->getSerializer().slice());
+
+                Json::Value params;
+                params[jss::tx_blob] = txBlob;
+                params[jss::fail_hard] = param;
+                auto const jrr = env.rpc("json", "submit", to_string(params))[jss::result];
+                BEAST_EXPECT(jrr[jss::error] == "invalidParams");
+                BEAST_EXPECT(jrr[jss::error_message] == "Invalid field 'fail_hard', not boolean.");
+            }
+
+            // Test with tx_json path (deprecated signing)
+            {
+                Json::Value params;
+                params[jss::secret] = toBase58(generateSeed("alice"));
+                params[jss::tx_json] = pay("alice", "bob", XRP(1));
+                params[jss::fail_hard] = param;
+                auto const jrr = env.rpc("json", "submit", to_string(params))[jss::result];
+                BEAST_EXPECT(jrr[jss::error] == "invalidParams");
+                BEAST_EXPECT(jrr[jss::error_message] == "Invalid field 'fail_hard', not boolean.");
+            }
+        };
+
+        // Test all invalid types
+        testInvalidFailHard("true");
+        testInvalidFailHard("yes");
+        testInvalidFailHard(1);
+        testInvalidFailHard(0);
+        testInvalidFailHard(1.5);
+        testInvalidFailHard(Json::Value(Json::objectValue));
+        testInvalidFailHard(Json::Value(Json::arrayValue));
+
+        // Valid boolean values should work (not return invalidParams)
+        {
+            JTx const jt = env.jt(pay(alice, bob, XRP(1)));
+            auto const txBlob = strHex(jt.stx->getSerializer().slice());
+
+            Json::Value params;
+            params[jss::tx_blob] = txBlob;
+            params[jss::fail_hard] = true;
+            auto const jrr = env.rpc("json", "submit", to_string(params))[jss::result];
+            BEAST_EXPECT(!jrr.isMember(jss::error) || jrr[jss::error] != "invalidParams");
+        }
+        {
+            JTx const jt = env.jt(pay(alice, bob, XRP(1)));
+            auto const txBlob = strHex(jt.stx->getSerializer().slice());
+
+            Json::Value params;
+            params[jss::tx_blob] = txBlob;
+            params[jss::fail_hard] = false;
+            auto const jrr = env.rpc("json", "submit", to_string(params))[jss::result];
+            BEAST_EXPECT(!jrr.isMember(jss::error) || jrr[jss::error] != "invalidParams");
+        }
+    }
+
+    void
+    run() override
+    {
+        testFailHardValidation();
+    }
+};
+
+BEAST_DEFINE_TESTSUITE(Submit, rpc, xrpl);
+
+}  // namespace xrpl::test
diff --git a/src/test/rpc/Subscribe_test.cpp b/src/test/rpc/Subscribe_test.cpp
index 02c4fd8c8d..0e43713c2a 100644
--- a/src/test/rpc/Subscribe_test.cpp
+++ b/src/test/rpc/Subscribe_test.cpp
@@ -214,16 +214,12 @@ public:
             // Check stream update for payment transaction
             BEAST_EXPECT(wsc->findMsg(5s, [&](auto const& jv) {
                 return jv[jss::meta]["AffectedNodes"][1u]["CreatedNode"]["NewFields"]
-                         [jss::Account]  //
-                    == Account("alice").human() &&
-                    jv[jss::transaction][jss::TransactionType]  //
-                    == jss::Payment &&
-                    jv[jss::transaction][jss::DeliverMax]  //
-                    == std::to_string(10000000000 + baseFee) &&
-                    jv[jss::transaction][jss::Fee]  //
-                    == std::to_string(baseFee) &&
-                    jv[jss::transaction][jss::Sequence]  //
-                    == 1;
+                         [jss::Account] == Account("alice").human() &&
+                    jv[jss::transaction][jss::TransactionType] == jss::Payment &&
+                    jv[jss::transaction][jss::DeliverMax] ==
+                    std::to_string(10000000000 + baseFee) &&
+                    jv[jss::transaction][jss::Fee] == std::to_string(baseFee) &&
+                    jv[jss::transaction][jss::Sequence] == 1;
             }));
 
             // Check stream update for accountset transaction
@@ -579,7 +575,7 @@ public:
         auto wsc = makeWSClient(env.app().config());
 
         {
-            auto jr = env.rpc("json", method, "{}")[jss::result];
+            auto const jr = env.rpc("json", method, "{}")[jss::result];
             BEAST_EXPECT(jr[jss::error] == "invalidParams");
             BEAST_EXPECT(jr[jss::error_message] == "Invalid parameters.");
         }
@@ -589,7 +585,7 @@ public:
             jv[jss::url] = "not-a-url";
             jv[jss::username] = "admin";
             jv[jss::password] = "password";
-            auto jr = env.rpc("json", method, to_string(jv))[jss::result];
+            auto const jr = env.rpc("json", method, to_string(jv))[jss::result];
             if (subscribe)
             {
                 BEAST_EXPECT(jr[jss::error] == "invalidParams");
@@ -602,7 +598,7 @@ public:
         {
             Json::Value jv;
             jv[jss::url] = "ftp://scheme.not.supported.tld";
-            auto jr = env.rpc("json", method, to_string(jv))[jss::result];
+            auto const jr = env.rpc("json", method, to_string(jv))[jss::result];
             if (subscribe)
             {
                 BEAST_EXPECT(jr[jss::error] == "invalidParams");
@@ -614,7 +610,7 @@ public:
             Env env_nonadmin{*this, single_thread_io(no_admin(envconfig()))};
             Json::Value jv;
             jv[jss::url] = "no-url";
-            auto jr = env_nonadmin.rpc("json", method, to_string(jv))[jss::result];
+            auto const jr = env_nonadmin.rpc("json", method, to_string(jv))[jss::result];
             BEAST_EXPECT(jr[jss::error] == "noPermission");
             BEAST_EXPECT(jr[jss::error_message] == "You don't have permission for this command.");
         }
@@ -634,7 +630,7 @@ public:
             {
                 Json::Value jv;
                 jv[f] = nonArray;
-                auto jr = wsc->invoke(method, jv)[jss::result];
+                auto const jr = wsc->invoke(method, jv)[jss::result];
                 BEAST_EXPECT(jr[jss::error] == "invalidParams");
                 BEAST_EXPECT(jr[jss::error_message] == "Invalid parameters.");
             }
@@ -642,7 +638,7 @@ public:
             {
                 Json::Value jv;
                 jv[f] = Json::arrayValue;
-                auto jr = wsc->invoke(method, jv)[jss::result];
+                auto const jr = wsc->invoke(method, jv)[jss::result];
                 BEAST_EXPECT(jr[jss::error] == "actMalformed");
                 BEAST_EXPECT(jr[jss::error_message] == "Account malformed.");
             }
@@ -652,7 +648,7 @@ public:
         {
             Json::Value jv;
             jv[jss::books] = nonArray;
-            auto jr = wsc->invoke(method, jv)[jss::result];
+            auto const jr = wsc->invoke(method, jv)[jss::result];
             BEAST_EXPECT(jr[jss::error] == "invalidParams");
             BEAST_EXPECT(jr[jss::error_message] == "Invalid parameters.");
         }
@@ -661,7 +657,7 @@ public:
             Json::Value jv;
             jv[jss::books] = Json::arrayValue;
             jv[jss::books][0u] = 1;
-            auto jr = wsc->invoke(method, jv)[jss::result];
+            auto const jr = wsc->invoke(method, jv)[jss::result];
             BEAST_EXPECT(jr[jss::error] == "invalidParams");
             BEAST_EXPECT(jr[jss::error_message] == "Invalid parameters.");
         }
@@ -672,7 +668,7 @@ public:
             jv[jss::books][0u] = Json::objectValue;
             jv[jss::books][0u][jss::taker_gets] = Json::objectValue;
             jv[jss::books][0u][jss::taker_pays] = Json::objectValue;
-            auto jr = wsc->invoke(method, jv)[jss::result];
+            auto const jr = wsc->invoke(method, jv)[jss::result];
             BEAST_EXPECT(jr[jss::error] == "srcCurMalformed");
             BEAST_EXPECT(jr[jss::error_message] == "Source currency is malformed.");
         }
@@ -684,7 +680,7 @@ public:
             jv[jss::books][0u][jss::taker_gets] = Json::objectValue;
             jv[jss::books][0u][jss::taker_pays] = Json::objectValue;
             jv[jss::books][0u][jss::taker_pays][jss::currency] = "ZZZZ";
-            auto jr = wsc->invoke(method, jv)[jss::result];
+            auto const jr = wsc->invoke(method, jv)[jss::result];
             BEAST_EXPECT(jr[jss::error] == "srcCurMalformed");
             BEAST_EXPECT(jr[jss::error_message] == "Source currency is malformed.");
         }
@@ -697,7 +693,7 @@ public:
             jv[jss::books][0u][jss::taker_pays] = Json::objectValue;
             jv[jss::books][0u][jss::taker_pays][jss::currency] = "USD";
             jv[jss::books][0u][jss::taker_pays][jss::issuer] = 1;
-            auto jr = wsc->invoke(method, jv)[jss::result];
+            auto const jr = wsc->invoke(method, jv)[jss::result];
             BEAST_EXPECT(jr[jss::error] == "srcIsrMalformed");
             BEAST_EXPECT(jr[jss::error_message] == "Source issuer is malformed.");
         }
@@ -710,7 +706,7 @@ public:
             jv[jss::books][0u][jss::taker_pays] = Json::objectValue;
             jv[jss::books][0u][jss::taker_pays][jss::currency] = "USD";
             jv[jss::books][0u][jss::taker_pays][jss::issuer] = Account{"gateway"}.human() + "DEAD";
-            auto jr = wsc->invoke(method, jv)[jss::result];
+            auto const jr = wsc->invoke(method, jv)[jss::result];
             BEAST_EXPECT(jr[jss::error] == "srcIsrMalformed");
             BEAST_EXPECT(jr[jss::error_message] == "Source issuer is malformed.");
         }
@@ -722,7 +718,7 @@ public:
             jv[jss::books][0u][jss::taker_pays] =
                 Account{"gateway"}["USD"](1).value().getJson(JsonOptions::include_date);
             jv[jss::books][0u][jss::taker_gets] = Json::objectValue;
-            auto jr = wsc->invoke(method, jv)[jss::result];
+            auto const jr = wsc->invoke(method, jv)[jss::result];
             // NOTE: this error is slightly incongruous with the
             // equivalent source currency error
             BEAST_EXPECT(jr[jss::error] == "dstAmtMalformed");
@@ -737,7 +733,7 @@ public:
             jv[jss::books][0u][jss::taker_pays] =
                 Account{"gateway"}["USD"](1).value().getJson(JsonOptions::include_date);
             jv[jss::books][0u][jss::taker_gets][jss::currency] = "ZZZZ";
-            auto jr = wsc->invoke(method, jv)[jss::result];
+            auto const jr = wsc->invoke(method, jv)[jss::result];
             // NOTE: this error is slightly incongruous with the
             // equivalent source currency error
             BEAST_EXPECT(jr[jss::error] == "dstAmtMalformed");
@@ -753,7 +749,7 @@ public:
                 Account{"gateway"}["USD"](1).value().getJson(JsonOptions::include_date);
             jv[jss::books][0u][jss::taker_gets][jss::currency] = "USD";
             jv[jss::books][0u][jss::taker_gets][jss::issuer] = 1;
-            auto jr = wsc->invoke(method, jv)[jss::result];
+            auto const jr = wsc->invoke(method, jv)[jss::result];
             BEAST_EXPECT(jr[jss::error] == "dstIsrMalformed");
             BEAST_EXPECT(jr[jss::error_message] == "Destination issuer is malformed.");
         }
@@ -766,7 +762,7 @@ public:
                 Account{"gateway"}["USD"](1).value().getJson(JsonOptions::include_date);
             jv[jss::books][0u][jss::taker_gets][jss::currency] = "USD";
             jv[jss::books][0u][jss::taker_gets][jss::issuer] = Account{"gateway"}.human() + "DEAD";
-            auto jr = wsc->invoke(method, jv)[jss::result];
+            auto const jr = wsc->invoke(method, jv)[jss::result];
             BEAST_EXPECT(jr[jss::error] == "dstIsrMalformed");
             BEAST_EXPECT(jr[jss::error_message] == "Destination issuer is malformed.");
         }
@@ -779,7 +775,7 @@ public:
                 Account{"gateway"}["USD"](1).value().getJson(JsonOptions::include_date);
             jv[jss::books][0u][jss::taker_gets] =
                 Account{"gateway"}["USD"](1).value().getJson(JsonOptions::include_date);
-            auto jr = wsc->invoke(method, jv)[jss::result];
+            auto const jr = wsc->invoke(method, jv)[jss::result];
             BEAST_EXPECT(jr[jss::error] == "badMarket");
             BEAST_EXPECT(jr[jss::error_message] == "No such market.");
         }
@@ -788,7 +784,7 @@ public:
         {
             Json::Value jv;
             jv[jss::streams] = nonArray;
-            auto jr = wsc->invoke(method, jv)[jss::result];
+            auto const jr = wsc->invoke(method, jv)[jss::result];
             BEAST_EXPECT(jr[jss::error] == "invalidParams");
             BEAST_EXPECT(jr[jss::error_message] == "Invalid parameters.");
         }
@@ -797,7 +793,7 @@ public:
             Json::Value jv;
             jv[jss::streams] = Json::arrayValue;
             jv[jss::streams][0u] = 1;
-            auto jr = wsc->invoke(method, jv)[jss::result];
+            auto const jr = wsc->invoke(method, jv)[jss::result];
             BEAST_EXPECT(jr[jss::error] == "malformedStream");
             BEAST_EXPECT(jr[jss::error_message] == "Stream malformed.");
         }
@@ -806,10 +802,55 @@ public:
             Json::Value jv;
             jv[jss::streams] = Json::arrayValue;
             jv[jss::streams][0u] = "not_a_stream";
-            auto jr = wsc->invoke(method, jv)[jss::result];
+            auto const jr = wsc->invoke(method, jv)[jss::result];
             BEAST_EXPECT(jr[jss::error] == "malformedStream");
             BEAST_EXPECT(jr[jss::error_message] == "Stream malformed.");
         }
+
+        if (subscribe)
+        {
+            // invalid taker - not a string
+            {
+                Json::Value jv;
+                jv[jss::books] = Json::arrayValue;
+                jv[jss::books][0u] = Json::objectValue;
+                jv[jss::books][0u][jss::taker_pays] =
+                    Account{"gateway"}["USD"](1).value().getJson(JsonOptions::include_date);
+                jv[jss::books][0u][jss::taker_gets][jss::currency] = "XRP";
+                jv[jss::books][0u][jss::taker] = 1;
+                auto const jr = wsc->invoke(method, jv)[jss::result];
+                BEAST_EXPECTS(jr[jss::error] == "actMalformed", jr.toStyledString());
+                BEAST_EXPECT(jr[jss::error_message] == "Account malformed.");
+            }
+
+            // invalid taker - malformed account string
+            {
+                Json::Value jv;
+                jv[jss::books] = Json::arrayValue;
+                jv[jss::books][0u] = Json::objectValue;
+                jv[jss::books][0u][jss::taker_pays] =
+                    Account{"gateway"}["USD"](1).value().getJson(JsonOptions::include_date);
+                jv[jss::books][0u][jss::taker_gets][jss::currency] = "XRP";
+                jv[jss::books][0u][jss::taker] = "not_an_account";
+                auto const jr = wsc->invoke(method, jv)[jss::result];
+                BEAST_EXPECTS(jr[jss::error] == "actMalformed", jr.toStyledString());
+                BEAST_EXPECT(jr[jss::error_message] == "Account malformed.");
+            }
+
+            // invalid taker - account string with extra characters
+            {
+                Json::Value jv;
+                jv[jss::books] = Json::arrayValue;
+                jv[jss::books][0u] = Json::objectValue;
+                jv[jss::books][0u][jss::taker_pays] =
+                    Account{"gateway"}["USD"](1).value().getJson(JsonOptions::include_date);
+                jv[jss::books][0u][jss::taker_gets][jss::currency] = "XRP";
+                jv[jss::books][0u][jss::taker] = Account{"alice"}.human() + "DEAD";
+                auto const jr = wsc->invoke(method, jv)[jss::result];
+                BEAST_EXPECTS(jr[jss::error] == "actMalformed", jr.toStyledString());
+                BEAST_EXPECT(jr[jss::error_message] == "Account malformed.");
+            }
+        }
     }
 
     void
diff --git a/src/test/shamap/FetchPack_test.cpp b/src/test/shamap/FetchPack_test.cpp
index cd3bc99fa8..a68b0442d0 100644
--- a/src/test/shamap/FetchPack_test.cpp
+++ b/src/test/shamap/FetchPack_test.cpp
@@ -33,6 +33,8 @@ namespace xrpl::tests {
 class FetchPack_test : public beast::unit_test::suite
 {
 public:
+    // Need to be named before converting
+    // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
     enum { tableItems = 100, tableItemsExtra = 20 };
 
     using Map = hash_map<SHAMapHash, Blob>;
diff --git a/src/test/shamap/common.h b/src/test/shamap/common.h
index 08910b5c5d..3f05bc2c57 100644
--- a/src/test/shamap/common.h
+++ b/src/test/shamap/common.h
@@ -91,8 +91,8 @@ public:
     void
     reset() override
     {
-        fbCache_->reset();
-        tnCache_->reset();
+        (*fbCache_).reset();
+        (*tnCache_).reset();
     }
 
     beast::manual_clock<std::chrono::steady_clock>
diff --git a/src/test/unit_test/SuiteJournal.h b/src/test/unit_test/SuiteJournal.h
index f4cbb5baa0..b0b3807dd3 100644
--- a/src/test/unit_test/SuiteJournal.h
+++ b/src/test/unit_test/SuiteJournal.h
@@ -69,7 +69,7 @@ SuiteJournalSink::writeAlways(beast::severities::Severity level, std::string con
     }();
 
     static std::mutex log_mutex;
-    std::lock_guard const lock(log_mutex);
+    std::scoped_lock const lock(log_mutex);
     suite_.log << s << partition_ << text << std::endl;
 }
 
diff --git a/src/test/unit_test/multi_runner.cpp b/src/test/unit_test/multi_runner.cpp
index a09110ca43..1dffece1da 100644
--- a/src/test/unit_test/multi_runner.cpp
+++ b/src/test/unit_test/multi_runner.cpp
@@ -167,7 +167,7 @@ template <bool IsParent>
 std::size_t
 multi_runner_base<IsParent>::inner::tests() const
 {
-    std::lock_guard const l{m_};
+    std::scoped_lock const l{m_};
     return results_.total;
 }
 
@@ -175,7 +175,7 @@ template <bool IsParent>
 std::size_t
 multi_runner_base<IsParent>::inner::suites() const
 {
-    std::lock_guard const l{m_};
+    std::scoped_lock const l{m_};
     return results_.suites;
 }
 
@@ -197,7 +197,7 @@ template <bool IsParent>
 void
 multi_runner_base<IsParent>::inner::add(results const& r)
 {
-    std::lock_guard const l{m_};
+    std::scoped_lock const l{m_};
     results_.merge(r);
 }
 
@@ -206,7 +206,7 @@ template <class S>
 void
 multi_runner_base<IsParent>::inner::print_results(S& s)
 {
-    std::lock_guard const l{m_};
+    std::scoped_lock const l{m_};
     results_.print(s);
 }
 
@@ -339,7 +339,7 @@ void
 multi_runner_base<IsParent>::message_queue_send(MessageType mt, std::string const& s)
 {
     // must use a mutex since the two "sends" must happen in order
-    std::lock_guard const l{inner_->m_};
+    std::scoped_lock const l{inner_->m_};
     message_queue_->send(&mt, sizeof(mt), /*priority*/ 0);
     message_queue_->send(s.c_str(), s.size(), /*priority*/ 0);
 }
diff --git a/src/test/unit_test/multi_runner.h b/src/test/unit_test/multi_runner.h
index 0f675955de..4ccedf9498 100644
--- a/src/test/unit_test/multi_runner.h
+++ b/src/test/unit_test/multi_runner.h
@@ -59,6 +59,8 @@ struct results
     // pointers from different memory spaces do not co-mingle
     using run_time = std::pair<static_string, typename clock_type::duration>;
 
+    // Need to be named before converting
+    // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
     enum { max_top = 10 };
 
     std::size_t suites = 0;
diff --git a/src/tests/libxrpl/CMakeLists.txt b/src/tests/libxrpl/CMakeLists.txt
index 0b666441d1..ee07698519 100644
--- a/src/tests/libxrpl/CMakeLists.txt
+++ b/src/tests/libxrpl/CMakeLists.txt
@@ -8,9 +8,12 @@ add_custom_target(xrpl.tests)
 
 # Test helpers
 add_library(xrpl.helpers.test STATIC)
-target_sources(xrpl.helpers.test PRIVATE helpers/TestSink.cpp)
+target_sources(
+    xrpl.helpers.test
+    PRIVATE helpers/Account.cpp helpers/TestSink.cpp helpers/TxTest.cpp
+)
 target_include_directories(xrpl.helpers.test PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
-target_link_libraries(xrpl.helpers.test PRIVATE xrpl.libxrpl)
+target_link_libraries(xrpl.helpers.test PUBLIC xrpl.libxrpl gtest::gtest)
 
 # Common library dependencies for the rest of the tests.
 add_library(xrpl.imports.test INTERFACE)
@@ -32,6 +35,10 @@ xrpl_add_test(json)
 target_link_libraries(xrpl.test.json PRIVATE xrpl.imports.test)
 add_dependencies(xrpl.tests xrpl.test.json)
 
+xrpl_add_test(tx)
+target_link_libraries(xrpl.test.tx PRIVATE xrpl.imports.test)
+add_dependencies(xrpl.tests xrpl.test.tx)
+
 xrpl_add_test(protocol_autogen)
 target_link_libraries(xrpl.test.protocol_autogen PRIVATE xrpl.imports.test)
 add_dependencies(xrpl.tests xrpl.test.protocol_autogen)
diff --git a/src/tests/libxrpl/basics/Mutex.cpp b/src/tests/libxrpl/basics/Mutex.cpp
index e91781c463..260bd49da1 100644
--- a/src/tests/libxrpl/basics/Mutex.cpp
+++ b/src/tests/libxrpl/basics/Mutex.cpp
@@ -197,7 +197,7 @@ struct MutexDifferentLockTypesTest : ::testing::Test
 {
 };
 
-TEST_F(MutexDifferentLockTypesTest, lock_guard)
+TEST_F(MutexDifferentLockTypesTest, scoped_lock)
 {
     Mutex<int> m(0);
     {
diff --git a/src/tests/libxrpl/helpers/Account.cpp b/src/tests/libxrpl/helpers/Account.cpp
new file mode 100644
index 0000000000..736ae0a24b
--- /dev/null
+++ b/src/tests/libxrpl/helpers/Account.cpp
@@ -0,0 +1,19 @@
+#include <helpers/Account.h>
+
+#include <xrpl/protocol/KeyType.h>
+#include <xrpl/protocol/PublicKey.h>
+#include <xrpl/protocol/SecretKey.h>
+#include <xrpl/protocol/Seed.h>
+
+namespace xrpl::test {
+
+Account const Account::master{"masterpassphrase"};
+
+Account::Account(std::string_view name, KeyType type)
+    : name_(name)
+    , keyPair_(generateKeyPair(type, generateSeed(name_)))
+    , id_(calcAccountID(keyPair_.first))
+{
+}
+
+}  // namespace xrpl::test
diff --git a/src/tests/libxrpl/helpers/Account.h b/src/tests/libxrpl/helpers/Account.h
new file mode 100644
index 0000000000..9c3ad19bbb
--- /dev/null
+++ b/src/tests/libxrpl/helpers/Account.h
@@ -0,0 +1,81 @@
+#pragma once
+
+#include <xrpl/protocol/AccountID.h>
+#include <xrpl/protocol/KeyType.h>
+#include <xrpl/protocol/PublicKey.h>
+#include <xrpl/protocol/SecretKey.h>
+
+#include <string>
+#include <string_view>
+#include <utility>
+
+namespace xrpl::test {
+
+/**
+ * @brief A test account with cryptographic keys.
+ *
+ * Generates keys deterministically from a name, making tests reproducible.
+ * The same name always produces the same AccountID and keys.
+ */
+class Account
+{
+public:
+    /**
+     * @brief The master account that holds all XRP in genesis.
+     *
+     * This account is created in the genesis ledger with all 100 billion XRP.
+     * It uses the well-known seed "masterpassphrase".
+     */
+    static Account const master;
+
+    /**
+     * @brief Create an account from a name.
+     *
+     * Keys are derived deterministically from the name.
+     *
+     * @param name Human-readable name for the account.
+     * @param type Key type to use (defaults to secp256k1).
+     */
+    explicit Account(std::string_view name, KeyType type = KeyType::secp256k1);
+
+    /** @brief Return the human-readable name. */
+    std::string const&
+    name() const noexcept
+    {
+        return name_;
+    }
+
+    /** @brief Return the AccountID. */
+    AccountID const&
+    id() const noexcept
+    {
+        return id_;
+    }
+
+    /** @brief Return the public key. */
+    PublicKey const&
+    pk() const noexcept
+    {
+        return keyPair_.first;
+    }
+
+    /** @brief Return the secret key. */
+    SecretKey const&
+    sk() const noexcept
+    {
+        return keyPair_.second;
+    }
+
+    /** @brief Implicit conversion to AccountID. */
+    operator AccountID const&() const noexcept
+    {
+        return id_;
+    }
+
+private:
+    std::string name_;
+    std::pair<PublicKey, SecretKey> keyPair_;
+    AccountID id_;
+};
+
+}  // namespace xrpl::test
diff --git a/src/tests/libxrpl/helpers/IOU.h b/src/tests/libxrpl/helpers/IOU.h
new file mode 100644
index 0000000000..1e845f5ae6
--- /dev/null
+++ b/src/tests/libxrpl/helpers/IOU.h
@@ -0,0 +1,132 @@
+#pragma once
+
+#include <xrpl/basics/Number.h>
+#include <xrpl/protocol/Asset.h>
+#include <xrpl/protocol/Issue.h>
+#include <xrpl/protocol/STAmount.h>
+#include <xrpl/protocol/UintTypes.h>
+
+#include <helpers/Account.h>
+
+#include <concepts>
+#include <string>
+#include <string_view>
+#include <type_traits>
+
+namespace xrpl::test {
+
+/**
+ * @brief Represents an IOU (issued currency) for testing.
+ *
+ * Provides a clear, explicit API for creating currencies issued by an account.
+ * This replaces the cryptic `Account::operator[]` from the jtx framework.
+ *
+ * @code
+ *     Account gw("gateway");
+ *     IOU USD("USD", gw);
+ *
+ *     auto issue = USD.issue();      // Get the Issue
+ *     auto asset = USD.asset();      // Get the Asset
+ *     auto amt = USD.amount(100);    // Get STAmount of 100 USD
+ * @endcode
+ */
+class IOU
+{
+public:
+    /**
+     * @brief Construct an IOU from a currency code and issuing account.
+     * @param currencyCode A 3-character ISO currency code (e.g., "USD").
+     * @param issuer The account that issues this currency.
+     */
+    IOU(std::string_view currencyCode, Account const& issuer)
+        : currency_(to_currency(std::string(currencyCode))), issuer_(issuer.id())
+    {
+        XRPL_ASSERT(!isXRP(currency_), "IOU: currency code must not resolve to XRP");
+    }
+
+    /**
+     * @brief Construct an IOU from a Currency and issuing account.
+     * @param currency The Currency object.
+     * @param issuer The account that issues this currency.
+     */
+    IOU(Currency currency, Account const& issuer)
+        : currency_(std::move(currency)), issuer_(issuer.id())
+    {
+        XRPL_ASSERT(!isXRP(currency_), "IOU: currency code must not resolve to XRP");
+    }
+
+    /**
+     * @brief Get the Issue (currency + issuer pair).
+     * @return An Issue object representing this IOU.
+     */
+    [[nodiscard]] Issue
+    issue() const
+    {
+        return Issue{currency_, issuer_};
+    }
+
+    /**
+     * @brief Get the Asset.
+     * @return An Asset object representing this IOU.
+     */
+    [[nodiscard]] Asset
+    asset() const
+    {
+        return Asset{issue()};
+    }
+
+    /**
+     * @brief Create an STAmount of this IOU.
+     *
+     * Works with any arithmetic type (int, double, etc.) by converting
+     * to string and parsing. This matches the jtx IOU behaviour.
+     *
+     * @tparam T An arithmetic type.
+     * @param value The amount as any arithmetic type.
+     * @return An STAmount representing value units of this IOU.
+     */
+    template <typename T>
+        requires std::is_arithmetic_v<T>
+    [[nodiscard]] STAmount
+    amount(T value) const
+    {
+        return amountFromString(issue(), to_string(value));
+    }
+
+    /**
+     * @brief Create an STAmount of this IOU from a Number.
+     * @param value The amount as a Number.
+     * @return An STAmount representing value units of this IOU.
+     */
+    [[nodiscard]] STAmount
+    amount(Number const& value) const
+    {
+        return STAmount{issue(), value};
+    }
+
+    /**
+     * @brief Get the currency.
+     * @return The currency.
+     */
+    [[nodiscard]] Currency const&
+    currency() const
+    {
+        return currency_;
+    }
+
+    /**
+     * @brief Get the issuer account ID.
+     * @return The issuer's AccountID.
+     */
+    [[nodiscard]] AccountID const&
+    issuer() const
+    {
+        return issuer_;
+    }
+
+private:
+    Currency currency_;
+    AccountID issuer_;
+};
+
+}  // namespace xrpl::test
diff --git a/src/tests/libxrpl/helpers/TestFamily.h b/src/tests/libxrpl/helpers/TestFamily.h
new file mode 100644
index 0000000000..98c5a379e4
--- /dev/null
+++ b/src/tests/libxrpl/helpers/TestFamily.h
@@ -0,0 +1,111 @@
+#pragma once
+
+#include <xrpl/basics/chrono.h>
+#include <xrpl/nodestore/DummyScheduler.h>
+#include <xrpl/nodestore/Manager.h>
+#include <xrpl/shamap/Family.h>
+
+#include <memory>
+
+namespace xrpl {
+namespace test {
+
+/** Test implementation of Family for unit tests.
+
+    Uses an in-memory NodeStore database and simple caches.
+    The missingNode methods throw since tests shouldn't encounter missing nodes.
+*/
+class TestFamily : public Family
+{
+private:
+    std::unique_ptr<NodeStore::Database> db_;
+    TestStopwatch clock_;
+    std::shared_ptr<FullBelowCache> fbCache_;
+    std::shared_ptr<TreeNodeCache> tnCache_;
+    NodeStore::DummyScheduler scheduler_;
+    beast::Journal j_;
+
+public:
+    explicit TestFamily(beast::Journal j)
+        : fbCache_(std::make_shared<FullBelowCache>("TestFamily full below cache", clock_, j))
+        , tnCache_(
+              std::make_shared<TreeNodeCache>(
+                  "TestFamily tree node cache",
+                  65536,
+                  std::chrono::minutes{1},
+                  clock_,
+                  j))
+        , j_(j)
+    {
+        Section config;
+        config.set("type", "memory");
+        config.set("path", "TestFamily");
+        db_ = NodeStore::Manager::instance().make_Database(megabytes(4), scheduler_, 1, config, j);
+    }
+
+    NodeStore::Database&
+    db() override
+    {
+        return *db_;
+    }
+
+    NodeStore::Database const&
+    db() const override
+    {
+        return *db_;
+    }
+
+    beast::Journal const&
+    journal() override
+    {
+        return j_;
+    }
+
+    std::shared_ptr<FullBelowCache>
+    getFullBelowCache() override
+    {
+        return fbCache_;
+    }
+
+    std::shared_ptr<TreeNodeCache>
+    getTreeNodeCache() override
+    {
+        return tnCache_;
+    }
+
+    void
+    sweep() override
+    {
+        fbCache_->sweep();
+        tnCache_->sweep();
+    }
+
+    void
+    missingNodeAcquireBySeq(std::uint32_t refNum, uint256 const& nodeHash) override
+    {
+        Throw<std::runtime_error>("TestFamily: missing node (by seq)");
+    }
+
+    void
+    missingNodeAcquireByHash(uint256 const& refHash, std::uint32_t refNum) override
+    {
+        Throw<std::runtime_error>("TestFamily: missing node (by hash)");
+    }
+
+    void
+    reset() override
+    {
+        fbCache_->reset();
+        tnCache_->reset();
+    }
+
+    /** Access the test clock for time manipulation in tests. */
+    TestStopwatch&
+    clock()
+    {
+        return clock_;
+    }
+};
+
+}  // namespace test
+}  // namespace xrpl
diff --git a/src/tests/libxrpl/helpers/TestServiceRegistry.h b/src/tests/libxrpl/helpers/TestServiceRegistry.h
new file mode 100644
index 0000000000..4f39124087
--- /dev/null
+++ b/src/tests/libxrpl/helpers/TestServiceRegistry.h
@@ -0,0 +1,378 @@
+#pragma once
+
+#include <xrpl/basics/Log.h>
+#include <xrpl/basics/chrono.h>
+#include <xrpl/core/HashRouter.h>
+#include <xrpl/core/NetworkIDService.h>
+#include <xrpl/core/ServiceRegistry.h>
+#include <xrpl/ledger/PendingSaves.h>
+#include <xrpl/server/LoadFeeTrack.h>
+
+#include <boost/asio/io_context.hpp>
+
+#include <helpers/TestFamily.h>
+#include <helpers/TestSink.h>
+
+#include <optional>
+#include <stdexcept>
+
+namespace xrpl {
+namespace test {
+
+/** Logs implementation that creates TestSink instances. */
+class TestLogs : public Logs
+{
+public:
+    explicit TestLogs(beast::severities::Severity level = beast::severities::kWarning) : Logs(level)
+    {
+    }
+
+    std::unique_ptr<beast::Journal::Sink>
+    makeSink(std::string const&, beast::severities::Severity threshold) override
+    {
+        return std::make_unique<TestSink>(threshold);
+    }
+};
+
+/** Simple NetworkIDService implementation for tests. */
+class TestNetworkIDService final : public NetworkIDService
+{
+public:
+    explicit TestNetworkIDService(std::uint32_t networkID = 0) : networkID_(networkID)
+    {
+    }
+
+    [[nodiscard]] std::uint32_t
+    getNetworkID() const noexcept override
+    {
+        return networkID_;
+    }
+
+private:
+    std::uint32_t networkID_;
+};
+
+/** Test implementation of ServiceRegistry for unit tests.
+
+    This class provides real implementations for services that can be
+    instantiated from libxrpl (such as Logs, io_context, caches), and
+    throws std::logic_error for services that require the full Application.
+
+    Tests can subclass this to provide additional services they need.
+*/
+class TestServiceRegistry : public ServiceRegistry
+{
+    TestLogs logs_{beast::severities::kWarning};
+    boost::asio::io_context io_context_;
+    TestFamily family_{logs_.journal("TestFamily")};
+    LoadFeeTrack feeTrack_{logs_.journal("LoadFeeTrack")};
+    TestNetworkIDService networkIDService_;
+    HashRouter hashRouter_{HashRouter::Setup{}, stopwatch()};
+    NodeCache tempNodeCache_{
+        "TempNodeCache",
+        16384,
+        std::chrono::minutes{1},
+        stopwatch(),
+        logs_.journal("TaggedCache")};
+    CachedSLEs cachedSLEs_{
+        "CachedSLEs",
+        16384,
+        std::chrono::minutes{1},
+        stopwatch(),
+        logs_.journal("TaggedCache")};
+    PendingSaves pendingSaves_;
+    std::optional<uint256> trapTxID_;
+
+public:
+    TestServiceRegistry() = default;
+    ~TestServiceRegistry() override = default;
+
+    // Core infrastructure services
+    CollectorManager&
+    getCollectorManager() override
+    {
+        throw std::logic_error("TestServiceRegistry::getCollectorManager() not implemented");
+    }
+
+    Family&
+    getNodeFamily() override
+    {
+        return family_;
+    }
+
+    TimeKeeper&
+    getTimeKeeper() override
+    {
+        throw std::logic_error("TestServiceRegistry::timeKeeper() not implemented");
+    }
+
+    JobQueue&
+    getJobQueue() override
+    {
+        throw std::logic_error("TestServiceRegistry::getJobQueue() not implemented");
+    }
+
+    NodeCache&
+    getTempNodeCache() override
+    {
+        return tempNodeCache_;
+    }
+
+    CachedSLEs&
+    getCachedSLEs() override
+    {
+        return cachedSLEs_;
+    }
+
+    NetworkIDService&
+    getNetworkIDService() override
+    {
+        return networkIDService_;
+    }
+
+    // Protocol and validation services
+    AmendmentTable&
+    getAmendmentTable() override
+    {
+        throw std::logic_error("TestServiceRegistry::getAmendmentTable() not implemented");
+    }
+
+    HashRouter&
+    getHashRouter() override
+    {
+        return hashRouter_;
+    }
+
+    LoadFeeTrack&
+    getFeeTrack() override
+    {
+        return feeTrack_;
+    }
+
+    LoadManager&
+    getLoadManager() override
+    {
+        throw std::logic_error("TestServiceRegistry::getLoadManager() not implemented");
+    }
+
+    RCLValidations&
+    getValidations() override
+    {
+        throw std::logic_error("TestServiceRegistry::getValidations() not implemented");
+    }
+
+    ValidatorList&
+    getValidators() override
+    {
+        throw std::logic_error("TestServiceRegistry::validators() not implemented");
+    }
+
+    ValidatorSite&
+    getValidatorSites() override
+    {
+        throw std::logic_error("TestServiceRegistry::validatorSites() not implemented");
+    }
+
+    ManifestCache&
+    getValidatorManifests() override
+    {
+        throw std::logic_error("TestServiceRegistry::validatorManifests() not implemented");
+    }
+
+    ManifestCache&
+    getPublisherManifests() override
+    {
+        throw std::logic_error("TestServiceRegistry::publisherManifests() not implemented");
+    }
+
+    // Network services
+    Overlay&
+    getOverlay() override
+    {
+        throw std::logic_error("TestServiceRegistry::overlay() not implemented");
+    }
+
+    Cluster&
+    getCluster() override
+    {
+        throw std::logic_error("TestServiceRegistry::cluster() not implemented");
+    }
+
+    PeerReservationTable&
+    getPeerReservations() override
+    {
+        throw std::logic_error("TestServiceRegistry::peerReservations() not implemented");
+    }
+
+    Resource::Manager&
+    getResourceManager() override
+    {
+        throw std::logic_error("TestServiceRegistry::getResourceManager() not implemented");
+    }
+
+    // Storage services
+    NodeStore::Database&
+    getNodeStore() override
+    {
+        throw std::logic_error("TestServiceRegistry::getNodeStore() not implemented");
+    }
+
+    SHAMapStore&
+    getSHAMapStore() override
+    {
+        throw std::logic_error("TestServiceRegistry::getSHAMapStore() not implemented");
+    }
+
+    RelationalDatabase&
+    getRelationalDatabase() override
+    {
+        throw std::logic_error("TestServiceRegistry::getRelationalDatabase() not implemented");
+    }
+
+    // Ledger services
+    InboundLedgers&
+    getInboundLedgers() override
+    {
+        throw std::logic_error("TestServiceRegistry::getInboundLedgers() not implemented");
+    }
+
+    InboundTransactions&
+    getInboundTransactions() override
+    {
+        throw std::logic_error("TestServiceRegistry::getInboundTransactions() not implemented");
+    }
+
+    TaggedCache<uint256, AcceptedLedger>&
+    getAcceptedLedgerCache() override
+    {
+        throw std::logic_error("TestServiceRegistry::getAcceptedLedgerCache() not implemented");
+    }
+
+    LedgerMaster&
+    getLedgerMaster() override
+    {
+        throw std::logic_error("TestServiceRegistry::getLedgerMaster() not implemented");
+    }
+
+    LedgerCleaner&
+    getLedgerCleaner() override
+    {
+        throw std::logic_error("TestServiceRegistry::getLedgerCleaner() not implemented");
+    }
+
+    LedgerReplayer&
+    getLedgerReplayer() override
+    {
+        throw std::logic_error("TestServiceRegistry::getLedgerReplayer() not implemented");
+    }
+
+    PendingSaves&
+    getPendingSaves() override
+    {
+        return pendingSaves_;
+    }
+
+    OpenLedger&
+    getOpenLedger() override
+    {
+        throw std::logic_error("TestServiceRegistry::openLedger() not implemented");
+    }
+
+    OpenLedger const&
+    getOpenLedger() const override
+    {
+        throw std::logic_error("TestServiceRegistry::openLedger() const not implemented");
+    }
+
+    // Transaction and operation services
+    NetworkOPs&
+    getOPs() override
+    {
+        throw std::logic_error("TestServiceRegistry::getOPs() not implemented");
+    }
+
+    OrderBookDB&
+    getOrderBookDB() override
+    {
+        throw std::logic_error("TestServiceRegistry::getOrderBookDB() not implemented");
+    }
+
+    TransactionMaster&
+    getMasterTransaction() override
+    {
+        throw std::logic_error("TestServiceRegistry::getMasterTransaction() not implemented");
+    }
+
+    TxQ&
+    getTxQ() override
+    {
+        throw std::logic_error("TestServiceRegistry::getTxQ() not implemented");
+    }
+
+    PathRequestManager&
+    getPathRequestManager() override
+    {
+        throw std::logic_error("TestServiceRegistry::getPathRequestManager() not implemented");
+    }
+
+    // Server services
+    ServerHandler&
+    getServerHandler() override
+    {
+        throw std::logic_error("TestServiceRegistry::getServerHandler() not implemented");
+    }
+
+    perf::PerfLog&
+    getPerfLog() override
+    {
+        throw std::logic_error("TestServiceRegistry::getPerfLog() not implemented");
+    }
+
+    // Configuration and state
+    bool
+    isStopping() const override
+    {
+        return false;
+    }
+
+    beast::Journal
+    getJournal(std::string const& name) override
+    {
+        return logs_.journal(name);
+    }
+
+    boost::asio::io_context&
+    getIOContext() override
+    {
+        return io_context_;
+    }
+
+    Logs&
+    getLogs() override
+    {
+        return logs_;
+    }
+
+    std::optional<uint256> const&
+    getTrapTxID() const override
+    {
+        return trapTxID_;
+    }
+
+    DatabaseCon&
+    getWalletDB() override
+    {
+        throw std::logic_error("TestServiceRegistry::getWalletDB() not implemented");
+    }
+
+    // Temporary: Get the underlying Application
+    Application&
+    getApp() override
+    {
+        throw std::logic_error(
+            "TestServiceRegistry::app() not implemented - no Application available in tests");
+    }
+};
+
+}  // namespace test
+}  // namespace xrpl
diff --git a/src/tests/libxrpl/helpers/TxTest.cpp b/src/tests/libxrpl/helpers/TxTest.cpp
new file mode 100644
index 0000000000..d88f700356
--- /dev/null
+++ b/src/tests/libxrpl/helpers/TxTest.cpp
@@ -0,0 +1,252 @@
+#include <helpers/TxTest.h>
+
+#include <xrpl/basics/base_uint.h>
+#include <xrpl/basics/chrono.h>
+#include <xrpl/basics/contract.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/CanonicalTXSet.h>
+#include <xrpl/ledger/Ledger.h>
+#include <xrpl/ledger/OpenView.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/protocol/AccountID.h>
+#include <xrpl/protocol/Feature.h>
+#include <xrpl/protocol/Fees.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/SField.h>
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/STTx.h>
+#include <xrpl/protocol/TER.h>
+#include <xrpl/protocol_autogen/ledger_entries/AccountRoot.h>
+#include <xrpl/protocol_autogen/ledger_entries/RippleState.h>
+#include <xrpl/protocol_autogen/transactions/AccountSet.h>
+#include <xrpl/protocol_autogen/transactions/Payment.h>
+#include <xrpl/tx/apply.h>
+
+#include <helpers/Account.h>
+#include <helpers/IOU.h>
+
+#include <cstdint>
+#include <memory>
+#include <optional>
+#include <stdexcept>
+#include <utility>
+#include <vector>
+
+namespace xrpl::test {
+
+//------------------------------------------------------------------------------
+// Feature helpers
+//------------------------------------------------------------------------------
+
+FeatureBitset
+allFeatures()
+{
+    static FeatureBitset const features = [] {
+        auto const& sa = allAmendments();
+        std::vector<uint256> feats;
+        feats.reserve(sa.size());
+        for ([[maybe_unused]] auto const& [name, _] : sa)
+        {
+            if (auto const f = getRegisteredFeature(name); f.has_value())
+                feats.push_back(*f);
+        }
+        return FeatureBitset(feats);
+    }();
+    return features;
+}
+
+//------------------------------------------------------------------------------
+// TxTest
+//------------------------------------------------------------------------------
+
+TxTest::TxTest(std::optional<FeatureBitset> features)
+{
+    // Convert FeatureBitset to unordered_set for Rules constructor
+    auto const featureBits = features.value_or(allFeatures());
+    foreachFeature(featureBits, [&](uint256 const& f) { featureSet_.insert(f); });
+
+    // Create rules with the specified features
+    rules_.emplace(featureSet_);
+
+    // Default fees for testing
+    Fees const fees{XRPAmount{10}, XRPAmount{10000000}, XRPAmount{2000000}};
+
+    // Create a genesis ledger as the base
+    closedLedger_ = std::make_shared<Ledger>(
+        create_genesis,
+        // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+        *rules_,
+        fees,
+        std::vector<uint256>{featureSet_.begin(), featureSet_.end()},
+        registry_.getNodeFamily());
+
+    // Initialize time from the genesis ledger
+    now_ = closedLedger_->header().closeTime;
+
+    // Create an open view on top of the genesis ledger
+    openLedger_ =
+        std::make_shared<OpenView>(open_ledger, closedLedger_.get(), *rules_, closedLedger_);
+}
+
+bool
+TxTest::isEnabled(uint256 const& feature) const
+{
+    // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+    return rules_->enabled(feature);
+}
+
+Rules const&
+TxTest::getRules() const
+{
+    // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+    return *rules_;
+}
+
+[[nodiscard]] TxResult
+TxTest::submit(std::shared_ptr<STTx const> stx)
+{
+    auto result = apply(registry_, *openLedger_, *stx, tapNONE, registry_.getJournal("apply"));
+
+    // Track successfully applied transactions for canonical reordering on close
+    // We make a copy since the TransactionBase doesn't own the STTx
+    if (result.applied)
+        pendingTxs_.push_back(stx);
+
+    return TxResult{
+        .ter = result.ter,
+        .applied = result.applied,
+        .metadata = std::move(result).metadata,
+        .tx = std::move(stx)};
+}
+
+void
+TxTest::createAccount(Account const& account, XRPAmount xrp, uint32_t accountFlags)
+{
+    auto const paymentTer =
+        submit(transactions::PaymentBuilder{Account::master, account, xrp}, Account::master).ter;
+
+    if (paymentTer != tesSUCCESS)
+    {
+        throw std::runtime_error("TxTest::createAccount: failed to create account");
+    }
+
+    close();
+
+    if (accountFlags != 0)
+    {
+        auto const accountSetTer =
+            submit(transactions::AccountSetBuilder{account}.setSetFlag(accountFlags), account).ter;
+        if (accountSetTer != tesSUCCESS)
+        {
+            throw std::runtime_error("TxTest::createAccount: failed to set account flags");
+        }
+        close();
+    }
+}
+
+ledger_entries::AccountRoot
+TxTest::getAccountRoot(AccountID const& id) const
+{
+    auto const sle = getOpenLedger().read(keylet::account(id));
+    if (!sle)
+        Throw<std::runtime_error>("TxTest::getAccountRoot: account not found");
+    return ledger_entries::AccountRoot{std::const_pointer_cast<SLE const>(sle)};
+}
+
+OpenView&
+TxTest::getOpenLedger()
+{
+    return *openLedger_;
+}
+
+OpenView const&
+TxTest::getOpenLedger() const
+{
+    return *openLedger_;
+}
+
+ReadView const&
+TxTest::getClosedLedger() const
+{
+    return *closedLedger_;
+}
+
+void
+TxTest::close()
+{
+    // Build a new closed ledger from the previous closed ledger,
+    // similar to how buildLedgerImpl works:
+    // 1. Create a new Ledger from the previous closed ledger
+    // 2. Re-apply transactions in canonical order
+    // 3. Mark it as accepted/immutable
+
+    auto const& prevLedger = *closedLedger_;
+
+    auto const ledgerCloseTime = now_ + prevLedger.header().closeTimeResolution;
+
+    now_ = ledgerCloseTime;
+
+    auto newLedger = std::make_shared<Ledger>(prevLedger, ledgerCloseTime);
+
+    CanonicalTXSet txSet(prevLedger.header().hash);
+    for (auto const& tx : pendingTxs_)
+        txSet.insert(tx);
+
+    {
+        OpenView accum(&*newLedger);
+        for (auto const& [key, tx] : txSet)
+        {
+            auto result = apply(registry_, accum, *tx, tapNONE, registry_.getJournal("apply"));
+            if (!result.applied)
+            {
+                throw std::runtime_error("TxTest::close: failed to apply transaction");
+            }
+        }
+        accum.apply(*newLedger);
+    }
+
+    newLedger->setAccepted(ledgerCloseTime, newLedger->header().closeTimeResolution, true);
+
+    closedLedger_ = newLedger;
+
+    pendingTxs_.clear();
+
+    openLedger_ =
+        // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+        std::make_shared<OpenView>(open_ledger, closedLedger_.get(), *rules_, closedLedger_);
+}
+
+void
+TxTest::advanceTime(NetClock::duration duration)
+{
+    now_ += duration;
+}
+
+NetClock::time_point
+TxTest::getCloseTime() const
+{
+    return now_;
+}
+
+STAmount
+TxTest::getBalance(AccountID const& account, IOU const& iou) const
+{
+    auto const sle = openLedger_->read(keylet::line(account, iou.issue()));
+    if (!sle)
+        return STAmount{iou.issue(), 0};
+
+    auto const rippleState = ledger_entries::RippleState{sle};
+
+    auto balance = rippleState.getBalance();
+    if (iou.issue().account == account)
+    {
+        throw std::logic_error("TxTest::getBalance: account is issuer");
+    }
+
+    balance.get<Issue>().account = iou.issue().account;
+    if (account > iou.issue().account)
+        balance.negate();
+    return balance;
+}
+
+}  // namespace xrpl::test
diff --git a/src/tests/libxrpl/helpers/TxTest.h b/src/tests/libxrpl/helpers/TxTest.h
new file mode 100644
index 0000000000..864b19c399
--- /dev/null
+++ b/src/tests/libxrpl/helpers/TxTest.h
@@ -0,0 +1,364 @@
+#pragma once
+
+#include <xrpl/basics/Number.h>
+#include <xrpl/basics/chrono.h>
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/core/ServiceRegistry.h>
+#include <xrpl/ledger/ApplyViewImpl.h>
+#include <xrpl/ledger/Ledger.h>
+#include <xrpl/ledger/OpenView.h>
+#include <xrpl/protocol/Feature.h>
+#include <xrpl/protocol/LedgerFormats.h>
+#include <xrpl/protocol/Rules.h>
+#include <xrpl/protocol/STTx.h>
+#include <xrpl/protocol/TER.h>
+#include <xrpl/protocol/TxFlags.h>
+#include <xrpl/protocol/XRPAmount.h>
+#include <xrpl/protocol_autogen/TransactionBuilderBase.h>
+#include <xrpl/protocol_autogen/ledger_entries/AccountRoot.h>
+#include <xrpl/tx/applySteps.h>
+
+#include <helpers/Account.h>
+#include <helpers/IOU.h>
+#include <helpers/TestServiceRegistry.h>
+
+#include <cmath>
+#include <concepts>
+#include <memory>
+#include <optional>
+#include <stdexcept>
+#include <type_traits>
+#include <unordered_set>
+#include <vector>
+
+namespace xrpl::test {
+
+//------------------------------------------------------------------------------
+// Amount helpers
+//------------------------------------------------------------------------------
+
+/**
+ * @brief Convert XRP to drops (integral types).
+ * @param xrp The amount in XRP.
+ * @return The equivalent amount in drops as XRPAmount.
+ */
+template <std::integral T>
+constexpr XRPAmount
+XRP(T xrp)
+{
+    return XRPAmount{static_cast<std::int64_t>(xrp) * DROPS_PER_XRP.drops()};
+}
+
+/**
+ * @brief Convert XRP to drops (floating point types).
+ * @param xrp The amount in XRP (may be fractional).
+ * @return The equivalent amount in drops as XRPAmount.
+ */
+template <std::floating_point T>
+XRPAmount
+XRP(T xrp)
+{
+    return XRPAmount{static_cast<std::int64_t>(std::round(xrp * DROPS_PER_XRP.drops()))};
+}
+
+/**
+ * @brief Convert XRP to drops (Number type).
+ * @param xrp The amount in XRP as a Number.
+ * @return The equivalent amount in drops as XRPAmount.
+ */
+inline XRPAmount
+XRP(Number const& xrp)
+{
+    return XRPAmount{static_cast<std::int64_t>(xrp * DROPS_PER_XRP.drops())};
+}
+
+//------------------------------------------------------------------------------
+// Flag helpers
+//------------------------------------------------------------------------------
+
+/**
+ * @brief Convert AccountSet flag (asf) to LedgerState flag (lsf).
+ * @param asf The AccountSet flag value.
+ * @return The corresponding LedgerState flag.
+ * @throws std::runtime_error if the flag is not supported.
+ *
+ * Supported flags:
+ *   asfRequireDest, asfRequireAuth, asfDisallowXRP, asfDisableMaster,
+ *   asfNoFreeze, asfGlobalFreeze, asfDefaultRipple, asfDepositAuth,
+ *   asfAllowTrustLineClawback, asfDisallowIncomingCheck,
+ *   asfDisallowIncomingNFTokenOffer, asfDisallowIncomingPayChan,
+ *   asfDisallowIncomingTrustline, asfAllowTrustLineLocking
+ */
+constexpr std::uint32_t
+asfToLsf(std::uint32_t asf)
+{
+    switch (asf)
+    {
+        case asfRequireDest:
+            return lsfRequireDestTag;
+        case asfRequireAuth:
+            return lsfRequireAuth;
+        case asfDisallowXRP:
+            return lsfDisallowXRP;
+        case asfDisableMaster:
+            return lsfDisableMaster;
+        case asfNoFreeze:
+            return lsfNoFreeze;
+        case asfGlobalFreeze:
+            return lsfGlobalFreeze;
+        case asfDefaultRipple:
+            return lsfDefaultRipple;
+        case asfDepositAuth:
+            return lsfDepositAuth;
+        case asfAllowTrustLineClawback:
+            return lsfAllowTrustLineClawback;
+        case asfDisallowIncomingCheck:
+            return lsfDisallowIncomingCheck;
+        case asfDisallowIncomingNFTokenOffer:
+            return lsfDisallowIncomingNFTokenOffer;
+        case asfDisallowIncomingPayChan:
+            return lsfDisallowIncomingPayChan;
+        case asfDisallowIncomingTrustline:
+            return lsfDisallowIncomingTrustline;
+        case asfAllowTrustLineLocking:
+            return lsfAllowTrustLineLocking;
+        default:
+            throw std::runtime_error("Unknown asf flag");
+    }
+}
+
+//------------------------------------------------------------------------------
+// Feature helpers
+//------------------------------------------------------------------------------
+
+/**
+ * @brief Returns all testable amendments.
+ * @note This is similar to jtx::testable_amendments() but for the TxTest framework.
+ */
+FeatureBitset
+allFeatures();
+
+//------------------------------------------------------------------------------
+// TxResult
+//------------------------------------------------------------------------------
+
+/**
+ * @brief Result of a transaction submission in TxTest.
+ *
+ * Contains the TER code, whether the transaction was applied,
+ * optional metadata, and a reference to the submitted transaction.
+ * Use standard gtest macros (EXPECT_EQ, EXPECT_TRUE, etc.) to verify results.
+ */
+struct TxResult
+{
+    TER ter;                        /**< The transaction engine result code. */
+    bool applied;                   /**< Whether the transaction was applied to the ledger. */
+    std::optional<TxMeta> metadata; /**< Transaction metadata, if available. */
+    std::shared_ptr<STTx const> tx; /**< Pointer to the submitted transaction. */
+};
+
+/**
+ * @brief A lightweight transaction testing harness.
+ *
+ * Unlike the JTx framework which requires a full Application and RPC layer,
+ * TxTest applies transactions directly to an OpenView using the transactor
+ * pipeline (preflight -> preclaim -> doApply).
+ *
+ * This makes it suitable for:
+ * - Unit testing individual transactors
+ * - Testing transaction validation logic
+ * - Fast, focused tests without full server infrastructure
+ *
+ * @code
+ *     TxTest env;
+ *     env.submit(paymentTx).expectSuccess();
+ *     env.submit(badTx).expectTer(tecNO_ENTRY);
+ * @endcode
+ */
+class TxTest
+{
+public:
+    /**
+     * @brief Construct a TxTest environment.
+     *
+     * Creates a genesis ledger and an open view on top of it.
+     *
+     * @param features Optional set of features to enable. If not specified,
+     *                 uses all testable amendments.
+     */
+    explicit TxTest(std::optional<FeatureBitset> features = std::nullopt);
+
+    /**
+     * @brief Check if a feature is enabled.
+     * @param feature The feature to check.
+     * @return True if the feature is enabled.
+     */
+    [[nodiscard]] bool
+    isEnabled(uint256 const& feature) const;
+
+    /**
+     * @brief Get the current rules.
+     * @return The current consensus rules.
+     */
+    [[nodiscard]] Rules const&
+    getRules() const;
+
+    /**
+     * @brief Submit a transaction from a builder.
+     *
+     * Convenience overload that accepts transaction builders.
+     * Automatically sets sequence and fee before submission.
+     *
+     * @tparam T A type derived from TransactionBuilderBase.
+     * @param builder The transaction builder.
+     * @param signer The account to sign with.
+     * @return TxResult containing the result code, applied status, and metadata.
+     */
+    template <typename T>
+        requires std::
+            derived_from<std::decay_t<T>, transactions::TransactionBuilderBase<std::decay_t<T>>>
+        [[nodiscard]] TxResult
+        submit(T&& builder, Account const& signer)
+    {
+        auto const& obj = builder.getSTObject();
+        auto accountId = obj[sfAccount];
+        // Only set sequence if not using a ticket (ticket sets sequence to 0)
+        if (!obj.isFieldPresent(sfTicketSequence))
+        {
+            builder.setSequence(getAccountRoot(accountId).getSequence());
+        }
+        else
+        {
+            builder.setSequence(0);
+        }
+        builder.setFee(XRPAmount(10));
+        return submit(builder.build(signer.pk(), signer.sk()).getSTTx());
+    }
+
+    /**
+     * @brief Submit a transaction to the open ledger.
+     *
+     * Applies the transaction through the full transactor pipeline:
+     * preflight -> preclaim -> doApply -> invariant checks
+     *
+     * Invariant checks are automatically run after doApply. If any
+     * invariant fails, the result will be tecINVARIANT_FAILED.
+     *
+     * @param stx The transaction to submit.
+     * @return TxResult containing the result code, applied status, and metadata.
+     */
+    [[nodiscard]] TxResult
+    submit(std::shared_ptr<STTx const> stx);
+
+    /**
+     * @brief Create a new account in the ledger.
+     *
+     * Sends a Payment from the master account to create and fund the account.
+     * Closes the ledger after creation. If accountFlags is non-zero, submits
+     * an AccountSet transaction and closes again.
+     *
+     * @param account The account to create.
+     * @param xrp The initial XRP balance.
+     * @param accountFlags Optional account flags to set. Defaults to 0
+     *        (no flags).
+     */
+    void
+    createAccount(Account const& account, XRPAmount xrp, uint32_t accountFlags = 0);
+
+    /**
+     * @brief Get the account root object from the current open ledger.
+     * @param id The account ID.
+     * @return The AccountRoot ledger entry.
+     * @throws std::runtime_error if the account does not exist.
+     * @todo Once we make keylet strongly typed, we can ditch this method.
+     */
+    [[nodiscard]] ledger_entries::AccountRoot
+    getAccountRoot(AccountID const& id) const;
+
+    /**
+     * @brief Get the current open ledger view.
+     * @return A mutable reference to the open ledger.
+     */
+    [[nodiscard]] OpenView&
+    getOpenLedger();
+
+    /**
+     * @brief Get the current open ledger view (const).
+     * @return A const reference to the open ledger.
+     */
+    [[nodiscard]] OpenView const&
+    getOpenLedger() const;
+
+    /**
+     * @brief Get the closed (base) ledger view.
+     * @return A const reference to the closed ledger.
+     */
+    [[nodiscard]] ReadView const&
+    getClosedLedger() const;
+
+    /**
+     * @brief Close the current ledger.
+     *
+     * Creates a new closed ledger from the current open ledger.
+     * All pending transactions are re-applied in canonical order.
+     */
+    void
+    close();
+
+    /**
+     * @brief Advance time without closing the ledger.
+     *
+     * Useful for testing time-dependent features like escrow release
+     * times or offer expirations.
+     *
+     * @param duration The amount of time to advance.
+     */
+    void
+    advanceTime(NetClock::duration duration);
+
+    /**
+     * @brief Get the current ledger close time.
+     * @return The current close time.
+     */
+    [[nodiscard]] NetClock::time_point
+    getCloseTime() const;
+
+    /**
+     * @brief Get the balance of an IOU for an account.
+     *
+     * Returns the balance from the perspective of the specified account.
+     * If the trust line doesn't exist, returns zero.
+     *
+     * @param account The account to check.
+     * @param iou The IOU to check the balance for.
+     * @return The balance as an STAmount.
+     * @todo Once we make keylet strongly typed, we can ditch this method.
+     */
+    [[nodiscard]] STAmount
+    getBalance(AccountID const& account, IOU const& iou) const;
+
+    /**
+     * @brief Get the service registry.
+     * @return A reference to the service registry.
+     */
+    ServiceRegistry&
+    getServiceRegistry()
+    {
+        return registry_;
+    }
+
+private:
+    TestServiceRegistry registry_;
+    std::unordered_set<uint256, beast::uhash<>> featureSet_;
+    std::optional<Rules> rules_;
+    std::shared_ptr<Ledger const> closedLedger_;
+    std::shared_ptr<OpenView> openLedger_;
+
+    /** Transactions submitted to the open ledger, for canonical reordering on close. */
+    std::vector<std::shared_ptr<STTx const>> pendingTxs_;
+
+    /** Current time (can be advanced arbitrarily for testing). */
+    NetClock::time_point now_;
+};
+
+}  // namespace xrpl::test
diff --git a/src/tests/libxrpl/json/Writer.cpp b/src/tests/libxrpl/json/Writer.cpp
index a21f27199f..71fead1b69 100644
--- a/src/tests/libxrpl/json/Writer.cpp
+++ b/src/tests/libxrpl/json/Writer.cpp
@@ -83,11 +83,11 @@ TEST_F(WriterFixture, primitives)
 
 TEST_F(WriterFixture, empty)
 {
-    writer->startRoot(Writer::array);
+    writer->startRoot(Writer::CollectionType::array);
     writer->finish();
     checkOutputAndReset("[]");
 
-    writer->startRoot(Writer::object);
+    writer->startRoot(Writer::CollectionType::object);
     writer->finish();
     checkOutputAndReset("{}");
 }
@@ -112,7 +112,7 @@ TEST_F(WriterFixture, escaping)
 
 TEST_F(WriterFixture, array)
 {
-    writer->startRoot(Writer::array);
+    writer->startRoot(Writer::CollectionType::array);
     writer->append(12);
     writer->finish();
     checkOutputAndReset("[12]");
@@ -120,7 +120,7 @@ TEST_F(WriterFixture, array)
 
 TEST_F(WriterFixture, long_array)
 {
-    writer->startRoot(Writer::array);
+    writer->startRoot(Writer::CollectionType::array);
     writer->append(12);
     writer->append(true);
     writer->append("hello");
@@ -130,8 +130,8 @@ TEST_F(WriterFixture, long_array)
 
 TEST_F(WriterFixture, embedded_array_simple)
 {
-    writer->startRoot(Writer::array);
-    writer->startAppend(Writer::array);
+    writer->startRoot(Writer::CollectionType::array);
+    writer->startAppend(Writer::CollectionType::array);
     writer->finish();
     writer->finish();
     checkOutputAndReset("[[]]");
@@ -139,7 +139,7 @@ TEST_F(WriterFixture, embedded_array_simple)
 
 TEST_F(WriterFixture, object)
 {
-    writer->startRoot(Writer::object);
+    writer->startRoot(Writer::CollectionType::object);
     writer->set("hello", "world");
     writer->finish();
     checkOutputAndReset(R"({"hello":"world"})");
@@ -147,15 +147,15 @@ TEST_F(WriterFixture, object)
 
 TEST_F(WriterFixture, complex_object)
 {
-    writer->startRoot(Writer::object);
+    writer->startRoot(Writer::CollectionType::object);
     writer->set("hello", "world");
-    writer->startSet(Writer::array, "array");
+    writer->startSet(Writer::CollectionType::array, "array");
     writer->append(true);
     writer->append(12);
-    writer->startAppend(Writer::array);
-    writer->startAppend(Writer::object);
+    writer->startAppend(Writer::CollectionType::array);
+    writer->startAppend(Writer::CollectionType::object);
     writer->set("goodbye", "cruel world.");
-    writer->startSet(Writer::array, "subarray");
+    writer->startSet(Writer::CollectionType::array, "subarray");
     writer->append(23.5);
     writer->finishAll();
     checkOutputAndReset(
@@ -166,7 +166,7 @@ TEST_F(WriterFixture, json_value)
 {
     Json::Value value(Json::objectValue);
     value["foo"] = 23;
-    writer->startRoot(Writer::object);
+    writer->startRoot(Writer::CollectionType::object);
     writer->set("hello", value);
     writer->finish();
     checkOutputAndReset(R"({"hello":{"foo":23}})");
diff --git a/src/tests/libxrpl/protocol_autogen/ledger_entries/DelegateTests.cpp b/src/tests/libxrpl/protocol_autogen/ledger_entries/DelegateTests.cpp
index 68d0e6c08e..24c7c97d7f 100644
--- a/src/tests/libxrpl/protocol_autogen/ledger_entries/DelegateTests.cpp
+++ b/src/tests/libxrpl/protocol_autogen/ledger_entries/DelegateTests.cpp
@@ -24,6 +24,7 @@ TEST(DelegateTests, BuilderSettersRoundTrip)
     auto const authorizeValue = canonical_ACCOUNT();
     auto const permissionsValue = canonical_ARRAY();
     auto const ownerNodeValue = canonical_UINT64();
+    auto const destinationNodeValue = canonical_UINT64();
     auto const previousTxnIDValue = canonical_UINT256();
     auto const previousTxnLgrSeqValue = canonical_UINT32();
 
@@ -36,6 +37,7 @@ TEST(DelegateTests, BuilderSettersRoundTrip)
         previousTxnLgrSeqValue
     };
 
+    builder.setDestinationNode(destinationNodeValue);
 
     builder.setLedgerIndex(index);
     builder.setFlags(0x1u);
@@ -82,6 +84,14 @@ TEST(DelegateTests, BuilderSettersRoundTrip)
         expectEqualField(expected, actual, "sfPreviousTxnLgrSeq");
     }
 
+    {
+        auto const& expected = destinationNodeValue;
+        auto const actualOpt = entry.getDestinationNode();
+        ASSERT_TRUE(actualOpt.has_value());
+        expectEqualField(expected, *actualOpt, "sfDestinationNode");
+        EXPECT_TRUE(entry.hasDestinationNode());
+    }
+
     EXPECT_TRUE(entry.hasLedgerIndex());
     auto const ledgerIndex = entry.getLedgerIndex();
     ASSERT_TRUE(ledgerIndex.has_value());
@@ -99,6 +109,7 @@ TEST(DelegateTests, BuilderFromSleRoundTrip)
     auto const authorizeValue = canonical_ACCOUNT();
     auto const permissionsValue = canonical_ARRAY();
     auto const ownerNodeValue = canonical_UINT64();
+    auto const destinationNodeValue = canonical_UINT64();
     auto const previousTxnIDValue = canonical_UINT256();
     auto const previousTxnLgrSeqValue = canonical_UINT32();
 
@@ -108,6 +119,7 @@ TEST(DelegateTests, BuilderFromSleRoundTrip)
     sle->at(sfAuthorize) = authorizeValue;
     sle->setFieldArray(sfPermissions, permissionsValue);
     sle->at(sfOwnerNode) = ownerNodeValue;
+    sle->at(sfDestinationNode) = destinationNodeValue;
     sle->at(sfPreviousTxnID) = previousTxnIDValue;
     sle->at(sfPreviousTxnLgrSeq) = previousTxnLgrSeqValue;
 
@@ -180,6 +192,19 @@ TEST(DelegateTests, BuilderFromSleRoundTrip)
         expectEqualField(expected, fromBuilder, "sfPreviousTxnLgrSeq");
     }
 
+    {
+        auto const& expected = destinationNodeValue;
+
+        auto const fromSleOpt = entryFromSle.getDestinationNode();
+        auto const fromBuilderOpt = entryFromBuilder.getDestinationNode();
+
+        ASSERT_TRUE(fromSleOpt.has_value());
+        ASSERT_TRUE(fromBuilderOpt.has_value());
+
+        expectEqualField(expected, *fromSleOpt, "sfDestinationNode");
+        expectEqualField(expected, *fromBuilderOpt, "sfDestinationNode");
+    }
+
     EXPECT_EQ(entryFromSle.getKey(), index);
     EXPECT_EQ(entryFromBuilder.getKey(), index);
 }
@@ -220,4 +245,31 @@ TEST(DelegateTests, BuilderThrowsOnWrongEntryType)
     EXPECT_THROW(DelegateBuilder{wrongEntry.getSle()}, std::runtime_error);
 }
 
+// 5) Build with only required fields and verify optional fields return nullopt.
+TEST(DelegateTests, OptionalFieldsReturnNullopt)
+{
+    uint256 const index{3u};
+
+    auto const accountValue = canonical_ACCOUNT();
+    auto const authorizeValue = canonical_ACCOUNT();
+    auto const permissionsValue = canonical_ARRAY();
+    auto const ownerNodeValue = canonical_UINT64();
+    auto const previousTxnIDValue = canonical_UINT256();
+    auto const previousTxnLgrSeqValue = canonical_UINT32();
+
+    DelegateBuilder builder{
+        accountValue,
+        authorizeValue,
+        permissionsValue,
+        ownerNodeValue,
+        previousTxnIDValue,
+        previousTxnLgrSeqValue
+    };
+
+    auto const entry = builder.build(index);
+
+    // Verify optional fields are not present
+    EXPECT_FALSE(entry.hasDestinationNode());
+    EXPECT_FALSE(entry.getDestinationNode().has_value());
+}
 }
diff --git a/src/tests/libxrpl/tx/AccountSet.cpp b/src/tests/libxrpl/tx/AccountSet.cpp
new file mode 100644
index 0000000000..3dbe7a4903
--- /dev/null
+++ b/src/tests/libxrpl/tx/AccountSet.cpp
@@ -0,0 +1,804 @@
+#include <xrpl/protocol_autogen/transactions/AccountSet.h>
+
+#include <xrpl/basics/Slice.h>
+#include <xrpl/basics/base_uint.h>
+#include <xrpl/beast/utility/Zero.h>
+#include <xrpl/core/ServiceRegistry.h>
+#include <xrpl/ledger/helpers/DirectoryHelpers.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/KeyType.h>
+#include <xrpl/protocol/LedgerFormats.h>
+#include <xrpl/protocol/Quality.h>
+#include <xrpl/protocol/Rate.h>
+#include <xrpl/protocol/SField.h>
+#include <xrpl/protocol/STArray.h>
+#include <xrpl/protocol/STObject.h>
+#include <xrpl/protocol/STTx.h>
+#include <xrpl/protocol/SecretKey.h>
+#include <xrpl/protocol/TER.h>
+#include <xrpl/protocol/TxFlags.h>
+#include <xrpl/protocol_autogen/ledger_entries/AccountRoot.h>
+#include <xrpl/protocol_autogen/transactions/Payment.h>
+#include <xrpl/protocol_autogen/transactions/SetRegularKey.h>
+#include <xrpl/protocol_autogen/transactions/SignerListSet.h>
+#include <xrpl/protocol_autogen/transactions/TicketCreate.h>
+#include <xrpl/protocol_autogen/transactions/TrustSet.h>
+
+#include <gtest/gtest.h>
+#include <helpers/Account.h>
+#include <helpers/IOU.h>
+#include <helpers/TxTest.h>
+
+#include <algorithm>
+#include <cstddef>
+#include <cstdint>
+#include <initializer_list>
+#include <limits>
+#include <memory>
+#include <string>
+#include <string_view>
+#include <utility>
+#include <vector>
+
+namespace xrpl::test {
+
+TEST(AccountSet, NullAccountSet)
+{
+    TxTest env;
+
+    Account const alice("alice");
+    env.createAccount(alice, XRP(10));
+
+    auto& view = env.getOpenLedger();
+
+    // ask for the ledger entry - account root, to check its flags
+    auto sle = view.read(keylet::account(alice));
+
+    EXPECT_NE(sle, nullptr);
+    ledger_entries::AccountRoot const accountRoot(sle);
+    EXPECT_EQ(accountRoot.getFlags(), 0);
+}
+
+TEST(AccountSet, MostFlags)
+{
+    Account const alice("alice");
+
+    TxTest env;
+    env.createAccount(alice, XRP(10000));
+
+    // Give alice a regular key so she can legally set and clear
+    // her asfDisableMaster flag.
+    Account const aliceRegularKey{"aliceRegularKey", KeyType::secp256k1};
+
+    env.createAccount(aliceRegularKey, XRP(10000));
+    env.close();
+
+    EXPECT_EQ(
+        env.submit(transactions::SetRegularKeyBuilder{alice}.setRegularKey(aliceRegularKey), alice)
+            .ter,
+        tesSUCCESS);
+    env.close();
+
+    auto testFlags = [&alice, &aliceRegularKey, &env](
+                         std::initializer_list<std::uint32_t> goodFlags) {
+        std::uint32_t const orig_flags = env.getAccountRoot(alice).getFlags();
+        for (std::uint32_t flag{1u}; flag < std::numeric_limits<std::uint32_t>::digits; ++flag)
+        {
+            if (flag == asfNoFreeze)
+            {
+                // The asfNoFreeze flag can't be cleared.  It is tested
+                // elsewhere.
+                continue;
+            }
+            if (flag == asfAuthorizedNFTokenMinter)
+            {
+                // The asfAuthorizedNFTokenMinter flag requires the
+                // presence or absence of the sfNFTokenMinter field in
+                // the transaction.  It is tested elsewhere.
+                continue;
+            }
+
+            if (flag == asfDisallowIncomingCheck || flag == asfDisallowIncomingPayChan ||
+                flag == asfDisallowIncomingNFTokenOffer || flag == asfDisallowIncomingTrustline)
+            {
+                // These flags are part of the DisallowIncoming amendment
+                // and are tested elsewhere
+                continue;
+            }
+            if (flag == asfAllowTrustLineClawback)
+            {
+                // The asfAllowTrustLineClawback flag can't be cleared.  It
+                // is tested elsewhere.
+                continue;
+            }
+            if (flag == asfAllowTrustLineLocking)
+            {
+                // These flags are part of the AllowTokenLocking amendment
+                // and are tested elsewhere
+                continue;
+            }
+            if (std::ranges::find(goodFlags, flag) != goodFlags.end())
+            {
+                // Good flag
+                EXPECT_FALSE(env.getAccountRoot(alice).isFlag(asfToLsf(flag)));
+
+                EXPECT_EQ(
+                    env.submit(transactions::AccountSetBuilder{alice}.setSetFlag(flag), alice).ter,
+                    tesSUCCESS);
+                env.close();
+
+                EXPECT_TRUE(env.getAccountRoot(alice).isFlag(asfToLsf(flag)));
+
+                EXPECT_EQ(
+                    env.submit(
+                           transactions::AccountSetBuilder{alice}.setClearFlag(flag),
+                           aliceRegularKey)
+                        .ter,
+                    tesSUCCESS);
+                env.close();
+
+                EXPECT_FALSE(env.getAccountRoot(alice).isFlag(asfToLsf(flag)));
+
+                std::uint32_t const now_flags = env.getAccountRoot(alice).getFlags();
+                EXPECT_EQ(now_flags, orig_flags);
+            }
+            else
+            {
+                // Bad flag
+                EXPECT_EQ(env.getAccountRoot(alice).getFlags(), orig_flags);
+                EXPECT_EQ(
+                    env.submit(transactions::AccountSetBuilder{alice}.setSetFlag(flag), alice).ter,
+                    tesSUCCESS);
+                env.close();
+                EXPECT_EQ(env.getAccountRoot(alice).getFlags(), orig_flags);
+
+                EXPECT_EQ(
+                    env.submit(
+                           transactions::AccountSetBuilder{alice}.setClearFlag(flag),
+                           aliceRegularKey)
+                        .ter,
+                    tesSUCCESS);
+                env.close();
+                EXPECT_EQ(env.getAccountRoot(alice).getFlags(), orig_flags);
+            }
+        }
+    };
+    testFlags({
+        asfRequireDest,
+        asfRequireAuth,
+        asfDisallowXRP,
+        asfGlobalFreeze,
+        asfDisableMaster,
+        asfDefaultRipple,
+        asfDepositAuth,
+    });
+}
+
+TEST(AccountSet, SetAndResetAccountTxnID)
+{
+    TxTest env;
+    Account const alice("alice");
+
+    env.createAccount(alice, XRP(10000));
+
+    std::uint32_t const orig_flags = env.getAccountRoot(alice).getFlags();
+
+    // asfAccountTxnID is special and not actually set as a flag,
+    // so we check the field presence instead
+    EXPECT_FALSE(env.getAccountRoot(alice).hasAccountTxnID());
+
+    EXPECT_EQ(
+        env.submit(transactions::AccountSetBuilder{alice}.setSetFlag(asfAccountTxnID), alice).ter,
+        tesSUCCESS);
+    env.close();
+
+    EXPECT_TRUE(env.getAccountRoot(alice).hasAccountTxnID());
+
+    EXPECT_EQ(
+        env.submit(transactions::AccountSetBuilder{alice}.setClearFlag(asfAccountTxnID), alice).ter,
+        tesSUCCESS);
+    env.close();
+
+    EXPECT_FALSE(env.getAccountRoot(alice).hasAccountTxnID());
+
+    std::uint32_t const now_flags = env.getAccountRoot(alice).getFlags();
+    EXPECT_EQ(now_flags, orig_flags);
+}
+
+TEST(AccountSet, SetNoFreeze)
+{
+    TxTest env;
+    Account const alice("alice");
+    Account const eric("eric");
+
+    env.createAccount(alice, XRP(10000));
+    env.close();
+
+    // Set eric as alice's regular key (eric doesn't need to be funded)
+    EXPECT_EQ(
+        env.submit(transactions::SetRegularKeyBuilder{alice}.setRegularKey(eric), alice).ter,
+        tesSUCCESS);
+    env.close();
+
+    // Verify alice doesn't have NoFreeze flag
+    EXPECT_FALSE(env.getAccountRoot(alice).isFlag(lsfNoFreeze));
+
+    // Setting NoFreeze with regular key should fail - requires master key
+    EXPECT_EQ(
+        env.submit(transactions::AccountSetBuilder{alice}.setSetFlag(asfNoFreeze), eric).ter,
+        tecNEED_MASTER_KEY);
+    env.close();
+
+    // Setting NoFreeze with master key should succeed
+    EXPECT_EQ(
+        env.submit(transactions::AccountSetBuilder{alice}.setSetFlag(asfNoFreeze), alice).ter,
+        tesSUCCESS);
+    env.close();
+
+    // Verify alice now has NoFreeze flag
+    EXPECT_TRUE(env.getAccountRoot(alice).isFlag(lsfNoFreeze));
+
+    // Try to clear NoFreeze - transaction succeeds but flag remains set
+    EXPECT_EQ(
+        env.submit(transactions::AccountSetBuilder{alice}.setClearFlag(asfNoFreeze), alice).ter,
+        tesSUCCESS);
+    env.close();
+
+    // Verify flag is still set (NoFreeze cannot be cleared once set)
+    EXPECT_TRUE(env.getAccountRoot(alice).isFlag(lsfNoFreeze));
+}
+
+TEST(AccountSet, Domain)
+{
+    TxTest env;
+    Account const alice("alice");
+
+    env.createAccount(alice, XRP(10000));
+    env.close();
+
+    // The Domain field is represented as the hex string of the lowercase
+    // ASCII of the domain. For example, the domain example.com would be
+    // represented as "6578616d706c652e636f6d".
+    //
+    // To remove the Domain field from an account, send an AccountSet with
+    // the Domain set to an empty string.
+    std::string const domain = "example.com";
+
+    // Set domain
+    EXPECT_EQ(
+        env.submit(transactions::AccountSetBuilder{alice}.setDomain(makeSlice(domain)), alice).ter,
+        tesSUCCESS);
+    env.close();
+
+    EXPECT_TRUE(env.getAccountRoot(alice).hasDomain());
+    // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+    EXPECT_EQ(*env.getAccountRoot(alice).getDomain(), makeSlice(domain));
+
+    // Clear domain by setting empty
+    EXPECT_EQ(
+        env.submit(transactions::AccountSetBuilder{alice}.setDomain(Slice{}), alice).ter,
+        tesSUCCESS);
+    env.close();
+
+    EXPECT_FALSE(env.getAccountRoot(alice).hasDomain());
+
+    // The upper limit on the length is 256 bytes
+    // (defined as DOMAIN_BYTES_MAX in SetAccount)
+    // test the edge cases: 255, 256, 257.
+    std::size_t const maxLength = 256;
+    for (std::size_t len = maxLength - 1; len <= maxLength + 1; ++len)
+    {
+        std::string const domain2 = std::string(len - domain.length() - 1, 'a') + "." + domain;
+
+        EXPECT_EQ(domain2.length(), len);
+
+        if (len <= maxLength)
+        {
+            EXPECT_EQ(
+                env.submit(
+                       transactions::AccountSetBuilder{alice}.setDomain(makeSlice(domain2)), alice)
+                    .ter,
+                tesSUCCESS);
+            env.close();
+
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+            EXPECT_EQ(*env.getAccountRoot(alice).getDomain(), makeSlice(domain2));
+        }
+        else
+        {
+            EXPECT_EQ(
+                env.submit(
+                       transactions::AccountSetBuilder{alice}.setDomain(makeSlice(domain2)), alice)
+                    .ter,
+                telBAD_DOMAIN);
+            env.close();
+        }
+    }
+}
+
+TEST(AccountSet, MessageKey)
+{
+    TxTest env;
+    Account const alice("alice");
+
+    env.createAccount(alice, XRP(10000));
+    env.close();
+
+    // Generate a random ed25519 key pair for the message key
+    auto const rkp = randomKeyPair(KeyType::ed25519);
+
+    // Set the message key
+    EXPECT_EQ(
+        env.submit(transactions::AccountSetBuilder{alice}.setMessageKey(rkp.first.slice()), alice)
+            .ter,
+        tesSUCCESS);
+    env.close();
+
+    EXPECT_TRUE(env.getAccountRoot(alice).hasMessageKey());
+    // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+    EXPECT_EQ(*env.getAccountRoot(alice).getMessageKey(), rkp.first.slice());
+
+    // Clear the message key by setting to empty
+    EXPECT_EQ(
+        env.submit(transactions::AccountSetBuilder{alice}.setMessageKey(Slice{}), alice).ter,
+        tesSUCCESS);
+    env.close();
+
+    EXPECT_FALSE(env.getAccountRoot(alice).hasMessageKey());
+
+    // Try to set an invalid public key - should fail
+    using namespace std::string_literals;
+    EXPECT_EQ(
+        env.submit(
+               transactions::AccountSetBuilder{alice}.setMessageKey(
+                   makeSlice("NOT_REALLY_A_PUBKEY"s)),
+               alice)
+            .ter,
+        telBAD_PUBLIC_KEY);
+}
+
+TEST(AccountSet, WalletID)
+{
+    TxTest env;
+    Account const alice("alice");
+
+    env.createAccount(alice, XRP(10000));
+    env.close();
+
+    std::string_view const locator =
+        "9633EC8AF54F16B5286DB1D7B519EF49EEFC050C0C8AC4384F1D88ACD1BFDF05";
+    uint256 locatorHash{};
+    EXPECT_TRUE(locatorHash.parseHex(locator));
+
+    // Set the wallet locator
+    EXPECT_EQ(
+        env.submit(transactions::AccountSetBuilder{alice}.setWalletLocator(locatorHash), alice).ter,
+        tesSUCCESS);
+    env.close();
+
+    EXPECT_TRUE(env.getAccountRoot(alice).hasWalletLocator());
+    // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+    EXPECT_EQ(*env.getAccountRoot(alice).getWalletLocator(), locatorHash);
+
+    // Clear the wallet locator by setting to zero
+    EXPECT_EQ(
+        env.submit(transactions::AccountSetBuilder{alice}.setWalletLocator(beast::zero), alice).ter,
+        tesSUCCESS);
+    env.close();
+
+    EXPECT_FALSE(env.getAccountRoot(alice).hasWalletLocator());
+}
+
+TEST(AccountSet, EmailHash)
+{
+    TxTest env;
+    Account const alice("alice");
+
+    env.createAccount(alice, XRP(10000));
+    env.close();
+
+    std::string_view const mh = "5F31A79367DC3137FADA860C05742EE6";
+    uint128 emailHash{};
+    EXPECT_TRUE(emailHash.parseHex(mh));
+
+    // Set the email hash
+    EXPECT_EQ(
+        env.submit(transactions::AccountSetBuilder{alice}.setEmailHash(emailHash), alice).ter,
+        tesSUCCESS);
+    env.close();
+
+    EXPECT_TRUE(env.getAccountRoot(alice).hasEmailHash());
+    // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+    EXPECT_EQ(*env.getAccountRoot(alice).getEmailHash(), emailHash);
+
+    // Clear the email hash by setting to zero
+    EXPECT_EQ(
+        env.submit(transactions::AccountSetBuilder{alice}.setEmailHash(beast::zero), alice).ter,
+        tesSUCCESS);
+    env.close();
+
+    EXPECT_FALSE(env.getAccountRoot(alice).hasEmailHash());
+}
+
+TEST(AccountSet, TransferRate)
+{
+    struct TestCase
+    {
+        double set;
+        TER code;
+        double get;
+    };
+
+    // Test data: {rate to set, expected TER, expected stored rate}
+    std::vector<TestCase> const testData = {
+        {1.0, tesSUCCESS, 1.0},
+        {1.1, tesSUCCESS, 1.1},
+        {2.0, tesSUCCESS, 2.0},
+        {2.1, temBAD_TRANSFER_RATE, 2.0},  // > 2.0 is invalid
+        {0.0, tesSUCCESS, 1.0},            // 0 clears the rate (default = 1.0)
+        {2.0, tesSUCCESS, 2.0},
+        {0.9, temBAD_TRANSFER_RATE, 2.0},  // < 1.0 is invalid
+    };
+
+    TxTest env;
+    Account const alice("alice");
+
+    env.createAccount(alice, XRP(10000));
+    env.close();
+
+    for (auto const& r : testData)
+    {
+        auto const rateValue = static_cast<std::uint32_t>(QUALITY_ONE * r.set);
+
+        EXPECT_EQ(
+            env.submit(transactions::AccountSetBuilder{alice}.setTransferRate(rateValue), alice)
+                .ter,
+            r.code);
+        env.close();
+
+        // If the field is not present, expect the default value (1.0)
+        if (!env.getAccountRoot(alice).hasTransferRate())
+        {
+            EXPECT_EQ(r.get, 1.0);
+        }
+        else
+        {
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+            EXPECT_EQ(
+                *env.getAccountRoot(alice).getTransferRate(),
+                static_cast<std::uint32_t>(r.get * QUALITY_ONE));
+        }
+    }
+}
+
+TEST(AccountSet, BadInputs)
+{
+    TxTest env;
+    Account const alice("alice");
+
+    env.createAccount(alice, XRP(10000));
+    env.close();
+
+    // Setting and clearing the same flag is invalid
+    EXPECT_EQ(
+        env.submit(
+               transactions::AccountSetBuilder{alice}
+                   .setSetFlag(asfDisallowXRP)
+                   .setClearFlag(asfDisallowXRP),
+               alice)
+            .ter,
+        temINVALID_FLAG);
+
+    EXPECT_EQ(
+        env.submit(
+               transactions::AccountSetBuilder{alice}
+                   .setSetFlag(asfRequireAuth)
+                   .setClearFlag(asfRequireAuth),
+               alice)
+            .ter,
+        temINVALID_FLAG);
+
+    EXPECT_EQ(
+        env.submit(
+               transactions::AccountSetBuilder{alice}
+                   .setSetFlag(asfRequireDest)
+                   .setClearFlag(asfRequireDest),
+               alice)
+            .ter,
+        temINVALID_FLAG);
+
+    // Setting asf flag while also using corresponding tf flag is invalid
+    EXPECT_EQ(
+        env.submit(
+               transactions::AccountSetBuilder{alice}
+                   .setSetFlag(asfDisallowXRP)
+                   .setFlags(tfAllowXRP),
+               alice)
+            .ter,
+        temINVALID_FLAG);
+
+    EXPECT_EQ(
+        env.submit(
+               transactions::AccountSetBuilder{alice}
+                   .setSetFlag(asfRequireAuth)
+                   .setFlags(tfOptionalAuth),
+               alice)
+            .ter,
+        temINVALID_FLAG);
+
+    EXPECT_EQ(
+        env.submit(
+               transactions::AccountSetBuilder{alice}
+                   .setSetFlag(asfRequireDest)
+                   .setFlags(tfOptionalDestTag),
+               alice)
+            .ter,
+        temINVALID_FLAG);
+
+    // Using invalid flags (mask) is invalid
+    EXPECT_EQ(
+        env.submit(
+               transactions::AccountSetBuilder{alice}
+                   .setSetFlag(asfRequireDest)
+                   .setFlags(tfAccountSetMask),
+               alice)
+            .ter,
+        temINVALID_FLAG);
+
+    // Disabling master key without an alternative key is invalid
+    EXPECT_EQ(
+        env.submit(transactions::AccountSetBuilder{alice}.setSetFlag(asfDisableMaster), alice).ter,
+        tecNO_ALTERNATIVE_KEY);
+}
+
+TEST(AccountSet, RequireAuthWithDir)
+{
+    TxTest env;
+    Account const alice("alice");
+    Account const bob("bob");
+
+    env.createAccount(alice, XRP(10000));
+    env.close();
+
+    // alice should have an empty directory
+    EXPECT_TRUE(dirIsEmpty(env.getClosedLedger(), keylet::ownerDir(alice.id())));
+
+    // Give alice a signer list, then there will be stuff in the directory
+    // Build the SignerEntries array
+    STArray signerEntries(1);
+    {
+        signerEntries.push_back(STObject::makeInnerObject(sfSignerEntry));
+        STObject& entry = signerEntries.back();
+        entry[sfAccount] = bob.id();
+        entry[sfSignerWeight] = std::uint16_t{1};
+    }
+
+    EXPECT_EQ(
+        env.submit(
+               transactions::SignerListSetBuilder{alice, 1}.setSignerEntries(signerEntries), alice)
+            .ter,
+        tesSUCCESS);
+    env.close();
+
+    EXPECT_FALSE(dirIsEmpty(env.getClosedLedger(), keylet::ownerDir(alice.id())));
+
+    // Setting RequireAuth should fail because alice has owner objects
+    EXPECT_EQ(
+        env.submit(transactions::AccountSetBuilder{alice}.setSetFlag(asfRequireAuth), alice).ter,
+        tecOWNERS);
+
+    // Remove the signer list (quorum = 0, no entries)
+    EXPECT_EQ(env.submit(transactions::SignerListSetBuilder{alice, 0}, alice).ter, tesSUCCESS);
+    env.close();
+
+    EXPECT_TRUE(dirIsEmpty(env.getClosedLedger(), keylet::ownerDir(alice.id())));
+
+    // Now setting RequireAuth should succeed
+    EXPECT_EQ(
+        env.submit(transactions::AccountSetBuilder{alice}.setSetFlag(asfRequireAuth), alice).ter,
+        tesSUCCESS);
+}
+
+TEST(AccountSet, Ticket)
+{
+    TxTest env;
+    Account const alice("alice");
+
+    env.createAccount(alice, XRP(10000));
+    env.close();
+
+    // Get alice's current sequence - the ticket will be created at seq + 1
+    std::uint32_t const aliceSeqBefore = env.getAccountRoot(alice.id()).getSequence();
+    std::uint32_t const ticketSeq = aliceSeqBefore + 1;
+
+    // Create a ticket
+    EXPECT_EQ(env.submit(transactions::TicketCreateBuilder{alice, 1}, alice).ter, tesSUCCESS);
+    env.close();
+
+    // Verify alice has 1 owner object (the ticket)
+    EXPECT_EQ(env.getAccountRoot(alice.id()).getOwnerCount(), 1u);
+    // Verify ticket exists
+    EXPECT_TRUE(env.getClosedLedger().exists(keylet::ticket(alice.id(), ticketSeq)));
+
+    // Try using a ticket that alice doesn't have
+    EXPECT_EQ(
+        env.submit(transactions::AccountSetBuilder{alice}.setTicketSequence(ticketSeq + 1), alice)
+            .ter,
+        terPRE_TICKET);
+    env.close();
+
+    // Verify ticket still exists
+    EXPECT_TRUE(env.getClosedLedger().exists(keylet::ticket(alice.id(), ticketSeq)));
+
+    // Get alice's sequence before using the ticket
+    std::uint32_t const aliceSeq = env.getAccountRoot(alice.id()).getSequence();
+
+    // Actually use alice's ticket (noop AccountSet)
+    EXPECT_EQ(
+        env.submit(transactions::AccountSetBuilder{alice}.setTicketSequence(ticketSeq), alice).ter,
+        tesSUCCESS);
+    env.close();
+
+    // Verify ticket is consumed (no owner objects)
+    EXPECT_EQ(env.getAccountRoot(alice.id()).getOwnerCount(), 0u);
+    EXPECT_FALSE(env.getClosedLedger().exists(keylet::ticket(alice.id(), ticketSeq)));
+
+    // Verify alice's sequence did NOT advance (ticket use doesn't increment seq)
+    EXPECT_EQ(env.getAccountRoot(alice.id()).getSequence(), aliceSeq);
+
+    // Try re-using a ticket that alice already used
+    EXPECT_EQ(
+        env.submit(transactions::AccountSetBuilder{alice}.setTicketSequence(ticketSeq), alice).ter,
+        tefNO_TICKET);
+}
+
+TEST(AccountSet, BadSigningKey)
+{
+    TxTest env;
+    Account const alice("alice");
+
+    env.createAccount(alice, XRP(10000));
+    env.close();
+
+    // Build a valid transaction first, then corrupt the signing key
+    auto stx = transactions::AccountSetBuilder{alice}
+                   .setSequence(env.getAccountRoot(alice.id()).getSequence())
+                   .setFee(XRPAmount{10})
+                   .build(alice.pk(), alice.sk())
+                   .getSTTx();
+
+    // Create a copy with a bad signing key
+    STObject obj = *stx;
+    obj.setFieldVL(sfSigningPubKey, makeSlice(std::string("badkey")));
+
+    auto result = env.submit(std::make_shared<STTx>(std::move(obj)));
+    EXPECT_EQ(result.ter, temBAD_SIGNATURE);
+    EXPECT_FALSE(result.applied);
+}
+
+TEST(AccountSet, Gateway)
+{
+    Account const alice("alice");
+    Account const bob("bob");
+    Account const gw("gateway");
+    IOU const USD("USD", gw);
+
+    // Test gateway with a variety of allowed transfer rates
+    for (double transferRate = 1.0; transferRate <= 2.0; transferRate += 0.03125)
+    {
+        TxTest env;
+
+        env.createAccount(gw, XRP(10000), asfDefaultRipple);
+        env.createAccount(alice, XRP(10000), asfDefaultRipple);
+        env.createAccount(bob, XRP(10000), asfDefaultRipple);
+        env.close();
+
+        // Set up trust lines: alice and bob trust gw for USD
+        EXPECT_EQ(
+            env.submit(transactions::TrustSetBuilder{alice}.setLimitAmount(USD.amount(10)), alice)
+                .ter,
+            tesSUCCESS);
+        EXPECT_EQ(
+            env.submit(transactions::TrustSetBuilder{bob}.setLimitAmount(USD.amount(10)), bob).ter,
+            tesSUCCESS);
+        env.close();
+
+        // Set transfer rate on the gateway
+        EXPECT_EQ(
+            env.submit(
+                   transactions::AccountSetBuilder{gw}.setTransferRate(
+                       static_cast<std::uint32_t>(transferRate * QUALITY_ONE)),
+                   gw)
+                .ter,
+            tesSUCCESS);
+        env.close();
+
+        // Calculate the amount with transfer rate applied
+        auto const amount = USD.amount(1);
+        Rate const rate(static_cast<std::uint32_t>(transferRate * QUALITY_ONE));
+        auto const amountWithRate = multiply(amount, rate);
+
+        // Gateway pays alice 10 USD
+        EXPECT_EQ(
+            env.submit(transactions::PaymentBuilder{gw, alice, USD.amount(10)}, gw).ter,
+            tesSUCCESS);
+        env.close();
+
+        // Alice pays bob 1 USD (with sendmax to cover transfer fee)
+        EXPECT_EQ(
+            env.submit(
+                   transactions::PaymentBuilder{alice, bob, USD.amount(1)}.setSendMax(
+                       USD.amount(10)),
+                   alice)
+                .ter,
+            tesSUCCESS);
+        env.close();
+
+        // Check balances
+        EXPECT_EQ(env.getBalance(alice.id(), USD), USD.amount(10) - amountWithRate);
+        EXPECT_EQ(env.getBalance(bob.id(), USD), USD.amount(1));
+    }
+
+    // Test out-of-bounds legacy transfer rates (4.0 and 4.294967295)
+    // These require direct ledger modification since the transactor blocks them
+    for (std::uint32_t const transferRate : {4000000000U, 4294967295U})
+    {
+        TxTest env;
+        env.createAccount(gw, XRP(10000), asfDefaultRipple);
+        env.createAccount(alice, XRP(10000), asfDefaultRipple);
+        env.createAccount(bob, XRP(10000), asfDefaultRipple);
+        env.close();
+
+        // Set up trust lines
+        EXPECT_EQ(
+            env.submit(transactions::TrustSetBuilder{alice}.setLimitAmount(USD.amount(10)), alice)
+                .ter,
+            tesSUCCESS);
+        EXPECT_EQ(
+            env.submit(transactions::TrustSetBuilder{bob}.setLimitAmount(USD.amount(10)), bob).ter,
+            tesSUCCESS);
+        env.close();
+
+        // Set an acceptable transfer rate first (we'll hack it later)
+        EXPECT_EQ(
+            env.submit(
+                   transactions::AccountSetBuilder{gw}.setTransferRate(
+                       static_cast<std::uint32_t>(2.0 * QUALITY_ONE)),
+                   gw)
+                .ter,
+            tesSUCCESS);
+        env.close();
+
+        // Directly modify the ledger to set an out-of-bounds transfer rate
+        // This bypasses the transactor's validation
+        auto& view = env.getOpenLedger();
+        auto slePtr = view.read(keylet::account(gw.id()));
+        ASSERT_NE(slePtr, nullptr);
+        auto sleCopy = std::make_shared<SLE>(*slePtr);
+        (*sleCopy)[sfTransferRate] = transferRate;
+        view.rawReplace(sleCopy);
+
+        // Calculate the amount with the legacy transfer rate
+        auto const amount = USD.amount(1);
+        auto const amountWithRate = multiply(amount, Rate(transferRate));
+
+        // Gateway pays alice 10 USD
+        EXPECT_EQ(
+            env.submit(transactions::PaymentBuilder{gw, alice, USD.amount(10)}, gw).ter,
+            tesSUCCESS);
+
+        // Alice pays bob 1 USD
+        EXPECT_EQ(
+            env.submit(
+                   transactions::PaymentBuilder{alice, bob, amount}.setSendMax(USD.amount(10)),
+                   alice)
+                .ter,
+            tesSUCCESS);
+
+        // Check balances
+        EXPECT_EQ(env.getBalance(alice.id(), USD), USD.amount(10) - amountWithRate);
+        EXPECT_EQ(env.getBalance(bob.id(), USD), amount);
+    }
+}
+
+}  // namespace xrpl::test
diff --git a/src/tests/libxrpl/tx/main.cpp b/src/tests/libxrpl/tx/main.cpp
new file mode 100644
index 0000000000..5142bbe08a
--- /dev/null
+++ b/src/tests/libxrpl/tx/main.cpp
@@ -0,0 +1,8 @@
+#include <gtest/gtest.h>
+
+int
+main(int argc, char** argv)
+{
+    ::testing::InitGoogleTest(&argc, argv);
+    return RUN_ALL_TESTS();
+}
diff --git a/src/xrpld/app/consensus/RCLConsensus.cpp b/src/xrpld/app/consensus/RCLConsensus.cpp
index 6d99c2ee15..262f217680 100644
--- a/src/xrpld/app/consensus/RCLConsensus.cpp
+++ b/src/xrpld/app/consensus/RCLConsensus.cpp
@@ -907,7 +907,7 @@ RCLConsensus::getJson(bool full) const
 {
     Json::Value ret;
     {
-        std::lock_guard const _{mutex_};
+        std::scoped_lock const _{mutex_};
         ret = consensus_.getJson(full);
     }
     ret["validating"] = adaptor_.validating();
@@ -921,7 +921,7 @@ RCLConsensus::timerEntry(
 {
     try
     {
-        std::lock_guard const _{mutex_};
+        std::scoped_lock const _{mutex_};
         consensus_.timerEntry(now, clog);
     }
     catch (SHAMapMissingNode const& mn)
@@ -940,7 +940,7 @@ RCLConsensus::gotTxSet(NetClock::time_point const& now, RCLTxSet const& txSet)
 {
     try
     {
-        std::lock_guard const _{mutex_};
+        std::scoped_lock const _{mutex_};
         consensus_.gotTxSet(now, txSet);
     }
     catch (SHAMapMissingNode const& mn)
@@ -958,14 +958,14 @@ RCLConsensus::simulate(
     NetClock::time_point const& now,
     std::optional<std::chrono::milliseconds> consensusDelay)
 {
-    std::lock_guard const _{mutex_};
+    std::scoped_lock const _{mutex_};
     consensus_.simulate(now, consensusDelay);
 }
 
 bool
 RCLConsensus::peerProposal(NetClock::time_point const& now, RCLCxPeerPos const& newProposal)
 {
-    std::lock_guard const _{mutex_};
+    std::scoped_lock const _{mutex_};
     return consensus_.peerProposal(now, newProposal);
 }
 
@@ -1064,7 +1064,7 @@ RCLConsensus::startRound(
     hash_set<NodeID> const& nowTrusted,
     std::unique_ptr<std::stringstream> const& clog)
 {
-    std::lock_guard const _{mutex_};
+    std::scoped_lock const _{mutex_};
     consensus_.startRound(
         now, prevLgrId, prevLgr, nowUntrusted, adaptor_.preStartRound(prevLgr, nowTrusted), clog);
 }
diff --git a/src/xrpld/app/consensus/RCLConsensus.h b/src/xrpld/app/consensus/RCLConsensus.h
index c965ed3d87..b8695fd46e 100644
--- a/src/xrpld/app/consensus/RCLConsensus.h
+++ b/src/xrpld/app/consensus/RCLConsensus.h
@@ -472,7 +472,7 @@ public:
     RCLCxLedger::ID
     prevLedgerID() const
     {
-        std::lock_guard const _{mutex_};
+        std::scoped_lock const _{mutex_};
         return consensus_.prevLedgerID();
     }
 
diff --git a/src/xrpld/app/ledger/AccountStateSF.cpp b/src/xrpld/app/ledger/AccountStateSF.cpp
index d5fa5d83ff..bca527d3d0 100644
--- a/src/xrpld/app/ledger/AccountStateSF.cpp
+++ b/src/xrpld/app/ledger/AccountStateSF.cpp
@@ -19,7 +19,8 @@ AccountStateSF::gotNode(
     Blob&& nodeData,
     SHAMapNodeType) const
 {
-    db_.store(hotACCOUNT_NODE, std::move(nodeData), nodeHash.as_uint256(), ledgerSeq);
+    db_.store(
+        NodeObjectType::hotACCOUNT_NODE, std::move(nodeData), nodeHash.as_uint256(), ledgerSeq);
 }
 
 std::optional<Blob>
diff --git a/src/xrpld/app/ledger/LedgerHolder.h b/src/xrpld/app/ledger/LedgerHolder.h
index bf9d478c40..322ad85e23 100644
--- a/src/xrpld/app/ledger/LedgerHolder.h
+++ b/src/xrpld/app/ledger/LedgerHolder.h
@@ -28,7 +28,7 @@ public:
             LogicError("LedgerHolder::set with nullptr");
         if (!ledger->isImmutable())
             LogicError("LedgerHolder::set with mutable Ledger");
-        std::lock_guard const sl(m_lock);
+        std::scoped_lock const sl(m_lock);
         m_heldLedger = std::move(ledger);
     }
 
@@ -36,14 +36,14 @@ public:
     std::shared_ptr<Ledger const>
     get()
     {
-        std::lock_guard const sl(m_lock);
+        std::scoped_lock const sl(m_lock);
         return m_heldLedger;
     }
 
     bool
     empty()
     {
-        std::lock_guard const sl(m_lock);
+        std::scoped_lock const sl(m_lock);
         return m_heldLedger == nullptr;
     }
 
diff --git a/src/xrpld/app/ledger/LedgerMaster.h b/src/xrpld/app/ledger/LedgerMaster.h
index 1bd4530d6d..62970eab15 100644
--- a/src/xrpld/app/ledger/LedgerMaster.h
+++ b/src/xrpld/app/ledger/LedgerMaster.h
@@ -387,7 +387,7 @@ private:
     void
     collect_metrics()
     {
-        std::lock_guard const lock(m_mutex);
+        std::scoped_lock const lock(m_mutex);
         m_stats.validatedLedgerAge.set(getValidatedLedgerAge().count());
         m_stats.publishedLedgerAge.set(getPublishedLedgerAge().count());
     }
diff --git a/src/xrpld/app/ledger/LedgerReplayer.h b/src/xrpld/app/ledger/LedgerReplayer.h
index ce2acb0699..9ea544c79b 100644
--- a/src/xrpld/app/ledger/LedgerReplayer.h
+++ b/src/xrpld/app/ledger/LedgerReplayer.h
@@ -103,21 +103,21 @@ public:
     std::size_t
     tasksSize() const
     {
-        std::lock_guard<std::mutex> const lock(mtx_);
+        std::scoped_lock const lock(mtx_);
         return tasks_.size();
     }
 
     std::size_t
     deltasSize() const
     {
-        std::lock_guard<std::mutex> const lock(mtx_);
+        std::scoped_lock const lock(mtx_);
         return deltas_.size();
     }
 
     std::size_t
     skipListsSize() const
     {
-        std::lock_guard<std::mutex> const lock(mtx_);
+        std::scoped_lock const lock(mtx_);
         return skipLists_.size();
     }
 
diff --git a/src/xrpld/app/ledger/LedgerToJson.h b/src/xrpld/app/ledger/LedgerToJson.h
index 53985f343b..91878c3c1b 100644
--- a/src/xrpld/app/ledger/LedgerToJson.h
+++ b/src/xrpld/app/ledger/LedgerToJson.h
@@ -23,6 +23,8 @@ struct LedgerFill
             closeTime = context->ledgerMaster.getCloseTimeBySeq(ledger.seq());
     }
 
+    // Bitwise bitmask
+    // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
     enum Options {
         dumpTxrp = 1,
         dumpState = 2,
diff --git a/src/xrpld/app/ledger/OpenLedger.h b/src/xrpld/app/ledger/OpenLedger.h
index 5b1d611b44..d55c9c97e3 100644
--- a/src/xrpld/app/ledger/OpenLedger.h
+++ b/src/xrpld/app/ledger/OpenLedger.h
@@ -169,7 +169,7 @@ private:
         ApplyFlags flags,
         beast::Journal j);
 
-    enum Result { success, failure, retry };
+    enum class Result { success, failure, retry };
 
     std::shared_ptr<OpenView>
     create(Rules const& rules, std::shared_ptr<Ledger const> const& ledger);
diff --git a/src/xrpld/app/ledger/OrderBookDBImpl.cpp b/src/xrpld/app/ledger/OrderBookDBImpl.cpp
index 1c64c5e6fa..4bfa982082 100644
--- a/src/xrpld/app/ledger/OrderBookDBImpl.cpp
+++ b/src/xrpld/app/ledger/OrderBookDBImpl.cpp
@@ -210,7 +210,7 @@ OrderBookDBImpl::update(std::shared_ptr<ReadView const> const& ledger)
     JLOG(j_.debug()) << "Update completed (" << ledger->seq() << "): " << cnt << " books found";
 
     {
-        std::lock_guard const sl(mLock);
+        std::scoped_lock const sl(mLock);
         allBooks_.swap(allBooks);
         xrpBooks_.swap(xrpBooks);
         domainBooks_.swap(domainBooks);
@@ -225,7 +225,7 @@ OrderBookDBImpl::addOrderBook(Book const& book)
 {
     bool const toXRP = isXRP(book.out);
 
-    std::lock_guard const sl(mLock);
+    std::scoped_lock const sl(mLock);
 
     if (book.domain)
     {
@@ -253,7 +253,7 @@ OrderBookDBImpl::getBooksByTakerPays(Asset const& asset, std::optional<uint256>
     std::vector<Book> ret;
 
     {
-        std::lock_guard const sl(mLock);
+        std::scoped_lock const sl(mLock);
 
         auto getBooks = [&](auto const& container, auto const& key) {
             if (auto it = container.find(key); it != container.end())
@@ -282,7 +282,7 @@ OrderBookDBImpl::getBooksByTakerPays(Asset const& asset, std::optional<uint256>
 int
 OrderBookDBImpl::getBookSize(Asset const& asset, std::optional<uint256> const& domain)
 {
-    std::lock_guard const sl(mLock);
+    std::scoped_lock const sl(mLock);
 
     if (!domain)
     {
@@ -301,7 +301,7 @@ OrderBookDBImpl::getBookSize(Asset const& asset, std::optional<uint256> const& d
 bool
 OrderBookDBImpl::isBookToXRP(Asset const& asset, std::optional<Domain> const& domain)
 {
-    std::lock_guard const sl(mLock);
+    std::scoped_lock const sl(mLock);
     if (domain)
         return xrpDomainBooks_.contains({asset, *domain});
     return xrpBooks_.contains(asset);
@@ -310,7 +310,7 @@ OrderBookDBImpl::isBookToXRP(Asset const& asset, std::optional<Domain> const& do
 BookListeners::pointer
 OrderBookDBImpl::makeBookListeners(Book const& book)
 {
-    std::lock_guard const sl(mLock);
+    std::scoped_lock const sl(mLock);
     auto ret = getBookListeners(book);
 
     if (!ret)
@@ -331,7 +331,7 @@ BookListeners::pointer
 OrderBookDBImpl::getBookListeners(Book const& book)
 {
     BookListeners::pointer ret;
-    std::lock_guard const sl(mLock);
+    std::scoped_lock const sl(mLock);
 
     auto it0 = mListeners.find(book);
     if (it0 != mListeners.end())
@@ -348,7 +348,7 @@ OrderBookDBImpl::processTxn(
     AcceptedLedgerTx const& alTx,
     MultiApiJson const& jvObj)
 {
-    std::lock_guard const sl(mLock);
+    std::scoped_lock const sl(mLock);
 
     // For this particular transaction, maintain the set of unique
     // subscriptions that have already published it.  This prevents sending
diff --git a/src/xrpld/app/ledger/TransactionStateSF.cpp b/src/xrpld/app/ledger/TransactionStateSF.cpp
index e2ec3ca7b6..201a2204a5 100644
--- a/src/xrpld/app/ledger/TransactionStateSF.cpp
+++ b/src/xrpld/app/ledger/TransactionStateSF.cpp
@@ -24,7 +24,8 @@ TransactionStateSF::gotNode(
     XRPL_ASSERT(
         type != SHAMapNodeType::tnTRANSACTION_NM,
         "xrpl::TransactionStateSF::gotNode : valid input");
-    db_.store(hotTRANSACTION_NODE, std::move(nodeData), nodeHash.as_uint256(), ledgerSeq);
+    db_.store(
+        NodeObjectType::hotTRANSACTION_NODE, std::move(nodeData), nodeHash.as_uint256(), ledgerSeq);
 }
 
 std::optional<Blob>
diff --git a/src/xrpld/app/ledger/detail/BuildLedger.cpp b/src/xrpld/app/ledger/detail/BuildLedger.cpp
index 8f5184336a..c75b1e0a12 100644
--- a/src/xrpld/app/ledger/detail/BuildLedger.cpp
+++ b/src/xrpld/app/ledger/detail/BuildLedger.cpp
@@ -63,8 +63,8 @@ buildLedgerImpl(
         // Write the final version of all modified SHAMap
         // nodes to the node store to preserve the new LCL
 
-        int const asf = built->stateMap().flushDirty(hotACCOUNT_NODE);
-        int const tmf = built->txMap().flushDirty(hotTRANSACTION_NODE);
+        int const asf = built->stateMap().flushDirty(NodeObjectType::hotACCOUNT_NODE);
+        int const tmf = built->txMap().flushDirty(NodeObjectType::hotTRANSACTION_NODE);
         JLOG(j.debug()) << "Flushed " << asf << " accounts and " << tmf << " transaction nodes";
     }
     built->unshare();
diff --git a/src/xrpld/app/ledger/detail/InboundLedger.cpp b/src/xrpld/app/ledger/detail/InboundLedger.cpp
index a65fae2ff3..52636d08c6 100644
--- a/src/xrpld/app/ledger/detail/InboundLedger.cpp
+++ b/src/xrpld/app/ledger/detail/InboundLedger.cpp
@@ -53,6 +53,8 @@ namespace xrpl {
 
 using namespace std::chrono_literals;
 
+// Need to be named before converting
+// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
 enum {
     // Number of peers to start with
     peerCountStart = 5
@@ -276,7 +278,8 @@ InboundLedger::tryDB(NodeStore::Database& srcDB)
             if (std::addressof(dstDB) != std::addressof(srcDB))
             {
                 Blob blob{nodeObject->getData()};
-                dstDB.store(hotLEDGER, std::move(blob), hash_, mLedger->header().seq);
+                dstDB.store(
+                    NodeObjectType::hotLEDGER, std::move(blob), hash_, mLedger->header().seq);
             }
         }
         else
@@ -294,7 +297,7 @@ InboundLedger::tryDB(NodeStore::Database& srcDB)
 
             // Store the ledger header in the ledger's database
             mLedger->stateMap().family().db().store(
-                hotLEDGER, std::move(*data), hash_, mLedger->header().seq);
+                NodeObjectType::hotLEDGER, std::move(*data), hash_, mLedger->header().seq);
         }
 
         if (mSeq == 0)
@@ -820,7 +823,7 @@ InboundLedger::takeHeader(std::string const& data)
     Serializer s(data.size() + 4);
     s.add32(HashPrefix::ledgerMaster);
     s.addRaw(data.data(), data.size());
-    f->db().store(hotLEDGER, std::move(s.modData()), hash_, mSeq);
+    f->db().store(NodeObjectType::hotLEDGER, std::move(s.modData()), hash_, mSeq);
 
     if (mLedger->header().txHash.isZero())
         mHaveTransactions = true;
@@ -1021,7 +1024,7 @@ InboundLedger::gotData(
     std::weak_ptr<Peer> peer,
     std::shared_ptr<protocol::TMLedgerData> const& data)
 {
-    std::lock_guard const sl(mReceivedDataLock);
+    std::scoped_lock const sl(mReceivedDataLock);
 
     if (isDone())
         return false;
@@ -1233,7 +1236,7 @@ InboundLedger::runData()
         data.clear();
 
         {
-            std::lock_guard const sl(mReceivedDataLock);
+            std::scoped_lock const sl(mReceivedDataLock);
 
             if (mReceivedData.empty())
             {
diff --git a/src/xrpld/app/ledger/detail/InboundLedgers.cpp b/src/xrpld/app/ledger/detail/InboundLedgers.cpp
index 2207308737..a882f5be73 100644
--- a/src/xrpld/app/ledger/detail/InboundLedgers.cpp
+++ b/src/xrpld/app/ledger/detail/InboundLedgers.cpp
@@ -284,7 +284,7 @@ public:
     std::size_t
     fetchRate() override
     {
-        std::lock_guard const lock(fetchRateMutex_);
+        std::scoped_lock const lock(fetchRateMutex_);
         return 60 * fetchRate_.value(m_clock.now());
     }
 
@@ -293,7 +293,7 @@ public:
     void
     onLedgerFetched() override
     {
-        std::lock_guard const lock(fetchRateMutex_);
+        std::scoped_lock const lock(fetchRateMutex_);
         fetchRate_.add(1, m_clock.now());
     }
 
diff --git a/src/xrpld/app/ledger/detail/InboundTransactions.cpp b/src/xrpld/app/ledger/detail/InboundTransactions.cpp
index 56c9c633f4..cbf0ac04d5 100644
--- a/src/xrpld/app/ledger/detail/InboundTransactions.cpp
+++ b/src/xrpld/app/ledger/detail/InboundTransactions.cpp
@@ -27,6 +27,8 @@
 
 namespace xrpl {
 
+// Need to be named before converting
+// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
 enum {
     // Ideal number of peers to start with
     startPeers = 2,
@@ -77,7 +79,7 @@ public:
     getAcquire(uint256 const& hash)
     {
         {
-            std::lock_guard const sl(mLock);
+            std::scoped_lock const sl(mLock);
 
             auto it = m_map.find(hash);
 
@@ -93,7 +95,7 @@ public:
         TransactionAcquire::pointer ta;
 
         {
-            std::lock_guard const sl(mLock);
+            std::scoped_lock const sl(mLock);
 
             if (auto it = m_map.find(hash); it != m_map.end())
             {
@@ -176,7 +178,7 @@ public:
         bool isNew = true;
 
         {
-            std::lock_guard const sl(mLock);
+            std::scoped_lock const sl(mLock);
 
             auto& inboundSet = m_map[hash];
 
@@ -201,7 +203,7 @@ public:
     void
     newRound(std::uint32_t seq) override
     {
-        std::lock_guard const lock(mLock);
+        std::scoped_lock const lock(mLock);
 
         // Protect zero set from expiration
         m_zeroSet.mSeq = seq;
@@ -232,7 +234,7 @@ public:
     void
     stop() override
     {
-        std::lock_guard const lock(mLock);
+        std::scoped_lock const lock(mLock);
         stopping_ = true;
         m_map.clear();
     }
diff --git a/src/xrpld/app/ledger/detail/LedgerCleaner.cpp b/src/xrpld/app/ledger/detail/LedgerCleaner.cpp
index 850b60f4ed..d500c8ee7b 100644
--- a/src/xrpld/app/ledger/detail/LedgerCleaner.cpp
+++ b/src/xrpld/app/ledger/detail/LedgerCleaner.cpp
@@ -98,7 +98,7 @@ public:
     {
         JLOG(j_.info()) << "Stopping";
         {
-            std::lock_guard const lock(mutex_);
+            std::scoped_lock const lock(mutex_);
             shouldExit_ = true;
             wakeup_.notify_one();
         }
@@ -114,7 +114,7 @@ public:
     void
     onWrite(beast::PropertyStream::Map& map) override
     {
-        std::lock_guard const lock(mutex_);
+        std::scoped_lock const lock(mutex_);
 
         if (maxRange_ == 0)
         {
@@ -146,7 +146,7 @@ public:
         app_.getLedgerMaster().getFullValidatedRange(minRange, maxRange);
 
         {
-            std::lock_guard const lock(mutex_);
+            std::scoped_lock const lock(mutex_);
 
             maxRange_ = maxRange;
             minRange_ = minRange;
@@ -376,7 +376,7 @@ private:
     doLedgerCleaner()
     {
         auto shouldExit = [this] {
-            std::lock_guard const lock(mutex_);
+            std::scoped_lock const lock(mutex_);
             return shouldExit_;
         };
 
@@ -397,7 +397,7 @@ private:
             }
 
             {
-                std::lock_guard const lock(mutex_);
+                std::scoped_lock const lock(mutex_);
                 if ((minRange_ > maxRange_) || (maxRange_ == 0) || (minRange_ == 0))
                 {
                     minRange_ = maxRange_ = 0;
@@ -425,7 +425,7 @@ private:
             if (fail)
             {
                 {
-                    std::lock_guard const lock(mutex_);
+                    std::scoped_lock const lock(mutex_);
                     ++failures_;
                 }
                 // Wait for acquiring to catch up to us
@@ -434,7 +434,7 @@ private:
             else
             {
                 {
-                    std::lock_guard const lock(mutex_);
+                    std::scoped_lock const lock(mutex_);
                     if (ledgerIndex == minRange_)
                         ++minRange_;
                     if (ledgerIndex == maxRange_)
diff --git a/src/xrpld/app/ledger/detail/LedgerMaster.cpp b/src/xrpld/app/ledger/detail/LedgerMaster.cpp
index c53249fa07..1c0e627cd0 100644
--- a/src/xrpld/app/ledger/detail/LedgerMaster.cpp
+++ b/src/xrpld/app/ledger/detail/LedgerMaster.cpp
@@ -163,7 +163,7 @@ LedgerMaster::isCompatible(ReadView const& view, beast::Journal::Stream s, char
     }
 
     {
-        std::lock_guard const sl(m_mutex);
+        std::scoped_lock const sl(m_mutex);
 
         if ((mLastValidLedger.second != 0) &&
             !areCompatible(mLastValidLedger.first, mLastValidLedger.second, view, s, reason))
@@ -342,7 +342,7 @@ LedgerMaster::setPubLedger(std::shared_ptr<Ledger const> const& l)
 void
 LedgerMaster::addHeldTransaction(std::shared_ptr<Transaction> const& transaction)
 {
-    std::lock_guard const ml(m_mutex);
+    std::scoped_lock const ml(m_mutex);
     mHeldTransactions.insert(transaction->getSTransaction());
 }
 
@@ -425,7 +425,7 @@ LedgerMaster::switchLCL(std::shared_ptr<Ledger const> const& lastClosed)
         LogicError("The new last closed ledger is open!");
 
     {
-        std::lock_guard const ml(m_mutex);
+        std::scoped_lock const ml(m_mutex);
         mClosedLedger.set(lastClosed);
     }
 
@@ -463,7 +463,7 @@ void
 LedgerMaster::applyHeldTransactions()
 {
     CanonicalTXSet const set = [this]() {
-        std::lock_guard const sl(m_mutex);
+        std::scoped_lock const sl(m_mutex);
         // VFALCO NOTE The hash for an open ledger is undefined so we use
         // something that is a reasonable substitute.
         CanonicalTXSet set(app_.getOpenLedger().current()->header().parentHash);
@@ -478,7 +478,7 @@ LedgerMaster::applyHeldTransactions()
 std::shared_ptr<STTx const>
 LedgerMaster::popAcctTransaction(std::shared_ptr<STTx const> const& tx)
 {
-    std::lock_guard const sl(m_mutex);
+    std::scoped_lock const sl(m_mutex);
 
     return mHeldTransactions.popAcctTransaction(tx);
 }
@@ -492,14 +492,14 @@ LedgerMaster::setBuildingLedger(LedgerIndex i)
 bool
 LedgerMaster::haveLedger(std::uint32_t seq)
 {
-    std::lock_guard const sl(mCompleteLock);
+    std::scoped_lock const sl(mCompleteLock);
     return boost::icl::contains(mCompleteLedgers, seq);
 }
 
 void
 LedgerMaster::clearLedger(std::uint32_t seq)
 {
-    std::lock_guard const sl(mCompleteLock);
+    std::scoped_lock const sl(mCompleteLock);
     mCompleteLedgers.erase(seq);
 }
 
@@ -560,7 +560,7 @@ LedgerMaster::getFullValidatedRange(std::uint32_t& minVal, std::uint32_t& maxVal
 
     std::optional<std::uint32_t> maybeMin;
     {
-        std::lock_guard const sl(mCompleteLock);
+        std::scoped_lock const sl(mCompleteLock);
         maybeMin = prevMissing(mCompleteLedgers, maxVal);
     }
 
@@ -655,7 +655,7 @@ LedgerMaster::tryFill(std::shared_ptr<Ledger const> ledger)
     while (!app_.getJobQueue().isStopping() && seq > 0)
     {
         {
-            std::lock_guard const ml(m_mutex);
+            std::scoped_lock const ml(m_mutex);
             minHas = seq;
             --seq;
 
@@ -671,7 +671,7 @@ LedgerMaster::tryFill(std::shared_ptr<Ledger const> ledger)
                 return;
 
             {
-                std::lock_guard const ml(mCompleteLock);
+                std::scoped_lock const ml(mCompleteLock);
                 mCompleteLedgers.insert(range(minHas, maxHas));
             }
             maxHas = minHas;
@@ -699,11 +699,11 @@ LedgerMaster::tryFill(std::shared_ptr<Ledger const> ledger)
     }
 
     {
-        std::lock_guard const ml(mCompleteLock);
+        std::scoped_lock const ml(mCompleteLock);
         mCompleteLedgers.insert(range(minHas, maxHas));
     }
     {
-        std::lock_guard const ml(m_mutex);
+        std::scoped_lock const ml(m_mutex);
         mFillInProgress = 0;
         tryAdvance();
     }
@@ -841,12 +841,12 @@ LedgerMaster::setFullLedger(
     pendSaveValidated(app_, ledger, isSynchronous, isCurrent);
 
     {
-        std::lock_guard const ml(mCompleteLock);
+        std::scoped_lock const ml(mCompleteLock);
         mCompleteLedgers.insert(ledger->header().seq);
     }
 
     {
-        std::lock_guard const ml(m_mutex);
+        std::scoped_lock const ml(m_mutex);
 
         if (ledger->header().seq > mValidLedgerSeq)
             setValidLedger(ledger);
@@ -896,7 +896,7 @@ LedgerMaster::checkAccept(uint256 const& hash, std::uint32_t seq)
         valCount = validations.size();
         if (valCount >= app_.getValidators().quorum())
         {
-            std::lock_guard const ml(m_mutex);
+            std::scoped_lock const ml(m_mutex);
             if (seq > mLastValidLedger.second)
                 mLastValidLedger = std::make_pair(hash, seq);
         }
@@ -950,7 +950,7 @@ LedgerMaster::checkAccept(std::shared_ptr<Ledger const> const& ledger)
 
     // Can we advance the last fully-validated ledger? If so, can we
     // publish?
-    std::lock_guard const ml(m_mutex);
+    std::scoped_lock const ml(m_mutex);
 
     if (ledger->header().seq <= mValidLedgerSeq)
         return;
@@ -1344,7 +1344,7 @@ LedgerMaster::findNewLedgersToPublish(std::unique_lock<std::recursive_mutex>& sl
 void
 LedgerMaster::tryAdvance()
 {
-    std::lock_guard const ml(m_mutex);
+    std::scoped_lock const ml(m_mutex);
 
     // Can't advance without at least one fully-valid ledger
     mAdvanceWork = true;
@@ -1379,7 +1379,7 @@ void
 LedgerMaster::updatePaths()
 {
     {
-        std::lock_guard const ml(m_mutex);
+        std::scoped_lock const ml(m_mutex);
         if (app_.getOPs().isNeedNetworkLedger())
         {
             --mPathFindThread;
@@ -1394,7 +1394,7 @@ LedgerMaster::updatePaths()
         JLOG(m_journal.debug()) << "updatePaths running";
         std::shared_ptr<ReadView const> lastLedger;
         {
-            std::lock_guard const ml(m_mutex);
+            std::scoped_lock const ml(m_mutex);
 
             if (!mValidLedger.empty() &&
                 (!mPathLedger || (mPathLedger->header().seq != mValidLedgerSeq)))
@@ -1423,7 +1423,7 @@ LedgerMaster::updatePaths()
             if (age > 1min)
             {
                 JLOG(m_journal.debug()) << "Published ledger too old for updating paths";
-                std::lock_guard const ml(m_mutex);
+                std::scoped_lock const ml(m_mutex);
                 --mPathFindThread;
                 mPathLedger.reset();
                 return;
@@ -1434,7 +1434,7 @@ LedgerMaster::updatePaths()
         {
             auto& pathRequests = app_.getPathRequestManager();
             {
-                std::lock_guard const ml(m_mutex);
+                std::scoped_lock const ml(m_mutex);
                 if (!pathRequests.requestsPending())
                 {
                     --mPathFindThread;
@@ -1448,7 +1448,7 @@ LedgerMaster::updatePaths()
             JLOG(m_journal.debug()) << "Updating paths";
             pathRequests.updateAll(lastLedger);
 
-            std::lock_guard const ml(m_mutex);
+            std::scoped_lock const ml(m_mutex);
             if (!pathRequests.requestsPending())
             {
                 JLOG(m_journal.debug()) << "No path requests left. No need for further updating "
@@ -1492,7 +1492,7 @@ LedgerMaster::newPathRequest()
 bool
 LedgerMaster::isNewPathRequest()
 {
-    std::lock_guard const ml(m_mutex);
+    std::scoped_lock const ml(m_mutex);
     bool const ret = mPathFindNewRequest;
     mPathFindNewRequest = false;
     return ret;
@@ -1565,14 +1565,14 @@ LedgerMaster::getValidatedRules()
 std::shared_ptr<ReadView const>
 LedgerMaster::getPublishedLedger()
 {
-    std::lock_guard const lock(m_mutex);
+    std::scoped_lock const lock(m_mutex);
     return mPubLedger;
 }
 
 std::string
 LedgerMaster::getCompleteLedgers()
 {
-    std::lock_guard const sl(mCompleteLock);
+    std::scoped_lock const sl(mCompleteLock);
     return to_string(mCompleteLedgers);
 }
 
@@ -1731,7 +1731,7 @@ LedgerMaster::getLedgerByHash(uint256 const& hash)
 void
 LedgerMaster::setLedgerRangePresent(std::uint32_t minV, std::uint32_t maxV)
 {
-    std::lock_guard const sl(mCompleteLock);
+    std::scoped_lock const sl(mCompleteLock);
     mCompleteLedgers.insert(range(minV, maxV));
 }
 
@@ -1751,7 +1751,7 @@ LedgerMaster::getCacheHitRate()
 void
 LedgerMaster::clearPriorLedgers(LedgerIndex seq)
 {
-    std::lock_guard const sl(mCompleteLock);
+    std::scoped_lock const sl(mCompleteLock);
     if (seq > 0)
         mCompleteLedgers.erase(range(0u, seq - 1));
 }
@@ -1812,7 +1812,7 @@ LedgerMaster::fetchForHistory(
             setFullLedger(ledger, false, false);
             int fillInProgress = 0;
             {
-                std::lock_guard const lock(m_mutex);
+                std::scoped_lock const lock(m_mutex);
                 mHistLedger = ledger;
                 fillInProgress = mFillInProgress;
             }
@@ -1821,7 +1821,7 @@ LedgerMaster::fetchForHistory(
             {
                 {
                     // Previous ledger is in DB
-                    std::lock_guard const lock(m_mutex);
+                    std::scoped_lock const lock(m_mutex);
                     mFillInProgress = seq;
                 }
                 app_.getJobQueue().addJob(
@@ -1893,7 +1893,7 @@ LedgerMaster::doAdvance(std::unique_lock<std::recursive_mutex>& sl)
                 InboundLedger::Reason const reason = InboundLedger::Reason::HISTORY;
                 std::optional<std::uint32_t> missing;
                 {
-                    std::lock_guard const sll(mCompleteLock);
+                    std::scoped_lock const sll(mCompleteLock);
                     missing = prevMissing(
                         mCompleteLedgers,
                         mPubLedger->header().seq,
diff --git a/src/xrpld/app/ledger/detail/LedgerReplayer.cpp b/src/xrpld/app/ledger/detail/LedgerReplayer.cpp
index 7779132b39..8f5d38132c 100644
--- a/src/xrpld/app/ledger/detail/LedgerReplayer.cpp
+++ b/src/xrpld/app/ledger/detail/LedgerReplayer.cpp
@@ -39,7 +39,7 @@ LedgerReplayer::LedgerReplayer(
 
 LedgerReplayer::~LedgerReplayer()
 {
-    std::lock_guard<std::mutex> const lock(mtx_);
+    std::scoped_lock const lock(mtx_);
     tasks_.clear();
 }
 
@@ -61,7 +61,7 @@ LedgerReplayer::replay(
     std::shared_ptr<SkipListAcquire> skipList;
     bool newSkipList = false;
     {
-        std::lock_guard<std::mutex> const lock(mtx_);
+        std::scoped_lock const lock(mtx_);
         if (app_.isStopping())
             return;
         if (tasks_.size() >= LedgerReplayParameters::MAX_TASKS)
@@ -139,7 +139,7 @@ LedgerReplayer::createDeltas(std::shared_ptr<LedgerReplayTask> task)
             std::shared_ptr<LedgerDeltaAcquire> delta;
             bool newDelta = false;
             {
-                std::lock_guard<std::mutex> const lock(mtx_);
+                std::scoped_lock const lock(mtx_);
                 if (app_.isStopping())
                     return;
                 auto i = deltas_.find(*skipListItem);
@@ -169,7 +169,7 @@ LedgerReplayer::gotSkipList(
 {
     std::shared_ptr<SkipListAcquire> skipList = {};
     {
-        std::lock_guard<std::mutex> const lock(mtx_);
+        std::scoped_lock const lock(mtx_);
         auto i = skipLists_.find(info.hash);
         if (i == skipLists_.end())
             return;
@@ -192,7 +192,7 @@ LedgerReplayer::gotReplayDelta(
 {
     std::shared_ptr<LedgerDeltaAcquire> delta = {};
     {
-        std::lock_guard<std::mutex> const lock(mtx_);
+        std::scoped_lock const lock(mtx_);
         auto i = deltas_.find(info.hash);
         if (i == deltas_.end())
             return;
@@ -213,7 +213,7 @@ LedgerReplayer::sweep()
 {
     auto const start = std::chrono::steady_clock::now();
     {
-        std::lock_guard<std::mutex> const lock(mtx_);
+        std::scoped_lock const lock(mtx_);
         JLOG(j_.debug()) << "Sweeping, LedgerReplayer has " << tasks_.size() << " tasks, "
                          << skipLists_.size() << " skipLists, and " << deltas_.size() << " deltas.";
 
@@ -260,7 +260,7 @@ LedgerReplayer::stop()
 {
     JLOG(j_.info()) << "Stopping...";
     {
-        std::lock_guard<std::mutex> const lock(mtx_);
+        std::scoped_lock const lock(mtx_);
         std::ranges::for_each(tasks_, [](auto& i) { i->cancel(); });
         tasks_.clear();
         auto lockAndCancel = [](auto& i) {
diff --git a/src/xrpld/app/ledger/detail/LedgerToJson.cpp b/src/xrpld/app/ledger/detail/LedgerToJson.cpp
index 8ba45fb515..2d244942e7 100644
--- a/src/xrpld/app/ledger/detail/LedgerToJson.cpp
+++ b/src/xrpld/app/ledger/detail/LedgerToJson.cpp
@@ -206,7 +206,7 @@ fillJsonTx(
                 fill.ledger,
                 account,
                 amount,
-                fhIGNORE_FREEZE,
+                FreezeHandling::fhIGNORE_FREEZE,
                 beast::Journal{beast::Journal::getNullSink()});
             txJson[jss::owner_funds] = ownerFunds.getText();
         }
diff --git a/src/xrpld/app/ledger/detail/LocalTxs.cpp b/src/xrpld/app/ledger/detail/LocalTxs.cpp
index 83d9c61c3c..6cc83261d1 100644
--- a/src/xrpld/app/ledger/detail/LocalTxs.cpp
+++ b/src/xrpld/app/ledger/detail/LocalTxs.cpp
@@ -106,7 +106,7 @@ public:
     void
     push_back(LedgerIndex index, std::shared_ptr<STTx const> const& txn) override
     {
-        std::lock_guard const lock(m_lock);
+        std::scoped_lock const lock(m_lock);
 
         m_txns.emplace_back(index, txn);
     }
@@ -119,7 +119,7 @@ public:
         // Get the set of local transactions as a canonical
         // set (so they apply in a valid order)
         {
-            std::lock_guard const lock(m_lock);
+            std::scoped_lock const lock(m_lock);
 
             for (auto const& it : m_txns)
                 tset.insert(it.getTX());
@@ -133,7 +133,7 @@ public:
     void
     sweep(ReadView const& view) override
     {
-        std::lock_guard const lock(m_lock);
+        std::scoped_lock const lock(m_lock);
 
         m_txns.remove_if([&view](auto const& txn) {
             if (txn.isExpired(view.header().seq))
@@ -170,7 +170,7 @@ public:
     std::size_t
     size() override
     {
-        std::lock_guard const lock(m_lock);
+        std::scoped_lock const lock(m_lock);
 
         return m_txns.size();
     }
diff --git a/src/xrpld/app/ledger/detail/OpenLedger.cpp b/src/xrpld/app/ledger/detail/OpenLedger.cpp
index 5db4e23e1e..20ddf27237 100644
--- a/src/xrpld/app/ledger/detail/OpenLedger.cpp
+++ b/src/xrpld/app/ledger/detail/OpenLedger.cpp
@@ -47,26 +47,26 @@ OpenLedger::OpenLedger(
 bool
 OpenLedger::empty() const
 {
-    std::lock_guard const lock(modify_mutex_);
+    std::scoped_lock const lock(modify_mutex_);
     return current_->txCount() == 0;
 }
 
 std::shared_ptr<OpenView const>
 OpenLedger::current() const
 {
-    std::lock_guard const lock(current_mutex_);
+    std::scoped_lock const lock(current_mutex_);
     return current_;
 }
 
 bool
 OpenLedger::modify(modify_type const& f)
 {
-    std::lock_guard const lock1(modify_mutex_);
+    std::scoped_lock const lock1(modify_mutex_);
     auto next = std::make_shared<OpenView>(*current_);
     auto const changed = f(*next, j_);
     if (changed)
     {
-        std::lock_guard const lock2(current_mutex_);
+        std::scoped_lock const lock2(current_mutex_);
         current_ = std::move(next);
     }
     return changed;
@@ -95,7 +95,7 @@ OpenLedger::accept(
     // Block calls to modify, otherwise
     // new tx going into the open ledger
     // would get lost.
-    std::lock_guard const lock1(modify_mutex_);
+    std::scoped_lock const lock1(modify_mutex_);
     // Apply tx from the current open view
     if (!current_->txs.empty())
     {
@@ -153,7 +153,7 @@ OpenLedger::accept(
     }
 
     // Switch to the new open view
-    std::lock_guard const lock2(current_mutex_);
+    std::scoped_lock const lock2(current_mutex_);
     current_ = std::move(next);
 }
 
diff --git a/src/xrpld/app/ledger/detail/TransactionAcquire.cpp b/src/xrpld/app/ledger/detail/TransactionAcquire.cpp
index b38c413344..686d33ce63 100644
--- a/src/xrpld/app/ledger/detail/TransactionAcquire.cpp
+++ b/src/xrpld/app/ledger/detail/TransactionAcquire.cpp
@@ -31,6 +31,8 @@ using namespace std::chrono_literals;
 // Timeout interval in milliseconds
 auto constexpr TX_ACQUIRE_TIMEOUT = 250ms;
 
+// Need to be named before converting
+// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
 enum {
     NORM_TIMEOUTS = 4,
     MAX_TIMEOUTS = 20,
diff --git a/src/xrpld/app/ledger/detail/TransactionMaster.cpp b/src/xrpld/app/ledger/detail/TransactionMaster.cpp
index 798c29dc05..bc0b7ca4ab 100644
--- a/src/xrpld/app/ledger/detail/TransactionMaster.cpp
+++ b/src/xrpld/app/ledger/detail/TransactionMaster.cpp
@@ -50,7 +50,7 @@ TransactionMaster::inLedger(
     if (!txn)
         return false;
 
-    txn->setStatus(COMMITTED, ledger, tseq, netID);
+    txn->setStatus(TransStatus::COMMITTED, ledger, tseq, netID);
     return true;
 }
 
@@ -130,7 +130,7 @@ TransactionMaster::fetch(
     else
     {
         if (uCommitLedger != 0u)
-            iTx->setStatus(COMMITTED, uCommitLedger);
+            iTx->setStatus(TransStatus::COMMITTED, uCommitLedger);
 
         txn = iTx->getSTransaction();
     }
diff --git a/src/xrpld/app/main/Application.cpp b/src/xrpld/app/main/Application.cpp
index 005586eaba..d43f842eed 100644
--- a/src/xrpld/app/main/Application.cpp
+++ b/src/xrpld/app/main/Application.cpp
@@ -1885,7 +1885,7 @@ ApplicationImp::loadLedgerFromFile(std::string const& name)
             }
         }
 
-        loadLedger->stateMap().flushDirty(hotACCOUNT_NODE);
+        loadLedger->stateMap().flushDirty(NodeObjectType::hotACCOUNT_NODE);
 
         XRPL_ASSERT(
             loadLedger->header().seq < XRP_LEDGER_EARLIEST_FEES || loadLedger->read(keylet::fees()),
diff --git a/src/xrpld/app/main/LoadManager.cpp b/src/xrpld/app/main/LoadManager.cpp
index 84c57ad360..4f9023dbc5 100644
--- a/src/xrpld/app/main/LoadManager.cpp
+++ b/src/xrpld/app/main/LoadManager.cpp
@@ -42,7 +42,7 @@ LoadManager::~LoadManager()
 void
 LoadManager::activateStallDetector()
 {
-    std::lock_guard const sl(mutex_);
+    std::scoped_lock const sl(mutex_);
     armed_ = true;
     lastHeartbeat_ = std::chrono::steady_clock::now();
 }
@@ -51,7 +51,7 @@ void
 LoadManager::heartbeat()
 {
     auto const heartbeat = std::chrono::steady_clock::now();
-    std::lock_guard const sl(mutex_);
+    std::scoped_lock const sl(mutex_);
     lastHeartbeat_ = heartbeat;
 }
 
@@ -70,7 +70,7 @@ void
 LoadManager::stop()
 {
     {
-        std::lock_guard const lock(mutex_);
+        std::scoped_lock const lock(mutex_);
         stop_ = true;
         // There is at most one thread waiting on this condition.
         cv_.notify_all();
diff --git a/src/xrpld/app/main/Main.cpp b/src/xrpld/app/main/Main.cpp
index 3da6e3a2ad..c774c77253 100644
--- a/src/xrpld/app/main/Main.cpp
+++ b/src/xrpld/app/main/Main.cpp
@@ -213,7 +213,7 @@ public:
         std::ranges::for_each(v, [this](std::string s) {
             boost::trim(s);
             if (selectors_.empty() || !s.empty())
-                selectors_.emplace_back(beast::unit_test::selector::automatch, s);
+                selectors_.emplace_back(beast::unit_test::selector::mode_t::automatch, s);
         });
     }
 
diff --git a/src/xrpld/app/misc/NegativeUNLVote.cpp b/src/xrpld/app/misc/NegativeUNLVote.cpp
index 8db726ff48..c733de3bd3 100644
--- a/src/xrpld/app/misc/NegativeUNLVote.cpp
+++ b/src/xrpld/app/misc/NegativeUNLVote.cpp
@@ -93,7 +93,7 @@ NegativeUNLVote::doVoting(
             auto n = choose(prevLedger->header().hash, candidates.toDisableCandidates);
             XRPL_ASSERT(
                 nidToKeyMap.contains(n), "xrpl::NegativeUNLVote::doVoting : found node to disable");
-            addTx(seq, nidToKeyMap.at(n), ToDisable, initialSet);
+            addTx(seq, nidToKeyMap.at(n), NegativeUNLModify::ToDisable, initialSet);
         }
 
         if (!candidates.toReEnableCandidates.empty())
@@ -101,7 +101,7 @@ NegativeUNLVote::doVoting(
             auto n = choose(prevLedger->header().hash, candidates.toReEnableCandidates);
             XRPL_ASSERT(
                 nidToKeyMap.contains(n), "xrpl::NegativeUNLVote::doVoting : found node to enable");
-            addTx(seq, nidToKeyMap.at(n), ToReEnable, initialSet);
+            addTx(seq, nidToKeyMap.at(n), NegativeUNLModify::ToReEnable, initialSet);
         }
     }
 }
@@ -114,7 +114,7 @@ NegativeUNLVote::addTx(
     std::shared_ptr<SHAMap> const& initialSet)
 {
     STTx const negUnlTx(ttUNL_MODIFY, [&](auto& obj) {
-        obj.setFieldU8(sfUNLModifyDisabling, modify == ToDisable ? 1 : 0);
+        obj.setFieldU8(sfUNLModifyDisabling, modify == NegativeUNLModify::ToDisable ? 1 : 0);
         obj.setFieldU32(sfLedgerSequence, seq);
         obj.setFieldVL(sfUNLModifyValidator, vp.slice());
     });
@@ -132,7 +132,8 @@ NegativeUNLVote::addTx(
         JLOG(j_.debug()) << "N-UNL: ledger seq=" << seq
                          << ", add a ttUNL_MODIFY Tx with txID: " << negUnlTx.getTransactionID()
                          << ", the validator to "
-                         << (modify == ToDisable ? "disable: " : "re-enable: ") << vp;
+                         << (modify == NegativeUNLModify::ToDisable ? "disable: " : "re-enable: ")
+                         << vp;
     }
 }
 
@@ -308,7 +309,7 @@ NegativeUNLVote::findAllCandidates(
 void
 NegativeUNLVote::newValidators(LedgerIndex seq, hash_set<NodeID> const& nowTrusted)
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     for (auto const& n : nowTrusted)
     {
         if (!newValidators_.contains(n))
@@ -322,7 +323,7 @@ NegativeUNLVote::newValidators(LedgerIndex seq, hash_set<NodeID> const& nowTrust
 void
 NegativeUNLVote::purgeNewValidators(LedgerIndex seq)
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     auto i = newValidators_.begin();
     while (i != newValidators_.end())
     {
diff --git a/src/xrpld/app/misc/NegativeUNLVote.h b/src/xrpld/app/misc/NegativeUNLVote.h
index 2cc63cf8c5..02e84ccca1 100644
--- a/src/xrpld/app/misc/NegativeUNLVote.h
+++ b/src/xrpld/app/misc/NegativeUNLVote.h
@@ -57,7 +57,7 @@ public:
      * A flag indicating whether a UNLModify Tx is to disable or to re-enable
      * a validator.
      */
-    enum NegativeUNLModify {
+    enum class NegativeUNLModify {
         ToDisable,  // UNLModify Tx is to disable a validator
         ToReEnable  // UNLModify Tx is to re-enable a validator
     };
diff --git a/src/xrpld/app/misc/NetworkOPs.cpp b/src/xrpld/app/misc/NetworkOPs.cpp
index 8de65d8b39..964a51e15e 100644
--- a/src/xrpld/app/misc/NetworkOPs.cpp
+++ b/src/xrpld/app/misc/NetworkOPs.cpp
@@ -257,7 +257,7 @@ class NetworkOPsImp final : public NetworkOPs
         CounterData
         getCounterData() const
         {
-            std::lock_guard const lock(mutex_);
+            std::scoped_lock const lock(mutex_);
             return {
                 .counters = counters_,
                 .mode = mode_,
@@ -809,6 +809,8 @@ private:
 
     SubAccountHistoryMapType mSubAccountHistory;
 
+    // Used as array indices; converting to enum class would require casts at ~40 call sites.
+    // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
     enum SubTypes {
         sLedger,          // Accepted ledgers.
         sManifests,       // Received validator manifests.
@@ -1261,7 +1263,7 @@ NetworkOPsImp::preProcessTransaction(std::shared_ptr<Transaction>& transaction)
     {
         // cached bad
         JLOG(m_journal.warn()) << transaction->getID() << ": cached bad!\n";
-        transaction->setStatus(INVALID);
+        transaction->setStatus(TransStatus::INVALID);
         transaction->setResult(temBAD_SIGNATURE);
         return false;
     }
@@ -1274,7 +1276,7 @@ NetworkOPsImp::preProcessTransaction(std::shared_ptr<Transaction>& transaction)
     auto const sttx = *transaction->getSTransaction();
     if (sttx.isFlag(tfInnerBatchTxn) && view->rules().enabled(featureBatch))
     {
-        transaction->setStatus(INVALID);
+        transaction->setStatus(TransStatus::INVALID);
         transaction->setResult(temINVALID_FLAG);
         registry_.get().getHashRouter().setFlags(transaction->getID(), HashRouterFlags::BAD);
         return false;
@@ -1292,7 +1294,7 @@ NetworkOPsImp::preProcessTransaction(std::shared_ptr<Transaction>& transaction)
     if (validity == Validity::SigBad)
     {
         JLOG(m_journal.info()) << "Transaction has bad signature: " << reason;
-        transaction->setStatus(INVALID);
+        transaction->setStatus(TransStatus::INVALID);
         transaction->setResult(temBAD_SIGNATURE);
         registry_.get().getHashRouter().setFlags(transaction->getID(), HashRouterFlags::BAD);
         return false;
@@ -1333,7 +1335,7 @@ NetworkOPsImp::doTransactionAsync(
     bool bUnlimited,
     FailHard failType)
 {
-    std::lock_guard const lock(mMutex);
+    std::scoped_lock const lock(mMutex);
 
     if (transaction->getApplying())
         return;
@@ -1408,7 +1410,7 @@ NetworkOPsImp::processTransactionSet(CanonicalTXSet const& set)
         std::string reason;
         auto transaction = std::make_shared<Transaction>(tx, reason, registry_.get().getApp());
 
-        if (transaction->getStatus() == INVALID)
+        if (transaction->getStatus() == TransStatus::INVALID)
         {
             if (!reason.empty())
             {
@@ -1559,7 +1561,7 @@ NetworkOPsImp::apply(std::unique_lock<std::mutex>& batchLock)
             if (isTesSuccess(e.result))
             {
                 JLOG(m_journal.debug()) << "Transaction is now included in open ledger";
-                e.transaction->setStatus(INCLUDED);
+                e.transaction->setStatus(TransStatus::INCLUDED);
 
                 // Pop as many "reasonable" transactions for this account as
                 // possible. "Reasonable" means they have sequential sequence
@@ -1588,14 +1590,14 @@ NetworkOPsImp::apply(std::unique_lock<std::mutex>& batchLock)
             {
                 // duplicate or conflict
                 JLOG(m_journal.info()) << "Transaction is obsolete";
-                e.transaction->setStatus(OBSOLETE);
+                e.transaction->setStatus(TransStatus::OBSOLETE);
             }
             else if (e.result == terQUEUED)
             {
                 JLOG(m_journal.debug()) << "Transaction is likely to claim a"
                                         << " fee, but is queued until fee drops";
 
-                e.transaction->setStatus(HELD);
+                e.transaction->setStatus(TransStatus::HELD);
                 // Add to held transactions, because it could get
                 // kicked out of the queue, and this will try to
                 // put it back.
@@ -1634,7 +1636,7 @@ NetworkOPsImp::apply(std::unique_lock<std::mutex>& batchLock)
                     {
                         // transaction should be held
                         JLOG(m_journal.debug()) << "Transaction should be held: " << e.result;
-                        e.transaction->setStatus(HELD);
+                        e.transaction->setStatus(TransStatus::HELD);
                         m_ledgerMaster.addHeldTransaction(e.transaction);
                         e.transaction->setKept();
                     }
@@ -1649,7 +1651,7 @@ NetworkOPsImp::apply(std::unique_lock<std::mutex>& batchLock)
             else
             {
                 JLOG(m_journal.debug()) << "Status other than success " << e.result;
-                e.transaction->setStatus(INVALID);
+                e.transaction->setStatus(TransStatus::INVALID);
             }
 
             auto const enforceFailHard = e.failType == FailHard::yes && !isTesSuccess(e.result);
@@ -2190,7 +2192,7 @@ void
 NetworkOPsImp::pubManifest(Manifest const& mo)
 {
     // VFALCO consider std::shared_mutex
-    std::lock_guard const sl(mSubLock);
+    std::scoped_lock const sl(mSubLock);
 
     if (!mStreamMaps[sManifests].empty())
     {
@@ -2268,7 +2270,7 @@ NetworkOPsImp::pubServer()
     //             list into a local array while holding the lock then release
     //             the lock and call send on everyone.
     //
-    std::lock_guard const sl(mSubLock);
+    std::scoped_lock const sl(mSubLock);
 
     if (!mStreamMaps[sServer].empty())
     {
@@ -2327,7 +2329,7 @@ NetworkOPsImp::pubServer()
 void
 NetworkOPsImp::pubConsensus(ConsensusPhase phase)
 {
-    std::lock_guard const sl(mSubLock);
+    std::scoped_lock const sl(mSubLock);
 
     auto& streamMap = mStreamMaps[sConsensusPhase];
     if (!streamMap.empty())
@@ -2355,7 +2357,7 @@ void
 NetworkOPsImp::pubValidation(std::shared_ptr<STValidation> const& val)
 {
     // VFALCO consider std::shared_mutex
-    std::lock_guard const sl(mSubLock);
+    std::scoped_lock const sl(mSubLock);
 
     if (!mStreamMaps[sValidations].empty())
     {
@@ -2460,7 +2462,7 @@ NetworkOPsImp::pubValidation(std::shared_ptr<STValidation> const& val)
 void
 NetworkOPsImp::pubPeerStatus(std::function<Json::Value(void)> const& func)
 {
-    std::lock_guard const sl(mSubLock);
+    std::scoped_lock const sl(mSubLock);
 
     if (!mStreamMaps[sPeerStatus].empty())
     {
@@ -3017,7 +3019,7 @@ NetworkOPsImp::pubProposedTransaction(
     MultiApiJson jvObj = transJson(transaction, result, false, ledger, std::nullopt);
 
     {
-        std::lock_guard const sl(mSubLock);
+        std::scoped_lock const sl(mSubLock);
 
         auto it = mStreamMaps[sRTTransactions].begin();
         while (it != mStreamMaps[sRTTransactions].end())
@@ -3064,7 +3066,7 @@ NetworkOPsImp::pubLedger(std::shared_ptr<ReadView const> const& lpAccepted)
         JLOG(m_journal.debug()) << "Publishing ledger " << lpAccepted->header().seq << " "
                                 << lpAccepted->header().hash;
 
-        std::lock_guard const sl(mSubLock);
+        std::scoped_lock const sl(mSubLock);
 
         if (!mStreamMaps[sLedger].empty())
         {
@@ -3267,8 +3269,8 @@ NetworkOPsImp::transJson(
                 *ledger,
                 account,
                 amount,
-                fhIGNORE_FREEZE,
-                ahIGNORE_AUTH,
+                FreezeHandling::fhIGNORE_FREEZE,
+                AuthHandling::ahIGNORE_AUTH,
                 registry_.get().getJournal("View"));
             jvObj[jss::transaction][jss::owner_funds] = ownerFunds.getText();
         }
@@ -3309,7 +3311,7 @@ NetworkOPsImp::pubValidatedTransaction(
     MultiApiJson jvObj = transJson(stTxn, trResult, true, ledger, metaRef);
 
     {
-        std::lock_guard const sl(mSubLock);
+        std::scoped_lock const sl(mSubLock);
 
         auto it = mStreamMaps[sTransactions].begin();
         while (it != mStreamMaps[sTransactions].end())
@@ -3368,7 +3370,7 @@ NetworkOPsImp::pubAccountTransaction(
     std::vector<SubAccountHistoryInfo> accountHistoryNotify;
     auto const currLedgerSeq = ledger->seq();
     {
-        std::lock_guard const sl(mSubLock);
+        std::scoped_lock const sl(mSubLock);
 
         if (!mSubAccount.empty() || !mSubRTAccount.empty() || !mSubAccountHistory.empty())
         {
@@ -3471,7 +3473,7 @@ NetworkOPsImp::pubAccountTransaction(
             jvObj.set(jss::account_history_boundary, true);
 
         XRPL_ASSERT(
-            jvObj.isMember(jss::account_history_tx_stream) == MultiApiJson::none,
+            jvObj.isMember(jss::account_history_tx_stream) == MultiApiJson::IsMemberResult::none,
             "xrpl::NetworkOPsImp::pubAccountTransaction : "
             "account_history_tx_stream not set");
         for (auto& info : accountHistoryNotify)
@@ -3501,7 +3503,7 @@ NetworkOPsImp::pubProposedAccountTransaction(
     std::vector<SubAccountHistoryInfo> accountHistoryNotify;
 
     {
-        std::lock_guard const sl(mSubLock);
+        std::scoped_lock const sl(mSubLock);
 
         if (mSubRTAccount.empty())
             return;
@@ -3550,7 +3552,7 @@ NetworkOPsImp::pubProposedAccountTransaction(
         }
 
         XRPL_ASSERT(
-            jvObj.isMember(jss::account_history_tx_stream) == MultiApiJson::none,
+            jvObj.isMember(jss::account_history_tx_stream) == MultiApiJson::IsMemberResult::none,
             "xrpl::NetworkOPs::pubProposedAccountTransaction : "
             "account_history_tx_stream not set");
         for (auto& info : accountHistoryNotify)
@@ -3585,7 +3587,7 @@ NetworkOPsImp::subAccount(
         isrListener->insertSubAccountInfo(naAccountID, rt);
     }
 
-    std::lock_guard const sl(mSubLock);
+    std::scoped_lock const sl(mSubLock);
 
     for (auto const& naAccountID : vnaAccountIDs)
     {
@@ -3628,7 +3630,7 @@ NetworkOPsImp::unsubAccountInternal(
     hash_set<AccountID> const& vnaAccountIDs,
     bool rt)
 {
-    std::lock_guard const sl(mSubLock);
+    std::scoped_lock const sl(mSubLock);
 
     SubInfoMapType& subMap = rt ? mSubRTAccount : mSubAccount;
 
@@ -3934,7 +3936,7 @@ NetworkOPsImp::subAccountHistory(InfoSub::ref isrListener, AccountID const& acco
         return rpcINVALID_PARAMS;
     }
 
-    std::lock_guard const sl(mSubLock);
+    std::scoped_lock const sl(mSubLock);
     SubAccountHistoryInfoWeak ahi{
         .sinkWptr_ = isrListener, .index_ = std::make_shared<SubAccountHistoryIndex>(accountId)};
     auto simIterator = mSubAccountHistory.find(accountId);
@@ -3982,7 +3984,7 @@ NetworkOPsImp::unsubAccountHistoryInternal(
     AccountID const& account,
     bool historyOnly)
 {
-    std::lock_guard const sl(mSubLock);
+    std::scoped_lock const sl(mSubLock);
     auto simIterator = mSubAccountHistory.find(account);
     if (simIterator != mSubAccountHistory.end())
     {
@@ -4071,7 +4073,7 @@ NetworkOPsImp::subLedger(InfoSub::ref isrListener, Json::Value& jvResult)
         jvResult[jss::validated_ledgers] = registry_.get().getLedgerMaster().getCompleteLedgers();
     }
 
-    std::lock_guard const sl(mSubLock);
+    std::scoped_lock const sl(mSubLock);
     return mStreamMaps[sLedger].emplace(isrListener->getSeq(), isrListener).second;
 }
 
@@ -4079,7 +4081,7 @@ NetworkOPsImp::subLedger(InfoSub::ref isrListener, Json::Value& jvResult)
 bool
 NetworkOPsImp::subBookChanges(InfoSub::ref isrListener)
 {
-    std::lock_guard const sl(mSubLock);
+    std::scoped_lock const sl(mSubLock);
     return mStreamMaps[sBookChanges].emplace(isrListener->getSeq(), isrListener).second;
 }
 
@@ -4087,7 +4089,7 @@ NetworkOPsImp::subBookChanges(InfoSub::ref isrListener)
 bool
 NetworkOPsImp::unsubLedger(std::uint64_t uSeq)
 {
-    std::lock_guard const sl(mSubLock);
+    std::scoped_lock const sl(mSubLock);
     return mStreamMaps[sLedger].erase(uSeq) != 0u;
 }
 
@@ -4095,7 +4097,7 @@ NetworkOPsImp::unsubLedger(std::uint64_t uSeq)
 bool
 NetworkOPsImp::unsubBookChanges(std::uint64_t uSeq)
 {
-    std::lock_guard const sl(mSubLock);
+    std::scoped_lock const sl(mSubLock);
     return mStreamMaps[sBookChanges].erase(uSeq) != 0u;
 }
 
@@ -4103,7 +4105,7 @@ NetworkOPsImp::unsubBookChanges(std::uint64_t uSeq)
 bool
 NetworkOPsImp::subManifests(InfoSub::ref isrListener)
 {
-    std::lock_guard const sl(mSubLock);
+    std::scoped_lock const sl(mSubLock);
     return mStreamMaps[sManifests].emplace(isrListener->getSeq(), isrListener).second;
 }
 
@@ -4111,7 +4113,7 @@ NetworkOPsImp::subManifests(InfoSub::ref isrListener)
 bool
 NetworkOPsImp::unsubManifests(std::uint64_t uSeq)
 {
-    std::lock_guard const sl(mSubLock);
+    std::scoped_lock const sl(mSubLock);
     return mStreamMaps[sManifests].erase(uSeq) != 0u;
 }
 
@@ -4136,7 +4138,7 @@ NetworkOPsImp::subServer(InfoSub::ref isrListener, Json::Value& jvResult, bool a
     jvResult[jss::pubkey_node] =
         toBase58(TokenType::NodePublic, registry_.get().getApp().nodeIdentity().first);
 
-    std::lock_guard const sl(mSubLock);
+    std::scoped_lock const sl(mSubLock);
     return mStreamMaps[sServer].emplace(isrListener->getSeq(), isrListener).second;
 }
 
@@ -4144,7 +4146,7 @@ NetworkOPsImp::subServer(InfoSub::ref isrListener, Json::Value& jvResult, bool a
 bool
 NetworkOPsImp::unsubServer(std::uint64_t uSeq)
 {
-    std::lock_guard const sl(mSubLock);
+    std::scoped_lock const sl(mSubLock);
     return mStreamMaps[sServer].erase(uSeq) != 0u;
 }
 
@@ -4152,7 +4154,7 @@ NetworkOPsImp::unsubServer(std::uint64_t uSeq)
 bool
 NetworkOPsImp::subTransactions(InfoSub::ref isrListener)
 {
-    std::lock_guard const sl(mSubLock);
+    std::scoped_lock const sl(mSubLock);
     return mStreamMaps[sTransactions].emplace(isrListener->getSeq(), isrListener).second;
 }
 
@@ -4160,7 +4162,7 @@ NetworkOPsImp::subTransactions(InfoSub::ref isrListener)
 bool
 NetworkOPsImp::unsubTransactions(std::uint64_t uSeq)
 {
-    std::lock_guard const sl(mSubLock);
+    std::scoped_lock const sl(mSubLock);
     return mStreamMaps[sTransactions].erase(uSeq) != 0u;
 }
 
@@ -4168,7 +4170,7 @@ NetworkOPsImp::unsubTransactions(std::uint64_t uSeq)
 bool
 NetworkOPsImp::subRTTransactions(InfoSub::ref isrListener)
 {
-    std::lock_guard const sl(mSubLock);
+    std::scoped_lock const sl(mSubLock);
     return mStreamMaps[sRTTransactions].emplace(isrListener->getSeq(), isrListener).second;
 }
 
@@ -4176,7 +4178,7 @@ NetworkOPsImp::subRTTransactions(InfoSub::ref isrListener)
 bool
 NetworkOPsImp::unsubRTTransactions(std::uint64_t uSeq)
 {
-    std::lock_guard const sl(mSubLock);
+    std::scoped_lock const sl(mSubLock);
     return mStreamMaps[sRTTransactions].erase(uSeq) != 0u;
 }
 
@@ -4184,7 +4186,7 @@ NetworkOPsImp::unsubRTTransactions(std::uint64_t uSeq)
 bool
 NetworkOPsImp::subValidations(InfoSub::ref isrListener)
 {
-    std::lock_guard const sl(mSubLock);
+    std::scoped_lock const sl(mSubLock);
     return mStreamMaps[sValidations].emplace(isrListener->getSeq(), isrListener).second;
 }
 
@@ -4198,7 +4200,7 @@ NetworkOPsImp::stateAccounting(Json::Value& obj)
 bool
 NetworkOPsImp::unsubValidations(std::uint64_t uSeq)
 {
-    std::lock_guard const sl(mSubLock);
+    std::scoped_lock const sl(mSubLock);
     return mStreamMaps[sValidations].erase(uSeq) != 0u;
 }
 
@@ -4206,7 +4208,7 @@ NetworkOPsImp::unsubValidations(std::uint64_t uSeq)
 bool
 NetworkOPsImp::subPeerStatus(InfoSub::ref isrListener)
 {
-    std::lock_guard const sl(mSubLock);
+    std::scoped_lock const sl(mSubLock);
     return mStreamMaps[sPeerStatus].emplace(isrListener->getSeq(), isrListener).second;
 }
 
@@ -4214,7 +4216,7 @@ NetworkOPsImp::subPeerStatus(InfoSub::ref isrListener)
 bool
 NetworkOPsImp::unsubPeerStatus(std::uint64_t uSeq)
 {
-    std::lock_guard const sl(mSubLock);
+    std::scoped_lock const sl(mSubLock);
     return mStreamMaps[sPeerStatus].erase(uSeq) != 0u;
 }
 
@@ -4222,7 +4224,7 @@ NetworkOPsImp::unsubPeerStatus(std::uint64_t uSeq)
 bool
 NetworkOPsImp::subConsensus(InfoSub::ref isrListener)
 {
-    std::lock_guard const sl(mSubLock);
+    std::scoped_lock const sl(mSubLock);
     return mStreamMaps[sConsensusPhase].emplace(isrListener->getSeq(), isrListener).second;
 }
 
@@ -4230,14 +4232,14 @@ NetworkOPsImp::subConsensus(InfoSub::ref isrListener)
 bool
 NetworkOPsImp::unsubConsensus(std::uint64_t uSeq)
 {
-    std::lock_guard const sl(mSubLock);
+    std::scoped_lock const sl(mSubLock);
     return mStreamMaps[sConsensusPhase].erase(uSeq) != 0u;
 }
 
 InfoSub::pointer
 NetworkOPsImp::findRpcSub(std::string const& strUrl)
 {
-    std::lock_guard const sl(mSubLock);
+    std::scoped_lock const sl(mSubLock);
 
     subRpcMapType::iterator const it = mRpcSubMap.find(strUrl);
 
@@ -4250,7 +4252,7 @@ NetworkOPsImp::findRpcSub(std::string const& strUrl)
 InfoSub::pointer
 NetworkOPsImp::addRpcSub(std::string const& strUrl, InfoSub::ref rspEntry)
 {
-    std::lock_guard const sl(mSubLock);
+    std::scoped_lock const sl(mSubLock);
 
     mRpcSubMap.emplace(strUrl, rspEntry);
 
@@ -4260,7 +4262,7 @@ NetworkOPsImp::addRpcSub(std::string const& strUrl, InfoSub::ref rspEntry)
 bool
 NetworkOPsImp::tryRemoveRpcSub(std::string const& strUrl)
 {
-    std::lock_guard const sl(mSubLock);
+    std::scoped_lock const sl(mSubLock);
     auto pInfo = findRpcSub(strUrl);
 
     if (!pInfo)
@@ -4400,8 +4402,8 @@ NetworkOPsImp::getBookPage(
                             view,
                             uOfferOwnerID,
                             book.out,
-                            fhZERO_IF_FROZEN,
-                            ahZERO_IF_UNAUTHORIZED,
+                            FreezeHandling::fhZERO_IF_FROZEN,
+                            AuthHandling::ahZERO_IF_UNAUTHORIZED,
                             viewJ);
 
                         if (saOwnerFunds < beast::zero)
@@ -4545,7 +4547,10 @@ NetworkOPsImp::getBookPage(
                     // Did not find balance in table.
 
                     saOwnerFunds = lesActive.accountHolds(
-                        uOfferOwnerID, book.out.currency, book.out.account, fhZERO_IF_FROZEN);
+                        uOfferOwnerID,
+                        book.out.currency,
+                        book.out.account,
+                        FreezeHandling::fhZERO_IF_FROZEN);
 
                     if (saOwnerFunds.isNegative())
                     {
@@ -4621,7 +4626,7 @@ NetworkOPsImp::collect_metrics()
         std::chrono::steady_clock::now() - start);
     counters[static_cast<std::size_t>(mode)].dur += current;
 
-    std::lock_guard const lock(m_statsMutex);
+    std::scoped_lock const lock(m_statsMutex);
     m_stats.disconnected_duration.set(
         counters[static_cast<std::size_t>(OperatingMode::DISCONNECTED)].dur.count());
     m_stats.connected_duration.set(
@@ -4649,7 +4654,7 @@ NetworkOPsImp::StateAccounting::mode(OperatingMode om)
 {
     auto now = std::chrono::steady_clock::now();
 
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     ++counters_[static_cast<std::size_t>(om)].transitions;
     if (om == OperatingMode::FULL && counters_[static_cast<std::size_t>(om)].transitions == 1)
     {
diff --git a/src/xrpld/app/misc/SHAMapStoreImp.cpp b/src/xrpld/app/misc/SHAMapStoreImp.cpp
index 518d9f6b14..3a6cb1742d 100644
--- a/src/xrpld/app/misc/SHAMapStoreImp.cpp
+++ b/src/xrpld/app/misc/SHAMapStoreImp.cpp
@@ -45,14 +45,14 @@ namespace xrpl {
 void
 SHAMapStoreImp::SavedStateDB::init(BasicConfig const& config, std::string const& dbName)
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     initStateDB(sqlDb_, config, dbName);
 }
 
 LedgerIndex
 SHAMapStoreImp::SavedStateDB::getCanDelete()
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
 
     return xrpl::getCanDelete(sqlDb_);
 }
@@ -60,7 +60,7 @@ SHAMapStoreImp::SavedStateDB::getCanDelete()
 LedgerIndex
 SHAMapStoreImp::SavedStateDB::setCanDelete(LedgerIndex canDelete)
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
 
     return xrpl::setCanDelete(sqlDb_, canDelete);
 }
@@ -68,7 +68,7 @@ SHAMapStoreImp::SavedStateDB::setCanDelete(LedgerIndex canDelete)
 SavedState
 SHAMapStoreImp::SavedStateDB::getState()
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
 
     return xrpl::getSavedState(sqlDb_);
 }
@@ -76,14 +76,14 @@ SHAMapStoreImp::SavedStateDB::getState()
 void
 SHAMapStoreImp::SavedStateDB::setState(SavedState const& state)
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     xrpl::setSavedState(sqlDb_, state);
 }
 
 void
 SHAMapStoreImp::SavedStateDB::setLastRotated(LedgerIndex seq)
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     xrpl::setLastRotated(sqlDb_, seq);
 }
 
@@ -209,7 +209,7 @@ void
 SHAMapStoreImp::onLedgerClosed(std::shared_ptr<Ledger const> const& ledger)
 {
     {
-        std::lock_guard const lock(mutex_);
+        std::scoped_lock const lock(mutex_);
         newLedger_ = ledger;
         working_ = true;
     }
@@ -240,7 +240,7 @@ SHAMapStoreImp::copyNode(std::uint64_t& nodeCount, SHAMapTreeNode const& node)
         node.getHash().as_uint256(), 0, NodeStore::FetchType::synchronous, true);
     if ((++nodeCount % checkHealthInterval_) == 0u)
     {
-        if (healthWait() == stopping)
+        if (healthWait() == HealthResult::stopping)
             return false;
     }
 
@@ -290,7 +290,7 @@ SHAMapStoreImp::run()
         }
 
         bool const readyToRotate = validatedSeq >= lastRotated + deleteInterval_ &&
-            canDelete_ >= lastRotated - 1 && healthWait() == keepGoing;
+            canDelete_ >= lastRotated - 1 && healthWait() == HealthResult::keepGoing;
 
         // will delete up to (not including) lastRotated
         if (readyToRotate)
@@ -302,7 +302,7 @@ SHAMapStoreImp::run()
                                   << ledgerMaster_->getValidatedLedgerAge().count() << 's';
 
             clearPrior(lastRotated);
-            if (healthWait() == stopping)
+            if (healthWait() == HealthResult::stopping)
                 return;
 
             JLOG(journal_.debug()) << "copying ledger " << validatedSeq;
@@ -324,7 +324,7 @@ SHAMapStoreImp::run()
                 continue;
             }
 
-            if (healthWait() == stopping)
+            if (healthWait() == HealthResult::stopping)
                 return;
             // Only log if we completed without a "health" abort
             JLOG(journal_.debug())
@@ -332,7 +332,7 @@ SHAMapStoreImp::run()
 
             JLOG(journal_.debug()) << "freshening caches";
             freshenCaches();
-            if (healthWait() == stopping)
+            if (healthWait() == HealthResult::stopping)
                 return;
             // Only log if we completed without a "health" abort
             JLOG(journal_.debug()) << validatedSeq << " freshened caches";
@@ -342,7 +342,7 @@ SHAMapStoreImp::run()
             JLOG(journal_.debug()) << validatedSeq << " new backend " << newBackend->getName();
 
             clearCaches(validatedSeq);
-            if (healthWait() == stopping)
+            if (healthWait() == HealthResult::stopping)
                 return;
 
             lastRotated = validatedSeq;
@@ -506,7 +506,7 @@ SHAMapStoreImp::clearSql(
         min = *m;
     }
 
-    if (min > lastRotated || healthWait() == stopping)
+    if (min > lastRotated || healthWait() == HealthResult::stopping)
         return;
     if (min == lastRotated)
     {
@@ -525,11 +525,11 @@ SHAMapStoreImp::clearSql(
         deleteBeforeSeq(min);
         JLOG(journal_.trace()) << "End: Delete up to " << deleteBatch_ << " rows with LedgerSeq < "
                                << min << " from: " << TableName;
-        if (healthWait() == stopping)
+        if (healthWait() == HealthResult::stopping)
             return;
         if (min < lastRotated)
             std::this_thread::sleep_for(backOff_);
-        if (healthWait() == stopping)
+        if (healthWait() == HealthResult::stopping)
             return;
     }
     JLOG(journal_.debug()) << "finished deleting from: " << TableName;
@@ -563,7 +563,7 @@ SHAMapStoreImp::clearPrior(LedgerIndex lastRotated)
     JLOG(journal_.trace()) << "Begin: Clear internal ledgers up to " << lastRotated;
     ledgerMaster_->clearPriorLedgers(lastRotated);
     JLOG(journal_.trace()) << "End: Clear internal ledgers up to " << lastRotated;
-    if (healthWait() == stopping)
+    if (healthWait() == HealthResult::stopping)
         return;
 
     auto& db = app_.getRelationalDatabase();
@@ -573,7 +573,7 @@ SHAMapStoreImp::clearPrior(LedgerIndex lastRotated)
         "Ledgers",
         [&db]() -> std::optional<LedgerIndex> { return db.getMinLedgerSeq(); },
         [&db](LedgerIndex min) -> void { db.deleteBeforeLedgerSeq(min); });
-    if (healthWait() == stopping)
+    if (healthWait() == HealthResult::stopping)
         return;
 
     if (!app_.config().useTxTables())
@@ -584,7 +584,7 @@ SHAMapStoreImp::clearPrior(LedgerIndex lastRotated)
         "Transactions",
         [&db]() -> std::optional<LedgerIndex> { return db.getTransactionsMinLedgerSeq(); },
         [&db](LedgerIndex min) -> void { db.deleteTransactionsBeforeLedgerSeq(min); });
-    if (healthWait() == stopping)
+    if (healthWait() == HealthResult::stopping)
         return;
 
     clearSql(
@@ -592,7 +592,7 @@ SHAMapStoreImp::clearPrior(LedgerIndex lastRotated)
         "AccountTransactions",
         [&db]() -> std::optional<LedgerIndex> { return db.getAccountTransactionsMinLedgerSeq(); },
         [&db](LedgerIndex min) -> void { db.deleteAccountTransactionsBeforeLedgerSeq(min); });
-    if (healthWait() == stopping)
+    if (healthWait() == HealthResult::stopping)
         return;
 }
 
@@ -615,7 +615,7 @@ SHAMapStoreImp::healthWait()
         lock.lock();
     }
 
-    return stop_ ? stopping : keepGoing;
+    return stop_ ? HealthResult::stopping : HealthResult::keepGoing;
 }
 
 void
@@ -624,7 +624,7 @@ SHAMapStoreImp::stop()
     if (thread_.joinable())
     {
         {
-            std::lock_guard const lock(mutex_);
+            std::scoped_lock const lock(mutex_);
             stop_ = true;
             cond_.notify_one();
         }
diff --git a/src/xrpld/app/misc/SHAMapStoreImp.h b/src/xrpld/app/misc/SHAMapStoreImp.h
index 08e3dd70eb..22cb06c0e4 100644
--- a/src/xrpld/app/misc/SHAMapStoreImp.h
+++ b/src/xrpld/app/misc/SHAMapStoreImp.h
@@ -170,7 +170,7 @@ private:
         for (auto const& key : cache.getKeys())
         {
             dbRotating_->fetchNodeObject(key, 0, NodeStore::FetchType::synchronous, true);
-            if (!(++check % checkHealthInterval_) && healthWait() == stopping)
+            if (!(++check % checkHealthInterval_) && healthWait() == HealthResult::stopping)
                 return true;
         }
 
@@ -201,7 +201,7 @@ private:
      *
      * @return Whether the server is stopping.
      */
-    enum HealthResult { stopping, keepGoing };
+    enum class HealthResult { stopping, keepGoing };
     [[nodiscard]] HealthResult
     healthWait();
 
diff --git a/src/xrpld/app/misc/Transaction.h b/src/xrpld/app/misc/Transaction.h
index 40e0a3d10d..43ef2094fe 100644
--- a/src/xrpld/app/misc/Transaction.h
+++ b/src/xrpld/app/misc/Transaction.h
@@ -23,7 +23,7 @@ namespace xrpl {
 class Application;
 class Rules;
 
-enum TransStatus {
+enum class TransStatus {
     NEW = 0,         // just received / generated
     INVALID = 1,     // no valid signature, insufficient funds
     INCLUDED = 2,    // added to the current ledger
@@ -369,7 +369,7 @@ private:
     LedgerIndex mLedgerIndex = 0;
     std::optional<uint32_t> mTxnSeq;
     std::optional<uint32_t> mNetworkID;
-    TransStatus mStatus = INVALID;
+    TransStatus mStatus = TransStatus::INVALID;
     TER mResult = temUNCERTAIN;
     /* Note that all access to mApplying are made by NetworkOPsImp,
         and must be done under that class's lock. This avoids the overhead of
diff --git a/src/xrpld/app/misc/TxQ.h b/src/xrpld/app/misc/TxQ.h
index ce32755db1..c3dddd12ba 100644
--- a/src/xrpld/app/misc/TxQ.h
+++ b/src/xrpld/app/misc/TxQ.h
@@ -344,7 +344,7 @@ private:
     SeqProxy
     nextQueuableSeqImpl(
         std::shared_ptr<SLE const> const& sleAccount,
-        std::lock_guard<std::mutex> const&) const;
+        std::scoped_lock<std::mutex> const&) const;
 
     /**
         Track and use the fee escalation metrics of the
@@ -701,7 +701,7 @@ private:
         OpenView& view,
         ApplyFlags flags,
         FeeMetrics::Snapshot const& metricsSnapshot,
-        std::lock_guard<std::mutex> const& lock);
+        std::scoped_lock<std::mutex> const& lock);
 
     // Helper function for TxQ::apply.  If a transaction's fee is high enough,
     // attempt to directly apply that transaction to the ledger.
@@ -785,7 +785,7 @@ private:
         std::shared_ptr<SLE const> const& sleAccount,
         AccountMap::iterator const&,
         std::optional<TxQAccount::TxMap::iterator> const&,
-        std::lock_guard<std::mutex> const& lock);
+        std::scoped_lock<std::mutex> const& lock);
 
     /// Erase and return the next entry in byFee_ (lower fee level)
     FeeMultiSet::iterator_type erase(FeeMultiSet::const_iterator_type);
diff --git a/src/xrpld/app/misc/ValidatorList.h b/src/xrpld/app/misc/ValidatorList.h
index 2c7900465c..ee6f14ed4c 100644
--- a/src/xrpld/app/misc/ValidatorList.h
+++ b/src/xrpld/app/misc/ValidatorList.h
@@ -207,7 +207,7 @@ class ValidatorList
     boost::filesystem::path const dataPath_;
     beast::Journal const j_;
     std::shared_mutex mutable mutex_;
-    using lock_guard = std::lock_guard<decltype(mutex_)>;
+    using scoped_lock = std::scoped_lock<decltype(mutex_)>;
     using shared_lock = std::shared_lock<decltype(mutex_)>;
 
     std::atomic<std::size_t> quorum_;
@@ -759,7 +759,7 @@ private:
         std::uint32_t version,
         std::string siteUri,
         std::optional<uint256> const& hash,
-        lock_guard const&);
+        scoped_lock const&);
 
     // This function updates the keyListings_ counts for all the trusted
     // master keys
@@ -768,7 +768,7 @@ private:
         PublicKey const& pubKey,
         PublisherList const& current,
         std::vector<PublicKey> const& oldList,
-        lock_guard const&);
+        scoped_lock const&);
 
     static void
     buildBlobInfos(
@@ -804,7 +804,7 @@ private:
     /** Get the filename used for caching UNLs
      */
     boost::filesystem::path
-    getCacheFileName(lock_guard const&, PublicKey const& pubKey) const;
+    getCacheFileName(scoped_lock const&, PublicKey const& pubKey) const;
 
     /** Build a Json representation of the collection, suitable for
         writing to a cache file, or serving to a /vl/ query
@@ -836,7 +836,7 @@ private:
     /** Write a JSON UNL to a cache file
      */
     void
-    cacheValidatorFile(lock_guard const& lock, PublicKey const& pubKey) const;
+    cacheValidatorFile(scoped_lock const& lock, PublicKey const& pubKey) const;
 
     /** Check response for trusted valid published list
 
@@ -848,7 +848,7 @@ private:
     */
     std::pair<ListDisposition, std::optional<PublicKey>>
     verify(
-        lock_guard const&,
+        scoped_lock const&,
         Json::Value& list,
         Manifest manifest,
         std::string const& blob,
@@ -865,7 +865,7 @@ private:
         Calling public member function is expected to lock mutex
     */
     bool
-    removePublisherList(lock_guard const&, PublicKey const& publisherKey, PublisherStatus reason);
+    removePublisherList(scoped_lock const&, PublicKey const& publisherKey, PublisherStatus reason);
 
     /** Return quorum for trusted validator set
 
diff --git a/src/xrpld/app/misc/ValidatorSite.h b/src/xrpld/app/misc/ValidatorSite.h
index ab82ae168d..308b8f72bc 100644
--- a/src/xrpld/app/misc/ValidatorSite.h
+++ b/src/xrpld/app/misc/ValidatorSite.h
@@ -177,12 +177,12 @@ public:
 private:
     /// Load configured site URIs.
     bool
-    load(std::vector<std::string> const& siteURIs, std::lock_guard<std::mutex> const&);
+    load(std::vector<std::string> const& siteURIs, std::scoped_lock<std::mutex> const&);
 
     /// Queue next site to be fetched
     /// lock over site_mutex_ and state_mutex_ required
     void
-    setTimer(std::lock_guard<std::mutex> const&, std::lock_guard<std::mutex> const&);
+    setTimer(std::scoped_lock<std::mutex> const&, std::scoped_lock<std::mutex> const&);
 
     /// request took too long
     void
@@ -210,7 +210,7 @@ private:
     makeRequest(
         std::shared_ptr<Site::Resource> resource,
         std::size_t siteIdx,
-        std::lock_guard<std::mutex> const&);
+        std::scoped_lock<std::mutex> const&);
 
     /// Parse json response from validator list site.
     /// lock over sites_mutex_ required
@@ -218,7 +218,7 @@ private:
     parseJsonResponse(
         std::string const& res,
         std::size_t siteIdx,
-        std::lock_guard<std::mutex> const&);
+        std::scoped_lock<std::mutex> const&);
 
     /// Interpret a redirect response.
     /// lock over sites_mutex_ required
@@ -226,12 +226,12 @@ private:
     processRedirect(
         detail::response_type const& res,
         std::size_t siteIdx,
-        std::lock_guard<std::mutex> const&);
+        std::scoped_lock<std::mutex> const&);
 
     /// If no sites are provided, or a site fails to load,
     /// get a list of local cache files from the ValidatorList.
     bool
-    missingSite(std::lock_guard<std::mutex> const&);
+    missingSite(std::scoped_lock<std::mutex> const&);
 };
 
 }  // namespace xrpl
diff --git a/src/xrpld/app/misc/detail/AmendmentTable.cpp b/src/xrpld/app/misc/detail/AmendmentTable.cpp
index 65342dac2f..1eee034a16 100644
--- a/src/xrpld/app/misc/detail/AmendmentTable.cpp
+++ b/src/xrpld/app/misc/detail/AmendmentTable.cpp
@@ -126,7 +126,7 @@ public:
     //
     // Call with AmendmentTable::mutex_ locked.
     void
-    trustChanged(hash_set<PublicKey> const& allTrusted, std::lock_guard<std::mutex> const& lock)
+    trustChanged(hash_set<PublicKey> const& allTrusted, std::scoped_lock<std::mutex> const& lock)
     {
         decltype(recordedVotes_) newRecordedVotes;
         newRecordedVotes.reserve(allTrusted.size());
@@ -162,7 +162,7 @@ public:
         std::vector<std::shared_ptr<STValidation>> const& valSet,
         NetClock::time_point const closeTime,
         beast::Journal j,
-        std::lock_guard<std::mutex> const& lock)
+        std::scoped_lock<std::mutex> const& lock)
     {
         // When we get an STValidation we save the upVotes it contains, but
         // we also set an expiration for those upVotes.  The following constant
@@ -259,7 +259,7 @@ public:
     //
     // Call with AmendmentTable::mutex_ locked.
     [[nodiscard]] std::pair<int, hash_map<uint256, int>>
-    getVotes(Rules const& rules, std::lock_guard<std::mutex> const& lock) const
+    getVotes(Rules const& rules, std::scoped_lock<std::mutex> const& lock) const
     {
         hash_map<uint256, int> ret;
         int available = 0;
@@ -319,7 +319,7 @@ public:
     AmendmentSet(
         Rules const& rules,
         TrustedVotes const& trustedVotes,
-        std::lock_guard<std::mutex> const& lock)
+        std::scoped_lock<std::mutex> const& lock)
     {
         // process validations for ledger before flag ledger.
         auto [trustedCount, newVotes] = trustedVotes.getVotes(rules, lock);
@@ -415,14 +415,14 @@ private:
 
     // Finds or creates state.  Must be called with mutex_ locked.
     AmendmentState&
-    add(uint256 const& amendment, std::lock_guard<std::mutex> const& lock);
+    add(uint256 const& amendment, std::scoped_lock<std::mutex> const& lock);
 
     // Finds existing state.  Must be called with mutex_ locked.
     AmendmentState*
-    get(uint256 const& amendment, std::lock_guard<std::mutex> const& lock);
+    get(uint256 const& amendment, std::scoped_lock<std::mutex> const& lock);
 
     AmendmentState const*
-    get(uint256 const& amendment, std::lock_guard<std::mutex> const& lock) const;
+    get(uint256 const& amendment, std::scoped_lock<std::mutex> const& lock) const;
 
     // Injects amendment json into v.  Must be called with mutex_ locked.
     void
@@ -431,7 +431,7 @@ private:
         uint256 const& amendment,
         AmendmentState const& state,
         bool isAdmin,
-        std::lock_guard<std::mutex> const& lock) const;
+        std::scoped_lock<std::mutex> const& lock) const;
 
     void
     persistVote(uint256 const& amendment, std::string const& name, AmendmentVote vote) const;
@@ -510,7 +510,7 @@ AmendmentTableImpl::AmendmentTableImpl(
     beast::Journal journal)
     : majorityTime_(majorityTime), j_(journal), db_(registry.getWalletDB())
 {
-    std::lock_guard lock(mutex_);
+    std::scoped_lock lock(mutex_);
 
     // Find out if the FeatureVotes table exists in WalletDB
     bool const featureVotesExist = [this]() {
@@ -633,21 +633,21 @@ AmendmentTableImpl::AmendmentTableImpl(
 }
 
 AmendmentState&
-AmendmentTableImpl::add(uint256 const& amendmentHash, std::lock_guard<std::mutex> const&)
+AmendmentTableImpl::add(uint256 const& amendmentHash, std::scoped_lock<std::mutex> const&)
 {
     // call with the mutex held
     return amendmentMap_[amendmentHash];
 }
 
 AmendmentState*
-AmendmentTableImpl::get(uint256 const& amendmentHash, std::lock_guard<std::mutex> const& lock)
+AmendmentTableImpl::get(uint256 const& amendmentHash, std::scoped_lock<std::mutex> const& lock)
 {
     // Forward to the const version of get.
     return const_cast<AmendmentState*>(std::as_const(*this).get(amendmentHash, lock));
 }
 
 AmendmentState const*
-AmendmentTableImpl::get(uint256 const& amendmentHash, std::lock_guard<std::mutex> const&) const
+AmendmentTableImpl::get(uint256 const& amendmentHash, std::scoped_lock<std::mutex> const&) const
 {
     // call with the mutex held
     auto ret = amendmentMap_.find(amendmentHash);
@@ -661,7 +661,7 @@ AmendmentTableImpl::get(uint256 const& amendmentHash, std::lock_guard<std::mutex
 uint256
 AmendmentTableImpl::find(std::string const& name) const
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
 
     for (auto const& e : amendmentMap_)
     {
@@ -688,7 +688,7 @@ AmendmentTableImpl::persistVote(
 bool
 AmendmentTableImpl::veto(uint256 const& amendment)
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     AmendmentState& s = add(amendment, lock);
 
     if (s.vote != AmendmentVote::up)
@@ -701,7 +701,7 @@ AmendmentTableImpl::veto(uint256 const& amendment)
 bool
 AmendmentTableImpl::unVeto(uint256 const& amendment)
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     AmendmentState* const s = get(amendment, lock);
 
     if ((s == nullptr) || s->vote != AmendmentVote::down)
@@ -714,7 +714,7 @@ AmendmentTableImpl::unVeto(uint256 const& amendment)
 bool
 AmendmentTableImpl::enable(uint256 const& amendment)
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     AmendmentState& s = add(amendment, lock);
 
     if (s.enabled)
@@ -734,7 +734,7 @@ AmendmentTableImpl::enable(uint256 const& amendment)
 bool
 AmendmentTableImpl::isEnabled(uint256 const& amendment) const
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     AmendmentState const* s = get(amendment, lock);
     return (s != nullptr) && s->enabled;
 }
@@ -742,7 +742,7 @@ AmendmentTableImpl::isEnabled(uint256 const& amendment) const
 bool
 AmendmentTableImpl::isSupported(uint256 const& amendment) const
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     AmendmentState const* s = get(amendment, lock);
     return (s != nullptr) && s->supported;
 }
@@ -750,14 +750,14 @@ AmendmentTableImpl::isSupported(uint256 const& amendment) const
 bool
 AmendmentTableImpl::hasUnsupportedEnabled() const
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     return unsupportedEnabled_;
 }
 
 std::optional<NetClock::time_point>
 AmendmentTableImpl::firstUnsupportedExpected() const
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     return firstUnsupportedExpected_;
 }
 
@@ -769,7 +769,7 @@ AmendmentTableImpl::doValidation(std::set<uint256> const& enabled) const
     std::vector<uint256> amendments;
 
     {
-        std::lock_guard const lock(mutex_);
+        std::scoped_lock const lock(mutex_);
         amendments.reserve(amendmentMap_.size());
         for (auto const& e : amendmentMap_)
         {
@@ -807,7 +807,7 @@ AmendmentTableImpl::doVoting(
                      << enabledAmendments.size() << ", " << majorityAmendments.size() << ", "
                      << valSet.size();
 
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
 
     // Keep a record of the votes we received.
     previousTrustedVotes_.recordVotes(rules, valSet, closeTime, j_, lock);
@@ -889,7 +889,7 @@ AmendmentTableImpl::doVoting(
 bool
 AmendmentTableImpl::needValidatedLedger(LedgerIndex ledgerSeq) const
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
 
     // Is there a ledger in which an amendment could have been enabled
     // between these two ledger sequences?
@@ -906,7 +906,7 @@ AmendmentTableImpl::doValidatedLedger(
     for (auto& e : enabled)
         enable(e);
 
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
 
     // Remember the ledger sequence of this update.
     lastUpdateSeq_ = ledgerSeq;
@@ -937,7 +937,7 @@ AmendmentTableImpl::doValidatedLedger(
 void
 AmendmentTableImpl::trustChanged(hash_set<PublicKey> const& allTrusted)
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     previousTrustedVotes_.trustChanged(allTrusted, lock);
 }
 
@@ -947,7 +947,7 @@ AmendmentTableImpl::injectJson(
     uint256 const& id,
     AmendmentState const& fs,
     bool isAdmin,
-    std::lock_guard<std::mutex> const&) const
+    std::scoped_lock<std::mutex> const&) const
 {
     if (!fs.name.empty())
         v[jss::name] = fs.name;
@@ -985,7 +985,7 @@ AmendmentTableImpl::getJson(bool isAdmin) const
 {
     Json::Value ret(Json::objectValue);
     {
-        std::lock_guard const lock(mutex_);
+        std::scoped_lock const lock(mutex_);
         for (auto const& e : amendmentMap_)
         {
             injectJson(
@@ -1001,7 +1001,7 @@ AmendmentTableImpl::getJson(uint256 const& amendmentID, bool isAdmin) const
     Json::Value ret = Json::objectValue;
 
     {
-        std::lock_guard const lock(mutex_);
+        std::scoped_lock const lock(mutex_);
         AmendmentState const* a = get(amendmentID, lock);
         if (a != nullptr)
         {
diff --git a/src/xrpld/app/misc/detail/Transaction.cpp b/src/xrpld/app/misc/detail/Transaction.cpp
index 758f560835..34a9613171 100644
--- a/src/xrpld/app/misc/detail/Transaction.cpp
+++ b/src/xrpld/app/misc/detail/Transaction.cpp
@@ -48,7 +48,7 @@ Transaction::Transaction(
         return;
     }
 
-    mStatus = NEW;
+    mStatus = TransStatus::NEW;
 }
 
 //
@@ -78,22 +78,22 @@ Transaction::sqlTransactionStatus(boost::optional<std::string> const& status)
     switch (static_cast<TxnSql>(c))
     {
         case TxnSql::txnSqlNew:
-            return NEW;
+            return TransStatus::NEW;
         case TxnSql::txnSqlConflict:
-            return CONFLICTED;
+            return TransStatus::CONFLICTED;
         case TxnSql::txnSqlHeld:
-            return HELD;
+            return TransStatus::HELD;
         case TxnSql::txnSqlValidated:
-            return COMMITTED;
+            return TransStatus::COMMITTED;
         case TxnSql::txnSqlIncluded:
-            return INCLUDED;
+            return TransStatus::INCLUDED;
         default:
             XRPL_ASSERT(
                 c == TxnSql::txnSqlUnknown,
                 "xrpl::Transaction::sqlTransactionStatus : unknown transaction status");
     }
 
-    return INVALID;
+    return TransStatus::INVALID;
 }
 
 Transaction::pointer
diff --git a/src/xrpld/app/misc/detail/TxQ.cpp b/src/xrpld/app/misc/detail/TxQ.cpp
index dde0988b4a..3e4a420e48 100644
--- a/src/xrpld/app/misc/detail/TxQ.cpp
+++ b/src/xrpld/app/misc/detail/TxQ.cpp
@@ -390,7 +390,7 @@ TxQ::canBeHeld(
     std::shared_ptr<SLE const> const& sleAccount,
     AccountMap::iterator const& accountIter,
     std::optional<TxQAccount::TxMap::iterator> const& replacementIter,
-    std::lock_guard<std::mutex> const& lock)
+    std::scoped_lock<std::mutex> const& lock)
 {
     // PreviousTxnID is deprecated and should never be used.
     // AccountTxnID is not supported by the transaction
@@ -775,7 +775,7 @@ TxQ::apply(
         return {terPRE_TICKET, false};
     }
 
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
 
     // accountIter is not const because it may be updated further down.
     AccountMap::iterator accountIter = byAccount_.find(account);
@@ -1332,7 +1332,7 @@ TxQ::apply(
 void
 TxQ::processClosedLedger(Application& app, ReadView const& view, bool timeLeap)
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
 
     feeMetrics_.update(app, view, timeLeap, setup_);
     auto const& snapshot = feeMetrics_.getSnapshot();
@@ -1411,7 +1411,7 @@ TxQ::accept(Application& app, OpenView& view)
 
     auto ledgerChanged = false;
 
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
 
     auto const metricsSnapshot = feeMetrics_.getSnapshot();
 
@@ -1575,7 +1575,7 @@ TxQ::accept(Application& app, OpenView& view)
 SeqProxy
 TxQ::nextQueuableSeq(std::shared_ptr<SLE const> const& sleAccount) const
 {
-    std::lock_guard<std::mutex> const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     return nextQueuableSeqImpl(sleAccount, lock);
 }
 
@@ -1588,7 +1588,7 @@ TxQ::nextQueuableSeq(std::shared_ptr<SLE const> const& sleAccount) const
 SeqProxy
 TxQ::nextQueuableSeqImpl(
     std::shared_ptr<SLE const> const& sleAccount,
-    std::lock_guard<std::mutex> const&) const
+    std::scoped_lock<std::mutex> const&) const
 {
     // If the account is not in the ledger or a non-account was passed
     // then return zero.  We have no idea.
@@ -1637,7 +1637,7 @@ TxQ::getRequiredFeeLevel(
     OpenView& view,
     ApplyFlags flags,
     FeeMetrics::Snapshot const& metricsSnapshot,
-    std::lock_guard<std::mutex> const& lock)
+    std::scoped_lock<std::mutex> const& lock)
 {
     return FeeMetrics::scaleFeeLevel(metricsSnapshot, view);
 }
@@ -1666,7 +1666,7 @@ TxQ::tryDirectApply(
         return {};
 
     FeeLevel64 const requiredFeeLevel = [this, &view, flags]() {
-        std::lock_guard const lock(mutex_);
+        std::scoped_lock const lock(mutex_);
         return getRequiredFeeLevel(view, flags, feeMetrics_.getSnapshot(), lock);
     }();
 
@@ -1690,7 +1690,7 @@ TxQ::tryDirectApply(
         {
             // If the applied transaction replaced a transaction in the
             // queue then remove the replaced transaction.
-            std::lock_guard const lock(mutex_);
+            std::scoped_lock const lock(mutex_);
 
             AccountMap::iterator const accountIter = byAccount_.find(account);
             if (accountIter != byAccount_.end())
@@ -1739,7 +1739,7 @@ TxQ::getMetrics(OpenView const& view) const
 {
     Metrics result;
 
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
 
     auto const snapshot = feeMetrics_.getSnapshot();
 
@@ -1760,7 +1760,7 @@ TxQ::getTxRequiredFeeAndSeq(OpenView const& view, std::shared_ptr<STTx const> co
 {
     auto const account = (*tx)[sfAccount];
 
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
 
     auto const snapshot = feeMetrics_.getSnapshot();
     auto const baseFee = calculateBaseFee(view, *tx);
@@ -1782,7 +1782,7 @@ TxQ::getAccountTxs(AccountID const& account) const
 {
     std::vector<TxDetails> result;
 
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
 
     AccountMap::const_iterator const accountIter{byAccount_.find(account)};
 
@@ -1802,7 +1802,7 @@ TxQ::getTxs() const
 {
     std::vector<TxDetails> result;
 
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
 
     result.reserve(byFee_.size());
 
diff --git a/src/xrpld/app/misc/detail/ValidatorList.cpp b/src/xrpld/app/misc/detail/ValidatorList.cpp
index 8a62a71972..b9a32f1463 100644
--- a/src/xrpld/app/misc/detail/ValidatorList.cpp
+++ b/src/xrpld/app/misc/detail/ValidatorList.cpp
@@ -169,7 +169,7 @@ ValidatorList::load(
         ")?"                 // end optional comment block
     );
 
-    std::lock_guard const lock{mutex_};
+    std::scoped_lock const lock{mutex_};
 
     JLOG(j_.debug()) << "Loading configured trusted validator list publisher keys";
 
@@ -289,7 +289,7 @@ ValidatorList::load(
 }
 
 boost::filesystem::path
-ValidatorList::getCacheFileName(ValidatorList::lock_guard const&, PublicKey const& pubKey) const
+ValidatorList::getCacheFileName(ValidatorList::scoped_lock const&, PublicKey const& pubKey) const
 {
     return dataPath_ / (filePrefix_ + strHex(pubKey));
 }
@@ -366,7 +366,7 @@ ValidatorList::buildFileData(
 }
 
 void
-ValidatorList::cacheValidatorFile(ValidatorList::lock_guard const& lock, PublicKey const& pubKey)
+ValidatorList::cacheValidatorFile(ValidatorList::scoped_lock const& lock, PublicKey const& pubKey)
     const
 {
     if (dataPath_.empty())
@@ -982,7 +982,7 @@ ValidatorList::applyLists(
         1)
         return PublisherListStats{ListDisposition::unsupported_version};
 
-    std::lock_guard const lock{mutex_};
+    std::scoped_lock const lock{mutex_};
 
     PublisherListStats result;
     for (auto const& blobInfo : blobs)
@@ -1052,7 +1052,7 @@ ValidatorList::updatePublisherList(
     PublicKey const& pubKey,
     PublisherList const& current,
     std::vector<PublicKey> const& oldList,
-    ValidatorList::lock_guard const&)
+    ValidatorList::scoped_lock const&)
 {
     // Update keyListings_ for added and removed keys
     std::vector<PublicKey> const& publisherList = current.list;
@@ -1121,7 +1121,7 @@ ValidatorList::applyList(
     std::uint32_t version,
     std::string siteUri,
     std::optional<uint256> const& hash,
-    ValidatorList::lock_guard const& lock)
+    ValidatorList::scoped_lock const& lock)
 {
     using namespace std::string_literals;
 
@@ -1286,7 +1286,7 @@ ValidatorList::loadLists()
     using namespace boost::filesystem;
     using namespace boost::system::errc;
 
-    std::lock_guard const lock{mutex_};
+    std::scoped_lock const lock{mutex_};
 
     std::vector<std::string> sites;
     sites.reserve(publisherLists_.size());
@@ -1336,7 +1336,7 @@ ValidatorList::loadLists()
 // contain the default-constructed public keys
 std::pair<ListDisposition, std::optional<PublicKey>>
 ValidatorList::verify(
-    ValidatorList::lock_guard const& lock,
+    ValidatorList::scoped_lock const& lock,
     Json::Value& list,
     Manifest manifest,
     std::string const& blob,
@@ -1494,7 +1494,7 @@ ValidatorList::localPublicKey() const
 
 bool
 ValidatorList::removePublisherList(
-    ValidatorList::lock_guard const&,
+    ValidatorList::scoped_lock const&,
     PublicKey const& publisherKey,
     PublisherStatus reason)
 {
@@ -1901,7 +1901,7 @@ ValidatorList::updateTrusted(
     if (timeKeeper_.now() > closeTime + 30s)
         closeTime = timeKeeper_.now();
 
-    std::lock_guard const lock{mutex_};
+    std::scoped_lock const lock{mutex_};
 
     // Rotate pending and remove expired published lists
     bool good = true;
@@ -2095,7 +2095,7 @@ ValidatorList::getNegativeUNL() const
 void
 ValidatorList::setNegativeUNL(hash_set<PublicKey> const& negUnl)
 {
-    std::lock_guard const lock{mutex_};
+    std::scoped_lock const lock{mutex_};
     negativeUNL_ = negUnl;
 }
 
diff --git a/src/xrpld/app/misc/detail/ValidatorSite.cpp b/src/xrpld/app/misc/detail/ValidatorSite.cpp
index 557a4e4f25..4c05ce5f09 100644
--- a/src/xrpld/app/misc/detail/ValidatorSite.cpp
+++ b/src/xrpld/app/misc/detail/ValidatorSite.cpp
@@ -130,7 +130,7 @@ ValidatorSite::~ValidatorSite()
 }
 
 bool
-ValidatorSite::missingSite(std::lock_guard<std::mutex> const& lock_sites)
+ValidatorSite::missingSite(std::scoped_lock<std::mutex> const& lock_sites)
 {
     auto const sites = app_.getValidators().loadLists();
     return sites.empty() || load(sites, lock_sites);
@@ -141,7 +141,7 @@ ValidatorSite::load(std::vector<std::string> const& siteURIs)
 {
     JLOG(j_.debug()) << "Loading configured validator list sites";
 
-    std::lock_guard const lock{sites_mutex_};
+    std::scoped_lock const lock{sites_mutex_};
 
     return load(siteURIs, lock);
 }
@@ -149,7 +149,7 @@ ValidatorSite::load(std::vector<std::string> const& siteURIs)
 bool
 ValidatorSite::load(
     std::vector<std::string> const& siteURIs,
-    std::lock_guard<std::mutex> const& lock_sites)
+    std::scoped_lock<std::mutex> const& lock_sites)
 {
     // If no sites are provided, act as if a site failed to load.
     if (siteURIs.empty())
@@ -178,8 +178,8 @@ ValidatorSite::load(
 void
 ValidatorSite::start()
 {
-    std::lock_guard const l0{sites_mutex_};
-    std::lock_guard const l1{state_mutex_};
+    std::scoped_lock const l0{sites_mutex_};
+    std::scoped_lock const l1{state_mutex_};
     if (timer_.expiry() == clock_type::time_point{})
         setTimer(l0, l1);
 }
@@ -219,8 +219,8 @@ ValidatorSite::stop()
 
 void
 ValidatorSite::setTimer(
-    std::lock_guard<std::mutex> const& site_lock,
-    std::lock_guard<std::mutex> const& state_lock)
+    std::scoped_lock<std::mutex> const& site_lock,
+    std::scoped_lock<std::mutex> const& state_lock)
 {
     auto next = std::ranges::min_element(
         sites_, [](Site const& a, Site const& b) { return a.nextRefresh < b.nextRefresh; });
@@ -240,13 +240,13 @@ void
 ValidatorSite::makeRequest(
     std::shared_ptr<Site::Resource> resource,
     std::size_t siteIdx,
-    std::lock_guard<std::mutex> const& sites_lock)
+    std::scoped_lock<std::mutex> const& sites_lock)
 {
     fetching_ = true;
     sites_[siteIdx].activeResource = resource;
     std::shared_ptr<detail::Work> sp;
     auto timeoutCancel = [this]() {
-        std::lock_guard const lock_state{state_mutex_};
+        std::scoped_lock const lock_state{state_mutex_};
         // docs indicate cancel_one() can throw, but this
         // should be reconsidered if it changes to noexcept
         try
@@ -312,7 +312,7 @@ ValidatorSite::makeRequest(
     sp->run();
     // start a timer for the request, which shouldn't take more
     // than requestTimeout_ to complete
-    std::lock_guard const lock_state{state_mutex_};
+    std::scoped_lock const lock_state{state_mutex_};
     timer_.expires_after(requestTimeout_);
     timer_.async_wait([this, siteIdx](boost::system::error_code const& ec) {
         this->onRequestTimeout(siteIdx, ec);
@@ -326,7 +326,7 @@ ValidatorSite::onRequestTimeout(std::size_t siteIdx, error_code const& ec)
         return;
 
     {
-        std::lock_guard const lock_site{sites_mutex_};
+        std::scoped_lock const lock_site{sites_mutex_};
         // In some circumstances, both this function and the response
         // handler (onSiteFetch or onTextFetch) can get queued and
         // processed. In all observed cases, the response handler
@@ -343,7 +343,7 @@ ValidatorSite::onRequestTimeout(std::size_t siteIdx, error_code const& ec)
                                 "already been processed";
     }
 
-    std::lock_guard const lock_state{state_mutex_};
+    std::scoped_lock const lock_state{state_mutex_};
     if (auto sp = work_.lock())
         sp->cancel();
 }
@@ -362,7 +362,7 @@ ValidatorSite::onTimer(std::size_t siteIdx, error_code const& ec)
 
     try
     {
-        std::lock_guard const lock{sites_mutex_};
+        std::scoped_lock const lock{sites_mutex_};
         sites_[siteIdx].nextRefresh = clock_type::now() + sites_[siteIdx].refreshInterval;
         sites_[siteIdx].redirCount = 0;
         // the WorkSSL client ctor can throw if SSL init fails
@@ -383,7 +383,7 @@ void
 ValidatorSite::parseJsonResponse(
     std::string const& res,
     std::size_t siteIdx,
-    std::lock_guard<std::mutex> const& sites_lock)
+    std::scoped_lock<std::mutex> const& sites_lock)
 {
     Json::Value const body = [&res, siteIdx, this]() {
         Json::Reader r;
@@ -501,7 +501,7 @@ std::shared_ptr<ValidatorSite::Site::Resource>
 ValidatorSite::processRedirect(
     detail::response_type const& res,
     std::size_t siteIdx,
-    std::lock_guard<std::mutex> const& sites_lock)
+    std::scoped_lock<std::mutex> const& sites_lock)
 {
     using namespace boost::beast::http;
     std::shared_ptr<Site::Resource> newLocation;
@@ -545,7 +545,7 @@ ValidatorSite::onSiteFetch(
     detail::response_type const& res,
     std::size_t siteIdx)
 {
-    std::lock_guard lock_sites{sites_mutex_};
+    std::scoped_lock lock_sites{sites_mutex_};
     {
         if (endpoint != endpoint_type{})
             sites_[siteIdx].lastRequestEndpoint = endpoint;
@@ -617,7 +617,7 @@ ValidatorSite::onSiteFetch(
         sites_[siteIdx].activeResource.reset();
     }
 
-    std::lock_guard const lock_state{state_mutex_};
+    std::scoped_lock const lock_state{state_mutex_};
     fetching_ = false;
     if (!stopping_)
         setTimer(lock_sites, lock_state);
@@ -630,7 +630,7 @@ ValidatorSite::onTextFetch(
     std::string const& res,
     std::size_t siteIdx)
 {
-    std::lock_guard const lock_sites{sites_mutex_};
+    std::scoped_lock const lock_sites{sites_mutex_};
     {
         try
         {
@@ -657,7 +657,7 @@ ValidatorSite::onTextFetch(
         sites_[siteIdx].activeResource.reset();
     }
 
-    std::lock_guard const lock_state{state_mutex_};
+    std::scoped_lock const lock_state{state_mutex_};
     fetching_ = false;
     if (!stopping_)
         setTimer(lock_sites, lock_state);
@@ -673,7 +673,7 @@ ValidatorSite::getJson() const
     Json::Value jrr(Json::objectValue);
     Json::Value& jSites = (jrr[jss::validator_sites] = Json::arrayValue);
     {
-        std::lock_guard const lock{sites_mutex_};
+        std::scoped_lock const lock{sites_mutex_};
         for (Site const& site : sites_)
         {
             Json::Value& v = jSites.append(Json::objectValue);
diff --git a/src/xrpld/app/rdb/backend/detail/Node.cpp b/src/xrpld/app/rdb/backend/detail/Node.cpp
index f1b5f4edc3..c698c7ca76 100644
--- a/src/xrpld/app/rdb/backend/detail/Node.cpp
+++ b/src/xrpld/app/rdb/backend/detail/Node.cpp
@@ -249,7 +249,8 @@ saveValidatedLedger(
         Serializer s(128);
         s.add32(HashPrefix::ledgerMaster);
         addRaw(ledger->header(), s);
-        app.getNodeStore().store(hotLEDGER, std::move(s.modData()), ledger->header().hash, seq);
+        app.getNodeStore().store(
+            NodeObjectType::hotLEDGER, std::move(s.modData()), ledger->header().hash, seq);
     }
 
     std::shared_ptr<AcceptedLedger> aLedger;
diff --git a/src/xrpld/consensus/Consensus.h b/src/xrpld/consensus/Consensus.h
index 9edbebd429..32460516bd 100644
--- a/src/xrpld/consensus/Consensus.h
+++ b/src/xrpld/consensus/Consensus.h
@@ -551,7 +551,7 @@ private:
 
     NetClock::duration closeResolution_ = ledgerDefaultTimeResolution;
 
-    ConsensusParms::AvalancheState closeTimeAvalancheState_ = ConsensusParms::init;
+    ConsensusParms::AvalancheState closeTimeAvalancheState_ = ConsensusParms::AvalancheState::init;
 
     // Time it took for the last consensus round to converge
     std::chrono::milliseconds prevRoundTime_{};
@@ -677,7 +677,7 @@ Consensus<Adaptor>::startRoundInternal(
     previousLedger_ = prevLedger;
     result_.reset();
     convergePercent_ = 0;
-    closeTimeAvalancheState_ = ConsensusParms::init;
+    closeTimeAvalancheState_ = ConsensusParms::AvalancheState::init;
     haveCloseTimeConsensus_ = false;
     openTime_.reset(clock_.now());
     currPeerPositions_.clear();
diff --git a/src/xrpld/consensus/ConsensusParms.h b/src/xrpld/consensus/ConsensusParms.h
index c8b79c4de9..7b9ec5dcff 100644
--- a/src/xrpld/consensus/ConsensusParms.h
+++ b/src/xrpld/consensus/ConsensusParms.h
@@ -106,7 +106,7 @@ struct ConsensusParms
     // As a function of the percent this round's duration is of the prior round,
     // we increase the threshold for yes votes to add a transaction to our
     // position.
-    enum AvalancheState { init, mid, late, stuck };
+    enum class AvalancheState { init, mid, late, stuck };
     struct AvalancheCutoff
     {
         int const consensusTime;
@@ -121,14 +121,18 @@ struct ConsensusParms
     std::map<AvalancheState, AvalancheCutoff> const avalancheCutoffs{
         // {state, {time, percent, nextState}},
         // Initial state: 50% of nodes must vote yes
-        {init, {.consensusTime = 0, .consensusPct = 50, .next = mid}},
+        {AvalancheState::init,
+         {.consensusTime = 0, .consensusPct = 50, .next = AvalancheState::mid}},
         // mid-consensus starts after 50% of the previous round time, and
         // requires 65% yes
-        {mid, {.consensusTime = 50, .consensusPct = 65, .next = late}},
+        {AvalancheState::mid,
+         {.consensusTime = 50, .consensusPct = 65, .next = AvalancheState::late}},
         // late consensus starts after 85% time, and requires 70% yes
-        {late, {.consensusTime = 85, .consensusPct = 70, .next = stuck}},
+        {AvalancheState::late,
+         {.consensusTime = 85, .consensusPct = 70, .next = AvalancheState::stuck}},
         // we're stuck after 2x time, requires 95% yes votes
-        {stuck, {.consensusTime = 200, .consensusPct = 95, .next = stuck}},
+        {AvalancheState::stuck,
+         {.consensusTime = 200, .consensusPct = 95, .next = AvalancheState::stuck}},
     };
 
     //! Percentage of nodes required to reach agreement on ledger close time
diff --git a/src/xrpld/consensus/DisputedTx.h b/src/xrpld/consensus/DisputedTx.h
index aff4ccae68..4320505d0f 100644
--- a/src/xrpld/consensus/DisputedTx.h
+++ b/src/xrpld/consensus/DisputedTx.h
@@ -185,7 +185,7 @@ private:
     //! The number of rounds we've gone without changing our vote
     std::size_t currentVoteCounter_ = 0;
     //! Which minimum acceptance percentage phase we are currently in
-    ConsensusParms::AvalancheState avalancheState_ = ConsensusParms::init;
+    ConsensusParms::AvalancheState avalancheState_ = ConsensusParms::AvalancheState::init;
     //! How long we have been in the current acceptance phase
     std::size_t avalancheCounter_ = 0;
     beast::Journal const j_;
diff --git a/src/xrpld/consensus/Validations.h b/src/xrpld/consensus/Validations.h
index 46b0ef0b32..5edb1db77f 100644
--- a/src/xrpld/consensus/Validations.h
+++ b/src/xrpld/consensus/Validations.h
@@ -334,7 +334,7 @@ class Validations
 private:
     // Remove support of a validated ledger
     void
-    removeTrie(std::lock_guard<Mutex> const&, NodeID const& nodeID, Validation const& val)
+    removeTrie(std::scoped_lock<Mutex> const&, NodeID const& nodeID, Validation const& val)
     {
         {
             auto it = acquiring_.find(std::make_pair(val.seq(), val.ledgerID()));
@@ -357,7 +357,7 @@ private:
 
     // Check if any pending acquire ledger requests are complete
     void
-    checkAcquired(std::lock_guard<Mutex> const& lock)
+    checkAcquired(std::scoped_lock<Mutex> const& lock)
     {
         for (auto it = acquiring_.begin(); it != acquiring_.end();)
         {
@@ -377,7 +377,7 @@ private:
 
     // Update the trie to reflect a new validated ledger
     void
-    updateTrie(std::lock_guard<Mutex> const&, NodeID const& nodeID, Ledger ledger)
+    updateTrie(std::scoped_lock<Mutex> const&, NodeID const& nodeID, Ledger ledger)
     {
         auto const [it, inserted] = lastLedger_.emplace(nodeID, ledger);
         if (!inserted)
@@ -403,7 +403,7 @@ private:
     */
     void
     updateTrie(
-        std::lock_guard<Mutex> const& lock,
+        std::scoped_lock<Mutex> const& lock,
         NodeID const& nodeID,
         Validation const& val,
         std::optional<std::pair<Seq, ID>> prior)
@@ -457,7 +457,7 @@ private:
     */
     template <class F>
     auto
-    withTrie(std::lock_guard<Mutex> const& lock, F&& f)
+    withTrie(std::scoped_lock<Mutex> const& lock, F&& f)
     {
         // Call current to flush any stale validations
         current(lock, [](auto) {}, [](auto, auto) {});
@@ -483,7 +483,7 @@ private:
 
     template <class Pre, class F>
     void
-    current(std::lock_guard<Mutex> const& lock, Pre&& pre, F&& f)
+    current(std::scoped_lock<Mutex> const& lock, Pre&& pre, F&& f)
     {
         NetClock::time_point const t = adaptor_.now();
         pre(current_.size());
@@ -520,7 +520,7 @@ private:
     */
     template <class Pre, class F>
     void
-    byLedger(std::lock_guard<Mutex> const&, ID const& ledgerID, Pre&& pre, F&& f)
+    byLedger(std::scoped_lock<Mutex> const&, ID const& ledgerID, Pre&& pre, F&& f)
     {
         auto it = byLedger_.find(ledgerID);
         if (it != byLedger_.end())
@@ -575,7 +575,7 @@ public:
     bool
     canValidateSeq(Seq const s)
     {
-        std::lock_guard const lock{mutex_};
+        std::scoped_lock const lock{mutex_};
         return localSeqEnforcer_(byLedger_.clock().now(), s, parms_);
     }
 
@@ -594,7 +594,7 @@ public:
             return ValStatus::stale;
 
         {
-            std::lock_guard const lock{mutex_};
+            std::scoped_lock const lock{mutex_};
 
             // Check that validation sequence is greater than any non-expired
             // validations sequence from that validator; if it's not, perform
@@ -682,7 +682,7 @@ public:
     void
     setSeqToKeep(Seq const& low, Seq const& high)
     {
-        std::lock_guard const lock{mutex_};
+        std::scoped_lock const lock{mutex_};
         XRPL_ASSERT(low < high, "xrpl::Validations::setSeqToKeep : valid inputs");
         toKeep_ = {low, high};
     }
@@ -697,7 +697,7 @@ public:
     {
         auto const start = std::chrono::steady_clock::now();
         {
-            std::lock_guard const lock{mutex_};
+            std::scoped_lock const lock{mutex_};
             if (toKeep_)
             {
                 // We only need to refresh the keep range when it's just about
@@ -754,7 +754,7 @@ public:
     void
     trustChanged(hash_set<NodeID> const& added, hash_set<NodeID> const& removed)
     {
-        std::lock_guard const lock{mutex_};
+        std::scoped_lock const lock{mutex_};
 
         for (auto& [nodeId, validation] : current_)
         {
@@ -790,7 +790,7 @@ public:
     Json::Value
     getJsonTrie() const
     {
-        std::lock_guard const lock{mutex_};
+        std::scoped_lock const lock{mutex_};
         return trie_.getJson();
     }
 
@@ -809,7 +809,7 @@ public:
     std::optional<std::pair<Seq, ID>>
     getPreferred(Ledger const& curr)
     {
-        std::lock_guard const lock{mutex_};
+        std::scoped_lock const lock{mutex_};
         std::optional<SpanTip<Ledger>> preferred = withTrie(lock, [this](LedgerTrie<Ledger>& trie) {
             return trie.getPreferred(localSeqEnforcer_.largest());
         });
@@ -921,7 +921,7 @@ public:
     std::size_t
     getNodesAfter(Ledger const& ledger, ID const& ledgerID)
     {
-        std::lock_guard const lock{mutex_};
+        std::scoped_lock const lock{mutex_};
 
         // Use trie if ledger is the right one
         if (ledger.id() == ledgerID)
@@ -946,7 +946,7 @@ public:
     currentTrusted()
     {
         std::vector<WrappedValidationType> ret;
-        std::lock_guard const lock{mutex_};
+        std::scoped_lock const lock{mutex_};
         current(
             lock,
             [&](std::size_t numValidations) { ret.reserve(numValidations); },
@@ -965,7 +965,7 @@ public:
     getCurrentNodeIDs() -> hash_set<NodeID>
     {
         hash_set<NodeID> ret;
-        std::lock_guard const lock{mutex_};
+        std::scoped_lock const lock{mutex_};
         current(
             lock,
             [&](std::size_t numValidations) { ret.reserve(numValidations); },
@@ -983,7 +983,7 @@ public:
     numTrustedForLedger(ID const& ledgerID)
     {
         std::size_t count = 0;
-        std::lock_guard const lock{mutex_};
+        std::scoped_lock const lock{mutex_};
         byLedger(
             lock,
             ledgerID,
@@ -1005,7 +1005,7 @@ public:
     getTrustedForLedger(ID const& ledgerID, Seq const& seq)
     {
         std::vector<WrappedValidationType> res;
-        std::lock_guard const lock{mutex_};
+        std::scoped_lock const lock{mutex_};
         byLedger(
             lock,
             ledgerID,
@@ -1028,7 +1028,7 @@ public:
     fees(ID const& ledgerID, std::uint32_t baseFee)
     {
         std::vector<std::uint32_t> res;
-        std::lock_guard const lock{mutex_};
+        std::scoped_lock const lock{mutex_};
         byLedger(
             lock,
             ledgerID,
@@ -1055,7 +1055,7 @@ public:
     void
     flush()
     {
-        std::lock_guard const lock{mutex_};
+        std::scoped_lock const lock{mutex_};
         current_.clear();
     }
 
@@ -1080,7 +1080,7 @@ public:
         std::size_t laggards = 0;
 
         current(
-            std::lock_guard{mutex_},
+            std::scoped_lock{mutex_},
             [](std::size_t) {},
             [&](NodeID const&, Validation const& v) {
                 if (adaptor_.now() < v.seenTime() + parms_.validationFRESHNESS &&
@@ -1098,28 +1098,28 @@ public:
     std::size_t
     sizeOfCurrentCache() const
     {
-        std::lock_guard const lock{mutex_};
+        std::scoped_lock const lock{mutex_};
         return current_.size();
     }
 
     std::size_t
     sizeOfSeqEnforcersCache() const
     {
-        std::lock_guard const lock{mutex_};
+        std::scoped_lock const lock{mutex_};
         return seqEnforcers_.size();
     }
 
     std::size_t
     sizeOfByLedgerCache() const
     {
-        std::lock_guard const lock{mutex_};
+        std::scoped_lock const lock{mutex_};
         return byLedger_.size();
     }
 
     std::size_t
     sizeOfBySequenceCache() const
     {
-        std::lock_guard const lock{mutex_};
+        std::scoped_lock const lock{mutex_};
         return bySequence_.size();
     }
 };
diff --git a/src/xrpld/overlay/detail/Cluster.cpp b/src/xrpld/overlay/detail/Cluster.cpp
index c74a9aa5bd..b15ed1859c 100644
--- a/src/xrpld/overlay/detail/Cluster.cpp
+++ b/src/xrpld/overlay/detail/Cluster.cpp
@@ -29,7 +29,7 @@ Cluster::Cluster(beast::Journal j) : j_(j)
 std::optional<std::string>
 Cluster::member(PublicKey const& identity) const
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
 
     auto iter = nodes_.find(identity);
     if (iter == nodes_.end())
@@ -40,7 +40,7 @@ Cluster::member(PublicKey const& identity) const
 std::size_t
 Cluster::size() const
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
 
     return nodes_.size();
 }
@@ -52,7 +52,7 @@ Cluster::update(
     std::uint32_t loadFee,
     NetClock::time_point reportTime)
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
 
     auto iter = nodes_.find(identity);
 
@@ -74,7 +74,7 @@ Cluster::update(
 void
 Cluster::for_each(std::function<void(ClusterNode const&)> func) const
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     for (auto const& ni : nodes_)
         func(ni);
 }
diff --git a/src/xrpld/overlay/detail/Message.cpp b/src/xrpld/overlay/detail/Message.cpp
index f8d3fbc8ff..eb8add8666 100644
--- a/src/xrpld/overlay/detail/Message.cpp
+++ b/src/xrpld/overlay/detail/Message.cpp
@@ -22,7 +22,8 @@ Message::Message(
     ::google::protobuf::Message const& message,
     protocol::MessageType type,
     std::optional<PublicKey> const& validator)
-    : category_(TrafficCount::categorize(message, type, false)), validatorKey_(validator)
+    : category_(static_cast<std::size_t>(TrafficCount::categorize(message, type, false)))
+    , validatorKey_(validator)
 {
     using namespace xrpl::compression;
 
diff --git a/src/xrpld/overlay/detail/OverlayImpl.cpp b/src/xrpld/overlay/detail/OverlayImpl.cpp
index f29d97cb11..d17a556dd8 100644
--- a/src/xrpld/overlay/detail/OverlayImpl.cpp
+++ b/src/xrpld/overlay/detail/OverlayImpl.cpp
@@ -92,6 +92,8 @@
 namespace xrpl {
 
 namespace CrawlOptions {
+// Need to be named before converting
+// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
 enum {
     Disabled = 0,
     Overlay = (1 << 0),
@@ -332,7 +334,7 @@ OverlayImpl::onHandoff(
             // As we are not on the strand, run() must be called
             // while holding the lock, otherwise new I/O can be
             // queued after a call to stop().
-            std::lock_guard<decltype(mutex_)> const lock(mutex_);
+            std::scoped_lock const lock(mutex_);
             {
                 auto const result = m_peers.emplace(peer->slot(), peer);
                 XRPL_ASSERT(result.second, "xrpl::OverlayImpl::onHandoff : peer is inserted");
@@ -455,7 +457,7 @@ OverlayImpl::connect(beast::IP::Endpoint const& remote_endpoint)
         app_.getJournal("Peer"),
         *this);
 
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     list_.emplace(p.get(), p);
     p->run();
 }
@@ -469,7 +471,7 @@ OverlayImpl::add_active(std::shared_ptr<PeerImp> const& peer)
     beast::WrappedSink sink{journal_.sink(), peer->prefix()};
     beast::Journal const journal{sink};
 
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
 
     {
         auto const result = m_peers.emplace(peer->slot(), peer);
@@ -497,7 +499,7 @@ OverlayImpl::add_active(std::shared_ptr<PeerImp> const& peer)
 void
 OverlayImpl::remove(std::shared_ptr<PeerFinder::Slot> const& slot)
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     auto const iter = m_peers.find(slot);
     XRPL_ASSERT(iter != m_peers.end(), "xrpl::OverlayImpl::remove : valid input");
     m_peers.erase(iter);
@@ -584,7 +586,7 @@ OverlayImpl::start()
             });
     }
     auto const timer = std::make_shared<Timer>(*this);
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     list_.emplace(timer.get(), timer);
     timer_ = timer;
     timer->async_wait();
@@ -637,7 +639,7 @@ OverlayImpl::activate(std::shared_ptr<PeerImp> const& peer)
 
     // Now track this peer
     {
-        std::lock_guard const lock(mutex_);
+        std::scoped_lock const lock(mutex_);
         auto const result(ids_.emplace(
             std::piecewise_construct, std::make_tuple(peer->id()), std::make_tuple(peer)));
         XRPL_ASSERT(result.second, "xrpl::OverlayImpl::activate : peer ID is inserted");
@@ -653,7 +655,7 @@ OverlayImpl::activate(std::shared_ptr<PeerImp> const& peer)
 void
 OverlayImpl::onPeerDeactivate(Peer::id_t id)
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     ids_.erase(id);
 }
 
@@ -732,7 +734,7 @@ OverlayImpl::reportOutboundTraffic(TrafficCount::category cat, int size)
 std::size_t
 OverlayImpl::size() const
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     return ids_.size();
 }
 
@@ -1091,7 +1093,7 @@ OverlayImpl::getActivePeers(
     std::size_t& enabledInSkip) const
 {
     Overlay::PeerSequence ret;
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
 
     active = ids_.size();
     disabled = enabledInSkip = 0;
@@ -1131,7 +1133,7 @@ OverlayImpl::checkTracking(std::uint32_t index)
 std::shared_ptr<Peer>
 OverlayImpl::findPeerByShortID(Peer::id_t const& id) const
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     auto const iter = ids_.find(id);
     if (iter != ids_.end())
         return iter->second.lock();
@@ -1143,7 +1145,7 @@ OverlayImpl::findPeerByShortID(Peer::id_t const& id) const
 std::shared_ptr<Peer>
 OverlayImpl::findPeerByPublicKey(PublicKey const& pubKey)
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     // NOTE The purpose of peer is to delay the destruction of PeerImp
     std::shared_ptr<PeerImp> peer;
     for (auto const& e : ids_)
@@ -1204,7 +1206,7 @@ OverlayImpl::relay(protocol::TMValidation& m, uint256 const& uid, PublicKey cons
 std::shared_ptr<Message>
 OverlayImpl::getManifestsMessage()
 {
-    std::lock_guard const g(manifestLock_);
+    std::scoped_lock const g(manifestLock_);
 
     if (auto seq = app_.getValidatorManifests().sequence(); seq != manifestListSeq_)
     {
@@ -1323,7 +1325,7 @@ OverlayImpl::relay(
 void
 OverlayImpl::remove(Child& child)
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     list_.erase(&child);
     if (list_.empty())
         cond_.notify_all();
@@ -1342,7 +1344,7 @@ OverlayImpl::stopChildren()
     // won't be called until vector<> children leaves scope.
     std::vector<std::shared_ptr<Child>> children;
     {
-        std::lock_guard const lock(mutex_);
+        std::scoped_lock const lock(mutex_);
         if (!work_)
             return;
         work_ = std::nullopt;
@@ -1377,7 +1379,7 @@ OverlayImpl::sendEndpoints()
     {
         std::shared_ptr<PeerImp> peer;
         {
-            std::lock_guard const lock(mutex_);
+            std::scoped_lock const lock(mutex_);
             auto const iter = m_peers.find(e.first);
             if (iter != m_peers.end())
                 peer = iter->second.lock();
@@ -1452,7 +1454,7 @@ OverlayImpl::updateSlotAndSquelch(
     for (auto id : peers)
     {
         slots_.updateSlotAndSquelch(key, validator, id, type, [&]() {
-            reportInboundTraffic(TrafficCount::squelch_ignored, 0);
+            reportInboundTraffic(TrafficCount::category::squelch_ignored, 0);
         });
     }
 }
@@ -1481,7 +1483,7 @@ OverlayImpl::updateSlotAndSquelch(
     }
 
     slots_.updateSlotAndSquelch(key, validator, peer, type, [&]() {
-        reportInboundTraffic(TrafficCount::squelch_ignored, 0);
+        reportInboundTraffic(TrafficCount::category::squelch_ignored, 0);
     });
 }
 
diff --git a/src/xrpld/overlay/detail/OverlayImpl.h b/src/xrpld/overlay/detail/OverlayImpl.h
index 0c4990a6f4..caccd35562 100644
--- a/src/xrpld/overlay/detail/OverlayImpl.h
+++ b/src/xrpld/overlay/detail/OverlayImpl.h
@@ -254,7 +254,7 @@ public:
     {
         std::vector<std::weak_ptr<PeerImp>> wp;
         {
-            std::lock_guard const lock(mutex_);
+            std::scoped_lock const lock(mutex_);
 
             // Iterate over a copy of the peer list because peer
             // destruction can invalidate iterators.
@@ -572,7 +572,7 @@ private:
     collect_metrics()
     {
         auto counts = m_traffic.getCounts();
-        std::lock_guard const lock(m_statsMutex);
+        std::scoped_lock const lock(m_statsMutex);
         XRPL_ASSERT(
             counts.size() == m_stats.trafficGauges.size(),
             "xrpl::OverlayImpl::collect_metrics : counts size do match");
diff --git a/src/xrpld/overlay/detail/PeerImp.cpp b/src/xrpld/overlay/detail/PeerImp.cpp
index 46a640ec5c..01cad680ba 100644
--- a/src/xrpld/overlay/detail/PeerImp.cpp
+++ b/src/xrpld/overlay/detail/PeerImp.cpp
@@ -240,7 +240,7 @@ PeerImp::run()
         fail("Malformed handshake data (3)");
 
     {
-        std::lock_guard<std::mutex> const sl(recentLock_);
+        std::scoped_lock const sl(recentLock_);
         if (closed)
             closedLedgerHash_ = *closed;
         if (previous)
@@ -408,8 +408,8 @@ PeerImp::removeTxQueue(uint256 const& hash)
 void
 PeerImp::charge(Resource::Charge const& fee, std::string const& context)
 {
-    if ((usage_.charge(fee, context) == Resource::drop) && usage_.disconnect(p_journal_) &&
-        strand_.running_in_this_thread())
+    if ((usage_.charge(fee, context) == Resource::Disposition::drop) &&
+        usage_.disconnect(p_journal_) && strand_.running_in_this_thread())
     {
         // Sever the connection
         overlay_.incPeerDisconnectCharges();
@@ -478,7 +478,7 @@ PeerImp::json()
     ret[jss::protocol] = to_string(protocol_);
 
     {
-        std::lock_guard const sl(recentLock_);
+        std::scoped_lock const sl(recentLock_);
         if (latency_)
             ret[jss::latency] = static_cast<Json::UInt>(latency_->count());
     }
@@ -510,7 +510,7 @@ PeerImp::json()
     uint256 closedLedgerHash;
     protocol::TMStatusChange last_status;
     {
-        std::lock_guard const sl(recentLock_);
+        std::scoped_lock const sl(recentLock_);
         closedLedgerHash = closedLedgerHash_;
         last_status = last_status_;
     }
@@ -577,7 +577,7 @@ bool
 PeerImp::hasLedger(uint256 const& hash, std::uint32_t seq) const
 {
     {
-        std::lock_guard const sl(recentLock_);
+        std::scoped_lock const sl(recentLock_);
         if ((seq != 0) && (seq >= minLedger_) && (seq <= maxLedger_) &&
             (tracking_.load() == Tracking::converged))
             return true;
@@ -590,7 +590,7 @@ PeerImp::hasLedger(uint256 const& hash, std::uint32_t seq) const
 void
 PeerImp::ledgerRange(std::uint32_t& minSeq, std::uint32_t& maxSeq) const
 {
-    std::lock_guard const sl(recentLock_);
+    std::scoped_lock const sl(recentLock_);
 
     minSeq = minLedger_;
     maxSeq = maxLedger_;
@@ -599,7 +599,7 @@ PeerImp::ledgerRange(std::uint32_t& minSeq, std::uint32_t& maxSeq) const
 bool
 PeerImp::hasTxSet(uint256 const& hash) const
 {
-    std::lock_guard const sl(recentLock_);
+    std::scoped_lock const sl(recentLock_);
     return std::ranges::find(recentTxSets_, hash) != recentTxSets_.end();
 }
 
@@ -608,7 +608,7 @@ PeerImp::cycleStatus()
 {
     // Operations on closedLedgerHash_ and previousLedgerHash_ must be
     // guarded by recentLock_.
-    std::lock_guard const sl(recentLock_);
+    std::scoped_lock const sl(recentLock_);
     previousLedgerHash_ = closedLedgerHash_;
     closedLedgerHash_.zero();
 }
@@ -616,7 +616,7 @@ PeerImp::cycleStatus()
 bool
 PeerImp::hasRange(std::uint32_t uMin, std::uint32_t uMax)
 {
-    std::lock_guard const sl(recentLock_);
+    std::scoped_lock const sl(recentLock_);
     return (tracking_ != Tracking::diverged) && (uMin >= minLedger_) && (uMax <= maxLedger_);
 }
 
@@ -813,7 +813,7 @@ PeerImp::onTimer(error_code const& ec)
         clock_type::duration duration;
 
         {
-            std::lock_guard const sl(recentLock_);
+            std::scoped_lock const sl(recentLock_);
             duration = clock_type::now() - trackingTime_;
         }
 
@@ -1267,7 +1267,7 @@ PeerImp::onMessage(std::shared_ptr<protocol::TMPing> const& m)
             auto const rtt =
                 std::chrono::round<std::chrono::milliseconds>(clock_type::now() - lastPingTime_);
 
-            std::lock_guard const sl(recentLock_);
+            std::scoped_lock const sl(recentLock_);
 
             if (latency_)
             {
@@ -1964,7 +1964,7 @@ PeerImp::onMessage(std::shared_ptr<protocol::TMStatusChange> const& m)
         m->set_networktime(app_.getTimeKeeper().now().time_since_epoch().count());
 
     {
-        std::lock_guard const sl(recentLock_);
+        std::scoped_lock const sl(recentLock_);
         if (!last_status_.has_newstatus() || m->has_newstatus())
         {
             last_status_ = *m;
@@ -1984,7 +1984,7 @@ PeerImp::onMessage(std::shared_ptr<protocol::TMStatusChange> const& m)
         {
             // Operations on closedLedgerHash_ and previousLedgerHash_ must be
             // guarded by recentLock_.
-            std::lock_guard const sl(recentLock_);
+            std::scoped_lock const sl(recentLock_);
             if (!closedLedgerHash_.isZero())
             {
                 outOfSync = true;
@@ -2006,7 +2006,7 @@ PeerImp::onMessage(std::shared_ptr<protocol::TMStatusChange> const& m)
         {
             // Operations on closedLedgerHash_ and previousLedgerHash_ must be
             // guarded by recentLock_.
-            std::lock_guard const sl(recentLock_);
+            std::scoped_lock const sl(recentLock_);
             if (peerChangedLedgers)
             {
                 closedLedgerHash_ = m->ledgerhash();
@@ -2040,7 +2040,7 @@ PeerImp::onMessage(std::shared_ptr<protocol::TMStatusChange> const& m)
 
     if (m->has_firstseq() && m->has_lastseq())
     {
-        std::lock_guard const sl(recentLock_);
+        std::scoped_lock const sl(recentLock_);
 
         minLedger_ = m->firstseq();
         maxLedger_ = m->lastseq();
@@ -2107,7 +2107,7 @@ PeerImp::onMessage(std::shared_ptr<protocol::TMStatusChange> const& m)
         {
             uint256 closedLedgerHash{};
             {
-                std::lock_guard const sl(recentLock_);
+                std::scoped_lock const sl(recentLock_);
                 closedLedgerHash = closedLedgerHash_;
             }
             j[jss::ledger_hash] = to_string(closedLedgerHash);
@@ -2135,7 +2135,7 @@ PeerImp::checkTracking(std::uint32_t validationSeq)
     {
         // Extract the sequence number of the highest
         // ledger this peer has
-        std::lock_guard const sl(recentLock_);
+        std::scoped_lock const sl(recentLock_);
 
         serverSeq = maxLedger_;
     }
@@ -2161,7 +2161,7 @@ PeerImp::checkTracking(std::uint32_t seq1, std::uint32_t seq2)
     if ((diff > Tuning::divergedLedgerLimit) && (tracking_.load() != Tracking::diverged))
     {
         // The peer's ledger sequence is way off the validation's
-        std::lock_guard const sl(recentLock_);
+        std::scoped_lock const sl(recentLock_);
 
         tracking_ = Tracking::diverged;
         trackingTime_ = clock_type::now();
@@ -2181,7 +2181,7 @@ PeerImp::onMessage(std::shared_ptr<protocol::TMHaveTransactionSet> const& m)
 
     if (m->status() == protocol::tsHAVE)
     {
-        std::lock_guard const sl(recentLock_);
+        std::scoped_lock const sl(recentLock_);
 
         if (std::ranges::find(recentTxSets_, hash) != recentTxSets_.end())
         {
@@ -2248,7 +2248,7 @@ PeerImp::onValidatorListMessage(
         case ListDisposition::expired:
         // Future list
         case ListDisposition::pending: {
-            std::lock_guard<std::mutex> const sl(recentLock_);
+            std::scoped_lock const sl(recentLock_);
 
             XRPL_ASSERT(
                 applyResult.publisherKey,
@@ -2272,7 +2272,7 @@ PeerImp::onValidatorListMessage(
         case ListDisposition::known_sequence:
 #ifndef NDEBUG
         {
-            std::lock_guard<std::mutex> const sl(recentLock_);
+            std::scoped_lock<std::mutex> const sl(recentLock_);
             XRPL_ASSERT(
                 applyResult.sequence && applyResult.publisherKey,
                 "xrpl::PeerImp::onValidatorListMessage : nonzero sequence "
@@ -2838,7 +2838,7 @@ PeerImp::onMessage(std::shared_ptr<protocol::TMSquelch> const& m)
 //--------------------------------------------------------------------------
 
 void
-PeerImp::addLedger(uint256 const& hash, std::lock_guard<std::mutex> const& lockedRecentLock)
+PeerImp::addLedger(uint256 const& hash, std::scoped_lock<std::mutex> const& lockedRecentLock)
 {
     // lockedRecentLock is passed as a reminder that recentLock_ must be
     // locked by the caller.
@@ -2925,7 +2925,8 @@ PeerImp::doTransactions(std::shared_ptr<protocol::TMGetObjectByHash> const& pack
         auto sttx = txn->getSTransaction();
         sttx->add(s);
         tx->set_rawtransaction(s.data(), s.size());
-        tx->set_status(txn->getStatus() == INCLUDED ? protocol::tsCURRENT : protocol::tsNEW);
+        tx->set_status(
+            txn->getStatus() == TransStatus::INCLUDED ? protocol::tsCURRENT : protocol::tsNEW);
         tx->set_receivetimestamp(app_.getTimeKeeper().now().time_since_epoch().count());
         tx->set_deferred(txn->getSubmitResult().queued);
     }
@@ -2989,10 +2990,10 @@ PeerImp::checkTransaction(
             std::string reason;
             auto tx = std::make_shared<Transaction>(stx, reason, app_);
             XRPL_ASSERT(
-                tx->getStatus() == NEW,
+                tx->getStatus() == TransStatus::NEW,
                 "xrpl::PeerImp::checkTransaction Transaction created "
                 "correctly");
-            if (tx->getStatus() == NEW)
+            if (tx->getStatus() == TransStatus::NEW)
             {
                 JLOG(p_journal_.debug()) << "Processing " << (batch ? "batch" : "unsolicited")
                                          << " pseudo-transaction tx " << tx->getID();
@@ -3044,7 +3045,7 @@ PeerImp::checkTransaction(
         std::string reason;
         auto tx = std::make_shared<Transaction>(stx, reason, app_);
 
-        if (tx->getStatus() == INVALID)
+        if (tx->getStatus() == TransStatus::INVALID)
         {
             if (!reason.empty())
             {
@@ -3557,7 +3558,7 @@ PeerImp::getScore(bool haveItem) const
 
     std::optional<std::chrono::milliseconds> latency;
     {
-        std::lock_guard const sl(recentLock_);
+        std::scoped_lock const sl(recentLock_);
         latency = latency_;
     }
 
@@ -3576,7 +3577,7 @@ PeerImp::getScore(bool haveItem) const
 bool
 PeerImp::isHighLatency() const
 {
-    std::lock_guard const sl(recentLock_);
+    std::scoped_lock const sl(recentLock_);
     return latency_ >= peerHighLatency;
 }
 
diff --git a/src/xrpld/overlay/detail/PeerImp.h b/src/xrpld/overlay/detail/PeerImp.h
index f2cca1407a..d2cf46e838 100644
--- a/src/xrpld/overlay/detail/PeerImp.h
+++ b/src/xrpld/overlay/detail/PeerImp.h
@@ -428,7 +428,7 @@ public:
     std::optional<std::size_t>
     publisherListSequence(PublicKey const& pubKey) const override
     {
-        std::lock_guard<std::mutex> const sl(recentLock_);
+        std::scoped_lock const sl(recentLock_);
 
         auto iter = publisherListSequences_.find(pubKey);
         if (iter != publisherListSequences_.end())
@@ -439,7 +439,7 @@ public:
     void
     setPublisherListSequence(PublicKey const& pubKey, std::size_t const seq) override
     {
-        std::lock_guard<std::mutex> const sl(recentLock_);
+        std::scoped_lock const sl(recentLock_);
 
         publisherListSequences_[pubKey] = seq;
     }
@@ -744,7 +744,7 @@ private:
     // lockedRecentLock is passed as a reminder to callers that recentLock_
     // must be locked.
     void
-    addLedger(uint256 const& hash, std::lock_guard<std::mutex> const& lockedRecentLock);
+    addLedger(uint256 const& hash, std::scoped_lock<std::mutex> const& lockedRecentLock);
 
     void
     doFetchPack(std::shared_ptr<protocol::TMGetObjectByHash> const& packet);
diff --git a/src/xrpld/overlay/detail/PeerReservationTable.cpp b/src/xrpld/overlay/detail/PeerReservationTable.cpp
index f0e5f55a00..6f004a3b39 100644
--- a/src/xrpld/overlay/detail/PeerReservationTable.cpp
+++ b/src/xrpld/overlay/detail/PeerReservationTable.cpp
@@ -32,7 +32,7 @@ PeerReservationTable::list() const -> std::vector<PeerReservation>
 {
     std::vector<PeerReservation> list;
     {
-        std::lock_guard const lock(mutex_);
+        std::scoped_lock const lock(mutex_);
         list.reserve(table_.size());
         std::ranges::copy(table_, std::back_inserter(list));
     }
@@ -49,7 +49,7 @@ PeerReservationTable::list() const -> std::vector<PeerReservation>
 bool
 PeerReservationTable::load(DatabaseCon& connection)
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
 
     connection_ = &connection;
     auto db = connection.checkoutDb();
@@ -64,7 +64,7 @@ PeerReservationTable::insert_or_assign(PeerReservation const& reservation)
 {
     std::optional<PeerReservation> previous;
 
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
 
     auto hint = table_.find(reservation);
     if (hint != table_.end())
@@ -98,7 +98,7 @@ PeerReservationTable::erase(PublicKey const& nodeId)
 {
     std::optional<PeerReservation> previous;
 
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
 
     auto const it = table_.find({.nodeId = nodeId});
     if (it != table_.end())
diff --git a/src/xrpld/overlay/detail/TrafficCount.h b/src/xrpld/overlay/detail/TrafficCount.h
index 736c3b76e3..8597ca897c 100644
--- a/src/xrpld/overlay/detail/TrafficCount.h
+++ b/src/xrpld/overlay/detail/TrafficCount.h
@@ -29,7 +29,7 @@ namespace xrpl {
 class TrafficCount
 {
 public:
-    enum category : std::size_t;
+    enum class category : std::size_t;
 
     class TrafficStats
     {
@@ -63,7 +63,7 @@ public:
     // If you add entries to this enum, you need to update the initialization
     // of the arrays at the bottom of this file which map array numbers to
     // human-readable, monitoring-tool friendly names.
-    enum category : std::size_t {
+    enum class category : std::size_t {
         base,  // basic peer overhead, must be first
 
         cluster,    // cluster overhead
@@ -193,7 +193,8 @@ public:
     addCount(category cat, bool inbound, int bytes)
     {
         XRPL_ASSERT(
-            cat <= category::unknown, "xrpl::TrafficCount::addCount : valid category input");
+            static_cast<std::size_t>(cat) <= static_cast<std::size_t>(category::unknown),
+            "xrpl::TrafficCount::addCount : valid category input");
 
         auto it = counts_.find(cat);
 
@@ -227,62 +228,62 @@ public:
     to_string(category cat)
     {
         static std::unordered_map<category, std::string> const category_map = {
-            {base, "overhead"},
-            {cluster, "overhead_cluster"},
-            {overlay, "overhead_overlay"},
-            {manifests, "overhead_manifest"},
-            {transaction, "transactions"},
-            {transaction_duplicate, "transactions_duplicate"},
-            {proposal, "proposals"},
-            {proposal_untrusted, "proposals_untrusted"},
-            {proposal_duplicate, "proposals_duplicate"},
-            {validation, "validations"},
-            {validation_untrusted, "validations_untrusted"},
-            {validation_duplicate, "validations_duplicate"},
-            {validatorlist, "validator_lists"},
-            {squelch, "squelch"},
-            {squelch_suppressed, "squelch_suppressed"},
-            {squelch_ignored, "squelch_ignored"},
-            {get_set, "set_get"},
-            {share_set, "set_share"},
-            {ld_tsc_get, "ledger_data_Transaction_Set_candidate_get"},
-            {ld_tsc_share, "ledger_data_Transaction_Set_candidate_share"},
-            {ld_txn_get, "ledger_data_Transaction_Node_get"},
-            {ld_txn_share, "ledger_data_Transaction_Node_share"},
-            {ld_asn_get, "ledger_data_Account_State_Node_get"},
-            {ld_asn_share, "ledger_data_Account_State_Node_share"},
-            {ld_get, "ledger_data_get"},
-            {ld_share, "ledger_data_share"},
-            {gl_tsc_share, "ledger_Transaction_Set_candidate_share"},
-            {gl_tsc_get, "ledger_Transaction_Set_candidate_get"},
-            {gl_txn_share, "ledger_Transaction_node_share"},
-            {gl_txn_get, "ledger_Transaction_node_get"},
-            {gl_asn_share, "ledger_Account_State_node_share"},
-            {gl_asn_get, "ledger_Account_State_node_get"},
-            {gl_share, "ledger_share"},
-            {gl_get, "ledger_get"},
-            {share_hash_ledger, "getobject_Ledger_share"},
-            {get_hash_ledger, "getobject_Ledger_get"},
-            {share_hash_tx, "getobject_Transaction_share"},
-            {get_hash_tx, "getobject_Transaction_get"},
-            {share_hash_txnode, "getobject_Transaction_node_share"},
-            {get_hash_txnode, "getobject_Transaction_node_get"},
-            {share_hash_asnode, "getobject_Account_State_node_share"},
-            {get_hash_asnode, "getobject_Account_State_node_get"},
-            {share_cas_object, "getobject_CAS_share"},
-            {get_cas_object, "getobject_CAS_get"},
-            {share_fetch_pack, "getobject_Fetch_Pack_share"},
-            {get_fetch_pack, "getobject_Fetch Pack_get"},
-            {get_transactions, "getobject_Transactions_get"},
-            {share_hash, "getobject_share"},
-            {get_hash, "getobject_get"},
-            {proof_path_request, "proof_path_request"},
-            {proof_path_response, "proof_path_response"},
-            {replay_delta_request, "replay_delta_request"},
-            {replay_delta_response, "replay_delta_response"},
-            {have_transactions, "have_transactions"},
-            {requested_transactions, "requested_transactions"},
-            {total, "total"}};
+            {category::base, "overhead"},
+            {category::cluster, "overhead_cluster"},
+            {category::overlay, "overhead_overlay"},
+            {category::manifests, "overhead_manifest"},
+            {category::transaction, "transactions"},
+            {category::transaction_duplicate, "transactions_duplicate"},
+            {category::proposal, "proposals"},
+            {category::proposal_untrusted, "proposals_untrusted"},
+            {category::proposal_duplicate, "proposals_duplicate"},
+            {category::validation, "validations"},
+            {category::validation_untrusted, "validations_untrusted"},
+            {category::validation_duplicate, "validations_duplicate"},
+            {category::validatorlist, "validator_lists"},
+            {category::squelch, "squelch"},
+            {category::squelch_suppressed, "squelch_suppressed"},
+            {category::squelch_ignored, "squelch_ignored"},
+            {category::get_set, "set_get"},
+            {category::share_set, "set_share"},
+            {category::ld_tsc_get, "ledger_data_Transaction_Set_candidate_get"},
+            {category::ld_tsc_share, "ledger_data_Transaction_Set_candidate_share"},
+            {category::ld_txn_get, "ledger_data_Transaction_Node_get"},
+            {category::ld_txn_share, "ledger_data_Transaction_Node_share"},
+            {category::ld_asn_get, "ledger_data_Account_State_Node_get"},
+            {category::ld_asn_share, "ledger_data_Account_State_Node_share"},
+            {category::ld_get, "ledger_data_get"},
+            {category::ld_share, "ledger_data_share"},
+            {category::gl_tsc_share, "ledger_Transaction_Set_candidate_share"},
+            {category::gl_tsc_get, "ledger_Transaction_Set_candidate_get"},
+            {category::gl_txn_share, "ledger_Transaction_node_share"},
+            {category::gl_txn_get, "ledger_Transaction_node_get"},
+            {category::gl_asn_share, "ledger_Account_State_node_share"},
+            {category::gl_asn_get, "ledger_Account_State_node_get"},
+            {category::gl_share, "ledger_share"},
+            {category::gl_get, "ledger_get"},
+            {category::share_hash_ledger, "getobject_Ledger_share"},
+            {category::get_hash_ledger, "getobject_Ledger_get"},
+            {category::share_hash_tx, "getobject_Transaction_share"},
+            {category::get_hash_tx, "getobject_Transaction_get"},
+            {category::share_hash_txnode, "getobject_Transaction_node_share"},
+            {category::get_hash_txnode, "getobject_Transaction_node_get"},
+            {category::share_hash_asnode, "getobject_Account_State_node_share"},
+            {category::get_hash_asnode, "getobject_Account_State_node_get"},
+            {category::share_cas_object, "getobject_CAS_share"},
+            {category::get_cas_object, "getobject_CAS_get"},
+            {category::share_fetch_pack, "getobject_Fetch_Pack_share"},
+            {category::get_fetch_pack, "getobject_Fetch Pack_get"},
+            {category::get_transactions, "getobject_Transactions_get"},
+            {category::share_hash, "getobject_share"},
+            {category::get_hash, "getobject_get"},
+            {category::proof_path_request, "proof_path_request"},
+            {category::proof_path_response, "proof_path_response"},
+            {category::replay_delta_request, "replay_delta_request"},
+            {category::replay_delta_response, "replay_delta_response"},
+            {category::have_transactions, "have_transactions"},
+            {category::requested_transactions, "requested_transactions"},
+            {category::total, "total"}};
 
         if (auto it = category_map.find(cat); it != category_map.end())
             return it->second;
@@ -292,63 +293,63 @@ public:
 
 protected:
     std::unordered_map<category, TrafficStats> counts_{
-        {base, {base}},
-        {cluster, {cluster}},
-        {overlay, {overlay}},
-        {manifests, {manifests}},
-        {transaction, {transaction}},
-        {transaction_duplicate, {transaction_duplicate}},
-        {proposal, {proposal}},
-        {proposal_untrusted, {proposal_untrusted}},
-        {proposal_duplicate, {proposal_duplicate}},
-        {validation, {validation}},
-        {validation_untrusted, {validation_untrusted}},
-        {validation_duplicate, {validation_duplicate}},
-        {validatorlist, {validatorlist}},
-        {squelch, {squelch}},
-        {squelch_suppressed, {squelch_suppressed}},
-        {squelch_ignored, {squelch_ignored}},
-        {get_set, {get_set}},
-        {share_set, {share_set}},
-        {ld_tsc_get, {ld_tsc_get}},
-        {ld_tsc_share, {ld_tsc_share}},
-        {ld_txn_get, {ld_txn_get}},
-        {ld_txn_share, {ld_txn_share}},
-        {ld_asn_get, {ld_asn_get}},
-        {ld_asn_share, {ld_asn_share}},
-        {ld_get, {ld_get}},
-        {ld_share, {ld_share}},
-        {gl_tsc_share, {gl_tsc_share}},
-        {gl_tsc_get, {gl_tsc_get}},
-        {gl_txn_share, {gl_txn_share}},
-        {gl_txn_get, {gl_txn_get}},
-        {gl_asn_share, {gl_asn_share}},
-        {gl_asn_get, {gl_asn_get}},
-        {gl_share, {gl_share}},
-        {gl_get, {gl_get}},
-        {share_hash_ledger, {share_hash_ledger}},
-        {get_hash_ledger, {get_hash_ledger}},
-        {share_hash_tx, {share_hash_tx}},
-        {get_hash_tx, {get_hash_tx}},
-        {share_hash_txnode, {share_hash_txnode}},
-        {get_hash_txnode, {get_hash_txnode}},
-        {share_hash_asnode, {share_hash_asnode}},
-        {get_hash_asnode, {get_hash_asnode}},
-        {share_cas_object, {share_cas_object}},
-        {get_cas_object, {get_cas_object}},
-        {share_fetch_pack, {share_fetch_pack}},
-        {get_fetch_pack, {get_fetch_pack}},
-        {get_transactions, {get_transactions}},
-        {share_hash, {share_hash}},
-        {get_hash, {get_hash}},
-        {proof_path_request, {proof_path_request}},
-        {proof_path_response, {proof_path_response}},
-        {replay_delta_request, {replay_delta_request}},
-        {replay_delta_response, {replay_delta_response}},
-        {have_transactions, {have_transactions}},
-        {requested_transactions, {requested_transactions}},
-        {total, {total}},
-        {unknown, {unknown}},
+        {category::base, {category::base}},
+        {category::cluster, {category::cluster}},
+        {category::overlay, {category::overlay}},
+        {category::manifests, {category::manifests}},
+        {category::transaction, {category::transaction}},
+        {category::transaction_duplicate, {category::transaction_duplicate}},
+        {category::proposal, {category::proposal}},
+        {category::proposal_untrusted, {category::proposal_untrusted}},
+        {category::proposal_duplicate, {category::proposal_duplicate}},
+        {category::validation, {category::validation}},
+        {category::validation_untrusted, {category::validation_untrusted}},
+        {category::validation_duplicate, {category::validation_duplicate}},
+        {category::validatorlist, {category::validatorlist}},
+        {category::squelch, {category::squelch}},
+        {category::squelch_suppressed, {category::squelch_suppressed}},
+        {category::squelch_ignored, {category::squelch_ignored}},
+        {category::get_set, {category::get_set}},
+        {category::share_set, {category::share_set}},
+        {category::ld_tsc_get, {category::ld_tsc_get}},
+        {category::ld_tsc_share, {category::ld_tsc_share}},
+        {category::ld_txn_get, {category::ld_txn_get}},
+        {category::ld_txn_share, {category::ld_txn_share}},
+        {category::ld_asn_get, {category::ld_asn_get}},
+        {category::ld_asn_share, {category::ld_asn_share}},
+        {category::ld_get, {category::ld_get}},
+        {category::ld_share, {category::ld_share}},
+        {category::gl_tsc_share, {category::gl_tsc_share}},
+        {category::gl_tsc_get, {category::gl_tsc_get}},
+        {category::gl_txn_share, {category::gl_txn_share}},
+        {category::gl_txn_get, {category::gl_txn_get}},
+        {category::gl_asn_share, {category::gl_asn_share}},
+        {category::gl_asn_get, {category::gl_asn_get}},
+        {category::gl_share, {category::gl_share}},
+        {category::gl_get, {category::gl_get}},
+        {category::share_hash_ledger, {category::share_hash_ledger}},
+        {category::get_hash_ledger, {category::get_hash_ledger}},
+        {category::share_hash_tx, {category::share_hash_tx}},
+        {category::get_hash_tx, {category::get_hash_tx}},
+        {category::share_hash_txnode, {category::share_hash_txnode}},
+        {category::get_hash_txnode, {category::get_hash_txnode}},
+        {category::share_hash_asnode, {category::share_hash_asnode}},
+        {category::get_hash_asnode, {category::get_hash_asnode}},
+        {category::share_cas_object, {category::share_cas_object}},
+        {category::get_cas_object, {category::get_cas_object}},
+        {category::share_fetch_pack, {category::share_fetch_pack}},
+        {category::get_fetch_pack, {category::get_fetch_pack}},
+        {category::get_transactions, {category::get_transactions}},
+        {category::share_hash, {category::share_hash}},
+        {category::get_hash, {category::get_hash}},
+        {category::proof_path_request, {category::proof_path_request}},
+        {category::proof_path_response, {category::proof_path_response}},
+        {category::replay_delta_request, {category::replay_delta_request}},
+        {category::replay_delta_response, {category::replay_delta_response}},
+        {category::have_transactions, {category::have_transactions}},
+        {category::requested_transactions, {category::requested_transactions}},
+        {category::total, {category::total}},
+        {category::unknown, {category::unknown}},
     };
 };
 
diff --git a/src/xrpld/overlay/detail/Tuning.h b/src/xrpld/overlay/detail/Tuning.h
index 0471587fec..07cf2d2238 100644
--- a/src/xrpld/overlay/detail/Tuning.h
+++ b/src/xrpld/overlay/detail/Tuning.h
@@ -4,6 +4,8 @@
 
 namespace xrpl::Tuning {
 
+// Need to be named before converting
+// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
 enum {
     /** How many ledgers off a server can be and we will
         still consider it converged */
diff --git a/src/xrpld/overlay/detail/TxMetrics.cpp b/src/xrpld/overlay/detail/TxMetrics.cpp
index 0a44c719f4..2bcf5f2f2f 100644
--- a/src/xrpld/overlay/detail/TxMetrics.cpp
+++ b/src/xrpld/overlay/detail/TxMetrics.cpp
@@ -17,7 +17,7 @@ void
 TxMetrics::addMetrics(protocol::MessageType type, std::uint32_t val)
 {
     auto add = [&](auto& m, std::uint32_t val) {
-        std::lock_guard const lock(mutex);
+        std::scoped_lock const lock(mutex);
         m.addMetrics(val);
     };
 
@@ -46,7 +46,7 @@ TxMetrics::addMetrics(protocol::MessageType type, std::uint32_t val)
 void
 TxMetrics::addMetrics(std::uint32_t selected, std::uint32_t suppressed, std::uint32_t notenabled)
 {
-    std::lock_guard const lock(mutex);
+    std::scoped_lock const lock(mutex);
     selectedPeers.addMetrics(selected);
     suppressedPeers.addMetrics(suppressed);
     notEnabled.addMetrics(notenabled);
@@ -55,7 +55,7 @@ TxMetrics::addMetrics(std::uint32_t selected, std::uint32_t suppressed, std::uin
 void
 TxMetrics::addMetrics(std::uint32_t missing)
 {
-    std::lock_guard const lock(mutex);
+    std::scoped_lock const lock(mutex);
     missingTx.addMetrics(missing);
 }
 
@@ -99,7 +99,7 @@ SingleMetrics::addMetrics(std::uint32_t val)
 Json::Value
 TxMetrics::json() const
 {
-    std::lock_guard const l(mutex);
+    std::scoped_lock const l(mutex);
 
     Json::Value ret(Json::objectValue);
 
diff --git a/src/xrpld/peerfinder/Slot.h b/src/xrpld/peerfinder/Slot.h
index 5c459b25ea..e67df7ee17 100644
--- a/src/xrpld/peerfinder/Slot.h
+++ b/src/xrpld/peerfinder/Slot.h
@@ -13,7 +13,7 @@ class Slot
 public:
     using ptr = std::shared_ptr<Slot>;
 
-    enum State { accept, connect, connected, active, closing };
+    enum class State { accept, connect, connected, active, closing };
 
     virtual ~Slot() = 0;
 
diff --git a/src/xrpld/peerfinder/detail/Checker.h b/src/xrpld/peerfinder/detail/Checker.h
index 3bd23f85db..820d030b23 100644
--- a/src/xrpld/peerfinder/detail/Checker.h
+++ b/src/xrpld/peerfinder/detail/Checker.h
@@ -149,7 +149,7 @@ template <class Protocol>
 void
 Checker<Protocol>::stop()
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     if (!stop_)
     {
         stop_ = true;
@@ -175,7 +175,7 @@ Checker<Protocol>::async_connect(beast::IP::Endpoint const& endpoint, Handler&&
     auto const op =
         std::make_shared<async_op<Handler>>(*this, io_context_, std::forward<Handler>(handler));
     {
-        std::lock_guard const lock(mutex_);
+        std::scoped_lock const lock(mutex_);
         list_.push_back(*op);
     }
     op->socket_.async_connect(
@@ -187,7 +187,7 @@ template <class Protocol>
 void
 Checker<Protocol>::remove(basic_async_op& op)
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     list_.erase(list_.iterator_to(op));
     if (list_.size() == 0)
         cond_.notify_all();
diff --git a/src/xrpld/peerfinder/detail/Counts.h b/src/xrpld/peerfinder/detail/Counts.h
index 6d1221d331..367caed54b 100644
--- a/src/xrpld/peerfinder/detail/Counts.h
+++ b/src/xrpld/peerfinder/detail/Counts.h
@@ -35,7 +35,7 @@ public:
     {
         // Must be handshaked and in the right state
         XRPL_ASSERT(
-            s.state() == Slot::connected || s.state() == Slot::accept,
+            s.state() == Slot::State::connected || s.state() == Slot::State::accept,
             "xrpl::PeerFinder::Counts::can_activate : valid input state");
 
         if (s.fixed() || s.reserved())
@@ -241,13 +241,13 @@ private:
 
         switch (s.state())
         {
-            case Slot::accept:
+            case Slot::State::accept:
                 XRPL_ASSERT(s.inbound(), "xrpl::PeerFinder::Counts::adjust : input is inbound");
                 adjustCounter(m_acceptCount, dir);
                 break;
 
-            case Slot::connect:
-            case Slot::connected:
+            case Slot::State::connect:
+            case Slot::State::connected:
                 XRPL_ASSERT(
                     !s.inbound(),
                     "xrpl::PeerFinder::Counts::adjust : input is not "
@@ -255,7 +255,7 @@ private:
                 adjustCounter(m_attempts, dir);
                 break;
 
-            case Slot::active:
+            case Slot::State::active:
                 if (s.fixed())
                     adjustCounter(m_fixed_active, dir);
                 if (!s.fixed() && !s.reserved())
@@ -272,7 +272,7 @@ private:
                 adjustCounter(m_active, dir);
                 break;
 
-            case Slot::closing:
+            case Slot::State::closing:
                 adjustCounter(m_closingCount, dir);
                 break;
 
diff --git a/src/xrpld/peerfinder/detail/Logic.h b/src/xrpld/peerfinder/detail/Logic.h
index 9e2cbedc64..c7e6c7d1f2 100644
--- a/src/xrpld/peerfinder/detail/Logic.h
+++ b/src/xrpld/peerfinder/detail/Logic.h
@@ -105,7 +105,7 @@ public:
     void
     load()
     {
-        std::lock_guard const _(lock_);
+        std::scoped_lock const _(lock_);
         bootcache_.load();
     }
 
@@ -118,7 +118,7 @@ public:
     void
     stop()
     {
-        std::lock_guard const _(lock_);
+        std::scoped_lock const _(lock_);
         stopping_ = true;
         if (fetchSource_ != nullptr)
             fetchSource_->cancel();
@@ -133,7 +133,7 @@ public:
     void
     config(Config const& c)
     {
-        std::lock_guard const _(lock_);
+        std::scoped_lock const _(lock_);
         config_ = c;
         counts_.onConfig(config_);
     }
@@ -141,7 +141,7 @@ public:
     Config
     config()
     {
-        std::lock_guard const _(lock_);
+        std::scoped_lock const _(lock_);
         return config_;
     }
 
@@ -154,7 +154,7 @@ public:
     void
     addFixedPeer(std::string const& name, std::vector<beast::IP::Endpoint> const& addresses)
     {
-        std::lock_guard const _(lock_);
+        std::scoped_lock const _(lock_);
 
         if (addresses.empty())
         {
@@ -196,7 +196,7 @@ public:
         if (ec == boost::asio::error::operation_aborted)
             return;
 
-        std::lock_guard const _(lock_);
+        std::scoped_lock const _(lock_);
         auto const iter(slots_.find(remoteAddress));
         if (iter == slots_.end())
         {
@@ -238,7 +238,7 @@ public:
         JLOG(m_journal.debug()) << beast::leftw(18) << "Logic accept" << remote_endpoint
                                 << " on local " << local_endpoint;
 
-        std::lock_guard const _(lock_);
+        std::scoped_lock const _(lock_);
 
         // Check for connection limit per address
         if (is_public(remote_endpoint))
@@ -286,7 +286,7 @@ public:
     {
         JLOG(m_journal.debug()) << beast::leftw(18) << "Logic connect " << remote_endpoint;
 
-        std::lock_guard const _(lock_);
+        std::scoped_lock const _(lock_);
 
         // Check for duplicate connection
         if (slots_.contains(remote_endpoint))
@@ -325,7 +325,7 @@ public:
 
         JLOG(journal.trace()) << "Logic connected on local " << local_endpoint;
 
-        std::lock_guard const _(lock_);
+        std::scoped_lock const _(lock_);
 
         // The object must exist in our table
         XRPL_ASSERT(
@@ -350,7 +350,7 @@ public:
 
         // Update counts
         counts_.remove(*slot);
-        slot->state(Slot::connected);
+        slot->state(Slot::State::connected);
         counts_.add(*slot);
         return true;
     }
@@ -364,7 +364,7 @@ public:
         JLOG(journal.debug()) << "Logic handshake " << slot->remote_endpoint() << " with "
                               << (reserved ? "reserved " : "") << "key " << key;
 
-        std::lock_guard const _(lock_);
+        std::scoped_lock const _(lock_);
 
         // The object must exist in our table
         XRPL_ASSERT(
@@ -372,7 +372,7 @@ public:
             "xrpl::PeerFinder::Logic::activate : valid slot input");
         // Must be accepted or connected
         XRPL_ASSERT(
-            slot->state() == Slot::accept || slot->state() == Slot::connected,
+            slot->state() == Slot::State::accept || slot->state() == Slot::State::connected,
             "xrpl::PeerFinder::Logic::activate : valid slot state");
 
         // Check for duplicate connection by key
@@ -437,7 +437,7 @@ public:
     std::vector<Endpoint>
     redirect(SlotImp::ptr const& slot)
     {
-        std::lock_guard const _(lock_);
+        std::scoped_lock const _(lock_);
         RedirectHandouts h(slot);
         livecache_.hops.shuffle();
         handout(&h, (&h) + 1, livecache_.hops.begin(), livecache_.hops.end());
@@ -455,7 +455,7 @@ public:
     {
         std::vector<beast::IP::Endpoint> none;
 
-        std::lock_guard const _(lock_);
+        std::scoped_lock const _(lock_);
 
         // Count how many more outbound attempts to make
         //
@@ -561,7 +561,7 @@ public:
     {
         std::vector<std::pair<std::shared_ptr<Slot>, std::vector<Endpoint>>> result;
 
-        std::lock_guard const _(lock_);
+        std::scoped_lock const _(lock_);
 
         clock_type::time_point const now = m_clock.now();
         if (m_whenBroadcast <= now)
@@ -574,7 +574,7 @@ public:
                 slots.reserve(slots_.size());
                 std::for_each(
                     slots_.cbegin(), slots_.cend(), [&slots](Slots::value_type const& value) {
-                        if (value.second->state() == Slot::active)
+                        if (value.second->state() == Slot::State::active)
                             slots.emplace_back(value.second);
                     });
                 std::shuffle(slots.begin(), slots.end(), default_prng());
@@ -640,7 +640,7 @@ public:
     void
     once_per_second()
     {
-        std::lock_guard const _(lock_);
+        std::scoped_lock const _(lock_);
 
         // Expire the Livecache
         livecache_.expire();
@@ -738,7 +738,7 @@ public:
         JLOG(journal.trace()) << "Endpoints contained " << list.size()
                               << ((list.size() > 1) ? " entries" : " entry");
 
-        std::lock_guard const _(lock_);
+        std::scoped_lock const _(lock_);
 
         // The object must exist in our table
         XRPL_ASSERT(
@@ -747,7 +747,7 @@ public:
 
         // Must be handshaked!
         XRPL_ASSERT(
-            slot->state() == Slot::active,
+            slot->state() == Slot::State::active,
             "xrpl::PeerFinder::Logic::on_endpoints : valid slot state");
 
         clock_type::time_point const now(m_clock.now());
@@ -870,7 +870,7 @@ public:
     void
     on_closed(SlotImp::ptr const& slot)
     {
-        std::lock_guard const _(lock_);
+        std::scoped_lock const _(lock_);
 
         remove(slot);
 
@@ -878,7 +878,7 @@ public:
         beast::Journal const journal{sink};
 
         // Mark fixed slot failure
-        if (slot->fixed() && !slot->inbound() && slot->state() != Slot::active)
+        if (slot->fixed() && !slot->inbound() && slot->state() != Slot::State::active)
         {
             auto iter(fixed_.find(slot->remote_endpoint()));
             if (iter == fixed_.end())
@@ -895,12 +895,12 @@ public:
         // Do state specific bookkeeping
         switch (slot->state())
         {
-            case Slot::accept:
+            case Slot::State::accept:
                 JLOG(journal.trace()) << "Logic accept failed";
                 break;
 
-            case Slot::connect:
-            case Slot::connected:
+            case Slot::State::connect:
+            case Slot::State::connected:
                 bootcache_.on_failure(slot->remote_endpoint());
                 // VFALCO TODO If the address exists in the ephemeral/live
                 //             endpoint livecache then we should mark the
@@ -909,11 +909,11 @@ public:
                 // avoid propagating the address.
                 break;
 
-            case Slot::active:
+            case Slot::State::active:
                 JLOG(journal.trace()) << "Logic close";
                 break;
 
-            case Slot::closing:
+            case Slot::State::closing:
                 JLOG(journal.trace()) << "Logic finished";
                 break;
 
@@ -930,7 +930,7 @@ public:
     void
     on_failure(SlotImp::ptr const& slot)
     {
-        std::lock_guard const _(lock_);
+        std::scoped_lock const _(lock_);
 
         bootcache_.on_failure(slot->remote_endpoint());
     }
@@ -1023,7 +1023,7 @@ public:
     addBootcacheAddresses(IPAddresses const& list)
     {
         int count(0);
-        std::lock_guard const _(lock_);
+        std::scoped_lock const _(lock_);
         for (auto const& addr : list)
         {
             if (bootcache_.insertStatic(addr))
@@ -1040,7 +1040,7 @@ public:
 
         {
             {
-                std::lock_guard const _(lock_);
+                std::scoped_lock const _(lock_);
                 if (stopping_)
                     return;
                 fetchSource_ = source;
@@ -1052,7 +1052,7 @@ public:
             source->fetch(results, m_journal);
 
             {
-                std::lock_guard const _(lock_);
+                std::scoped_lock const _(lock_);
                 if (stopping_)
                     return;
                 fetchSource_ = nullptr;
@@ -1123,7 +1123,7 @@ public:
     void
     onWrite(beast::PropertyStream::Map& map)
     {
-        std::lock_guard const _(lock_);
+        std::scoped_lock const _(lock_);
 
         // VFALCO NOTE These ugly casts are needed because
         //             of how std::size_t is declared on some linuxes
@@ -1174,15 +1174,15 @@ public:
     {
         switch (state)
         {
-            case Slot::accept:
+            case Slot::State::accept:
                 return "accept";
-            case Slot::connect:
+            case Slot::State::connect:
                 return "connect";
-            case Slot::connected:
+            case Slot::State::connected:
                 return "connected";
-            case Slot::active:
+            case Slot::State::active:
                 return "active";
-            case Slot::closing:
+            case Slot::State::closing:
                 return "closing";
             default:
                 break;
@@ -1201,7 +1201,7 @@ Logic<Checker>::onRedirects(
     FwdIter last,
     boost::asio::ip::tcp::endpoint const& remote_address)
 {
-    std::lock_guard const _(lock_);
+    std::scoped_lock const _(lock_);
     std::size_t n = 0;
     for (; first != last && n < Tuning::maxRedirects; ++first, ++n)
         bootcache_.insert(beast::IPAddressConversion::from_asio(*first));
diff --git a/src/xrpld/peerfinder/detail/PeerfinderManager.cpp b/src/xrpld/peerfinder/detail/PeerfinderManager.cpp
index 2858586120..d2378a2fbb 100644
--- a/src/xrpld/peerfinder/detail/PeerfinderManager.cpp
+++ b/src/xrpld/peerfinder/detail/PeerfinderManager.cpp
@@ -243,7 +243,7 @@ private:
     void
     collect_metrics()
     {
-        std::lock_guard const lock(m_statsMutex);
+        std::scoped_lock const lock(m_statsMutex);
         m_stats.activeInboundPeers = m_logic.counts_.inboundActive();
         m_stats.activeOutboundPeers = m_logic.counts_.out_active();
     }
diff --git a/src/xrpld/peerfinder/detail/SlotImp.cpp b/src/xrpld/peerfinder/detail/SlotImp.cpp
index f763a154aa..e7cc751472 100644
--- a/src/xrpld/peerfinder/detail/SlotImp.cpp
+++ b/src/xrpld/peerfinder/detail/SlotImp.cpp
@@ -22,7 +22,7 @@ SlotImp::SlotImp(
     , m_inbound(true)
     , m_fixed(fixed)
     , m_reserved(false)
-    , m_state(accept)
+    , m_state(State::accept)
     , m_remote_endpoint(std::move(remote_endpoint))
     , m_local_endpoint(local_endpoint)
     , m_listening_port(unknownPort)
@@ -37,7 +37,7 @@ SlotImp::SlotImp(beast::IP::Endpoint remote_endpoint, bool fixed, clock_type& cl
     , m_inbound(false)
     , m_fixed(fixed)
     , m_reserved(false)
-    , m_state(connect)
+    , m_state(State::connect)
     , m_remote_endpoint(std::move(remote_endpoint))
     , m_listening_port(unknownPort)
     , checked(true)
@@ -50,7 +50,8 @@ void
 SlotImp::state(State state_)
 {
     // Must go through activate() to set active state
-    XRPL_ASSERT(state_ != active, "xrpl::PeerFinder::SlotImp::state : input state is not active");
+    XRPL_ASSERT(
+        state_ != State::active, "xrpl::PeerFinder::SlotImp::state : input state is not active");
 
     // The state must be different
     XRPL_ASSERT(
@@ -60,18 +61,18 @@ SlotImp::state(State state_)
 
     // You can't transition into the initial states
     XRPL_ASSERT(
-        state_ != accept && state_ != connect,
+        state_ != State::accept && state_ != State::connect,
         "xrpl::PeerFinder::SlotImp::state : input state is not an initial");
 
     // Can only become connected from outbound connect state
     XRPL_ASSERT(
-        state_ != connected || (!m_inbound && m_state == connect),
+        state_ != State::connected || (!m_inbound && m_state == State::connect),
         "xrpl::PeerFinder::SlotImp::state : input state is not connected an "
         "invalid state");
 
     // Can't gracefully close on an outbound connection attempt
     XRPL_ASSERT(
-        state_ != closing || m_state != connect,
+        state_ != State::closing || m_state != State::connect,
         "xrpl::PeerFinder::SlotImp::state : input state is not closing an "
         "invalid state");
 
@@ -83,10 +84,10 @@ SlotImp::activate(clock_type::time_point const& now)
 {
     // Can only become active from the accept or connected state
     XRPL_ASSERT(
-        m_state == accept || m_state == connected,
+        m_state == State::accept || m_state == State::connected,
         "xrpl::PeerFinder::SlotImp::activate : valid state");
 
-    m_state = active;
+    m_state = State::active;
     whenAcceptEndpoints = now;
 }
 
diff --git a/src/xrpld/peerfinder/detail/StoreSqdb.h b/src/xrpld/peerfinder/detail/StoreSqdb.h
index 626a82c932..1d5ce50184 100644
--- a/src/xrpld/peerfinder/detail/StoreSqdb.h
+++ b/src/xrpld/peerfinder/detail/StoreSqdb.h
@@ -15,6 +15,8 @@ private:
     soci::session m_sqlDb;
 
 public:
+    // Need to be named before converting
+    // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
     enum {
         // This determines the on-database format of the data
         currentSchemaVersion = 4
diff --git a/src/xrpld/peerfinder/detail/Tuning.h b/src/xrpld/peerfinder/detail/Tuning.h
index 23a96a7374..e166ae32b8 100644
--- a/src/xrpld/peerfinder/detail/Tuning.h
+++ b/src/xrpld/peerfinder/detail/Tuning.h
@@ -6,6 +6,8 @@
 /** @{ */
 namespace xrpl::PeerFinder::Tuning {
 
+// Need to be named before converting
+// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
 enum {
     //---------------------------------------------------------
     //
@@ -61,6 +63,8 @@ static std::array<int, 10> const connectionBackoff{{1, 1, 2, 3, 5, 8, 13, 21, 34
 //
 //------------------------------------------------------------------------------
 
+// Need to be named before converting
+// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
 enum {
     // Threshold of cache entries above which we trim.
     bootcacheSize = 1000
diff --git a/src/xrpld/perflog/detail/PerfLogImp.cpp b/src/xrpld/perflog/detail/PerfLogImp.cpp
index 6b80d29cc6..64950fc689 100644
--- a/src/xrpld/perflog/detail/PerfLogImp.cpp
+++ b/src/xrpld/perflog/detail/PerfLogImp.cpp
@@ -79,7 +79,7 @@ PerfLogImp::Counters::countersJson() const
     {
         Rpc value;
         {
-            std::lock_guard const lock(proc.second.mutex);
+            std::scoped_lock const lock(proc.second.mutex);
             if ((proc.second.value.started == 0u) && (proc.second.value.finished == 0u) &&
                 (proc.second.value.errored == 0u))
             {
@@ -117,7 +117,7 @@ PerfLogImp::Counters::countersJson() const
     {
         Jq value;
         {
-            std::lock_guard const lock(proc.second.mutex);
+            std::scoped_lock const lock(proc.second.mutex);
             if ((proc.second.value.queued == 0u) && (proc.second.value.started == 0u) &&
                 (proc.second.value.finished == 0u))
             {
@@ -166,7 +166,7 @@ PerfLogImp::Counters::currentJson() const
 
     Json::Value jobsArray(Json::arrayValue);
     auto const jobs = [this] {
-        std::lock_guard const lock(jobsMutex_);
+        std::scoped_lock const lock(jobsMutex_);
         return jobs_;
     }();
 
@@ -184,7 +184,7 @@ PerfLogImp::Counters::currentJson() const
     Json::Value methodsArray(Json::arrayValue);
     std::vector<MethodStart> methods;
     {
-        std::lock_guard const lock(methodsMutex_);
+        std::scoped_lock const lock(methodsMutex_);
         methods.reserve(methods_.size());
         for (auto const& m : methods_)
             methods.push_back(m.second);
@@ -280,7 +280,7 @@ PerfLogImp::report()
     Json::Value report(Json::objectValue);
     report[jss::time] = to_string(std::chrono::floor<microseconds>(present));
     {
-        std::lock_guard const lock{counters_.jobsMutex_};
+        std::scoped_lock const lock{counters_.jobsMutex_};
         report[jss::workers] = static_cast<unsigned int>(counters_.jobs_.size());
     }
     report[jss::hostid] = hostname_;
@@ -321,10 +321,10 @@ PerfLogImp::rpcStart(std::string const& method, std::uint64_t const requestId)
     }
 
     {
-        std::lock_guard const lock(counter->second.mutex);
+        std::scoped_lock const lock(counter->second.mutex);
         ++counter->second.value.started;
     }
-    std::lock_guard const lock(counters_.methodsMutex_);
+    std::scoped_lock const lock(counters_.methodsMutex_);
     counters_.methods_[requestId] = {counter->first.c_str(), steady_clock::now()};
 }
 
@@ -341,7 +341,7 @@ PerfLogImp::rpcEnd(std::string const& method, std::uint64_t const requestId, boo
     }
     steady_time_point startTime;
     {
-        std::lock_guard const lock(counters_.methodsMutex_);
+        std::scoped_lock const lock(counters_.methodsMutex_);
         auto const e = counters_.methods_.find(requestId);
         if (e != counters_.methods_.end())
         {
@@ -355,7 +355,7 @@ PerfLogImp::rpcEnd(std::string const& method, std::uint64_t const requestId, boo
             // LCOV_EXCL_STOP
         }
     }
-    std::lock_guard const lock(counter->second.mutex);
+    std::scoped_lock const lock(counter->second.mutex);
     if (finish)
     {
         ++counter->second.value.finished;
@@ -379,7 +379,7 @@ PerfLogImp::jobQueue(JobType const type)
         return;
         // LCOV_EXCL_STOP
     }
-    std::lock_guard const lock(counter->second.mutex);
+    std::scoped_lock const lock(counter->second.mutex);
     ++counter->second.value.queued;
 }
 
@@ -400,11 +400,11 @@ PerfLogImp::jobStart(
     }
 
     {
-        std::lock_guard const lock(counter->second.mutex);
+        std::scoped_lock const lock(counter->second.mutex);
         ++counter->second.value.started;
         counter->second.value.queuedDuration += dur;
     }
-    std::lock_guard const lock(counters_.jobsMutex_);
+    std::scoped_lock const lock(counters_.jobsMutex_);
     if (instance >= 0 && instance < counters_.jobs_.size())
         counters_.jobs_[instance] = {type, startTime};
 }
@@ -422,11 +422,11 @@ PerfLogImp::jobFinish(JobType const type, microseconds dur, int instance)
     }
 
     {
-        std::lock_guard const lock(counter->second.mutex);
+        std::scoped_lock const lock(counter->second.mutex);
         ++counter->second.value.finished;
         counter->second.value.runningDuration += dur;
     }
-    std::lock_guard const lock(counters_.jobsMutex_);
+    std::scoped_lock const lock(counters_.jobsMutex_);
     if (instance >= 0 && instance < counters_.jobs_.size())
         counters_.jobs_[instance] = {jtINVALID, steady_time_point()};
 }
@@ -434,7 +434,7 @@ PerfLogImp::jobFinish(JobType const type, microseconds dur, int instance)
 void
 PerfLogImp::resizeJobs(int const resize)
 {
-    std::lock_guard const lock(counters_.jobsMutex_);
+    std::scoped_lock const lock(counters_.jobsMutex_);
     if (resize > counters_.jobs_.size())
         counters_.jobs_.resize(resize, {jtINVALID, steady_time_point()});
 }
@@ -445,7 +445,7 @@ PerfLogImp::rotate()
     if (setup_.perfLog.empty())
         return;
 
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     rotate_ = true;
     cond_.notify_one();
 }
@@ -463,7 +463,7 @@ PerfLogImp::stop()
     if (thread_.joinable())
     {
         {
-            std::lock_guard const lock(mutex_);
+            std::scoped_lock const lock(mutex_);
             stop_ = true;
             cond_.notify_one();
         }
diff --git a/src/xrpld/rpc/detail/AssetCache.cpp b/src/xrpld/rpc/detail/AssetCache.cpp
index bbe8fefc98..28924ceb5f 100644
--- a/src/xrpld/rpc/detail/AssetCache.cpp
+++ b/src/xrpld/rpc/detail/AssetCache.cpp
@@ -45,7 +45,7 @@ AssetCache::getRippleLines(AccountID const& accountID, LineDirection direction)
         direction == LineDirection::outgoing ? LineDirection::incoming : LineDirection::outgoing,
         hash);
 
-    std::lock_guard const sl(mLock);
+    std::scoped_lock const sl(mLock);
 
     auto [it, inserted] = [&]() {
         if (auto otheriter = lines_.find(otherkey); otheriter != lines_.end())
@@ -118,7 +118,7 @@ AssetCache::getRippleLines(AccountID const& accountID, LineDirection direction)
 std::shared_ptr<std::vector<PathFindMPT>> const&
 AssetCache::getMPTs(xrpl::AccountID const& account)
 {
-    std::lock_guard const sl(mLock);
+    std::scoped_lock const sl(mLock);
 
     if (auto it = mpts_.find(account); it != mpts_.end())
         return it->second;
diff --git a/src/xrpld/rpc/detail/Handler.h b/src/xrpld/rpc/detail/Handler.h
index d249409ffe..94d0ca87cf 100644
--- a/src/xrpld/rpc/detail/Handler.h
+++ b/src/xrpld/rpc/detail/Handler.h
@@ -15,6 +15,8 @@ class Object;
 namespace xrpl::RPC {
 
 // Under what condition can we call this RPC?
+// Bitwise flags
+// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
 enum Condition {
     NO_CONDITION = 0,
     NEEDS_NETWORK_CONNECTION = 1,
diff --git a/src/xrpld/rpc/detail/PathRequest.cpp b/src/xrpld/rpc/detail/PathRequest.cpp
index 1719567357..9707536cc8 100644
--- a/src/xrpld/rpc/detail/PathRequest.cpp
+++ b/src/xrpld/rpc/detail/PathRequest.cpp
@@ -121,7 +121,7 @@ PathRequest::~PathRequest()
 bool
 PathRequest::isNew()
 {
-    std::lock_guard const sl(mIndexLock);
+    std::scoped_lock const sl(mIndexLock);
 
     // does this path request still need its first full path
     return mLastIndex == 0;
@@ -130,7 +130,7 @@ PathRequest::isNew()
 bool
 PathRequest::needsUpdate(bool newOnly, LedgerIndex index)
 {
-    std::lock_guard const sl(mIndexLock);
+    std::scoped_lock const sl(mIndexLock);
 
     if (mInProgress)
     {
@@ -162,7 +162,7 @@ PathRequest::hasCompletion()
 void
 PathRequest::updateComplete()
 {
-    std::lock_guard const sl(mIndexLock);
+    std::scoped_lock const sl(mIndexLock);
 
     XRPL_ASSERT(mInProgress, "xrpl::PathRequest::updateComplete : in progress");
     mInProgress = false;
@@ -476,7 +476,7 @@ Json::Value
 PathRequest::doClose()
 {
     JLOG(m_journal.debug()) << iIdentifier << " closed";
-    std::lock_guard const sl(mLock);
+    std::scoped_lock const sl(mLock);
     jvStatus[jss::closed] = true;
     return jvStatus;
 }
@@ -484,7 +484,7 @@ PathRequest::doClose()
 Json::Value
 PathRequest::doStatus(Json::Value const&)
 {
-    std::lock_guard const sl(mLock);
+    std::scoped_lock const sl(mLock);
     jvStatus[jss::status] = jss::success;
     return jvStatus;
 }
@@ -714,7 +714,7 @@ PathRequest::doUpdate(
     JLOG(m_journal.debug()) << iIdentifier << " update " << (fast ? "fast" : "normal");
 
     {
-        std::lock_guard const sl(mLock);
+        std::scoped_lock const sl(mLock);
 
         if (!isValid(cache))
             return jvStatus;
@@ -805,7 +805,7 @@ PathRequest::doUpdate(
     }
 
     {
-        std::lock_guard const sl(mLock);
+        std::scoped_lock const sl(mLock);
         jvStatus = newStatus;
     }
 
diff --git a/src/xrpld/rpc/detail/PathRequestManager.cpp b/src/xrpld/rpc/detail/PathRequestManager.cpp
index 7508884be1..b05737197e 100644
--- a/src/xrpld/rpc/detail/PathRequestManager.cpp
+++ b/src/xrpld/rpc/detail/PathRequestManager.cpp
@@ -32,7 +32,7 @@ namespace xrpl {
 std::shared_ptr<AssetCache>
 PathRequestManager::getAssetCache(std::shared_ptr<ReadView const> const& ledger, bool authoritative)
 {
-    std::lock_guard const sl(mLock);
+    std::scoped_lock const sl(mLock);
 
     auto assetCache = assetCache_.lock();
 
@@ -66,7 +66,7 @@ PathRequestManager::updateAll(std::shared_ptr<ReadView const> const& inLedger)
 
     // Get the ledger and cache we should be using
     {
-        std::lock_guard const sl(mLock);
+        std::scoped_lock const sl(mLock);
         requests = requests_;
         cache = getAssetCache(inLedger, true);
     }
@@ -145,7 +145,7 @@ PathRequestManager::updateAll(std::shared_ptr<ReadView const> const& inLedger)
 
             if (remove)
             {
-                std::lock_guard const sl(mLock);
+                std::scoped_lock const sl(mLock);
 
                 // Remove any dangling weak pointers or weak
                 // pointers that refer to this path request.
@@ -189,7 +189,7 @@ PathRequestManager::updateAll(std::shared_ptr<ReadView const> const& inLedger)
         std::shared_ptr<AssetCache> lastCache;
         {
             // Get the latest requests, cache, and ledger for next pass
-            std::lock_guard const sl(mLock);
+            std::scoped_lock const sl(mLock);
 
             if (requests_.empty())
                 break;
@@ -206,14 +206,14 @@ PathRequestManager::updateAll(std::shared_ptr<ReadView const> const& inLedger)
 bool
 PathRequestManager::requestsPending() const
 {
-    std::lock_guard const sl(mLock);
+    std::scoped_lock const sl(mLock);
     return !requests_.empty();
 }
 
 void
 PathRequestManager::insertPathRequest(PathRequest::pointer const& req)
 {
-    std::lock_guard const sl(mLock);
+    std::scoped_lock const sl(mLock);
 
     // Insert after any older unserviced requests but before
     // any serviced requests
diff --git a/src/xrpld/rpc/detail/Pathfinder.cpp b/src/xrpld/rpc/detail/Pathfinder.cpp
index a31d4522a7..ed486c80a8 100644
--- a/src/xrpld/rpc/detail/Pathfinder.cpp
+++ b/src/xrpld/rpc/detail/Pathfinder.cpp
@@ -39,9 +39,23 @@
 #include <map>
 #include <memory>
 #include <optional>
+#include <ostream>
 #include <string>
 #include <vector>
 
+namespace xrpl {
+static std::ostream&
+operator<<(std::ostream& os, Pathfinder::NodeType t)
+{
+    return os << static_cast<int>(t);
+}
+static std::ostream&
+operator<<(std::ostream& os, Pathfinder::PaymentType t)
+{
+    return os << static_cast<int>(t);
+}
+}  // namespace xrpl
+
 /*
 
 Core Pathfinding Engine
@@ -139,22 +153,22 @@ pathTypeToString(Pathfinder::PathType const& type)
     {
         switch (node)
         {
-            case Pathfinder::nt_SOURCE:
+            case Pathfinder::NodeType::nt_SOURCE:
                 ret.append("s");
                 break;
-            case Pathfinder::nt_ACCOUNTS:
+            case Pathfinder::NodeType::nt_ACCOUNTS:
                 ret.append("a");
                 break;
-            case Pathfinder::nt_BOOKS:
+            case Pathfinder::NodeType::nt_BOOKS:
                 ret.append("b");
                 break;
-            case Pathfinder::nt_XRP_BOOK:
+            case Pathfinder::NodeType::nt_XRP_BOOK:
                 ret.append("x");
                 break;
-            case Pathfinder::nt_DEST_BOOK:
+            case Pathfinder::NodeType::nt_DEST_BOOK:
                 ret.append("f");
                 break;
-            case Pathfinder::nt_DESTINATION:
+            case Pathfinder::NodeType::nt_DESTINATION:
                 ret.append("d");
                 break;
         }
@@ -310,36 +324,36 @@ Pathfinder::findPaths(int searchLevel, std::function<bool(void)> const& continue
 
     // Now compute the payment type from the types of the source and destination
     // currencies.
-    PaymentType paymentType = pt_XRP_to_XRP;
+    PaymentType paymentType = PaymentType::pt_XRP_to_XRP;
     if (bSrcXrp && bDstXrp)
     {
         // XRP -> XRP
         JLOG(j_.debug()) << "XRP to XRP payment";
-        paymentType = pt_XRP_to_XRP;
+        paymentType = PaymentType::pt_XRP_to_XRP;
     }
     else if (bSrcXrp)
     {
         // XRP -> non-XRP
         JLOG(j_.debug()) << "XRP to non-XRP payment";
-        paymentType = pt_XRP_to_nonXRP;
+        paymentType = PaymentType::pt_XRP_to_nonXRP;
     }
     else if (bDstXrp)
     {
         // non-XRP -> XRP
         JLOG(j_.debug()) << "non-XRP to XRP payment";
-        paymentType = pt_nonXRP_to_XRP;
+        paymentType = PaymentType::pt_nonXRP_to_XRP;
     }
     else if (mSrcPathAsset == mDstAmount.asset())
     {
         // non-XRP -> non-XRP - Same currency
         JLOG(j_.debug()) << "non-XRP to non-XRP - same currency";
-        paymentType = pt_nonXRP_to_same;
+        paymentType = PaymentType::pt_nonXRP_to_same;
     }
     else
     {
         // non-XRP to non-XRP - Different currency
         JLOG(j_.debug()) << "non-XRP to non-XRP - cross currency";
-        paymentType = pt_nonXRP_to_nonXRP;
+        paymentType = PaymentType::pt_nonXRP_to_nonXRP;
     }
 
     // Now iterate over all paths for that paymentType.
@@ -888,29 +902,29 @@ Pathfinder::addPathsForType(
     auto nodeType = pathType.back();
     switch (nodeType)
     {
-        case nt_SOURCE:
+        case NodeType::nt_SOURCE:
             // Source must always be at the start, so pathsOut has to be empty.
             XRPL_ASSERT(pathsOut.empty(), "xrpl::Pathfinder::addPathsForType : empty paths");
             pathsOut.push_back(STPath());
             break;
 
-        case nt_ACCOUNTS:
+        case NodeType::nt_ACCOUNTS:
             addLinks(parentPaths, pathsOut, afADD_ACCOUNTS, continueCallback);
             break;
 
-        case nt_BOOKS:
+        case NodeType::nt_BOOKS:
             addLinks(parentPaths, pathsOut, afADD_BOOKS, continueCallback);
             break;
 
-        case nt_XRP_BOOK:
+        case NodeType::nt_XRP_BOOK:
             addLinks(parentPaths, pathsOut, afADD_BOOKS | afOB_XRP, continueCallback);
             break;
 
-        case nt_DEST_BOOK:
+        case NodeType::nt_DEST_BOOK:
             addLinks(parentPaths, pathsOut, afADD_BOOKS | afOB_LAST, continueCallback);
             break;
 
-        case nt_DESTINATION:
+        case NodeType::nt_DESTINATION:
             // FIXME: What if a different issuer was specified on the
             // destination amount?
             // TODO(tom): what does this even mean?  Should it be a JIRA?
@@ -1321,29 +1335,29 @@ makePath(char const* string)
         switch (*string++)
         {
             case 's':  // source
-                ret.push_back(Pathfinder::nt_SOURCE);
+                ret.push_back(Pathfinder::NodeType::nt_SOURCE);
                 break;
 
             case 'a':  // accounts
-                ret.push_back(Pathfinder::nt_ACCOUNTS);
+                ret.push_back(Pathfinder::NodeType::nt_ACCOUNTS);
                 break;
 
             case 'b':  // books
-                ret.push_back(Pathfinder::nt_BOOKS);
+                ret.push_back(Pathfinder::NodeType::nt_BOOKS);
                 break;
 
             case 'x':  // xrp book
-                ret.push_back(Pathfinder::nt_XRP_BOOK);
+                ret.push_back(Pathfinder::NodeType::nt_XRP_BOOK);
                 break;
 
             case 'f':  // book to final currency
-                ret.push_back(Pathfinder::nt_DEST_BOOK);
+                ret.push_back(Pathfinder::NodeType::nt_DEST_BOOK);
                 break;
 
             case 'd':
                 // Destination (with account, if required and not already
                 // present).
-                ret.push_back(Pathfinder::nt_DESTINATION);
+                ret.push_back(Pathfinder::NodeType::nt_DESTINATION);
                 break;
 
             case 0:
@@ -1376,11 +1390,11 @@ Pathfinder::initPathTable()
     // CAUTION: Do not include rules that build default paths
 
     mPathTable.clear();
-    fillPaths(pt_XRP_to_XRP, {});
+    fillPaths(PaymentType::pt_XRP_to_XRP, {});
     /* cspell: disable */
 
     fillPaths(
-        pt_XRP_to_nonXRP,
+        PaymentType::pt_XRP_to_nonXRP,
         {{1, "sfd"},    // source -> book -> gateway
          {3, "sfad"},   // source -> book -> account -> destination
          {5, "sfaad"},  // source -> book -> account -> account -> destination
@@ -1390,7 +1404,7 @@ Pathfinder::initPathTable()
          {10, "sbafad"}});
 
     fillPaths(
-        pt_nonXRP_to_XRP,
+        PaymentType::pt_nonXRP_to_XRP,
         {{1, "sxd"},   // gateway buys XRP
          {2, "saxd"},  // source -> gateway -> book(XRP) -> dest
          {6, "saaxd"},
@@ -1400,7 +1414,7 @@ Pathfinder::initPathTable()
 
     // non-XRP to non-XRP (same currency)
     fillPaths(
-        pt_nonXRP_to_same,
+        PaymentType::pt_nonXRP_to_same,
         {
             {1, "sad"},   // source -> gateway -> destination
             {1, "sfd"},   // source -> book -> destination
@@ -1419,7 +1433,7 @@ Pathfinder::initPathTable()
 
     // non-XRP to non-XRP (different currency)
     fillPaths(
-        pt_nonXRP_to_nonXRP,
+        PaymentType::pt_nonXRP_to_nonXRP,
         {
             {1, "sfad"},
             {1, "safd"},
diff --git a/src/xrpld/rpc/detail/Pathfinder.h b/src/xrpld/rpc/detail/Pathfinder.h
index 964ec8c1d1..b4380c04ca 100644
--- a/src/xrpld/rpc/detail/Pathfinder.h
+++ b/src/xrpld/rpc/detail/Pathfinder.h
@@ -60,7 +60,7 @@ public:
         AccountID const& srcIssuer,
         std::function<bool(void)> const& continueCallback = {});
 
-    enum NodeType {
+    enum class NodeType {
         nt_SOURCE,      // The source account: with an issuer account, if needed.
         nt_ACCOUNTS,    // Accounts that connect from this source/currency.
         nt_BOOKS,       // Order books that connect to this currency.
@@ -74,7 +74,7 @@ public:
 
     // PaymentType represents the types of the source and destination currencies
     // in a path request.
-    enum PaymentType {
+    enum class PaymentType {
         pt_XRP_to_XRP,
         pt_XRP_to_nonXRP,
         pt_nonXRP_to_XRP,
diff --git a/src/xrpld/rpc/detail/RPCSub.cpp b/src/xrpld/rpc/detail/RPCSub.cpp
index f9cd860908..f102f919c4 100644
--- a/src/xrpld/rpc/detail/RPCSub.cpp
+++ b/src/xrpld/rpc/detail/RPCSub.cpp
@@ -84,7 +84,7 @@ public:
     void
     send(Json::Value const& jvObj, bool broadcast) override
     {
-        std::lock_guard const sl(mLock);
+        std::scoped_lock const sl(mLock);
 
         auto jm = broadcast ? j_.debug() : j_.info();
         JLOG(jm) << "RPCCall::fromNetwork push: " << jvObj;
@@ -104,7 +104,7 @@ public:
     void
     setUsername(std::string const& strUsername) override
     {
-        std::lock_guard const sl(mLock);
+        std::scoped_lock const sl(mLock);
 
         mUsername = strUsername;
     }
@@ -112,7 +112,7 @@ public:
     void
     setPassword(std::string const& strPassword) override
     {
-        std::lock_guard const sl(mLock);
+        std::scoped_lock const sl(mLock);
 
         mPassword = strPassword;
     }
@@ -130,7 +130,7 @@ private:
         {
             {
                 // Obtain the lock to manipulate the queue and change sending.
-                std::lock_guard const sl(mLock);
+                std::scoped_lock const sl(mLock);
 
                 if (mDeque.empty())
                 {
diff --git a/src/xrpld/rpc/detail/Role.cpp b/src/xrpld/rpc/detail/Role.cpp
index 325b7eb3c6..f28905ba20 100644
--- a/src/xrpld/rpc/detail/Role.cpp
+++ b/src/xrpld/rpc/detail/Role.cpp
@@ -272,12 +272,12 @@ forwardedFor(http_request_type const& request)
 
         // We found a "for=".  Scan for the end of the IP address.
         std::size_t const pos = [&found, &it]() {
-            std::size_t const pos =
-                std::string_view(found, it->value().end() - found).find_first_of(",;");
-            if (pos != std::string_view::npos)
+            auto const remaining = static_cast<std::size_t>(it->value().end() - found);
+            if (std::size_t const pos = std::string_view(found, remaining).find_first_of(",;");
+                pos != std::string_view::npos)
                 return pos;
 
-            return it->value().size() - forStr.size();
+            return remaining;
         }();
 
         return extractIpAddrFromField({found, pos});
diff --git a/src/xrpld/rpc/detail/ServerHandler.cpp b/src/xrpld/rpc/detail/ServerHandler.cpp
index db6dad2f1c..1000df064f 100644
--- a/src/xrpld/rpc/detail/ServerHandler.cpp
+++ b/src/xrpld/rpc/detail/ServerHandler.cpp
@@ -194,7 +194,7 @@ ServerHandler::onAccept(Session& session, boost::asio::ip::tcp::endpoint endpoin
     auto const& port = session.port();
 
     auto const c = [this, &port]() {
-        std::lock_guard const lock(mutex_);
+        std::scoped_lock const lock(mutex_);
         return ++count_[port];
     }();
 
@@ -378,14 +378,14 @@ ServerHandler::onWSMessage(
 void
 ServerHandler::onClose(Session& session, boost::system::error_code const&)
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     --count_[session.port()];
 }
 
 void
 ServerHandler::onStopped(Server&)
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     stopped_ = true;
     condition_.notify_one();
 }
diff --git a/src/xrpld/rpc/detail/TransactionSign.cpp b/src/xrpld/rpc/detail/TransactionSign.cpp
index 85d5a62efc..284279fa3f 100644
--- a/src/xrpld/rpc/detail/TransactionSign.cpp
+++ b/src/xrpld/rpc/detail/TransactionSign.cpp
@@ -575,11 +575,7 @@ transactionPreProcessImpl(
 
     if (verify)
     {
-        if (!sle)
-        {
-            // XXX Ignore transactions for accounts not created.
-            return rpcError(rpcSRC_ACT_NOT_FOUND);
-        }
+        // sle validity is checked above
 
         JLOG(j.trace()) << "verify: " << toBase58(calcAccountID(pk)) << " : "
                         << toBase58(srcAddressID);
@@ -700,7 +696,7 @@ transactionConstructImpl(
     {
         std::string reason;
         tpTrans = std::make_shared<Transaction>(stTx, reason, app);
-        if (tpTrans->getStatus() != NEW)
+        if (tpTrans->getStatus() != TransStatus::NEW)
         {
             ret.first = RPC::make_error(rpcINTERNAL, "Unable to construct transaction: " + reason);
             return ret;
diff --git a/src/xrpld/rpc/handlers/account/AccountChannels.cpp b/src/xrpld/rpc/handlers/account/AccountChannels.cpp
index 1fa492a3c0..51282f699f 100644
--- a/src/xrpld/rpc/handlers/account/AccountChannels.cpp
+++ b/src/xrpld/rpc/handlers/account/AccountChannels.cpp
@@ -95,7 +95,11 @@ doAccountChannels(RPC::JsonContext& context)
 
     std::string strDst;
     if (params.isMember(jss::destination_account))
+    {
+        if (!params[jss::destination_account].isString())
+            return RPC::invalid_field_error(jss::destination_account);
         strDst = params[jss::destination_account].asString();
+    }
 
     auto const raDstAccount = [&]() -> std::optional<AccountID> {
         return strDst.empty() ? std::nullopt : parseBase58<AccountID>(strDst);
diff --git a/src/xrpld/rpc/handlers/account/AccountInfo.cpp b/src/xrpld/rpc/handlers/account/AccountInfo.cpp
index 019ff83def..c1c6c71339 100644
--- a/src/xrpld/rpc/handlers/account/AccountInfo.cpp
+++ b/src/xrpld/rpc/handlers/account/AccountInfo.cpp
@@ -58,10 +58,9 @@ injectSLE(Json::Value& jv, SLE const& sle)
             Blob const b(hash.begin(), hash.end());
             std::string md5 = strHex(makeSlice(b));
             boost::to_lower(md5);
-            // VFALCO TODO Give a name and move this constant
-            //             to a more visible location. Also
-            //             shouldn't this be https?
-            jv[jss::urlgravatar] = str(boost::format("http://www.gravatar.com/avatar/%s") % md5);
+            // VFALCO TODO Give a name to this constant and move it
+            //             to a more visible location.
+            jv[jss::urlgravatar] = str(boost::format("https://www.gravatar.com/avatar/%s") % md5);
         }
     }
     else
diff --git a/src/xrpld/rpc/handlers/account/NoRippleCheck.cpp b/src/xrpld/rpc/handlers/account/NoRippleCheck.cpp
index 54964be8da..d05d74170f 100644
--- a/src/xrpld/rpc/handlers/account/NoRippleCheck.cpp
+++ b/src/xrpld/rpc/handlers/account/NoRippleCheck.cpp
@@ -118,14 +118,14 @@ doNoRippleCheck(RPC::JsonContext& context)
 
     bool const bDefaultRipple = (sle->getFieldU32(sfFlags) & lsfDefaultRipple) != 0u;
 
-    if ((static_cast<int>(bDefaultRipple) & static_cast<int>(!roleGateway)) != 0)
+    if (bDefaultRipple && !roleGateway)
     {
         problems.append(
             "You appear to have set your default ripple flag even though you "
             "are not a gateway. This is not recommended unless you are "
             "experimenting");
     }
-    else if ((static_cast<int>(roleGateway) & static_cast<int>(!bDefaultRipple)) != 0)
+    else if (roleGateway && !bDefaultRipple)
     {
         problems.append("You should immediately set your default ripple flag");
         if (transactions)
@@ -148,12 +148,12 @@ doNoRippleCheck(RPC::JsonContext& context)
 
                 std::string problem;
                 bool needFix = false;
-                if (bNoRipple & roleGateway)
+                if (bNoRipple && roleGateway)
                 {
                     problem = "You should clear the no ripple flag on your ";
                     needFix = true;
                 }
-                else if (!roleGateway & !bNoRipple)
+                else if (!roleGateway && !bNoRipple)
                 {
                     problem = "You should probably set the no ripple flag on your ";
                     needFix = true;
diff --git a/src/xrpld/rpc/handlers/ledger/Ledger.cpp b/src/xrpld/rpc/handlers/ledger/Ledger.cpp
index dd2280b51c..dc5f24dffc 100644
--- a/src/xrpld/rpc/handlers/ledger/Ledger.cpp
+++ b/src/xrpld/rpc/handlers/ledger/Ledger.cpp
@@ -8,6 +8,7 @@
 #include <xrpld/rpc/Status.h>
 #include <xrpld/rpc/detail/RPCLedgerHelpers.h>
 
+#include <xrpl/basics/Expected.h>
 #include <xrpl/basics/Log.h>
 #include <xrpl/beast/utility/instrumentation.h>
 #include <xrpl/json/json_value.h>
@@ -42,28 +43,56 @@ Status
 LedgerHandler::check()
 {
     auto const& params = context_.params;
+
+    auto getBool = [&](Json::StaticString const& field) -> Expected<bool, Status> {
+        if (!params.isMember(field))
+        {
+            return false;
+        }
+        if (!params[field].isBool())
+        {
+            return Unexpected(rpcINVALID_PARAMS);
+        }
+
+        return params[field].asBool();
+    };
+
+    auto const full = getBool(jss::full);
+    auto const transactions = getBool(jss::transactions);
+    auto const accounts = getBool(jss::accounts);
+    auto const expand = getBool(jss::expand);
+    auto const binary = getBool(jss::binary);
+    auto const owner_funds = getBool(jss::owner_funds);
+    auto const queue = getBool(jss::queue);
+
+    if (!full.has_value())
+        return full.error();
+    if (!transactions.has_value())
+        return transactions.error();
+    if (!accounts.has_value())
+        return accounts.error();
+    if (!expand.has_value())
+        return expand.error();
+    if (!binary.has_value())
+        return binary.error();
+    if (!owner_funds.has_value())
+        return owner_funds.error();
+    if (!queue.has_value())
+        return queue.error();
+
+    options_ = (*full ? LedgerFill::full : 0) | (*expand ? LedgerFill::expand : 0) |
+        (*transactions ? LedgerFill::dumpTxrp : 0) | (*accounts ? LedgerFill::dumpState : 0) |
+        (*binary ? LedgerFill::binary : 0) | (*owner_funds ? LedgerFill::ownerFunds : 0) |
+        (*queue ? LedgerFill::dumpQueue : 0);
+
     bool const needsLedger = params.isMember(jss::ledger) || params.isMember(jss::ledger_hash) ||
         params.isMember(jss::ledger_index);
     if (!needsLedger)
         return Status::OK;
-
     if (auto s = lookupLedger(ledger_, context_, result_))
         return s;
 
-    bool const full = params[jss::full].asBool();
-    bool const transactions = params[jss::transactions].asBool();
-    bool const accounts = params[jss::accounts].asBool();
-    bool const expand = params[jss::expand].asBool();
-    bool const binary = params[jss::binary].asBool();
-    bool const owner_funds = params[jss::owner_funds].asBool();
-    bool const queue = params[jss::queue].asBool();
-
-    options_ = (full ? LedgerFill::full : 0) | (expand ? LedgerFill::expand : 0) |
-        (transactions ? LedgerFill::dumpTxrp : 0) | (accounts ? LedgerFill::dumpState : 0) |
-        (binary ? LedgerFill::binary : 0) | (owner_funds ? LedgerFill::ownerFunds : 0) |
-        (queue ? LedgerFill::dumpQueue : 0);
-
-    if (full || accounts)
+    if (*full || *accounts)
     {
         // Until some sane way to get full ledgers has been implemented,
         // disallow retrieving all state nodes.
@@ -76,7 +105,8 @@ LedgerHandler::check()
         }
         context_.loadType = binary ? Resource::feeMediumBurdenRPC : Resource::feeHeavyBurdenRPC;
     }
-    if (queue)
+
+    if (*queue)
     {
         if (!ledger_ || !ledger_->open())
         {
diff --git a/src/xrpld/rpc/handlers/ledger/LedgerData.cpp b/src/xrpld/rpc/handlers/ledger/LedgerData.cpp
index f0a361d951..367eaa8973 100644
--- a/src/xrpld/rpc/handlers/ledger/LedgerData.cpp
+++ b/src/xrpld/rpc/handlers/ledger/LedgerData.cpp
@@ -54,7 +54,13 @@ doLedgerData(RPC::JsonContext& context)
             return RPC::expected_field_error(jss::marker, "valid");
     }
 
-    bool const isBinary = params[jss::binary].asBool();
+    bool isBinary = false;
+    if (params.isMember(jss::binary))
+    {
+        if (!params[jss::binary].isBool())
+            return RPC::expected_field_error(jss::binary, "boolean");
+        isBinary = params[jss::binary].asBool();
+    }
 
     int limit = -1;
     if (params.isMember(jss::limit))
diff --git a/src/xrpld/rpc/handlers/orderbook/GetAggregatePrice.cpp b/src/xrpld/rpc/handlers/orderbook/GetAggregatePrice.cpp
index 10359c810e..7db7c2312e 100644
--- a/src/xrpld/rpc/handlers/orderbook/GetAggregatePrice.cpp
+++ b/src/xrpld/rpc/handlers/orderbook/GetAggregatePrice.cpp
@@ -241,7 +241,6 @@ doGetAggregatePrice(RPC::JsonContext& context)
         return result;
     }
 
-    // Get the ledger
     std::shared_ptr<ReadView const> ledger;
     result = RPC::lookupLedger(ledger, context);
     if (!ledger)
diff --git a/src/xrpld/rpc/handlers/subscribe/Subscribe.cpp b/src/xrpld/rpc/handlers/subscribe/Subscribe.cpp
index 9be273587d..f5e33922dc 100644
--- a/src/xrpld/rpc/handlers/subscribe/Subscribe.cpp
+++ b/src/xrpld/rpc/handlers/subscribe/Subscribe.cpp
@@ -248,9 +248,11 @@ doSubscribe(RPC::JsonContext& context)
 
             if (j.isMember(jss::taker))
             {
+                if (!j[jss::taker].isString())
+                    return rpcError(rpcACT_MALFORMED);
                 takerID = parseBase58<AccountID>(j[jss::taker].asString());
                 if (!takerID)
-                    return rpcError(rpcBAD_ISSUER);
+                    return rpcError(rpcACT_MALFORMED);
             }
 
             if (j.isMember(jss::domain))
diff --git a/src/xrpld/rpc/handlers/transaction/Submit.cpp b/src/xrpld/rpc/handlers/transaction/Submit.cpp
index 73260c0661..8b54083628 100644
--- a/src/xrpld/rpc/handlers/transaction/Submit.cpp
+++ b/src/xrpld/rpc/handlers/transaction/Submit.cpp
@@ -4,10 +4,12 @@
 #include <xrpld/rpc/Role.h>
 #include <xrpld/rpc/detail/TransactionSign.h>
 
+#include <xrpl/basics/Expected.h>
 #include <xrpl/basics/Slice.h>
 #include <xrpl/basics/StringUtilities.h>
 #include <xrpl/basics/safe_cast.h>
 #include <xrpl/basics/strHex.h>
+#include <xrpl/json/json_value.h>
 #include <xrpl/protocol/ErrorCodes.h>
 #include <xrpl/protocol/RPCErr.h>
 #include <xrpl/protocol/STTx.h>
@@ -24,11 +26,15 @@
 
 namespace xrpl {
 
-static NetworkOPs::FailHard
+static Expected<NetworkOPs::FailHard, Json::Value>
 getFailHard(RPC::JsonContext const& context)
 {
+    if (context.params.isMember(jss::fail_hard) && !context.params[jss::fail_hard].isBool())
+    {
+        return Unexpected(RPC::expected_field_error(jss::fail_hard, "boolean"));
+    }
     return NetworkOPs::doFailHard(
-        context.params.isMember("fail_hard") && context.params["fail_hard"].asBool());
+        context.params.isMember(jss::fail_hard) && context.params[jss::fail_hard].asBool());
 }
 
 // {
@@ -43,6 +49,8 @@ doSubmit(RPC::JsonContext& context)
     if (!context.params.isMember(jss::tx_blob))
     {
         auto const failType = getFailHard(context);
+        if (!failType)
+            return failType.error();
 
         if (context.role != Role::ADMIN && !context.app.config().canSign())
             return RPC::make_error(rpcNOT_SUPPORTED, "Signing is not supported by this server.");
@@ -50,7 +58,7 @@ doSubmit(RPC::JsonContext& context)
         auto ret = RPC::transactionSubmit(
             context.params,
             context.apiVersion,
-            failType,
+            *failType,
             context.role,
             context.ledgerMaster.getValidatedLedgerAge(),
             context.app,
@@ -107,7 +115,7 @@ doSubmit(RPC::JsonContext& context)
 
     std::string reason;
     auto transaction = std::make_shared<Transaction>(stTx, reason, context.app);
-    if (transaction->getStatus() != NEW)
+    if (transaction->getStatus() != TransStatus::NEW)
     {
         jvResult[jss::error] = "invalidTransaction";
         jvResult[jss::error_exception] = "fails local checks: " + reason;
@@ -118,8 +126,10 @@ doSubmit(RPC::JsonContext& context)
     try
     {
         auto const failType = getFailHard(context);
+        if (!failType)
+            return failType.error();
 
-        context.netOps.processTransaction(transaction, isUnlimited(context.role), true, failType);
+        context.netOps.processTransaction(transaction, isUnlimited(context.role), true, *failType);
     }
     catch (std::exception& e)
     {
diff --git a/src/xrpld/shamap/NodeFamily.cpp b/src/xrpld/shamap/NodeFamily.cpp
index 2c47515498..bf1b598620 100644
--- a/src/xrpld/shamap/NodeFamily.cpp
+++ b/src/xrpld/shamap/NodeFamily.cpp
@@ -53,12 +53,12 @@ void
 NodeFamily::reset()
 {
     {
-        std::lock_guard const lock(maxSeqMutex_);
+        std::scoped_lock const lock(maxSeqMutex_);
         maxSeq_ = 0;
     }
 
-    fbCache_->reset();
-    tnCache_->reset();
+    (*fbCache_).reset();
+    (*tnCache_).reset();
 }
 
 void