diff --git a/.clang-tidy b/.clang-tidy
index 6a7005b464..6a967532db 100644
--- a/.clang-tidy
+++ b/.clang-tidy
@@ -7,7 +7,6 @@ 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,
@@ -29,7 +28,6 @@ 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,
@@ -87,7 +85,6 @@ 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,
@@ -112,7 +109,6 @@ 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,
@@ -126,7 +122,6 @@ 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/scripts/levelization/generate.py b/.github/scripts/levelization/generate.py
old mode 100644
new mode 100755
diff --git a/.github/scripts/levelization/results/ordering.txt b/.github/scripts/levelization/results/ordering.txt
index 5a2307b1be..b77b1315a8 100644
--- a/.github/scripts/levelization/results/ordering.txt
+++ b/.github/scripts/levelization/results/ordering.txt
@@ -191,12 +191,18 @@ test.toplevel > xrpl.json
 test.unit_test > xrpl.basics
 test.unit_test > xrpl.protocol
 tests.libxrpl > xrpl.basics
+tests.libxrpl > xrpl.core
 tests.libxrpl > xrpld.telemetry
 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.telemetry
+tests.libxrpl > xrpl.tx
 xrpl.conditions > xrpl.basics
 xrpl.conditions > xrpl.protocol
 xrpl.core > xrpl.basics
diff --git a/.github/scripts/rename/README.md b/.github/scripts/rename/README.md
index ab685bb0c3..123881094e 100644
--- a/.github/scripts/rename/README.md
+++ b/.github/scripts/rename/README.md
@@ -1,11 +1,11 @@
 ## Renaming ripple(d) to xrpl(d)
 
 In the initial phases of development of the XRPL, the open source codebase was
-called "rippled" and it remains with that name even today. Today, over 1000
+called "xrpld" and it remains with that name even today. Today, over 1000
 nodes run the application, and code contributions have been submitted by
 developers located around the world. The XRPL community is larger than ever.
 In light of the decentralized and diversified nature of XRPL, we will rename any
-references to `ripple` and `rippled` to `xrpl` and `xrpld`, when appropriate.
+references to `ripple` and `xrpld` to `xrpl` and `xrpld`, when appropriate.
 
 See [here](https://xls.xrpl.org/xls/XLS-0095-rename-rippled-to-xrpld.html) for
 more information.
@@ -22,17 +22,17 @@ run from the repository root.
 2. `.github/scripts/rename/copyright.sh`: This script will remove superfluous
    copyright notices.
 3. `.github/scripts/rename/cmake.sh`: This script will rename all CMake files
-   from `RippleXXX.cmake` or `RippledXXX.cmake` to `XrplXXX.cmake`, and any
-   references to `ripple` and `rippled` (with or without capital letters) to
+   from `RippleXXX.cmake` or `XrpldXXX.cmake` to `XrplXXX.cmake`, and any
+   references to `ripple` and `xrpld` (with or without capital letters) to
    `xrpl` and `xrpld`, respectively. The name of the binary will remain as-is,
    and will only be renamed to `xrpld` by a later script.
 4. `.github/scripts/rename/binary.sh`: This script will rename the binary from
-   `rippled` to `xrpld`, and reverses the symlink so that `rippled` points to
+   `xrpld` to `xrpld`, and reverses the symlink so that `xrpld` points to
    the `xrpld` binary.
 5. `.github/scripts/rename/namespace.sh`: This script will rename the C++
    namespaces from `ripple` to `xrpl`.
 6. `.github/scripts/rename/config.sh`: This script will rename the config from
-   `rippled.cfg` to `xrpld.cfg`, and updating the code accordingly. The old
+   `xrpld.cfg` to `xrpld.cfg`, and updating the code accordingly. The old
    filename will still be accepted.
 7. `.github/scripts/rename/docs.sh`: This script will rename any lingering
    references of `ripple(d)` to `xrpl(d)` in code, comments, and documentation.
diff --git a/docker/telemetry/docker-compose.yml b/docker/telemetry/docker-compose.yml
index 5ea1ab3111..b2db1be183 100644
--- a/docker/telemetry/docker-compose.yml
+++ b/docker/telemetry/docker-compose.yml
@@ -27,7 +27,6 @@ services:
       - "4317:4317" # OTLP gRPC
       - "4318:4318" # OTLP HTTP (traces + native OTel metrics)
       - "8889:8889" # Prometheus metrics (spanmetrics + OTLP)
-      - "13133:13133" # Health check
       # StatsD UDP port removed — beast::insight now uses native OTLP.
       # Uncomment if using server=statsd fallback:
       # - "8125:8125/udp"
diff --git a/docker/telemetry/otel-collector-config.yaml b/docker/telemetry/otel-collector-config.yaml
index 76e88a4d20..c600b409df 100644
--- a/docker/telemetry/otel-collector-config.yaml
+++ b/docker/telemetry/otel-collector-config.yaml
@@ -2,7 +2,7 @@
 #
 # Pipelines:
 #   traces: OTLP receiver -> batch processor -> debug + Tempo + spanmetrics
-#   metrics: spanmetrics connector -> Prometheus exporter
+#   metrics: OTLP receiver + spanmetrics connector -> Prometheus exporter
 #
 # xrpld sends traces via OTLP/HTTP to port 4318. The collector batches
 # them, forwards to Tempo, and derives RED metrics via the spanmetrics
@@ -55,5 +55,5 @@ service:
       processors: [batch]
       exporters: [debug, otlp/tempo, spanmetrics]
     metrics:
-      receivers: [spanmetrics]
+      receivers: [otlp, spanmetrics]
       exporters: [prometheus]
diff --git a/docs/telemetry-runbook.md b/docs/telemetry-runbook.md
index 8c92e95cf0..3b22eca21d 100644
--- a/docs/telemetry-runbook.md
+++ b/docs/telemetry-runbook.md
@@ -294,7 +294,7 @@ prefix=xrpld
 
 The `OTelCollector` implementation exports metrics via OTLP/HTTP to the same OTel Collector that receives traces. No separate StatsD receiver is needed.
 
-> **Fallback**: Set `server=statsd` and `address=127.0.0.1:8125` to use the legacy StatsD UDP path during the transition period.
+> **Fallback**: Set `server=statsd` and `address=127.0.0.1:8125` to use the legacy StatsD UDP path. This requires re-enabling the `statsd` receiver in `otel-collector-config.yaml` and uncommenting port 8125 in `docker-compose.yml`.
 
 ### Metric Reference
 
diff --git a/include/xrpl/basics/Log.h b/include/xrpl/basics/Log.h
index 5c63166d93..58cca4f486 100644
--- a/include/xrpl/basics/Log.h
+++ b/include/xrpl/basics/Log.h
@@ -15,7 +15,6 @@
 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
@@ -208,8 +207,6 @@ 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 4432e27b4b..5855ee2017 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::scoped_lock>
+    template <template <typename...> typename LockType = std::lock_guard>
     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::scoped_lock>
+    template <template <typename...> typename LockType = std::lock_guard>
     Lock<ProtectedDataType, LockType, MutexType>
     lock()
     {
diff --git a/include/xrpl/basics/Number.h b/include/xrpl/basics/Number.h
index b82cb628b9..d14b17a042 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 class mantissa_scale { small, large };
+    enum 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 mantissa_scale::small:
+            case small:
                 return 1'000'000'000'000'000ULL;
-            case mantissa_scale::large:
+            case 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 class rounding_mode { to_nearest, towards_zero, downward, upward };
+    enum 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::mantissa_scale::small};
+    constexpr static MantissaRange smallRange{MantissaRange::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::mantissa_scale::large};
+    constexpr static MantissaRange largeRange{MantissaRange::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::mantissa_scale::small:
+        case MantissaRange::small:
             return "small";
-        case MantissaRange::mantissa_scale::large:
+        case MantissaRange::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 ddcc89d2da..39be029b42 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::scoped_lock const l(m_);
+                std::lock_guard const l(m_);
 
                 ret = l_;
 
@@ -121,7 +121,7 @@ class SlabAllocator
         {
             XRPL_ASSERT(own(ptr), "xrpl::SlabAllocator::SlabBlock::deallocate : own input");
 
-            std::scoped_lock const l(m_);
+            std::lock_guard 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 95703f0633..8cb0c6bfdf 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::scoped_lock<mutex_type> const& l);
+    initialFetch(key_type const& key, std::lock_guard<mutex_type> const& l);
 
     void
     collect_metrics();
@@ -266,7 +266,7 @@ private:
         typename KeyValueCacheType::map_type& partition,
         SweptPointersVector& stuffToSweep,
         std::atomic<int>& allRemovals,
-        std::scoped_lock<std::recursive_mutex> const&);
+        std::lock_guard<std::recursive_mutex> const&);
 
     [[nodiscard]] std::thread
     sweepHelper(
@@ -275,7 +275,7 @@ private:
         typename KeyOnlyCacheType::map_type& partition,
         SweptPointersVector&,
         std::atomic<int>& allRemovals,
-        std::scoped_lock<std::recursive_mutex> const&);
+        std::lock_guard<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 67c80b554e..6879ad435d 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::scoped_lock lock(m_mutex);
+    std::lock_guard 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::scoped_lock lock(m_mutex);
+    std::lock_guard 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::scoped_lock lock(m_mutex);
+    std::lock_guard lock(m_mutex);
     return m_cache.size();
 }
 
@@ -120,7 +120,7 @@ inline float
 TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
     getHitRate()
 {
-    std::scoped_lock lock(m_mutex);
+    std::lock_guard 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::scoped_lock lock(m_mutex);
+    std::lock_guard 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::scoped_lock lock(m_mutex);
+    std::lock_guard 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::scoped_lock lock(m_mutex);
+    std::lock_guard 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::scoped_lock lock(m_mutex);
+        std::lock_guard 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::scoped_lock lock(m_mutex);
+    std::lock_guard 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::scoped_lock lock(m_mutex);
+    std::lock_guard 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::scoped_lock<mutex_type> l(m_mutex);
+    std::lock_guard<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::scoped_lock lock(m_mutex);
+    std::lock_guard 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::scoped_lock lock(m_mutex);
+        std::lock_guard 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::scoped_lock lock(m_mutex);
+    std::lock_guard 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::scoped_lock l(m_mutex);
+        std::lock_guard 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::scoped_lock l(m_mutex);
+    std::lock_guard 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::scoped_lock<mutex_type> const& l)
+    initialFetch(key_type const& key, std::lock_guard<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::scoped_lock lock(m_mutex);
+            std::lock_guard 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::scoped_lock<std::recursive_mutex> const&)
+        std::lock_guard<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::scoped_lock<std::recursive_mutex> const&)
+        std::lock_guard<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 2722a5a4a7..3ff14c22c8 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::scoped_lock const lock(state.mutex);
+    std::lock_guard 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 a4018b7e5f..adf579442e 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::scoped_lock const lk(m);
+            std::lock_guard 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 f85f399196..dccb6d24b4 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::scoped_lock const lock(m_mutex);
+        std::lock_guard 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::scoped_lock const lock(m_mutex);
+        std::lock_guard 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::scoped_lock const lock(m_mutex);
+        std::lock_guard const lock(m_mutex);
         ++m_count;
     }
 
     void
     release()
     {
-        std::scoped_lock const lock(m_mutex);
+        std::lock_guard const lock(m_mutex);
         if (--m_count == 0)
             m_cond.notify_all();
     }
@@ -192,7 +192,7 @@ private:
             m_handler(elapsed);
 
             {
-                std::scoped_lock const lock(m_probe->m_mutex);
+                std::lock_guard const lock(m_probe->m_mutex);
                 if (m_probe->m_cancel)
                     return;
             }
diff --git a/include/xrpl/beast/insight/OTelCollector.h b/include/xrpl/beast/insight/OTelCollector.h
index 8c982a8856..8e59155998 100644
--- a/include/xrpl/beast/insight/OTelCollector.h
+++ b/include/xrpl/beast/insight/OTelCollector.h
@@ -49,7 +49,7 @@ namespace insight {
  * Replaces StatsD-based metric collection with native OTel Metrics SDK
  * instruments. Each beast::insight instrument maps to an OTel equivalent:
  *
- *   - Counter  -> OTel Counter<int64_t>
+ *   - Counter  -> OTel Counter<uint64_t>
  *   - Gauge    -> OTel ObservableGauge<int64_t> (async callback)
  *   - Event    -> OTel Histogram<double> (duration in milliseconds)
  *   - Meter    -> OTel Counter<uint64_t> (monotonic, unsigned)
diff --git a/include/xrpl/beast/test/yield_to.h b/include/xrpl/beast/test/yield_to.h
index 6c7f293122..4723fb49b8 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::scoped_lock const lock{m_};
+            std::lock_guard 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 dbafd67da5..084e2bc464 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 class mode_t {
+    enum 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_ == mode_t::automatch && pattern.empty())
-        mode_ = mode_t::all;
+    if (mode_ == automatch && pattern.empty())
+        mode_ = all;
 }
 
 template <class>
@@ -63,18 +63,18 @@ selector::operator()(suite_info const& s)
 {
     switch (mode_)
     {
-        case mode_t::automatch:
+        case automatch:
             // suite or full name
             if (s.name() == pat_ || s.full_name() == pat_)
             {
-                mode_ = mode_t::none;
+                mode_ = none;
                 return true;
             }
 
             // check module
             if (pat_ == s.module())
             {
-                mode_ = mode_t::module;
+                mode_ = module;
                 library_ = s.library();
                 return !s.manual();
             }
@@ -82,7 +82,7 @@ selector::operator()(suite_info const& s)
             // check library
             if (pat_ == s.library())
             {
-                mode_ = mode_t::library;
+                mode_ = library;
                 return !s.manual();
             }
 
@@ -96,19 +96,19 @@ selector::operator()(suite_info const& s)
 
             return false;
 
-        case mode_t::suite:
+        case suite:
             return pat_ == s.name();
 
-        case mode_t::module:
+        case module:
             return pat_ == s.module() && !s.manual();
 
-        case mode_t::library:
+        case library:
             return pat_ == s.library() && !s.manual();
 
-        case mode_t::none:
+        case none:
             return false;
 
-        case mode_t::all:
+        case all:
         default:
             break;
     };
@@ -138,28 +138,28 @@ selector::operator()(suite_info const& s)
 inline selector
 match_auto(std::string const& name)
 {
-    return selector(selector::mode_t::automatch, name);
+    return selector(selector::automatch, name);
 }
 
 /** Return a predicate that matches all suites not marked manual. */
 inline selector
 match_all()
 {
-    return selector(selector::mode_t::all);
+    return selector(selector::all);
 }
 
 /** Returns a predicate that matches a specific suite. */
 inline selector
 match_suite(std::string const& name)
 {
-    return selector(selector::mode_t::suite, name);
+    return selector(selector::suite, name);
 }
 
 /** Returns a predicate that matches all suites in a library. */
 inline selector
 match_library(std::string const& name)
 {
-    return selector(selector::mode_t::library, name);
+    return selector(selector::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 58bea93b2f..066d628ea2 100644
--- a/include/xrpl/beast/unit_test/reporter.h
+++ b/include/xrpl/beast/unit_test/reporter.h
@@ -62,8 +62,6 @@ 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 5601a8725f..2fdfbefa57 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::scoped_lock const lock(mutex_);
+    std::lock_guard 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::scoped_lock const lock(mutex_);
+    std::lock_guard const lock(mutex_);
     if (default_)
         testcase("");
     on_pass();
@@ -258,7 +258,7 @@ template <class>
 void
 runner::fail(std::string const& reason)
 {
-    std::scoped_lock const lock(mutex_);
+    std::lock_guard const lock(mutex_);
     if (default_)
         testcase("");
     on_fail(reason);
@@ -270,7 +270,7 @@ template <class>
 void
 runner::log(std::string const& s)
 {
-    std::scoped_lock const lock(mutex_);
+    std::lock_guard 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 c6967ecfe3..a7b9d3bacb 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 class abort_t { no_abort_on_fail, abort_on_fail };
+enum 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 = abort_t::no_abort_on_fail);
+        operator()(std::string const& name, abort_t abort = 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_t::abort_on_fail;
+    suite_.abort_ = abort == abort_on_fail;
     suite_.runner_->testcase(name);
 }
 
 inline suite::scoped_testcase
 suite::testcase_t::operator()(abort_t abort)
 {
-    suite_.abort_ = abort == abort_t::abort_on_fail;
+    suite_.abort_ = abort == abort_on_fail;
     return {suite_, ss_};
 }
 
diff --git a/include/xrpl/beast/utility/Journal.h b/include/xrpl/beast/utility/Journal.h
index 45b7b671cb..a056ce8d79 100644
--- a/include/xrpl/beast/utility/Journal.h
+++ b/include/xrpl/beast/utility/Journal.h
@@ -9,8 +9,6 @@ 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 76e52cb3cd..bcdfa7d673 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::scoped_lock const lock{mutex_};
+        std::lock_guard 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::scoped_lock const lock{mutex_};
+        std::lock_guard const lock{mutex_};
         if (!waitForClosures_)
             ret.emplace(*this, std::forward<Closure>(closure));
 
@@ -193,7 +193,7 @@ public:
     bool
     joined() const
     {
-        std::scoped_lock const lock{mutex_};
+        std::lock_guard const lock{mutex_};
         return waitForClosures_;
     }
 };
diff --git a/include/xrpl/core/Coro.ipp b/include/xrpl/core/Coro.ipp
index 2343f805a5..38d921a658 100644
--- a/include/xrpl/core/Coro.ipp
+++ b/include/xrpl/core/Coro.ipp
@@ -34,7 +34,7 @@ inline void
 JobQueue::Coro::yield() const
 {
     {
-        std::scoped_lock lock(jq_.m_mutex);
+        std::lock_guard lock(jq_.m_mutex);
         ++jq_.nSuspend_;
     }
     (*yield_)();
@@ -44,7 +44,7 @@ inline bool
 JobQueue::Coro::post()
 {
     {
-        std::scoped_lock lk(mutex_run_);
+        std::lock_guard lk(mutex_run_);
         running_ = true;
     }
 
@@ -55,7 +55,7 @@ JobQueue::Coro::post()
     }
 
     // The coroutine will not run.  Clean up running_.
-    std::scoped_lock lk(mutex_run_);
+    std::lock_guard lk(mutex_run_);
     running_ = false;
     cv_.notify_all();
     return false;
@@ -65,16 +65,16 @@ inline void
 JobQueue::Coro::resume()
 {
     {
-        std::scoped_lock lk(mutex_run_);
+        std::lock_guard lk(mutex_run_);
         running_ = true;
     }
     {
-        std::scoped_lock lk(jq_.m_mutex);
+        std::lock_guard lk(jq_.m_mutex);
         --jq_.nSuspend_;
     }
     auto saved = detail::getLocalValues().release();
     detail::getLocalValues().reset(&lvs_);
-    std::scoped_lock lock(mutex_);
+    std::lock_guard 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::scoped_lock lk(mutex_run_);
+    std::lock_guard 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::scoped_lock lock(jq_.m_mutex);
+        std::lock_guard 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 2fe5ab263c..9954fc4ba4 100644
--- a/include/xrpl/core/Job.h
+++ b/include/xrpl/core/Job.h
@@ -11,8 +11,6 @@ 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 80ad7196c3..0d107e879c 100644
--- a/include/xrpl/core/PeerReservationTable.h
+++ b/include/xrpl/core/PeerReservationTable.h
@@ -67,7 +67,7 @@ public:
     bool
     contains(PublicKey const& nodeId)
     {
-        std::scoped_lock const lock(this->mutex_);
+        std::lock_guard 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 38b7329ab1..b3bee00588 100644
--- a/include/xrpl/core/detail/semaphore.h
+++ b/include/xrpl/core/detail/semaphore.h
@@ -55,7 +55,7 @@ public:
     void
     notify()
     {
-        std::scoped_lock const lock{m_mutex};
+        std::lock_guard const lock{m_mutex};
         ++m_count;
         m_cond.notify_one();
     }
@@ -76,7 +76,7 @@ public:
     bool
     try_wait()
     {
-        std::scoped_lock lock{m_mutex};
+        std::lock_guard 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 34c4e8458a..e348e57825 100644
--- a/include/xrpl/json/Writer.h
+++ b/include/xrpl/json/Writer.h
@@ -107,7 +107,7 @@ namespace Json {
 class Writer
 {
 public:
-    enum class CollectionType { array, object };
+    enum 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 543f0cfb9c..d53569fb33 100644
--- a/include/xrpl/json/json_reader.h
+++ b/include/xrpl/json/json_reader.h
@@ -70,8 +70,6 @@ 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 def2696c5c..83b5142b27 100644
--- a/include/xrpl/json/json_value.h
+++ b/include/xrpl/json/json_value.h
@@ -15,8 +15,6 @@ 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
@@ -149,8 +147,6 @@ 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);
@@ -475,8 +471,6 @@ 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 0aea9813b9..bd38b57a58 100644
--- a/include/xrpl/ledger/ApplyView.h
+++ b/include/xrpl/ledger/ApplyView.h
@@ -7,8 +7,6 @@
 
 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 a18292df68..ff70d48bb9 100644
--- a/include/xrpl/ledger/PendingSaves.h
+++ b/include/xrpl/ledger/PendingSaves.h
@@ -31,7 +31,7 @@ public:
     bool
     startWork(LedgerIndex seq)
     {
-        std::scoped_lock const lock(mutex_);
+        std::lock_guard const lock(mutex_);
 
         auto it = map_.find(seq);
 
@@ -54,7 +54,7 @@ public:
     void
     finishWork(LedgerIndex seq)
     {
-        std::scoped_lock const lock(mutex_);
+        std::lock_guard const lock(mutex_);
 
         map_.erase(seq);
         await_.notify_all();
@@ -64,7 +64,7 @@ public:
     bool
     pending(LedgerIndex seq)
     {
-        std::scoped_lock const lock(mutex_);
+        std::lock_guard const lock(mutex_);
         return map_.contains(seq);
     }
 
@@ -117,7 +117,7 @@ public:
     std::map<LedgerIndex, bool>
     getSnapshot() const
     {
-        std::scoped_lock const lock(mutex_);
+        std::lock_guard const lock(mutex_);
 
         return map_;
     }
diff --git a/include/xrpl/ledger/helpers/AMMHelpers.h b/include/xrpl/ledger/helpers/AMMHelpers.h
index 9258d58fb6..d261f9e018 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::rounding_mode::towards_zero);
+    NumberRoundModeGuard const mg(Number::towards_zero);
     return amount * reducedOfferPct;
 }
 
@@ -180,7 +180,7 @@ getAMMOfferStartWithTakerGets(
     if (targetQuality.rate() == beast::zero)
         return std::nullopt;
 
-    NumberRoundModeGuard const mg(Number::rounding_mode::to_nearest);
+    NumberRoundModeGuard const mg(Number::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::rounding_mode::downward);
+            toAmount<TOut>(getAsset(pool.out), nTakerGetsProposed, Number::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::rounding_mode::to_nearest);
+    NumberRoundModeGuard const mg(Number::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::rounding_mode::downward);
+            toAmount<TIn>(getAsset(pool.in), nTakerPaysProposed, Number::downward);
         return TAmounts<TIn, TOut>{takerPays, swapAssetIn(pool, takerPays, tfee)};
     };
 
@@ -341,8 +341,7 @@ changeSpotPriceQuality(
                                 << " " << to_string(pool.out) << " " << quality << " " << tfee;
                 return std::nullopt;
             }
-            auto const takerPays =
-                toAmount<TIn>(getAsset(pool.in), nTakerPays, Number::rounding_mode::upward);
+            auto const takerPays = toAmount<TIn>(getAsset(pool.in), nTakerPays, Number::upward);
             // should not fail
             if (auto amounts = TAmounts<TIn, TOut>{takerPays, swapAssetIn(pool, takerPays, tfee)};
                 Quality{amounts} < quality &&
@@ -448,32 +447,32 @@ swapAssetIn(TAmounts<TIn, TOut> const& pool, TIn const& assetIn, std::uint16_t t
         // fee
         saveNumberRoundMode const _{Number::getround()};
 
-        Number::setround(Number::rounding_mode::upward);
+        Number::setround(Number::upward);
         auto const numerator = pool.in * pool.out;
         auto const fee = getFee(tfee);
 
-        Number::setround(Number::rounding_mode::downward);
+        Number::setround(Number::downward);
         auto const denom = pool.in + assetIn * (1 - fee);
 
         if (denom.signum() <= 0)
             return toAmount<TOut>(getAsset(pool.out), 0);
 
-        Number::setround(Number::rounding_mode::upward);
+        Number::setround(Number::upward);
         auto const ratio = numerator / denom;
 
-        Number::setround(Number::rounding_mode::downward);
+        Number::setround(Number::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::rounding_mode::downward);
+        return toAmount<TOut>(getAsset(pool.out), swapOut, Number::downward);
     }
 
     return toAmount<TOut>(
         getAsset(pool.out),
         pool.out - (pool.in * pool.out) / (pool.in + assetIn * feeMult(tfee)),
-        Number::rounding_mode::downward);
+        Number::downward);
 }
 
 /** Swap assetOut out of the pool and swap in a proportional amount
@@ -510,36 +509,36 @@ swapAssetOut(TAmounts<TIn, TOut> const& pool, TOut const& assetOut, std::uint16_
 
         saveNumberRoundMode const _{Number::getround()};
 
-        Number::setround(Number::rounding_mode::upward);
+        Number::setround(Number::upward);
         auto const numerator = pool.in * pool.out;
 
-        Number::setround(Number::rounding_mode::downward);
+        Number::setround(Number::downward);
         auto const denom = pool.out - assetOut;
         if (denom.signum() <= 0)
         {
             return toMaxAmount<TIn>(getAsset(pool.in));
         }
 
-        Number::setround(Number::rounding_mode::upward);
+        Number::setround(Number::upward);
         auto const ratio = numerator / denom;
         auto const numerator2 = ratio - pool.in;
         auto const fee = getFee(tfee);
 
-        Number::setround(Number::rounding_mode::downward);
+        Number::setround(Number::downward);
         auto const feeMult = 1 - fee;
 
-        Number::setround(Number::rounding_mode::upward);
+        Number::setround(Number::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::rounding_mode::upward);
+        return toAmount<TIn>(getAsset(pool.in), swapIn, Number::upward);
     }
 
     return toAmount<TIn>(
         getAsset(pool.in),
         ((pool.in * pool.out) / (pool.out - assetOut) - pool.in) / feeMult(tfee),
-        Number::rounding_mode::upward);
+        Number::upward);
 }
 
 /** Return square of n.
@@ -598,8 +597,7 @@ getLPTokenRounding(IsDeposit isDeposit)
 {
     // Minimize on deposit, maximize on withdraw to ensure
     // AMM invariant sqrt(poolAsset1 * poolAsset2) >= LPTokensBalance
-    return isDeposit == IsDeposit::Yes ? Number::rounding_mode::downward
-                                       : Number::rounding_mode::upward;
+    return isDeposit == IsDeposit::Yes ? Number::downward : Number::upward;
 }
 
 inline Number::rounding_mode
@@ -607,8 +605,7 @@ getAssetRounding(IsDeposit isDeposit)
 {
     // Maximize on deposit, minimize on withdraw to ensure
     // AMM invariant sqrt(poolAsset1 * poolAsset2) >= LPTokensBalance
-    return isDeposit == IsDeposit::Yes ? Number::rounding_mode::upward
-                                       : Number::rounding_mode::downward;
+    return isDeposit == IsDeposit::Yes ? Number::upward : Number::downward;
 }
 
 }  // namespace detail
diff --git a/include/xrpl/ledger/helpers/LendingHelpers.h b/include/xrpl/ledger/helpers/LendingHelpers.h
index e1d8626b7c..23b87de654 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::rounding_mode::upward);
+    return roundToAsset(asset, periodicPayment, scale, Number::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 8f83465da3..c05308295a 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 class FreezeHandling { fhIGNORE_FREEZE, fhZERO_IF_FROZEN };
+enum FreezeHandling { fhIGNORE_FREEZE, fhZERO_IF_FROZEN };
 
 /** Controls the treatment of unauthorized MPT balances */
-enum class AuthHandling { ahIGNORE_AUTH, ahZERO_IF_UNAUTHORIZED };
+enum AuthHandling { ahIGNORE_AUTH, ahZERO_IF_UNAUTHORIZED };
 
 /** Controls whether to include the account's full spendable balance */
-enum class SpendableHandling { shSIMPLE_BALANCE, shFULL_BALANCE };
+enum 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 = SpendableHandling::shSIMPLE_BALANCE);
+    SpendableHandling includeFullBalance = shSIMPLE_BALANCE);
 
 [[nodiscard]] STAmount
 accountHolds(
@@ -144,7 +144,7 @@ accountHolds(
     Issue const& issue,
     FreezeHandling zeroIfFrozen,
     beast::Journal j,
-    SpendableHandling includeFullBalance = SpendableHandling::shSIMPLE_BALANCE);
+    SpendableHandling includeFullBalance = shSIMPLE_BALANCE);
 
 [[nodiscard]] STAmount
 accountHolds(
@@ -154,7 +154,7 @@ accountHolds(
     FreezeHandling zeroIfFrozen,
     AuthHandling zeroIfUnauthorized,
     beast::Journal j,
-    SpendableHandling includeFullBalance = SpendableHandling::shSIMPLE_BALANCE);
+    SpendableHandling includeFullBalance = shSIMPLE_BALANCE);
 
 [[nodiscard]] STAmount
 accountHolds(
@@ -164,7 +164,7 @@ accountHolds(
     FreezeHandling zeroIfFrozen,
     AuthHandling zeroIfUnauthorized,
     beast::Journal j,
-    SpendableHandling includeFullBalance = SpendableHandling::shSIMPLE_BALANCE);
+    SpendableHandling includeFullBalance = 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 8759f244d2..6397ea2e4e 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 class NodeObjectType : std::uint32_t {
+enum 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 cc7d345067..851cbcfb8b 100644
--- a/include/xrpl/nodestore/Types.h
+++ b/include/xrpl/nodestore/Types.h
@@ -6,8 +6,6 @@
 
 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.
@@ -22,7 +20,7 @@ enum {
 };
 
 /** Return codes from Backend operations. */
-enum class Status {
+enum Status {
     ok = 0,
     notFound = 1,
     dataCorrupt = 2,
diff --git a/include/xrpl/nodestore/detail/codec.h b/include/xrpl/nodestore/detail/codec.h
index e127062b80..c159558f83 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, static_cast<std::uint8_t>(NodeObjectType::hotUNKNOWN));
+            write<std::uint8_t>(os, 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, static_cast<std::uint8_t>(NodeObjectType::hotUNKNOWN));
+            write<std::uint8_t>(os, 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, static_cast<std::uint8_t>(NodeObjectType::hotUNKNOWN));
+            write<std::uint8_t>(os, hotUNKNOWN);
         }
     }
 }
diff --git a/include/xrpl/protocol/ErrorCodes.h b/include/xrpl/protocol/ErrorCodes.h
index ed7f898312..2f16415bdf 100644
--- a/include/xrpl/protocol/ErrorCodes.h
+++ b/include/xrpl/protocol/ErrorCodes.h
@@ -17,8 +17,6 @@ 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,
@@ -150,8 +148,6 @@ 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 77ef9fcf1d..009a96533a 100644
--- a/include/xrpl/protocol/LedgerFormats.h
+++ b/include/xrpl/protocol/LedgerFormats.h
@@ -29,8 +29,6 @@ namespace xrpl {
 
     @ingroup protocol
 */
-// Protocol-critical, hundreds of usages
-// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
 enum LedgerEntryType : std::uint16_t {
 
 #pragma push_macro("LEDGER_ENTRY")
@@ -216,8 +214,6 @@ 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 6b0c799a56..6a86aa35b8 100644
--- a/include/xrpl/protocol/MultiApiJson.h
+++ b/include/xrpl/protocol/MultiApiJson.h
@@ -66,7 +66,8 @@ struct MultiApiJson
             a[key] = v;
     }
 
-    enum class IsMemberResult : int { none = 0, some, all };
+    // Intentionally not using class enum here, MultivarJson is scope enough
+    enum IsMemberResult : int { none = 0, some, all };
 
     [[nodiscard]] IsMemberResult
     isMember(char const* key) const
@@ -79,8 +80,8 @@ struct MultiApiJson
         }
 
         if (count == 0)
-            return IsMemberResult::none;
-        return count < size ? IsMemberResult::some : IsMemberResult::all;
+            return none;
+        return count < size ? some : all;
     }
 
     static constexpr struct visitor_t final
diff --git a/include/xrpl/protocol/Permissions.h b/include/xrpl/protocol/Permissions.h
index 3ce8918a16..4d26ba7cf8 100644
--- a/include/xrpl/protocol/Permissions.h
+++ b/include/xrpl/protocol/Permissions.h
@@ -16,8 +16,6 @@ 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
@@ -30,9 +28,6 @@ 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 784de5511e..7e42b9ec62 100644
--- a/include/xrpl/protocol/SField.h
+++ b/include/xrpl/protocol/SField.h
@@ -87,8 +87,6 @@ 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)};
@@ -127,8 +125,6 @@ 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 3bfe07d049..ca09fc3d71 100644
--- a/include/xrpl/protocol/SOTemplate.h
+++ b/include/xrpl/protocol/SOTemplate.h
@@ -11,8 +11,6 @@
 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
@@ -22,8 +20,7 @@ enum SOEStyle {
                       // constructed with STObject::makeInnerObject()
 };
 
-// Part of a Python-parsed DSL (transactions.macro); bare enumerator names required by the parser
-// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
+/** Amount fields that can support MPT */
 enum SOETxMPTIssue { soeMPTNone, soeMPTSupported, soeMPTNotSupported };
 
 //------------------------------------------------------------------------------
diff --git a/include/xrpl/protocol/STAmount.h b/include/xrpl/protocol/STAmount.h
index f681f811b7..06471df5c9 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::mantissa_scale::small)
+    if (Number::getMantissaScale() == MantissaRange::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 7ebf22fe8f..0beefe45f6 100644
--- a/include/xrpl/protocol/STBase.h
+++ b/include/xrpl/protocol/STBase.h
@@ -18,8 +18,6 @@ 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 187bde6dae..d27112e17c 100644
--- a/include/xrpl/protocol/STObject.h
+++ b/include/xrpl/protocol/STObject.h
@@ -413,9 +413,9 @@ public:
     class FieldErr;
 
 private:
-    enum class WhichFields : bool {
+    enum WhichFields : bool {
         // These values are carefully chosen to do the right thing if passed
-        // to SField::shouldInclude (bool) via static_cast<bool>
+        // to SField::shouldInclude (bool)
         omitSigningFields = false,
         withAllFields = true
     };
@@ -987,7 +987,7 @@ STObject::isFree() const
 inline void
 STObject::addWithoutSigningFields(Serializer& s) const
 {
-    add(s, WhichFields::omitSigningFields);
+    add(s, 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, WhichFields::withAllFields);
+    add(s, withAllFields);
     return s;
 }
 
diff --git a/include/xrpl/protocol/STPathSet.h b/include/xrpl/protocol/STPathSet.h
index ce9a73523c..38f4668b5d 100644
--- a/include/xrpl/protocol/STPathSet.h
+++ b/include/xrpl/protocol/STPathSet.h
@@ -25,8 +25,6 @@ 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 820004681d..86742bacc1 100644
--- a/include/xrpl/protocol/SeqProxy.h
+++ b/include/xrpl/protocol/SeqProxy.h
@@ -35,7 +35,7 @@ namespace xrpl {
 class SeqProxy
 {
 public:
-    enum class Type : std::uint8_t { seq = 0, ticket };
+    enum Type : std::uint8_t { seq = 0, ticket };
 
 private:
     std::uint32_t value_;
@@ -67,13 +67,13 @@ public:
     [[nodiscard]] constexpr bool
     isSeq() const
     {
-        return type_ == Type::seq;
+        return type_ == seq;
     }
 
     [[nodiscard]] constexpr bool
     isTicket() const
     {
-        return type_ == Type::ticket;
+        return 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 6494453b91..efec25962d 100644
--- a/include/xrpl/protocol/TER.h
+++ b/include/xrpl/protocol/TER.h
@@ -19,8 +19,6 @@ 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:
@@ -52,8 +50,6 @@ 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:
@@ -130,8 +126,6 @@ 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:
@@ -176,8 +170,6 @@ 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:
@@ -222,8 +214,6 @@ 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.
@@ -239,8 +229,6 @@ 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 235fb7b16e..563a28f39f 100644
--- a/include/xrpl/protocol/TxFormats.h
+++ b/include/xrpl/protocol/TxFormats.h
@@ -35,8 +35,6 @@ 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_autogen/LedgerEntryBase.h b/include/xrpl/protocol_autogen/LedgerEntryBase.h
index ad513992c7..0c5b367391 100644
--- a/include/xrpl/protocol_autogen/LedgerEntryBase.h
+++ b/include/xrpl/protocol_autogen/LedgerEntryBase.h
@@ -130,19 +130,6 @@ public:
         return sle_->at(sfFlags);
     }
 
-    /**
-     * @brief Check if a specific flag is set.
-     *
-     * @param f The flag bitmask to check
-     * @return true if all bits in f are set in the flags field
-     */
-    [[nodiscard]]
-    bool
-    isFlag(std::uint32_t f) const
-    {
-        return sle_->isFlag(f);
-    }
-
     /**
      * @brief Get the underlying SLE object.
      *
diff --git a/include/xrpl/resource/Disposition.h b/include/xrpl/resource/Disposition.h
index 59a1c3840a..22830ad470 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 class Disposition {
+enum Disposition {
     /** No action required. */
     ok
 
diff --git a/include/xrpl/resource/detail/Entry.h b/include/xrpl/resource/detail/Entry.h
index 2cbf06d5c3..89f27b2672 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 == Kind::kindUnlimited;
+        return key->kind == kindUnlimited;
     }
 
     // Balance including remote contributions
diff --git a/include/xrpl/resource/detail/Kind.h b/include/xrpl/resource/detail/Kind.h
index 5cbddce6bb..74115ba7f1 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 class Kind { kindInbound, kindOutbound, kindUnlimited };
+enum Kind { kindInbound, kindOutbound, kindUnlimited };
 
 }  // namespace xrpl::Resource
diff --git a/include/xrpl/resource/detail/Logic.h b/include/xrpl/resource/detail/Logic.h
index 3102a1f119..b775f0a965 100644
--- a/include/xrpl/resource/detail/Logic.h
+++ b/include/xrpl/resource/detail/Logic.h
@@ -92,11 +92,11 @@ public:
         Entry* entry(nullptr);
 
         {
-            std::scoped_lock const _(lock_);
+            std::lock_guard const _(lock_);
             auto [resultIt, resultInserted] = table_.emplace(
                 std::piecewise_construct,
-                std::make_tuple(Kind::kindInbound, address.at_port(0)),  // Key
-                std::make_tuple(m_clock.now()));                         // Entry
+                std::make_tuple(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::scoped_lock const _(lock_);
+            std::lock_guard const _(lock_);
             auto [resultIt, resultInserted] = table_.emplace(
                 std::piecewise_construct,
-                std::make_tuple(Kind::kindOutbound, address),  // Key
-                std::make_tuple(m_clock.now()));               // Entry
+                std::make_tuple(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::scoped_lock const _(lock_);
+            std::lock_guard const _(lock_);
             auto [resultIt, resultInserted] = table_.emplace(
                 std::piecewise_construct,
-                std::make_tuple(Kind::kindUnlimited, address.at_port(1)),  // Key
-                std::make_tuple(m_clock.now()));                           // Entry
+                std::make_tuple(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::scoped_lock const _(lock_);
+        std::lock_guard const _(lock_);
 
         for (auto& inboundEntry : inbound_)
         {
@@ -235,7 +235,7 @@ public:
         clock_type::time_point const now(m_clock.now());
 
         Gossip gossip;
-        std::scoped_lock const _(lock_);
+        std::lock_guard const _(lock_);
 
         gossip.items.reserve(inbound_.size());
 
@@ -260,7 +260,7 @@ public:
     {
         auto const elapsed = m_clock.now();
         {
-            std::scoped_lock const _(lock_);
+            std::lock_guard const _(lock_);
             auto [resultIt, resultInserted] = importTable_.emplace(
                 std::piecewise_construct,
                 std::make_tuple(origin),                                     // Key
@@ -317,7 +317,7 @@ public:
     void
     periodicActivity()
     {
-        std::scoped_lock const _(lock_);
+        std::lock_guard const _(lock_);
 
         auto const elapsed = m_clock.now();
 
@@ -375,7 +375,7 @@ public:
     void
     erase(Table::iterator iter)
     {
-        std::scoped_lock const _(lock_);
+        std::lock_guard 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::scoped_lock const _(lock_);
+        std::lock_guard const _(lock_);
         ++entry.refcount;
     }
 
     void
     release(Entry& entry)
     {
-        std::scoped_lock const _(lock_);
+        std::lock_guard const _(lock_);
         if (--entry.refcount == 0)
         {
             JLOG(m_journal.debug()) << "Inactive " << entry;
 
             switch (entry.key->kind)
             {
-                case Kind::kindInbound:
+                case kindInbound:
                     inbound_.erase(inbound_.iterator_to(entry));
                     break;
-                case Kind::kindOutbound:
+                case kindOutbound:
                     outbound_.erase(outbound_.iterator_to(entry));
                     break;
-                case Kind::kindUnlimited:
+                case kindUnlimited:
                     admin_.erase(admin_.iterator_to(entry));
                     break;
                 default:
@@ -443,7 +443,7 @@ public:
         if (!context.empty())
             context = " (" + context + ")";
 
-        std::scoped_lock const _(lock_);
+        std::lock_guard 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::scoped_lock const _(lock_);
+        std::lock_guard 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::scoped_lock const _(lock_);
+        std::lock_guard 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::scoped_lock const _(lock_);
+        std::lock_guard const _(lock_);
         return entry.balance(m_clock.now());
     }
 
@@ -530,7 +530,7 @@ public:
     {
         clock_type::time_point const now(m_clock.now());
 
-        std::scoped_lock const _(lock_);
+        std::lock_guard 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 d5e872d16c..1c903d8cd4 100644
--- a/include/xrpl/resource/detail/Tuning.h
+++ b/include/xrpl/resource/detail/Tuning.h
@@ -5,8 +5,6 @@
 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 e54ea4d280..6b9e96241c 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::scoped_lock const sl(lock_);
+        std::lock_guard const sl(lock_);
         remoteTxnLoadFee_ = f;
     }
 
     std::uint32_t
     getRemoteFee() const
     {
-        std::scoped_lock const sl(lock_);
+        std::lock_guard const sl(lock_);
         return remoteTxnLoadFee_;
     }
 
     std::uint32_t
     getLocalFee() const
     {
-        std::scoped_lock const sl(lock_);
+        std::lock_guard const sl(lock_);
         return localTxnLoadFee_;
     }
 
     std::uint32_t
     getClusterFee() const
     {
-        std::scoped_lock const sl(lock_);
+        std::lock_guard const sl(lock_);
         return clusterTxnLoadFee_;
     }
 
@@ -69,14 +69,14 @@ public:
     std::uint32_t
     getLoadFactor() const
     {
-        std::scoped_lock const sl(lock_);
+        std::lock_guard const sl(lock_);
         return std::max({clusterTxnLoadFee_, localTxnLoadFee_, remoteTxnLoadFee_});
     }
 
     std::pair<std::uint32_t, std::uint32_t>
     getScalingFactors() const
     {
-        std::scoped_lock const sl(lock_);
+        std::lock_guard 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::scoped_lock const sl(lock_);
+        std::lock_guard const sl(lock_);
         clusterTxnLoadFee_ = fee;
     }
 
@@ -99,14 +99,14 @@ public:
     bool
     isLoadedLocal() const
     {
-        std::scoped_lock const sl(lock_);
+        std::lock_guard const sl(lock_);
         return (raiseCount_ != 0) || (localTxnLoadFee_ != lftNormalFee);
     }
 
     bool
     isLoadedCluster() const
     {
-        std::scoped_lock const sl(lock_);
+        std::lock_guard 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 31820402ab..a0f8e1f318 100644
--- a/include/xrpl/server/detail/BaseHTTPPeer.h
+++ b/include/xrpl/server/detail/BaseHTTPPeer.h
@@ -38,8 +38,6 @@ 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,
@@ -305,7 +303,7 @@ BaseHTTPPeer<Handler, Impl>::on_write(error_code const& ec, std::size_t bytes_tr
         return fail(ec, "write");
     bytes_out_ += bytes_transferred;
     {
-        std::scoped_lock const lock(mutex_);
+        std::lock_guard const lock(mutex_);
         wq2_.clear();
         wq2_.reserve(wq_.size());
         std::swap(wq2_, wq_);
@@ -397,7 +395,7 @@ BaseHTTPPeer<Handler, Impl>::write(void const* buf, std::size_t bytes)
     if (bytes == 0)
         return;
     if ([&] {
-            std::scoped_lock const lock(mutex_);
+            std::lock_guard const lock(mutex_);
             wq_.emplace_back(buf, bytes);
             return wq_.size() == 1 && wq2_.size() == 0;
         }())
@@ -451,7 +449,7 @@ BaseHTTPPeer<Handler, Impl>::complete()
     complete_ = true;
 
     {
-        std::scoped_lock const lock(mutex_);
+        std::lock_guard const lock(mutex_);
         if (!wq_.empty() && !wq2_.empty())
             return;
     }
@@ -486,7 +484,7 @@ BaseHTTPPeer<Handler, Impl>::close(bool graceful)
     {
         graceful_ = true;
         {
-            std::scoped_lock const lock(mutex_);
+            std::lock_guard 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 2c3a8330e1..14d2b56fe4 100644
--- a/include/xrpl/server/detail/ServerImpl.h
+++ b/include/xrpl/server/detail/ServerImpl.h
@@ -62,8 +62,6 @@ 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 67e04d04b6..8c25a89f79 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::scoped_lock const lock(ios_->m_);
+        std::lock_guard 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::scoped_lock const lock(m_);
+    std::lock_guard const lock(m_);
     if (!closed_)
     {
         ++n_;
diff --git a/include/xrpl/shamap/FullBelowCache.h b/include/xrpl/shamap/FullBelowCache.h
index e17a640672..6a6da1463a 100644
--- a/include/xrpl/shamap/FullBelowCache.h
+++ b/include/xrpl/shamap/FullBelowCache.h
@@ -22,8 +22,6 @@ 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 918bbe5da6..e20ac70850 100644
--- a/include/xrpl/tx/Transactor.h
+++ b/include/xrpl/tx/Transactor.h
@@ -123,8 +123,6 @@ 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 dc4140956c..4f857bb7c1 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 class Category {
+    enum 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 44131167b6..684e40c8cf 100644
--- a/include/xrpl/tx/invariants/InvariantCheckPrivilege.h
+++ b/include/xrpl/tx/invariants/InvariantCheckPrivilege.h
@@ -25,8 +25,6 @@ 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 7f405814e7..e3aa06016a 100644
--- a/include/xrpl/tx/invariants/MPTInvariant.h
+++ b/include/xrpl/tx/invariants/MPTInvariant.h
@@ -35,10 +35,10 @@ public:
  */
 class ValidMPTPayment
 {
-    enum class Order { Before = 0, After = 1 };
+    enum Order { Before = 0, After = 1 };
     struct MPTData
     {
-        std::array<std::int64_t, 2> outstanding{};
+        std::array<std::int64_t, After + 1> 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 9b37f06ca9..b4d9d6e0b4 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 class OfferCrossing { no = 0, yes = 1, sell = 2 };
+enum 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 03ec9cc871..ee23de27b3 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 != OfferCrossing::no && limitQuality)
+            if (offerCrossing && limitQuality)
             {
                 auto const strandQ = qualityUpperBound(sb, *strand);
                 if (!strandQ || *strandQ < *limitQuality)
@@ -797,8 +797,7 @@ flow(
             // fixFillOrKill amendment:
             //   That case is handled here if tfSell is also not set; i.e,
             //   case 1.
-            if (offerCrossing == OfferCrossing::no ||
-                (fillOrKillEnabled && offerCrossing != OfferCrossing::sell))
+            if (!offerCrossing || (fillOrKillEnabled && offerCrossing != OfferCrossing::sell))
                 return {tecPATH_PARTIAL, actualIn, actualOut, std::move(ofrsToRmOnFail)};
         }
         else if (actualOut == beast::zero)
@@ -806,7 +805,7 @@ flow(
             return {tecPATH_DRY, std::move(ofrsToRmOnFail)};
         }
     }
-    if (offerCrossing != OfferCrossing::no &&
+    if (offerCrossing &&
         (!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 12419076e3..1f1a68ccc8 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 class Operation { unknown, set, destroy };
-    Operation do_{Operation::unknown};
+    enum Operation { unknown, set, destroy };
+    Operation do_{unknown};
     std::uint32_t quorum_{0};
     std::vector<SignerEntries::SignerEntry> signers_;
 
diff --git a/include/xrpl/tx/transactors/system/LedgerStateFix.h b/include/xrpl/tx/transactors/system/LedgerStateFix.h
index da3cb33398..a236a52c74 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 class FixType : std::uint16_t {
+    enum FixType : std::uint16_t {
         nfTokenPageLink = 1,
     };
 
diff --git a/src/libxrpl/basics/Log.cpp b/src/libxrpl/basics/Log.cpp
index bc56e68bfa..cff2f71be6 100644
--- a/src/libxrpl/basics/Log.cpp
+++ b/src/libxrpl/basics/Log.cpp
@@ -125,7 +125,7 @@ Logs::open(boost::filesystem::path const& pathToLogFile)
 beast::Journal::Sink&
 Logs::get(std::string const& name)
 {
-    std::scoped_lock const lock(mutex_);
+    std::lock_guard const lock(mutex_);
     auto const result = sinks_.emplace(name, makeSink(name, thresh_));
     return *result.first->second;
 }
@@ -151,7 +151,7 @@ Logs::threshold() const
 void
 Logs::threshold(beast::severities::Severity thresh)
 {
-    std::scoped_lock const lock(mutex_);
+    std::lock_guard const lock(mutex_);
     thresh_ = thresh;
     for (auto& sink : sinks_)
         sink.second->threshold(thresh);
@@ -161,7 +161,7 @@ std::vector<std::pair<std::string, std::string>>
 Logs::partition_severities() const
 {
     std::vector<std::pair<std::string, std::string>> list;
-    std::scoped_lock const lock(mutex_);
+    std::lock_guard const lock(mutex_);
     list.reserve(sinks_.size());
     for (auto const& [name, sink] : sinks_)
         list.emplace_back(name, toString(fromSeverity(sink->threshold())));
@@ -177,7 +177,7 @@ Logs::write(
 {
     std::string s;
     format(s, text, level, partition);
-    std::scoped_lock const lock(mutex_);
+    std::lock_guard const lock(mutex_);
     file_.writeln(s);
     if (!silent_)
         std::cerr << s << '\n';
@@ -189,7 +189,7 @@ Logs::write(
 std::string
 Logs::rotate()
 {
-    std::scoped_lock const lock(mutex_);
+    std::lock_guard const lock(mutex_);
     bool const wasOpened = file_.closeAndReopen();
     if (wasOpened)
         return "The log file was closed and reopened.";
@@ -445,7 +445,7 @@ public:
     std::unique_ptr<beast::Journal::Sink>
     set(std::unique_ptr<beast::Journal::Sink> sink)
     {
-        std::scoped_lock const _(m_);
+        std::lock_guard const _(m_);
 
         using std::swap;
         swap(holder_, sink);
@@ -465,7 +465,7 @@ public:
     beast::Journal::Sink&
     get()
     {
-        std::scoped_lock const _(m_);
+        std::lock_guard const _(m_);
         return sink_.get();
     }
 };
diff --git a/src/libxrpl/basics/Number.cpp b/src/libxrpl/basics/Number.cpp
index ba444b77e0..3b2b8670cb 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::rounding_mode::to_nearest;
+thread_local Number::rounding_mode Number::mode_ = Number::to_nearest;
 thread_local std::reference_wrapper<MantissaRange const> Number::range_ = largeRange;
 
 Number::rounding_mode
@@ -51,10 +51,9 @@ Number::getMantissaScale()
 void
 Number::setMantissaScale(MantissaRange::mantissa_scale scale)
 {
-    if (scale != MantissaRange::mantissa_scale::small &&
-        scale != MantissaRange::mantissa_scale::large)
+    if (scale != MantissaRange::small && scale != MantissaRange::large)
         LogicError("Unknown mantissa scale");
-    range_ = scale == MantissaRange::mantissa_scale::small ? smallRange : largeRange;
+    range_ = scale == MantissaRange::small ? smallRange : largeRange;
 }
 
 // Guard
@@ -177,10 +176,10 @@ Number::Guard::round() const noexcept
 {
     auto mode = Number::getround();
 
-    if (mode == rounding_mode::towards_zero)
+    if (mode == towards_zero)
         return -1;
 
-    if (mode == rounding_mode::downward)
+    if (mode == downward)
     {
         if (sbit_)
         {
@@ -190,7 +189,7 @@ Number::Guard::round() const noexcept
         return -1;
     }
 
-    if (mode == rounding_mode::upward)
+    if (mode == upward)
     {
         if (sbit_)
             return -1;
@@ -730,7 +729,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::mantissa_scale::small;
+    bool const small = Number::getMantissaScale() == MantissaRange::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 0443aa3502..fc71666768 100644
--- a/src/libxrpl/basics/ResolverAsio.cpp
+++ b/src/libxrpl/basics/ResolverAsio.cpp
@@ -177,7 +177,7 @@ public:
         if (m_stopped.exchange(false))
         {
             {
-                std::scoped_lock const lk{m_mut};
+                std::lock_guard 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 dc8f785974..2b7ce57742 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::scoped_lock const lock(mut_);
+        std::lock_guard 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/OTelCollector.cpp b/src/libxrpl/beast/insight/OTelCollector.cpp
index 3b5fdc09a1..03451cb6e1 100644
--- a/src/libxrpl/beast/insight/OTelCollector.cpp
+++ b/src/libxrpl/beast/insight/OTelCollector.cpp
@@ -17,7 +17,7 @@
  *   OTelCounterImpl / OTelGaugeImpl / OTelEventImpl / OTelMeterImpl
  *       |                    |                |              |
  *       v                    v                v              v
- *   OTel Counter<uint64> ObservableGauge  Histogram<double>  Counter<uint64>
+ *   Counter<uint64_t>  ObservableGauge  Histogram<double>  Counter<uint64_t>
  *       |                    |                |              |
  *       +--------------------+----------------+--------------+
  *       |
@@ -123,7 +123,7 @@ private:
 /**
  * @brief OTel-backed implementation of beast::insight::CounterImpl.
  *
- * Wraps an OTel Counter<int64_t> instrument. Each increment() call
+ * Wraps an OTel Counter<uint64_t> instrument. Each increment() call
  * is forwarded directly to the OTel counter's Add() method. The
  * PeriodicMetricReader collects and exports the accumulated delta.
  *
@@ -239,7 +239,7 @@ public:
     /**
      * @brief Increment (or decrement) the gauge by a signed amount.
      *
-     * Clamps the result to [0, UINT64_MAX] to match StatsDGaugeImpl
+     * Clamps the result to [0, INT64_MAX] to match StatsDGaugeImpl
      * behavior.
      *
      * @param amount  Signed amount to add to the current value.
@@ -254,6 +254,10 @@ public:
     int64_t
     currentValue() const;
 
+    /** Static callback registered with the OTel SDK observable gauge. */
+    static void
+    gaugeCallback(opentelemetry::metrics::ObserverResult result, void* state);
+
 private:
     OTelGaugeImpl&
     operator=(OTelGaugeImpl const&);
@@ -578,27 +582,25 @@ OTelGaugeImpl::OTelGaugeImpl(
     : m_gauge(meter->CreateInt64ObservableGauge(name)), m_collector(collector)
 {
     m_collector->addGauge(this);
+    m_gauge->AddCallback(gaugeCallback, this);
+}
 
-    // Register the async callback that the SDK calls during collection.
-    // Before reading the gauge value, invoke all registered hooks so that
-    // hook handlers (e.g. NetworkOPs State_Accounting) have a chance to
-    // update gauge values. callHooks() uses a debounce timestamp so hooks
-    // run at most once per collection cycle even with many gauges.
-    m_gauge->AddCallback(
-        [](opentelemetry::metrics::ObserverResult result, void* state) {
-            auto* self = static_cast<OTelGaugeImpl*>(state);
-            self->m_collector->callHooks();
-            if (auto intResult = opentelemetry::nostd::get_if<opentelemetry::nostd::shared_ptr<
-                    opentelemetry::metrics::ObserverResultT<int64_t>>>(&result))
-            {
-                (*intResult)->Observe(self->currentValue());
-            }
-        },
-        this);
+void
+OTelGaugeImpl::gaugeCallback(opentelemetry::metrics::ObserverResult result, void* state)
+{
+    auto* self = static_cast<OTelGaugeImpl*>(state);
+    self->m_collector->callHooks();
+    if (auto intResult = opentelemetry::nostd::get_if<
+            opentelemetry::nostd::shared_ptr<opentelemetry::metrics::ObserverResultT<int64_t>>>(
+            &result))
+    {
+        (*intResult)->Observe(self->currentValue());
+    }
 }
 
 OTelGaugeImpl::~OTelGaugeImpl()
 {
+    m_gauge->RemoveCallback(gaugeCallback, this);
     m_collector->removeGauge(this);
 }
 
@@ -720,8 +722,7 @@ OTelCollectorImp::~OTelCollectorImp()
         m_journal.info() << "OTelCollector shutting down";
     if (m_provider)
     {
-        // ForceFlush to export any pending metrics before shutdown.
-        m_provider->ForceFlush();
+        m_provider->ForceFlush(std::chrono::milliseconds(2000));
         m_provider->Shutdown();
     }
     if (m_journal.info())
@@ -783,10 +784,10 @@ OTelCollectorImp::callHooks()
     auto now = std::chrono::duration_cast<std::chrono::milliseconds>(
                    std::chrono::steady_clock::now().time_since_epoch())
                    .count();
-    auto last = m_lastHookCallMs.load(std::memory_order_relaxed);
+    auto last = m_lastHookCallMs.load(std::memory_order_acquire);
     if (now - last < 500)
         return;
-    if (!m_lastHookCallMs.compare_exchange_strong(last, now, std::memory_order_relaxed))
+    if (!m_lastHookCallMs.compare_exchange_strong(last, now, std::memory_order_acq_rel))
         return;  // Another thread won the race.
 
     std::lock_guard lock(m_mutex);
diff --git a/src/libxrpl/beast/insight/StatsDCollector.cpp b/src/libxrpl/beast/insight/StatsDCollector.cpp
index a83a11d7d6..d11e85830f 100644
--- a/src/libxrpl/beast/insight/StatsDCollector.cpp
+++ b/src/libxrpl/beast/insight/StatsDCollector.cpp
@@ -204,8 +204,6 @@ 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
@@ -295,14 +293,14 @@ public:
     void
     add(StatsDMetricBase& metric)
     {
-        std::scoped_lock const _(metricsLock_);
+        std::lock_guard const _(metricsLock_);
         metrics_.push_back(metric);
     }
 
     void
     remove(StatsDMetricBase& metric)
     {
-        std::scoped_lock const _(metricsLock_);
+        std::lock_guard const _(metricsLock_);
         metrics_.erase(metrics_.iterator_to(metric));
     }
 
@@ -446,7 +444,7 @@ public:
             return;
         }
 
-        std::scoped_lock const _(metricsLock_);
+        std::lock_guard 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 62c192bf64..ddfe075132 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::scoped_lock const _(lock_);
+    std::lock_guard const _(lock_);
     if (parent_ != nullptr)
         parent_->remove(*this);
     removeAll();
@@ -173,7 +173,9 @@ PropertyStream::Source::name() const
 void
 PropertyStream::Source::add(Source& source)
 {
-    std::scoped_lock const lock(lock_, source.lock_);
+    std::lock(lock_, source.lock_);
+    std::lock_guard const lk1(lock_, std::adopt_lock);
+    std::lock_guard const lk2(source.lock_, std::adopt_lock);
 
     XRPL_ASSERT(
         source.parent_ == nullptr, "beast::PropertyStream::Source::add : null source parent");
@@ -184,7 +186,9 @@ PropertyStream::Source::add(Source& source)
 void
 PropertyStream::Source::remove(Source& child)
 {
-    std::scoped_lock const lock(lock_, child.lock_);
+    std::lock(lock_, child.lock_);
+    std::lock_guard const lk1(lock_, std::adopt_lock);
+    std::lock_guard const lk2(child.lock_, std::adopt_lock);
 
     XRPL_ASSERT(
         child.parent_ == this, "beast::PropertyStream::Source::remove : child parent match");
@@ -195,10 +199,10 @@ PropertyStream::Source::remove(Source& child)
 void
 PropertyStream::Source::removeAll()
 {
-    std::scoped_lock const _(lock_);
+    std::lock_guard const _(lock_);
     for (auto iter = children_.begin(); iter != children_.end();)
     {
-        std::scoped_lock const _cl((*iter)->lock_);
+        std::lock_guard const _cl((*iter)->lock_);
         remove(*(*iter));
     }
 }
@@ -218,7 +222,7 @@ PropertyStream::Source::write(PropertyStream& stream)
     Map map(m_name, stream);
     onWrite(map);
 
-    std::scoped_lock const _(lock_);
+    std::lock_guard const _(lock_);
 
     for (auto& child : children_)
         child.source().write(stream);
@@ -320,7 +324,7 @@ PropertyStream::Source::find_one_deep(std::string const& name)
     if (found != nullptr)
         return found;
 
-    std::scoped_lock const _(lock_);
+    std::lock_guard const _(lock_);
     for (auto& s : children_)
     {
         found = s.source().find_one_deep(name);
@@ -351,7 +355,7 @@ PropertyStream::Source::find_path(std::string path)
 PropertyStream::Source*
 PropertyStream::Source::find_one(std::string const& name)
 {
-    std::scoped_lock const _(lock_);
+    std::lock_guard 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 ecc2aa9f14..4175d83340 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::scoped_lock const lock(mutex_);
+    std::lock_guard 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::scoped_lock const lock(mutex_);
+    std::lock_guard 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::scoped_lock const lock(mutex_);
+    std::lock_guard 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::scoped_lock const lock(mutex_);
+    std::lock_guard const lock(mutex_);
 
     auto result = emplace(key);
     auto& s = result.first;
@@ -85,7 +85,7 @@ HashRouter::shouldProcess(
 HashRouterFlags
 HashRouter::getFlags(uint256 const& key)
 {
-    std::scoped_lock const lock(mutex_);
+    std::lock_guard 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::scoped_lock const lock(mutex_);
+    std::lock_guard 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::scoped_lock const lock(mutex_);
+    std::lock_guard 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 9e6756e0c0..d55160f285 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::scoped_lock const lock(m_mutex);
+        std::lock_guard const lock(m_mutex);
 
         for (auto const& x : JobTypes::instance())
         {
@@ -65,7 +65,7 @@ JobQueue::~JobQueue()
 void
 JobQueue::collect()
 {
-    std::scoped_lock const lock(m_mutex);
+    std::lock_guard 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::scoped_lock const lock(m_mutex);
+        std::lock_guard 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::scoped_lock const lock(m_mutex);
+    std::lock_guard 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::scoped_lock const lock(m_mutex);
+    std::lock_guard 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::scoped_lock const lock(m_mutex);
+    std::lock_guard const lock(m_mutex);
 
     for (auto const& x : m_jobData)
     {
@@ -192,7 +192,7 @@ JobQueue::getJson(int c)
 
     Json::Value priorities = Json::arrayValue;
 
-    std::scoped_lock const lock(m_mutex);
+    std::lock_guard const lock(m_mutex);
 
     for (auto& x : m_jobData)
     {
@@ -349,7 +349,7 @@ JobQueue::processTask(int instance)
         {
             Job job;
             {
-                std::scoped_lock const lock(m_mutex);
+                std::lock_guard const lock(m_mutex);
                 getNextJob(job);
                 ++m_processCount;
             }
@@ -376,7 +376,7 @@ JobQueue::processTask(int instance)
     }
 
     {
-        std::scoped_lock const lock(m_mutex);
+        std::lock_guard 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 aea535fb81..2cf4e1f6ea 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::scoped_lock const sl(mutex_);
+    std::lock_guard const sl(mutex_);
 
     update();
     mCounts += count;
@@ -140,7 +140,7 @@ LoadMonitor::isOverTarget(std::chrono::milliseconds avg, std::chrono::millisecon
 bool
 LoadMonitor::isOver()
 {
-    std::scoped_lock const sl(mutex_);
+    std::lock_guard const sl(mutex_);
 
     update();
 
@@ -157,7 +157,7 @@ LoadMonitor::getStats()
     using namespace std::chrono_literals;
     Stats stats;
 
-    std::scoped_lock const sl(mutex_);
+    std::lock_guard const sl(mutex_);
 
     update();
 
diff --git a/src/libxrpl/core/detail/Workers.cpp b/src/libxrpl/core/detail/Workers.cpp
index a6f8885a86..e7d63c0900 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::scoped_lock const lock{mutex_};
+        std::lock_guard const lock{mutex_};
         ++wakeCount_;
         shouldExit_ = true;
     }
@@ -163,7 +163,7 @@ Workers::Worker::~Worker()
 void
 Workers::Worker::notify()
 {
-    std::scoped_lock const lock{mutex_};
+    std::lock_guard const lock{mutex_};
     ++wakeCount_;
     wakeup_.notify_one();
 }
@@ -179,7 +179,7 @@ Workers::Worker::run()
         //
         if (++m_workers.m_activeCount == 1)
         {
-            std::scoped_lock const lk{m_workers.m_mut};
+            std::lock_guard 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::scoped_lock const lk{m_workers.m_mut};
+                std::lock_guard 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::scoped_lock const lk{m_workers.m_mut};
+            std::lock_guard 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 7aef9b2831..dc16c9ac64 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::scoped_lock const lock(mutex_);
+    std::lock_guard 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::scoped_lock lock(mutex_);
+    std::lock_guard 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 31d74db7e0..e588d21d3c 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::CollectionType::array);
+            writer.startRoot(Writer::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::CollectionType::object);
+            writer.startRoot(Writer::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 188f0749f0..b4a85e0170 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 == CollectionType::array) ? openBracket : openBrace;
+        char const ch = (ct == array) ? openBracket : openBrace;
         output({&ch, 1});
         stack_.emplace(Collection{.type = ct});
     }
@@ -134,9 +134,7 @@ public:
         auto t = stack_.top().type;
         if (t != type)
         {
-            check(
-                false,
-                "Not an " + ((type == CollectionType::array ? "array: " : "object: ") + message));
+            check(false, "Not an " + ((type == array ? "array: " : "object: ") + message));
         }
         if (stack_.top().isFirst)
         {
@@ -173,7 +171,7 @@ public:
     {
         check(!empty(), "Empty stack in finish()");
 
-        auto isArray = stack_.top().type == CollectionType::array;
+        auto isArray = stack_.top().type == array;
         auto ch = isArray ? closeBracket : closeBrace;
         output_({&ch, 1});
         stack_.pop();
@@ -303,7 +301,7 @@ Writer::finishAll()
 void
 Writer::rawAppend()
 {
-    impl_->nextCollectionEntry(CollectionType::array, "append");
+    impl_->nextCollectionEntry(array, "append");
 }
 
 void
@@ -311,7 +309,7 @@ Writer::rawSet(std::string const& tag)
 {
     check(!tag.empty(), "Tag can't be empty");
 
-    impl_->nextCollectionEntry(CollectionType::object, "set");
+    impl_->nextCollectionEntry(object, "set");
     impl_->writeObjectTag(tag);
 }
 
@@ -324,14 +322,14 @@ Writer::startRoot(CollectionType type)
 void
 Writer::startAppend(CollectionType type)
 {
-    impl_->nextCollectionEntry(CollectionType::array, "startAppend");
+    impl_->nextCollectionEntry(array, "startAppend");
     impl_->start(type);
 }
 
 void
 Writer::startSet(CollectionType type, std::string const& key)
 {
-    impl_->nextCollectionEntry(CollectionType::object, "startSet");
+    impl_->nextCollectionEntry(object, "startSet");
     impl_->writeObjectTag(key);
     impl_->start(type);
 }
diff --git a/src/libxrpl/ledger/AcceptedLedgerTx.cpp b/src/libxrpl/ledger/AcceptedLedgerTx.cpp
index 21baa24323..e609f5bdc8 100644
--- a/src/libxrpl/ledger/AcceptedLedgerTx.cpp
+++ b/src/libxrpl/ledger/AcceptedLedgerTx.cpp
@@ -62,8 +62,8 @@ AcceptedLedgerTx::AcceptedLedgerTx(
                 *ledger,
                 account,
                 amount,
-                FreezeHandling::fhIGNORE_FREEZE,
-                AuthHandling::ahIGNORE_AUTH,
+                fhIGNORE_FREEZE,
+                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 d922dc3a67..36d02427bc 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::scoped_lock const sl(mLock);
+    std::lock_guard const sl(mLock);
     mListeners[sub->getSeq()] = sub;
 }
 
 void
 BookListeners::removeSubscriber(std::uint64_t seq)
 {
-    std::scoped_lock const sl(mLock);
+    std::lock_guard const sl(mLock);
     mListeners.erase(seq);
 }
 
 void
 BookListeners::publish(MultiApiJson const& jvObj, hash_set<std::uint64_t>& havePublished)
 {
-    std::scoped_lock const sl(mLock);
+    std::lock_guard 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 bb7ff97153..6bbe2d828b 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::scoped_lock const lock(mutex_);
+            std::lock_guard 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::scoped_lock const lock(mutex_);
+        std::lock_guard 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 729f1ebce9..18db482538 100644
--- a/src/libxrpl/ledger/Ledger.cpp
+++ b/src/libxrpl/ledger/Ledger.cpp
@@ -204,7 +204,7 @@ Ledger::Ledger(
         rawInsert(sle);
     }
 
-    stateMap_.flushDirty(NodeObjectType::hotACCOUNT_NODE);
+    stateMap_.flushDirty(hotACCOUNT_NODE);
     setImmutable();
 }
 
diff --git a/src/libxrpl/ledger/helpers/AMMHelpers.cpp b/src/libxrpl/ledger/helpers/AMMHelpers.cpp
index cc91dcaaf4..94ca2469f7 100644
--- a/src/libxrpl/ledger/helpers/AMMHelpers.cpp
+++ b/src/libxrpl/ledger/helpers/AMMHelpers.cpp
@@ -46,8 +46,7 @@ STAmount
 ammLPTokens(STAmount const& asset1, STAmount const& asset2, Asset const& lptIssue)
 {
     // AMM invariant: sqrt(asset1 * asset2) >= LPTokensBalance
-    auto const rounding =
-        isFeatureEnabled(fixAMMv1_3) ? Number::rounding_mode::downward : Number::getround();
+    auto const rounding = isFeatureEnabled(fixAMMv1_3) ? Number::downward : Number::getround();
     NumberRoundModeGuard const g(rounding);
     auto const tokens = root2(asset1 * asset2);
     return toSTAmount(lptIssue, tokens);
@@ -78,7 +77,7 @@ lpTokensOut(
 
     // minimize tokens out
     auto const frac = (r - c) / (1 + c);
-    return multiply(lptAMMBalance, frac, Number::rounding_mode::downward);
+    return multiply(lptAMMBalance, frac, Number::downward);
 }
 
 /* Equation 4 solves equation 3 for b:
@@ -114,7 +113,7 @@ ammAssetIn(
 
     // maximize deposit
     auto const frac = solveQuadraticEq(a, b, c);
-    return multiply(asset1Balance, frac, Number::rounding_mode::upward);
+    return multiply(asset1Balance, frac, Number::upward);
 }
 
 /* Equation 7:
@@ -139,7 +138,7 @@ lpTokensIn(
 
     // maximize tokens in
     auto const frac = (c - root2(c * c - 4 * fr)) / 2;
-    return multiply(lptAMMBalance, frac, Number::rounding_mode::upward);
+    return multiply(lptAMMBalance, frac, Number::upward);
 }
 
 /* Equation 8 solves equation 7 for b:
@@ -169,7 +168,7 @@ ammAssetOut(
 
     // minimize withdraw
     auto const frac = (t1 * t1 - t1 * (2 - f)) / (t1 * f - 1);
-    return multiply(assetBalance, frac, Number::rounding_mode::downward);
+    return multiply(assetBalance, frac, Number::downward);
 }
 
 Number
diff --git a/src/libxrpl/ledger/helpers/LendingHelpers.cpp b/src/libxrpl/ledger/helpers/LendingHelpers.cpp
index a263791e39..caccca752d 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::rounding_mode::downward) ==
-        roundToAsset(asset, value, scale, Number::rounding_mode::upward);
+    return roundToAsset(asset, value, scale, Number::downward) ==
+        roundToAsset(asset, value, scale, Number::upward);
 }
 
 namespace detail {
@@ -458,11 +458,7 @@ 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::rounding_mode::upward),
+        roundToAsset(asset, newTheoreticalState.principalOutstanding, loanScale, Number::upward),
         numZero,
         roundedOldState.principalOutstanding);
     auto const totalValueOutstanding = std::clamp(
@@ -470,7 +466,7 @@ tryOverpayment(
             asset,
             principalOutstanding + newTheoreticalState.interestOutstanding(),
             loanScale,
-            Number::rounding_mode::upward),
+            Number::upward),
         numZero,
         roundedOldState.valueOutstanding);
     auto const managementFeeOutstanding = std::clamp(
@@ -840,8 +836,7 @@ 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::rounding_mode::downward);
+        auto const interest = roundToAsset(asset, fullPaymentInterest, loanScale, Number::downward);
         return computeInterestAndFeeParts(asset, interest, managementFeeRate, loanScale);
     }();
 
@@ -1291,7 +1286,7 @@ checkLoanGuards(
     // loan can't be amortized in the specified number of payments, raise an
     // error
     {
-        NumberRoundModeGuard const mg(Number::rounding_mode::upward);
+        NumberRoundModeGuard const mg(Number::upward);
 
         if (std::int64_t const computedPayments{
                 properties.loanState.valueOutstanding / roundedPayment};
@@ -1470,8 +1465,7 @@ computeManagementFee(
     TenthBips32 managementFeeRate,
     std::int32_t scale)
 {
-    return roundToAsset(
-        asset, tenthBipsOfValue(value, managementFeeRate), scale, Number::rounding_mode::downward);
+    return roundToAsset(asset, tenthBipsOfValue(value, managementFeeRate), scale, Number::downward);
 }
 
 /*
@@ -1525,8 +1519,7 @@ computeLoanProperties(
 
     auto const [totalValueOutstanding, loanScale] = [&]() {
         // only round up if there should be interest
-        NumberRoundModeGuard const mg(
-            periodicRate == 0 ? Number::rounding_mode::to_nearest : Number::rounding_mode::upward);
+        NumberRoundModeGuard const mg(periodicRate == 0 ? Number::to_nearest : Number::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.
@@ -1555,7 +1548,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::rounding_mode::to_nearest);
+        roundToAsset(asset, principalOutstanding, loanScale, Number::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 15b3dc0953..d5f1d5eb39 100644
--- a/src/libxrpl/ledger/helpers/TokenHelpers.cpp
+++ b/src/libxrpl/ledger/helpers/TokenHelpers.cpp
@@ -165,7 +165,7 @@ getLineIfUsable(
         return nullptr;
     }
 
-    if (zeroIfFrozen == FreezeHandling::fhZERO_IF_FROZEN)
+    if (zeroIfFrozen == fhZERO_IF_FROZEN)
     {
         if (isFrozen(view, account, currency, issuer) ||
             isDeepFrozen(view, account, currency, issuer))
@@ -252,7 +252,7 @@ accountHolds(
         return {xrpLiquid(view, account, 0, j)};
     }
 
-    bool const returnSpendable = (includeFullBalance == SpendableHandling::shFULL_BALANCE);
+    bool const returnSpendable = (includeFullBalance == shFULL_BALANCE);
     if (returnSpendable && account == issuer)
     {
         // If the account is the issuer, then their limit is effectively
@@ -290,7 +290,7 @@ accountHolds(
     beast::Journal j,
     SpendableHandling includeFullBalance)
 {
-    bool const returnSpendable = (includeFullBalance == SpendableHandling::shFULL_BALANCE);
+    bool const returnSpendable = (includeFullBalance == shFULL_BALANCE);
     STAmount amount{mptIssue};
     auto const& issuer = mptIssue.getIssuer();
     bool const mptokensV2 = view.rules().enabled(featureMPTokensV2);
@@ -317,7 +317,7 @@ accountHolds(
     {
         amount.clear(mptIssue);
     }
-    else if (zeroIfFrozen == FreezeHandling::fhZERO_IF_FROZEN && isFrozen(view, account, mptIssue))
+    else if (zeroIfFrozen == fhZERO_IF_FROZEN && isFrozen(view, account, mptIssue))
     {
         amount.clear(mptIssue);
     }
@@ -327,14 +327,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 == AuthHandling::ahZERO_IF_UNAUTHORIZED &&
+        if (zeroIfUnauthorized == 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 == AuthHandling::ahZERO_IF_UNAUTHORIZED)
+        else if (zeroIfUnauthorized == ahZERO_IF_UNAUTHORIZED)
         {
             auto const sleIssuance = view.read(keylet::mptIssuance(mptIssue.getMptID()));
 
@@ -401,13 +401,7 @@ accountFunds(
         [&](Issue const&) { return accountFunds(view, id, saDefault, freezeHandling, j); },
         [&](MPTIssue const&) {
             return accountHolds(
-                view,
-                id,
-                saDefault.asset(),
-                freezeHandling,
-                authHandling,
-                j,
-                SpendableHandling::shFULL_BALANCE);
+                view, id, saDefault.asset(), freezeHandling, authHandling, j, shFULL_BALANCE);
         });
 }
 
diff --git a/src/libxrpl/nodestore/BatchWriter.cpp b/src/libxrpl/nodestore/BatchWriter.cpp
index b05c80ff00..9da6f504a9 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::scoped_lock const sl(mWriteMutex);
+    std::lock_guard const sl(mWriteMutex);
 
     return std::max(mWriteLoad, static_cast<int>(mWriteSet.size()));
 }
@@ -68,7 +68,7 @@ BatchWriter::writeBatch()
         set.reserve(batchWritePreallocationSize);
 
         {
-            std::scoped_lock const sl(mWriteMutex);
+            std::lock_guard const sl(mWriteMutex);
 
             mWriteSet.swap(set);
             XRPL_ASSERT(
diff --git a/src/libxrpl/nodestore/Database.cpp b/src/libxrpl/nodestore/Database.cpp
index fa69cba517..ee8d2f56aa 100644
--- a/src/libxrpl/nodestore/Database.cpp
+++ b/src/libxrpl/nodestore/Database.cpp
@@ -143,7 +143,7 @@ void
 Database::stop()
 {
     {
-        std::scoped_lock const lock(readLock_);
+        std::lock_guard 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::scoped_lock const lock(readLock_);
+    std::lock_guard const lock(readLock_);
 
     if (!isStopping())
     {
diff --git a/src/libxrpl/nodestore/DatabaseNodeImp.cpp b/src/libxrpl/nodestore/DatabaseNodeImp.cpp
index 1bb5f32308..7722f711bb 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 = Status::ok;
+    Status status = ok;
 
     try
     {
@@ -63,15 +63,15 @@ DatabaseNodeImp::fetchNodeObject(
 
     switch (status)
     {
-        case Status::ok:
-        case Status::notFound:
+        case ok:
+        case notFound:
             break;
-        case Status::dataCorrupt:
+        case dataCorrupt:
             JLOG(j_.fatal()) << "fetchNodeObject " << hash << ": nodestore data is corrupted";
             break;
         default:
             JLOG(j_.warn()) << "fetchNodeObject " << hash << ": backend returns unknown result "
-                            << static_cast<int>(status);
+                            << status;
             break;
     }
 
diff --git a/src/libxrpl/nodestore/DatabaseRotatingImp.cpp b/src/libxrpl/nodestore/DatabaseRotatingImp.cpp
index de34af7773..ef7431f5a3 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::scoped_lock const lock(mutex_);
+        std::lock_guard const lock(mutex_);
 
         archiveBackend_->setDeletePath();
         oldArchiveBackend = std::move(archiveBackend_);
@@ -70,14 +70,14 @@ DatabaseRotatingImp::rotate(
 std::string
 DatabaseRotatingImp::getName() const
 {
-    std::scoped_lock const lock(mutex_);
+    std::lock_guard const lock(mutex_);
     return writableBackend_->getName();
 }
 
 std::int32_t
 DatabaseRotatingImp::getWriteLoad() const
 {
-    std::scoped_lock const lock(mutex_);
+    std::lock_guard const lock(mutex_);
     return writableBackend_->getWriteLoad();
 }
 
@@ -85,7 +85,7 @@ void
 DatabaseRotatingImp::importDatabase(Database& source)
 {
     auto const backend = [&] {
-        std::scoped_lock const lock(mutex_);
+        std::lock_guard const lock(mutex_);
         return writableBackend_;
     }();
 
@@ -95,7 +95,7 @@ DatabaseRotatingImp::importDatabase(Database& source)
 void
 DatabaseRotatingImp::sync()
 {
-    std::scoped_lock const lock(mutex_);
+    std::lock_guard 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::scoped_lock const lock(mutex_);
+        std::lock_guard const lock(mutex_);
         return writableBackend_;
     }();
 
@@ -121,7 +121,7 @@ DatabaseRotatingImp::fetchNodeObject(
     bool duplicate)
 {
     auto fetch = [&](std::shared_ptr<Backend> const& backend) {
-        Status status = Status::ok;
+        Status status = ok;
         std::shared_ptr<NodeObject> nodeObject;
         try
         {
@@ -135,14 +135,14 @@ DatabaseRotatingImp::fetchNodeObject(
 
         switch (status)
         {
-            case Status::ok:
-            case Status::notFound:
+            case ok:
+            case notFound:
                 break;
-            case Status::dataCorrupt:
+            case dataCorrupt:
                 JLOG(j_.fatal()) << "Corrupt NodeObject #" << hash;
                 break;
             default:
-                JLOG(j_.warn()) << "Unknown status=" << static_cast<int>(status);
+                JLOG(j_.warn()) << "Unknown status=" << status;
                 break;
         }
 
@@ -153,7 +153,7 @@ DatabaseRotatingImp::fetchNodeObject(
     std::shared_ptr<NodeObject> nodeObject;
 
     auto [writable, archive] = [&] {
-        std::scoped_lock const lock(mutex_);
+        std::lock_guard const lock(mutex_);
         return std::make_pair(writableBackend_, archiveBackend_);
     }();
 
@@ -167,7 +167,7 @@ DatabaseRotatingImp::fetchNodeObject(
         {
             {
                 // Refresh the writable backend pointer
-                std::scoped_lock const lock(mutex_);
+                std::lock_guard 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::scoped_lock const lock(mutex_);
+        std::lock_guard const lock(mutex_);
         return std::make_pair(writableBackend_, archiveBackend_);
     }();
 
diff --git a/src/libxrpl/nodestore/DecodedBlob.cpp b/src/libxrpl/nodestore/DecodedBlob.cpp
index 437aef24da..1d60f2af86 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 = NodeObjectType::hotUNKNOWN;
+    m_objectType = 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 NodeObjectType::hotUNKNOWN:
-            case NodeObjectType::hotLEDGER:
-            case NodeObjectType::hotACCOUNT_NODE:
-            case NodeObjectType::hotTRANSACTION_NODE:
+            case hotUNKNOWN:
+            case hotLEDGER:
+            case hotACCOUNT_NODE:
+            case hotTRANSACTION_NODE:
                 m_success = true;
                 break;
         }
diff --git a/src/libxrpl/nodestore/ManagerImp.cpp b/src/libxrpl/nodestore/ManagerImp.cpp
index 1420bf3997..40a48f0875 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::scoped_lock const _(mutex_);
+    std::lock_guard const _(mutex_);
     list_.push_back(&factory);
 }
 
 void
 ManagerImp::erase(Factory& factory)
 {
-    std::scoped_lock const _(mutex_);
+    std::lock_guard 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::scoped_lock const _(mutex_);
+    std::lock_guard 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 ef07ebe957..abf25013ce 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::scoped_lock const _(mutex_);
+        std::lock_guard 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::scoped_lock const _(db_->mutex);
+        std::lock_guard const _(db_->mutex);
 
         Map::iterator const iter = db_->table.find(hash);
         if (iter == db_->table.end())
         {
             pObject->reset();
-            return Status::notFound;
+            return notFound;
         }
         *pObject = iter->second;
-        return Status::ok;
+        return 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 != Status::ok)
+            if (status != ok)
             {
                 results.push_back({});
             }
@@ -165,14 +165,14 @@ public:
             }
         }
 
-        return {results, Status::ok};
+        return {results, ok};
     }
 
     void
     store(std::shared_ptr<NodeObject> const& object) override
     {
         XRPL_ASSERT(db_, "xrpl::NodeStore::MemoryBackend::store : non-null database");
-        std::scoped_lock const _(db_->mutex);
+        std::lock_guard 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 18fe3c572e..86540016da 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 = Status::ok;
+        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 = Status::dataCorrupt;
+                    status = dataCorrupt;
                     return;
                 }
                 *pno = decoded.createObject();
-                status = Status::ok;
+                status = ok;
             },
             ec);
         if (ec == nudb::error::key_not_found)
-            return Status::notFound;
+            return 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 != Status::ok)
+            if (status != ok)
             {
                 results.push_back({});
             }
@@ -251,7 +251,7 @@ public:
             }
         }
 
-        return {results, Status::ok};
+        return {results, ok};
     }
 
     void
diff --git a/src/libxrpl/nodestore/backend/NullFactory.cpp b/src/libxrpl/nodestore/backend/NullFactory.cpp
index 917ee3d8d0..02e6ca4dda 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 Status::notFound;
+        return 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 be2506ec6f..86dff9240d 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(Status::ok);
+        Status status(ok);
 
         rocksdb::ReadOptions const options;
         rocksdb::Slice const slice(std::bit_cast<char const*>(hash.data()), m_keyBytes);
@@ -306,23 +306,22 @@ public:
             {
                 // Decoding failed, probably corrupted!
                 //
-                status = Status::dataCorrupt;
+                status = dataCorrupt;
             }
         }
         else
         {
             if (getStatus.IsCorruption())
             {
-                status = Status::dataCorrupt;
+                status = dataCorrupt;
             }
             else if (getStatus.IsNotFound())
             {
-                status = Status::notFound;
+                status = notFound;
             }
             else
             {
-                status = static_cast<Status>(
-                    static_cast<int>(Status::customCode) + unsafe_cast<int>(getStatus.code()));
+                status = Status(customCode + unsafe_cast<int>(getStatus.code()));
 
                 JLOG(m_journal.error()) << getStatus.ToString();
             }
@@ -340,7 +339,7 @@ public:
         {
             std::shared_ptr<NodeObject> nObj;
             Status const status = fetch(h, &nObj);
-            if (status != Status::ok)
+            if (status != ok)
             {
                 results.push_back({});
             }
@@ -350,7 +349,7 @@ public:
             }
         }
 
-        return {results, Status::ok};
+        return {results, ok};
     }
 
     void
diff --git a/src/libxrpl/protocol/AccountID.cpp b/src/libxrpl/protocol/AccountID.cpp
index ffebde2c1a..a89dc8fd11 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::scoped_lock const lock(sl);
+            std::lock_guard 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::scoped_lock const lock(sl);
+            std::lock_guard 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 3e4649a27f..7a8d0144bb 100644
--- a/src/libxrpl/protocol/Rules.cpp
+++ b/src/libxrpl/protocol/Rules.cpp
@@ -40,9 +40,7 @@ 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::mantissa_scale::large
-                           : MantissaRange::mantissa_scale::small);
+    Number::setMantissaScale(enableLargeNumbers ? MantissaRange::large : MantissaRange::small);
 
     *getCurrentTransactionRulesRef() = std::move(r);
 }
diff --git a/src/libxrpl/protocol/STAmount.cpp b/src/libxrpl/protocol/STAmount.cpp
index 654bcf1be4..89992b823c 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::rounding_mode::towards_zero);
+        MightSaveRound const savedRound(Number::towards_zero);
         return STAmount(asset, amount, offset, resultNegative);
     }();
 
diff --git a/src/libxrpl/protocol/STNumber.cpp b/src/libxrpl/protocol/STNumber.cpp
index d506751f86..25aa9eaa05 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::mantissa_scale::large,
+                Number::getMantissaScale() == MantissaRange::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 9f032a0962..baece3ca56 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, WhichFields::withAllFields);  // just inner elements
+    add(s, 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, WhichFields::withAllFields);
+    auto const sf = getSortedFields(*this, 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, WhichFields::withAllFields);
-    auto const sf2 = getSortedFields(*v, WhichFields::withAllFields);
+    auto const sf1 = getSortedFields(*this, withAllFields);
+    auto const sf2 = getSortedFields(*v, 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, WhichFields::withAllFields);
+    add(s, withAllFields);
     return s.getSHA512Half();
 }
 
@@ -375,7 +375,7 @@ STObject::getSigningHash(HashPrefix prefix) const
 {
     Serializer s;
     s.add32(prefix);
-    add(s, WhichFields::omitSigningFields);
+    add(s, omitSigningFields);
     return s.getSHA512Half();
 }
 
diff --git a/src/libxrpl/protocol/STTx.cpp b/src/libxrpl/protocol/STTx.cpp
index 0dd567e6cc..6da0d61b57 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::Type::ticket, *ticketSeq};
+    return SeqProxy{SeqProxy::ticket, *ticketSeq};
 }
 
 std::uint32_t
diff --git a/src/libxrpl/rdb/DatabaseCon.cpp b/src/libxrpl/rdb/DatabaseCon.cpp
index cc7692de78..5f4594b630 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::scoped_lock const l{mutex_};
+        std::lock_guard 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::scoped_lock const lock{mutex_};
+        std::lock_guard const lock{mutex_};
         checkpointers_.erase(id);
     }
 
@@ -50,7 +50,7 @@ public:
         JobQueue& jobQueue,
         ServiceRegistry& registry)
     {
-        std::scoped_lock const lock{mutex_};
+        std::lock_guard 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 1d69f1c984..c6e40ae90b 100644
--- a/src/libxrpl/rdb/SociDB.cpp
+++ b/src/libxrpl/rdb/SociDB.cpp
@@ -238,7 +238,7 @@ public:
     schedule() override
     {
         {
-            std::scoped_lock const lock(mutex_);
+            std::lock_guard const lock(mutex_);
             if (running_)
                 return;
             running_ = true;
@@ -258,7 +258,7 @@ public:
                         self->checkpoint();
                 }))
         {
-            std::scoped_lock const lock(mutex_);
+            std::lock_guard const lock(mutex_);
             running_ = false;
         }
     }
@@ -286,7 +286,7 @@ public:
             JLOG(j_.trace()) << "WAL(" << fname << "): frames=" << log << ", written=" << ckpt;
         }
 
-        std::scoped_lock const lock(mutex_);
+        std::lock_guard const lock(mutex_);
         running_ = false;
     }
 
diff --git a/src/libxrpl/resource/Consumer.cpp b/src/libxrpl/resource/Consumer.cpp
index c57344bd8f..3d03fa05db 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 = Disposition::ok;
+    Disposition d = 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 = Disposition::ok;
+    Disposition d = 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 e3f0ae8583..6652c1a66b 100644
--- a/src/libxrpl/resource/ResourceManager.cpp
+++ b/src/libxrpl/resource/ResourceManager.cpp
@@ -50,7 +50,7 @@ public:
     ~ManagerImp() override
     {
         {
-            std::scoped_lock const lock(mutex_);
+            std::lock_guard const lock(mutex_);
             stop_ = true;
             cond_.notify_one();
         }
diff --git a/src/libxrpl/server/InfoSub.cpp b/src/libxrpl/server/InfoSub.cpp
index c426d44646..30686dfe7e 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::scoped_lock const sl(mLock);
+    std::lock_guard 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::scoped_lock const sl(mLock);
+    std::lock_guard const sl(mLock);
 
     if (rt)
     {
@@ -103,14 +103,14 @@ InfoSub::deleteSubAccountInfo(AccountID const& account, bool rt)
 bool
 InfoSub::insertSubAccountHistory(AccountID const& account)
 {
-    std::scoped_lock const sl(mLock);
+    std::lock_guard const sl(mLock);
     return accountHistorySubscriptions_.insert(account).second;
 }
 
 void
 InfoSub::deleteSubAccountHistory(AccountID const& account)
 {
-    std::scoped_lock const sl(mLock);
+    std::lock_guard const sl(mLock);
     accountHistorySubscriptions_.erase(account);
 }
 
diff --git a/src/libxrpl/server/LoadFeeTrack.cpp b/src/libxrpl/server/LoadFeeTrack.cpp
index 2fa7e1beba..53fbb8cb84 100644
--- a/src/libxrpl/server/LoadFeeTrack.cpp
+++ b/src/libxrpl/server/LoadFeeTrack.cpp
@@ -16,7 +16,7 @@ namespace xrpl {
 bool
 LoadFeeTrack::raiseLocalFee()
 {
-    std::scoped_lock const sl(lock_);
+    std::lock_guard const sl(lock_);
 
     if (++raiseCount_ < 2)
         return false;
@@ -41,7 +41,7 @@ LoadFeeTrack::raiseLocalFee()
 bool
 LoadFeeTrack::lowerLocalFee()
 {
-    std::scoped_lock const sl(lock_);
+    std::lock_guard 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 837724babe..b638efc383 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, NodeObjectType::hotUNKNOWN);
+    return walkSubTree(false, hotUNKNOWN);
 }
 
 int
diff --git a/src/libxrpl/shamap/SHAMapDelta.cpp b/src/libxrpl/shamap/SHAMapDelta.cpp
index e80f28d25f..d8162710be 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::scoped_lock const l{m};
+                                std::lock_guard 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::scoped_lock const l(m);
+                    std::lock_guard 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::scoped_lock const l(m);
+    std::lock_guard 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 38300beadb..d3324e91d0 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::scoped_lock const lock(sl);
+    std::lock_guard 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::scoped_lock const lock(sl);
+    std::lock_guard 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::scoped_lock const lock(sl);
+    std::lock_guard 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::scoped_lock const lock(sl);
+    std::lock_guard const lock(sl);
 
     if (children[childIndex])
     {
diff --git a/src/libxrpl/shamap/SHAMapNodeID.cpp b/src/libxrpl/shamap/SHAMapNodeID.cpp
index 6116a997b6..c2d93f20ee 100644
--- a/src/libxrpl/shamap/SHAMapNodeID.cpp
+++ b/src/libxrpl/shamap/SHAMapNodeID.cpp
@@ -16,8 +16,6 @@ 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 a0667719c1..eb058e5ca6 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::mantissa_scale::small);
+        mantissaScaleGuard.emplace(MantissaRange::small);
     }
 
     switch (txnType)
@@ -130,7 +130,7 @@ template <class T>
 TxConsequences
 consequences_helper(PreflightContext const& ctx)
 {
-    return TxConsequences(ctx.tx, TxConsequences::Category::blocker);
+    return TxConsequences(ctx.tx, TxConsequences::blocker);
 };
 
 // For Transactor::Custom
@@ -279,7 +279,7 @@ TxConsequences::TxConsequences(STTx const& tx)
 
 TxConsequences::TxConsequences(STTx const& tx, Category category) : TxConsequences(tx)
 {
-    isBlocker_ = (category == Category::blocker);
+    isBlocker_ = (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 af60f3fc55..30be382c91 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(),
-            FreezeHandling::fhIGNORE_FREEZE,
-            AuthHandling::ahIGNORE_AUTH,
+            fhIGNORE_FREEZE,
+            ahIGNORE_AUTH,
             j);
         // Create invariant:
         // sqrt(amount * amount2) == LPTokens
@@ -210,13 +210,7 @@ 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],
-        FreezeHandling::fhIGNORE_FREEZE,
-        AuthHandling::ahIGNORE_AUTH,
-        j);
+        view, *ammAccount_, tx[sfAsset], tx[sfAsset2], fhIGNORE_FREEZE, 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 e97501f129..f2570d14e8 100644
--- a/src/libxrpl/tx/invariants/InvariantCheck.cpp
+++ b/src/libxrpl/tx/invariants/InvariantCheck.cpp
@@ -804,17 +804,10 @@ ValidClawback::finalize(
             AccountID const& holder = amount.getIssuer();
             STAmount const holderBalance = amount.asset().visit(
                 [&](Issue const& issue) {
-                    return accountHolds(
-                        view, holder, issue.currency, issuer, FreezeHandling::fhIGNORE_FREEZE, j);
+                    return accountHolds(view, holder, issue.currency, issuer, fhIGNORE_FREEZE, j);
                 },
                 [&](MPTIssue const& issue) {
-                    return accountHolds(
-                        view,
-                        issuer,
-                        issue,
-                        FreezeHandling::fhIGNORE_FREEZE,
-                        AuthHandling::ahIGNORE_AUTH,
-                        j);
+                    return accountHolds(view, issuer, issue, fhIGNORE_FREEZE, ahIGNORE_AUTH, j);
                 });
 
             if (holderBalance.signum() < 0)
diff --git a/src/libxrpl/tx/invariants/MPTInvariant.cpp b/src/libxrpl/tx/invariants/MPTInvariant.cpp
index 97db4aa385..e010b79b87 100644
--- a/src/libxrpl/tx/invariants/MPTInvariant.cpp
+++ b/src/libxrpl/tx/invariants/MPTInvariant.cpp
@@ -18,7 +18,6 @@
 #include <xrpl/protocol/XRPAmount.h>
 #include <xrpl/tx/invariants/InvariantCheckPrivilege.h>
 
-#include <cstddef>
 #include <cstdint>
 #include <memory>
 
@@ -304,7 +303,7 @@ ValidMPTPayment::visitEntry(
                 overflow_ = true;
                 return false;
             }
-            data_[makeKey(sle)].outstanding[static_cast<std::size_t>(order)] = outstanding;
+            data_[makeKey(sle)].outstanding[order] = outstanding;
         }
         else if (type == ltMPTOKEN)
         {
@@ -318,7 +317,7 @@ ValidMPTPayment::visitEntry(
             }
             auto const res = static_cast<std::int64_t>(mptAmt + lockedAmt);
             // subtract before from after
-            if (order == Order::Before)
+            if (order == Before)
             {
                 data_[makeKey(sle)].mptAmount -= res;
             }
@@ -330,7 +329,7 @@ ValidMPTPayment::visitEntry(
         return true;
     };
 
-    if (before && !update(*before, Order::Before))
+    if (before && !update(*before, Before))
         return;
 
     if (after)
@@ -339,7 +338,7 @@ ValidMPTPayment::visitEntry(
         {
             overflow_ = (*after)[sfOutstandingAmount] > maxMPTAmount(*after);
         }
-        if (!update(*after, Order::After))
+        if (!update(*after, After))
             return;
     }
 }
@@ -365,17 +364,15 @@ 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[iBefore] > (signedMax - data.mptAmount)) ||
-                (data.mptAmount < 0 && data.outstanding[iBefore] < (-signedMax - data.mptAmount));
+                (data.mptAmount > 0 && data.outstanding[Before] > (signedMax - data.mptAmount)) ||
+                (data.mptAmount < 0 && data.outstanding[Before] < (-signedMax - data.mptAmount));
             if (addOverflows ||
-                data.outstanding[iAfter] != (data.outstanding[iBefore] + data.mptAmount))
+                data.outstanding[After] != (data.outstanding[Before] + data.mptAmount))
             {
                 JLOG(j.fatal()) << "Invariant failed: invalid OutstandingAmount balance "
-                                << data.outstanding[iBefore] << " " << data.outstanding[iAfter]
-                                << " " << data.mptAmount;
+                                << data.outstanding[Before] << " " << data.outstanding[After] << " "
+                                << data.mptAmount;
                 return !enforce;
             }
         }
diff --git a/src/libxrpl/tx/paths/BookStep.cpp b/src/libxrpl/tx/paths/BookStep.cpp
index 480a702dc9..49a5f48034 100644
--- a/src/libxrpl/tx/paths/BookStep.cpp
+++ b/src/libxrpl/tx/paths/BookStep.cpp
@@ -1492,7 +1492,7 @@ make_BookStepHelper(StrandContext const& ctx, Asset const& in, Asset const& out)
 {
     TER ter = tefINTERNAL;
     std::unique_ptr<Step> r;
-    if (ctx.offerCrossing != OfferCrossing::no)
+    if (ctx.offerCrossing)
     {
         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 c2ad818b73..a6f74c9c9f 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_, FreezeHandling::fhIGNORE_FREEZE, j_));
+    auto const srcOwed =
+        toAmount<IOUAmount>(accountHolds(sb, src_, currency_, dst_, fhIGNORE_FREEZE, j_));
 
     if (srcOwed.signum() > 0)
         return {srcOwed, DebtDirection::redeems};
@@ -496,8 +496,7 @@ 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_, FreezeHandling::fhIGNORE_FREEZE, j_);
+    auto const srcOwed = accountHolds(sb, src_, currency_, dst_, fhIGNORE_FREEZE, j_);
     return srcOwed.signum() > 0 ? DebtDirection::redeems : DebtDirection::issues;
 }
 
@@ -931,7 +930,7 @@ make_DirectStepI(
 {
     TER ter = tefINTERNAL;
     std::unique_ptr<Step> r;
-    if (ctx.offerCrossing != OfferCrossing::no)
+    if (ctx.offerCrossing != 0u)
     {
         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 3dbc4e30cf..a79df25479 100644
--- a/src/libxrpl/tx/paths/MPTEndpointStep.cpp
+++ b/src/libxrpl/tx/paths/MPTEndpointStep.cpp
@@ -382,13 +382,8 @@ MPTEndpointPaymentStep::check(StrandContext const& ctx, std::shared_ptr<const SL
 
     if (prevStep_ == nullptr)
     {
-        auto const owed = accountFunds(
-            ctx.view,
-            src_,
-            mptIssue_,
-            FreezeHandling::fhIGNORE_FREEZE,
-            AuthHandling::ahIGNORE_AUTH,
-            j_);
+        auto const owed =
+            accountFunds(ctx.view, src_, mptIssue_, fhIGNORE_FREEZE, ahIGNORE_AUTH, j_);
         // Already at MaximumAmount
         if (owed <= beast::zero)
             return tecPATH_DRY;
@@ -429,8 +424,7 @@ template <class TDerived>
 std::pair<MPTAmount, DebtDirection>
 MPTEndpointStep<TDerived>::maxPaymentFlow(ReadView const& sb) const
 {
-    auto const maxFlow = accountFunds(
-        sb, src_, mptIssue_, FreezeHandling::fhIGNORE_FREEZE, AuthHandling::ahIGNORE_AUTH, j_);
+    auto const maxFlow = accountFunds(sb, src_, mptIssue_, fhIGNORE_FREEZE, 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 67f9a294b7..c2f2fed25b 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(),
-            FreezeHandling::fhZERO_IF_FROZEN,
-            AuthHandling::ahZERO_IF_UNAUTHORIZED,
+            fhZERO_IF_FROZEN,
+            ahZERO_IF_UNAUTHORIZED,
             j_);
 
         // Check for unfunded offer
@@ -281,8 +281,8 @@ TOfferStreamBase<TIn, TOut>::step()
                 offer_.owner(),
                 amount.out,
                 offer_.assetOut(),
-                FreezeHandling::fhZERO_IF_FROZEN,
-                AuthHandling::ahZERO_IF_UNAUTHORIZED,
+                fhZERO_IF_FROZEN,
+                ahZERO_IF_UNAUTHORIZED,
                 j_);
 
             if (original_funds == *ownerFunds_)
@@ -306,8 +306,8 @@ TOfferStreamBase<TIn, TOut>::step()
                 offer_.owner(),
                 amount.out,
                 offer_.assetOut(),
-                FreezeHandling::fhZERO_IF_FROZEN,
-                AuthHandling::ahZERO_IF_UNAUTHORIZED,
+                fhZERO_IF_FROZEN,
+                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 2310f72f34..95228ed158 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 != OfferCrossing::no)
+    if (ctx.offerCrossing != 0u)
     {
         auto offerCrossingStep = std::make_unique<XRPEndpointOfferCrossingStep>(ctx, acc);
         ter = offerCrossingStep->check(ctx);
diff --git a/src/libxrpl/tx/transactors/account/AccountSet.cpp b/src/libxrpl/tx/transactors/account/AccountSet.cpp
index e8555ecc04..a892bd045c 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::Category::blocker;
+            return TxConsequences::blocker;
 
         if (auto const uSetFlag = tx[~sfSetFlag]; uSetFlag &&
             (*uSetFlag == asfRequireAuth || *uSetFlag == asfDisableMaster ||
              *uSetFlag == asfAccountTxnID))
-            return TxConsequences::Category::blocker;
+            return TxConsequences::blocker;
 
         if (auto const uClearFlag = tx[~sfClearFlag]; uClearFlag &&
             (*uClearFlag == asfRequireAuth || *uClearFlag == asfDisableMaster ||
              *uClearFlag == asfAccountTxnID))
-            return TxConsequences::Category::blocker;
+            return TxConsequences::blocker;
 
-        return TxConsequences::Category::normal;
+        return TxConsequences::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 ee4cf583f4..87eb69e706 100644
--- a/src/libxrpl/tx/transactors/account/SignerListSet.cpp
+++ b/src/libxrpl/tx/transactors/account/SignerListSet.cpp
@@ -46,7 +46,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 = Operation::unknown;
+    Operation op = unknown;
 
     bool const hasSignerEntries(tx.isFieldPresent(sfSignerEntries));
     if ((quorum != 0u) && hasSignerEntries)
@@ -60,11 +60,11 @@ SignerListSet::determineOperation(STTx const& tx, ApplyFlags flags, beast::Journ
 
         // Save deserialized list for later.
         sign = std::move(*signers);
-        op = Operation::set;
+        op = set;
     }
     else if ((quorum == 0) && !hasSignerEntries)
     {
-        op = Operation::destroy;
+        op = destroy;
     }
 
     return std::make_tuple(tesSUCCESS, quorum, sign, op);
@@ -85,14 +85,14 @@ SignerListSet::preflight(PreflightContext const& ctx)
     if (!isTesSuccess(std::get<0>(result)))
         return std::get<0>(result);
 
-    if (std::get<3>(result) == Operation::unknown)
+    if (std::get<3>(result) == 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) == Operation::set)
+    if (std::get<3>(result) == set)
     {
         // Validate our settings.
         auto const account = ctx.tx.getAccountID(sfAccount);
@@ -113,10 +113,10 @@ SignerListSet::doApply()
     // Perform the operation preCompute() decided on.
     switch (do_)
     {
-        case Operation::set:
+        case set:
             return replaceSignerList();
 
-        case Operation::destroy:
+        case destroy:
             return destroySignerList();
 
         default:
@@ -137,7 +137,7 @@ SignerListSet::preCompute()
         isTesSuccess(std::get<0>(result)),
         "xrpl::SignerListSet::preCompute : result is tesSUCCESS");
     XRPL_ASSERT(
-        std::get<3>(result) != Operation::unknown,
+        std::get<3>(result) != 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 31bca0aa32..4498a3cd8e 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,
-                FreezeHandling::fhZERO_IF_FROZEN,
-                AuthHandling::ahZERO_IF_UNAUTHORIZED,
+                fhZERO_IF_FROZEN,
+                ahZERO_IF_UNAUTHORIZED,
                 ctx.j)};
 
             // Note that src will have one reserve's worth of additional XRP
diff --git a/src/libxrpl/tx/transactors/dex/OfferCreate.cpp b/src/libxrpl/tx/transactors/dex/OfferCreate.cpp
index 1ce48145f3..119f244185 100644
--- a/src/libxrpl/tx/transactors/dex/OfferCreate.cpp
+++ b/src/libxrpl/tx/transactors/dex/OfferCreate.cpp
@@ -192,13 +192,8 @@ OfferCreate::preclaim(PreclaimContext const& ctx)
 
     // Allow unfunded MPT for issuer (OutstandingAmount >= MaximumAmount)
     if ((!saTakerGets.holds<MPTIssue>() || saTakerGets.getIssuer() != id) &&
-        accountFunds(
-            ctx.view,
-            id,
-            saTakerGets,
-            FreezeHandling::fhZERO_IF_FROZEN,
-            AuthHandling::ahZERO_IF_UNAUTHORIZED,
-            viewJ) <= beast::zero)
+        accountFunds(ctx.view, id, saTakerGets, fhZERO_IF_FROZEN, ahZERO_IF_UNAUTHORIZED, viewJ) <=
+            beast::zero)
     {
         JLOG(ctx.j.debug()) << "delay: Offers must be at least partially funded.";
         return tecUNFUNDED_OFFER;
@@ -343,12 +338,7 @@ 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,
-            FreezeHandling::fhZERO_IF_FROZEN,
-            AuthHandling::ahZERO_IF_UNAUTHORIZED,
-            j_);
+            psb, account_, takerAmount.in, fhZERO_IF_FROZEN, ahZERO_IF_UNAUTHORIZED, j_);
         // Allow unfunded MPT issuer
         auto const disallowUnfunded =
             !inStartBalance.holds<MPTIssue>() || inStartBalance.getIssuer() != account_;
@@ -458,12 +448,7 @@ OfferCreate::flowCross(
         if (isTesSuccess(result.result()))
         {
             STAmount const takerInBalance = accountFunds(
-                psb,
-                account_,
-                takerAmount.in,
-                FreezeHandling::fhZERO_IF_FROZEN,
-                AuthHandling::ahZERO_IF_UNAUTHORIZED,
-                j_);
+                psb, account_, takerAmount.in, fhZERO_IF_FROZEN, 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 c112d3b349..9d16d41914 100644
--- a/src/libxrpl/tx/transactors/escrow/EscrowCreate.cpp
+++ b/src/libxrpl/tx/transactors/escrow/EscrowCreate.cpp
@@ -228,8 +228,8 @@ escrowCreatePreclaimHelper<Issue>(
     if (isFrozen(ctx.view, dest, issue))
         return tecFROZEN;
 
-    STAmount const spendableAmount = accountHolds(
-        ctx.view, account, issue.currency, issuer, FreezeHandling::fhIGNORE_FREEZE, ctx.j);
+    STAmount const spendableAmount =
+        accountHolds(ctx.view, account, issue.currency, issuer, fhIGNORE_FREEZE, ctx.j);
 
     // If the balance is less than or equal to 0, return tecINSUFFICIENT_FUNDS
     if (spendableAmount <= beast::zero)
@@ -305,12 +305,7 @@ escrowCreatePreclaimHelper<MPTIssue>(
         return ter;
 
     STAmount const spendableAmount = accountHolds(
-        ctx.view,
-        account,
-        amount.get<MPTIssue>(),
-        FreezeHandling::fhIGNORE_FREEZE,
-        AuthHandling::ahIGNORE_AUTH,
-        ctx.j);
+        ctx.view, account, amount.get<MPTIssue>(), fhIGNORE_FREEZE, 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 6dc57479e6..36ff1cc2de 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::rounding_mode::upward);
+        NumberRoundModeGuard const mg1(Number::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::rounding_mode::downward);
+        NumberRoundModeGuard const mg2(Number::downward);
         return sleBroker[sfCoverAvailable] - minRequiredCover;
     }();
     if (maxClawAmount <= beast::zero)
@@ -295,12 +295,8 @@ 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,
-            FreezeHandling::fhIGNORE_FREEZE,
-            AuthHandling::ahIGNORE_AUTH,
-            ctx.j) < clawAmount)
+            ctx.view, brokerPseudoAccountID, vaultAsset, fhIGNORE_FREEZE, 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 06f2e518ab..7061ec99c3 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::rounding_mode::upward);
+        NumberRoundModeGuard const mg(Number::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 8343b6e931..6b1abe45aa 100644
--- a/src/libxrpl/tx/transactors/lending/LoanBrokerDelete.cpp
+++ b/src/libxrpl/tx/transactors/lending/LoanBrokerDelete.cpp
@@ -81,8 +81,7 @@ LoanBrokerDelete::preclaim(PreclaimContext const& ctx)
         // Delete. This check is purely defensive.
         auto const scale = getAssetsTotalScale(vault);
 
-        auto const rounded =
-            roundToAsset(asset, debtTotal, scale, Number::rounding_mode::towards_zero);
+        auto const rounded = roundToAsset(asset, debtTotal, scale, Number::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 875af3a03b..784bef7d78 100644
--- a/src/libxrpl/tx/transactors/lending/LoanDelete.cpp
+++ b/src/libxrpl/tx/transactors/lending/LoanDelete.cpp
@@ -124,7 +124,7 @@ LoanDelete::doApply()
                     vaultSle->at(sfAsset),
                     debtTotalProxy,
                     getAssetsTotalScale(vaultSle),
-                    Number::rounding_mode::towards_zero) == beast::zero,
+                    Number::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 de3de6ca25..87afc2d908 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::rounding_mode::upward);
+        NumberRoundModeGuard const mg(Number::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::rounding_mode::downward);
+        auto const vaultDefaultRounded =
+            roundToAsset(vaultAsset, vaultDefaultAmount, vaultScale, Number::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 f24fdc19b3..c08518a93e 100644
--- a/src/libxrpl/tx/transactors/lending/LoanPay.cpp
+++ b/src/libxrpl/tx/transactors/lending/LoanPay.cpp
@@ -138,14 +138,12 @@ 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::rounding_mode::upward
-                                     : Number::rounding_mode::downward);
+    NumberRoundModeGuard const mg(tx.isFlag(tfLoanOverpayment) ? Number::upward : Number::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::rounding_mode::upward);
+    Number::setround(Number::upward);
     auto const feeIncrements = std::max(
         std::int64_t(1),
         static_cast<std::int64_t>(numPaymentEstimate / loanPaymentsPerFeeIncrement));
@@ -242,8 +240,8 @@ LoanPay::preclaim(PreclaimContext const& ctx)
             ctx.view,
             account,
             asset,
-            FreezeHandling::fhZERO_IF_FROZEN,
-            AuthHandling::ahZERO_IF_UNAUTHORIZED,
+            fhZERO_IF_FROZEN,
+            ahZERO_IF_UNAUTHORIZED,
             ctx.j,
             SpendableHandling::shFULL_BALANCE);
         balance < amount)
@@ -300,7 +298,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::rounding_mode::upward);
+        NumberRoundModeGuard const mg(Number::upward);
         return coverAvailableProxy >=
             roundToAsset(
                    asset, tenthBipsOfValue(debtTotalProxy.value(), coverRateMinimum), loanScale) &&
@@ -406,7 +404,7 @@ LoanPay::doApply()
 
     auto const totalPaidToVaultRaw = paymentParts->principalPaid + paymentParts->interestPaid;
     auto const totalPaidToVaultRounded =
-        roundToAsset(asset, totalPaidToVaultRaw, vaultScale, Number::rounding_mode::downward);
+        roundToAsset(asset, totalPaidToVaultRaw, vaultScale, Number::downward);
     XRPL_ASSERT_PARTS(
         !asset.integral() || totalPaidToVaultRaw == totalPaidToVaultRounded,
         "xrpl::LoanPay::doApply",
@@ -513,8 +511,8 @@ LoanPay::doApply()
         view,
         account_,
         asset,
-        FreezeHandling::fhIGNORE_FREEZE,
-        AuthHandling::ahIGNORE_AUTH,
+        fhIGNORE_FREEZE,
+        ahIGNORE_AUTH,
         j_,
         SpendableHandling::shFULL_BALANCE);
     auto const vaultBalanceBefore = account_ == vaultPseudoAccount
@@ -523,8 +521,8 @@ LoanPay::doApply()
               view,
               vaultPseudoAccount,
               asset,
-              FreezeHandling::fhIGNORE_FREEZE,
-              AuthHandling::ahIGNORE_AUTH,
+              fhIGNORE_FREEZE,
+              ahIGNORE_AUTH,
               j_,
               SpendableHandling::shFULL_BALANCE);
     auto const brokerBalanceBefore = account_ == brokerPayee
@@ -533,8 +531,8 @@ LoanPay::doApply()
               view,
               brokerPayee,
               asset,
-              FreezeHandling::fhIGNORE_FREEZE,
-              AuthHandling::ahIGNORE_AUTH,
+              fhIGNORE_FREEZE,
+              ahIGNORE_AUTH,
               j_,
               SpendableHandling::shFULL_BALANCE);
 #endif
@@ -590,8 +588,8 @@ LoanPay::doApply()
         view,
         account_,
         asset,
-        FreezeHandling::fhIGNORE_FREEZE,
-        AuthHandling::ahIGNORE_AUTH,
+        fhIGNORE_FREEZE,
+        ahIGNORE_AUTH,
         j_,
         SpendableHandling::shFULL_BALANCE);
     auto const vaultBalanceAfter = account_ == vaultPseudoAccount
@@ -600,8 +598,8 @@ LoanPay::doApply()
               view,
               vaultPseudoAccount,
               asset,
-              FreezeHandling::fhIGNORE_FREEZE,
-              AuthHandling::ahIGNORE_AUTH,
+              fhIGNORE_FREEZE,
+              ahIGNORE_AUTH,
               j_,
               SpendableHandling::shFULL_BALANCE);
     auto const brokerBalanceAfter = account_ == brokerPayee
@@ -610,8 +608,8 @@ LoanPay::doApply()
               view,
               brokerPayee,
               asset,
-              FreezeHandling::fhIGNORE_FREEZE,
-              AuthHandling::ahIGNORE_AUTH,
+              fhIGNORE_FREEZE,
+              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 757ec0ec66..48a6005c7b 100644
--- a/src/libxrpl/tx/transactors/lending/LoanSet.cpp
+++ b/src/libxrpl/tx/transactors/lending/LoanSet.cpp
@@ -495,7 +495,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::rounding_mode::upward);
+        NumberRoundModeGuard const mg(Number::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 9de382733d..296020ff95 100644
--- a/src/libxrpl/tx/transactors/nft/NFTokenAcceptOffer.cpp
+++ b/src/libxrpl/tx/transactors/nft/NFTokenAcceptOffer.cpp
@@ -189,8 +189,7 @@ NFTokenAcceptOffer::preclaim(PreclaimContext const& ctx)
         // own currency
         auto const needed = bo->at(sfAmount);
 
-        if (accountFunds(
-                ctx.view, (*bo)[sfOwner], needed, FreezeHandling::fhZERO_IF_FROZEN, ctx.j) < needed)
+        if (accountFunds(ctx.view, (*bo)[sfOwner], needed, fhZERO_IF_FROZEN, ctx.j) < needed)
             return tecINSUFFICIENT_FUNDS;
 
         // Check that the account accepting the buy offer (he's selling the NFT)
@@ -258,9 +257,7 @@ 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, FreezeHandling::fhZERO_IF_FROZEN, ctx.j) <
-                needed)
+            if (accountFunds(ctx.view, ctx.tx[sfAccount], needed, fhZERO_IF_FROZEN, ctx.j) < needed)
                 return tecINSUFFICIENT_FUNDS;
         }
 
@@ -348,9 +345,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, FreezeHandling::fhZERO_IF_FROZEN, j_).signum() < 0)
+    if (accountFunds(view(), from, amount, fhZERO_IF_FROZEN, j_).signum() < 0)
         return tecINSUFFICIENT_FUNDS;
-    if (accountFunds(view(), to, amount, FreezeHandling::fhZERO_IF_FROZEN, j_).signum() < 0)
+    if (accountFunds(view(), to, amount, 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 07ec677288..27cbad2e88 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 (static_cast<FixType>(ctx.tx[sfLedgerFixType]))
+    switch (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 (static_cast<FixType>(ctx.tx[sfLedgerFixType]) == FixType::nfTokenPageLink)
+    if (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 (static_cast<FixType>(ctx_.tx[sfLedgerFixType]) == FixType::nfTokenPageLink)
+    if (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 ff20bd82c3..c9e6d32f6c 100644
--- a/src/libxrpl/tx/transactors/token/Clawback.cpp
+++ b/src/libxrpl/tx/transactors/token/Clawback.cpp
@@ -138,12 +138,8 @@ 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,
-            FreezeHandling::fhIGNORE_FREEZE,
-            ctx.j) <= beast::zero)
+            ctx.view, holder, clawAmount.get<Issue>().currency, issuer, fhIGNORE_FREEZE, ctx.j) <=
+        beast::zero)
         return tecINSUFFICIENT_FUNDS;
 
     return tesSUCCESS;
@@ -173,12 +169,8 @@ preclaimHelper<MPTIssue>(
         return tecOBJECT_NOT_FOUND;
 
     if (accountHolds(
-            ctx.view,
-            holder,
-            clawAmount.get<MPTIssue>(),
-            FreezeHandling::fhIGNORE_FREEZE,
-            AuthHandling::ahIGNORE_AUTH,
-            ctx.j) <= beast::zero)
+            ctx.view, holder, clawAmount.get<MPTIssue>(), fhIGNORE_FREEZE, ahIGNORE_AUTH, ctx.j) <=
+        beast::zero)
         return tecINSUFFICIENT_FUNDS;
 
     return tesSUCCESS;
@@ -237,7 +229,7 @@ applyHelper<Issue>(ApplyContext& ctx)
         holder,
         clawAmount.get<Issue>().currency,
         clawAmount.getIssuer(),
-        FreezeHandling::fhIGNORE_FREEZE,
+        fhIGNORE_FREEZE,
         ctx.journal);
 
     return directSendNoFee(
@@ -257,8 +249,8 @@ applyHelper<MPTIssue>(ApplyContext& ctx)
         ctx.view(),
         holder,
         clawAmount.get<MPTIssue>(),
-        FreezeHandling::fhIGNORE_FREEZE,
-        AuthHandling::ahIGNORE_AUTH,
+        fhIGNORE_FREEZE,
+        ahIGNORE_AUTH,
         ctx.journal);
 
     return directSendNoFee(
diff --git a/src/test/app/AMMExtended_test.cpp b/src/test/app/AMMExtended_test.cpp
index 9eb7eb1620..c94f0f405f 100644
--- a/src/test/app/AMMExtended_test.cpp
+++ b/src/test/app/AMMExtended_test.cpp
@@ -68,7 +68,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::mantissa_scale::small};
+    NumberMantissaScaleGuard const sg_{xrpl::MantissaRange::small};
 
 private:
     void
diff --git a/src/test/app/AMM_test.cpp b/src/test/app/AMM_test.cpp
index d79bd667dd..d2d7fbf2c7 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::mantissa_scale::small};
+    NumberMantissaScaleGuard const sg_{xrpl::MantissaRange::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::mantissa_scale::small);
+        NumberMantissaScaleGuard const sg(MantissaRange::small);
 
         for (auto const& t : tests)
         {
@@ -6792,9 +6792,8 @@ private:
     {
         auto const [amount, amount2, lptBalance] = amm.balances(GBP, EUR);
 
-        NumberMantissaScaleGuard const sg(MantissaRange::mantissa_scale::small);
-        NumberRoundModeGuard const g(
-            env.enabled(fixAMMv1_3) ? Number::rounding_mode::upward : Number::getround());
+        NumberMantissaScaleGuard const sg(MantissaRange::small);
+        NumberRoundModeGuard const g(env.enabled(fixAMMv1_3) ? Number::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 d5847c5a85..5ed8c79146 100644
--- a/src/test/app/Delegate_test.cpp
+++ b/src/test/app/Delegate_test.cpp
@@ -1860,10 +1860,10 @@ class Delegate_test : public beast::unit_test::suite
 #pragma push_macro("TRANSACTION")
 #undef TRANSACTION
 
-#define TRANSACTION(tag, value, name, txDelegable, ...) \
-    if (txDelegable == xrpl::delegable)                 \
-    {                                                   \
-        delegableCount++;                               \
+#define TRANSACTION(tag, value, name, delegable, ...) \
+    if (delegable == xrpl::delegable)                 \
+    {                                                 \
+        delegableCount++;                             \
     }
 
 #include <xrpl/protocol/detail/transactions.macro>
@@ -1889,7 +1889,7 @@ class Delegate_test : public beast::unit_test::suite
         // DO NOT modify expectedDelegableCount unless all scenarios, including
         // edge cases, have been fully tested and verified.
         // ====================================================================
-        std::size_t const expectedDelegableCount = 51;
+        std::size_t const expectedDelegableCount = 75;
 
         BEAST_EXPECTS(
             delegableCount == expectedDelegableCount,
diff --git a/src/test/app/Invariants_test.cpp b/src/test/app/Invariants_test.cpp
index c7fe90daa7..5153e9d71e 100644
--- a/src/test/app/Invariants_test.cpp
+++ b/src/test/app/Invariants_test.cpp
@@ -4116,7 +4116,7 @@ class Invariants_test : public beast::unit_test::suite
             std::vector<ValidVault::DeltaInfo> values;
         };
 
-        NumberMantissaScaleGuard const g{MantissaRange::mantissa_scale::large};
+        NumberMantissaScaleGuard const g{MantissaRange::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 73944b617c..e78bdc588f 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(NodeObjectType::hotACCOUNT_NODE);
-            res->txMap().flushDirty(NodeObjectType::hotTRANSACTION_NODE);
+            res->stateMap().flushDirty(hotACCOUNT_NODE);
+            res->txMap().flushDirty(hotTRANSACTION_NODE);
         }
         res->unshare();
 
diff --git a/src/test/app/LoanBroker_test.cpp b/src/test/app/LoanBroker_test.cpp
index 1ffc34bdcc..55818b131c 100644
--- a/src/test/app/LoanBroker_test.cpp
+++ b/src/test/app/LoanBroker_test.cpp
@@ -847,7 +847,7 @@ class LoanBroker_test : public beast::unit_test::suite
         BEAST_EXPECT(env.ownerCount(alice) == aliceOriginalCount);
     }
 
-    enum class LoanBrokerTest { CoverClawback, CoverDeposit, CoverWithdraw, Delete, Set };
+    enum LoanBrokerTest { CoverClawback, CoverDeposit, CoverWithdraw, Delete, Set };
 
     void
     testLoanBroker(
@@ -922,7 +922,7 @@ class LoanBroker_test : public beast::unit_test::suite
             env(jv, txflags(tfFullyCanonicalSig), ter(temINVALID));
         };
 
-        if (brokerTest == LoanBrokerTest::CoverDeposit)
+        if (brokerTest == CoverDeposit)
         {
             // preflight: temINVALID (empty/zero broker id)
             testZeroBrokerID([&]() { return coverDeposit(alice, brokerKeylet.key, asset(10)); });
@@ -948,7 +948,7 @@ class LoanBroker_test : public beast::unit_test::suite
         }
         env.close();
 
-        if (brokerTest == LoanBrokerTest::CoverWithdraw)
+        if (brokerTest == CoverWithdraw)
         {
             // preflight: temINVALID (empty/zero broker id)
             testZeroBrokerID([&]() { return coverWithdraw(alice, brokerKeylet.key, asset(10)); });
@@ -1001,7 +1001,7 @@ class LoanBroker_test : public beast::unit_test::suite
                 ter(tecPSEUDO_ACCOUNT));
         }
 
-        if (brokerTest == LoanBrokerTest::CoverClawback)
+        if (brokerTest == CoverClawback)
         {
             // preflight: temINVALID (empty/zero broker id)
             testZeroBrokerID([&]() {
@@ -1038,7 +1038,7 @@ class LoanBroker_test : public beast::unit_test::suite
             env.close();
         }
 
-        if (brokerTest == LoanBrokerTest::Delete)
+        if (brokerTest == Delete)
         {
             Account const borrower{"borrower"};
             env.fund(XRP(1'000), borrower);
@@ -1070,7 +1070,7 @@ class LoanBroker_test : public beast::unit_test::suite
             env(del(alice, brokerKeylet.key));
         }
 
-        if (brokerTest == LoanBrokerTest::Set)
+        if (brokerTest == Set)
         {
             // preflight: temINVALID (empty/zero broker id)
             testZeroBrokerID([&]() {
@@ -1138,7 +1138,7 @@ class LoanBroker_test : public beast::unit_test::suite
 
         // Issue:
         // AllowTrustLineClawback is not set or NoFreeze is set
-        testLoanBroker({}, LoanBrokerTest::CoverClawback);
+        testLoanBroker({}, CoverClawback);
 
         // MPTIssue:
         // MPTCanClawback is not set
@@ -1147,7 +1147,7 @@ class LoanBroker_test : public beast::unit_test::suite
                 MPTTester const mpt({.env = env, .issuer = issuer, .holders = {alice}});
                 return mpt;
             },
-            LoanBrokerTest::CoverClawback);
+            CoverClawback);
     }
 
     void
@@ -1158,7 +1158,7 @@ class LoanBroker_test : public beast::unit_test::suite
 
         // preclaim:
         // tecWRONG_ASSET, tecINSUFFICIENT_FUNDS, frozen asset
-        testLoanBroker({}, LoanBrokerTest::CoverDeposit);
+        testLoanBroker({}, CoverDeposit);
     }
 
     void
@@ -1177,7 +1177,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({}, LoanBrokerTest::CoverWithdraw);
+        testLoanBroker({}, CoverWithdraw);
     }
 
     void
@@ -1191,7 +1191,7 @@ class LoanBroker_test : public beast::unit_test::suite
             accountSend failure, removeEmptyHolding failure,
             all tecHAS_OBLIGATIONS (can any of these happen?)
         */
-        testLoanBroker({}, LoanBrokerTest::Delete);
+        testLoanBroker({}, Delete);
     }
 
     void
@@ -1207,7 +1207,7 @@ class LoanBroker_test : public beast::unit_test::suite
             addEmptyHolding failure
             can any of these happen?
         */
-        testLoanBroker({}, LoanBrokerTest::Set);
+        testLoanBroker({}, Set);
     }
 
     void
@@ -1585,7 +1585,7 @@ class LoanBroker_test : public beast::unit_test::suite
         Account const dest("destination");
         auto const token = issuer["IOU"];
 
-        enum class TrustState {
+        enum TrustState {
             RequireAuth,
             ZeroLimit,
             ReachedLimit,
@@ -1601,10 +1601,10 @@ class LoanBroker_test : public beast::unit_test::suite
             auto setTrustLine = [&](Account const& acct, TrustState state) {
                 switch (state)
                 {
-                    case TrustState::RequireAuth:
+                    case RequireAuth:
                         env(trust(issuer, token(0), acct, tfSetfAuth));
                         break;
-                    case TrustState::ZeroLimit: {
+                    case ZeroLimit: {
                         auto jv = trust(acct, token(0));
                         // set QualityIn so that the trustline is not
                         // auto-deleted
@@ -1612,19 +1612,19 @@ class LoanBroker_test : public beast::unit_test::suite
                         env(jv);
                     }
                     break;
-                    case TrustState::ReachedLimit: {
+                    case ReachedLimit: {
                         env(trust(acct, token(1'000)));
                         env(pay(issuer, acct, token(1'000)));
                         env.close();
                     }
                     break;
-                    case TrustState::NearLimit: {
+                    case NearLimit: {
                         env(trust(acct, token(1'000)));
                         env(pay(issuer, acct, token(950)));
                         env.close();
                     }
                     break;
-                    case TrustState::NoTrustLine:
+                    case NoTrustLine:
                         // don't create a trustline
                         break;
                     default:
@@ -1636,12 +1636,12 @@ class LoanBroker_test : public beast::unit_test::suite
             env.fund(XRP(1'000), issuer, broker, dest);
             env.close();
 
-            if (trustState == TrustState::RequireAuth)
+            if (trustState == RequireAuth)
             {
                 env(fset(issuer, asfRequireAuth));
                 env.close();
 
-                setTrustLine(broker, TrustState::RequireAuth);
+                setTrustLine(broker, RequireAuth);
             }
 
             setTrustLine(dest, trustState);
@@ -1683,7 +1683,7 @@ class LoanBroker_test : public beast::unit_test::suite
             env.close();
 
             // Clearing RequireAuth shouldn't change the result
-            if (trustState == TrustState::RequireAuth)
+            if (trustState == RequireAuth)
             {
                 env(fclear(issuer, asfRequireAuth));
                 env.close();
@@ -1696,11 +1696,11 @@ class LoanBroker_test : public beast::unit_test::suite
             }
         };
 
-        test(TrustState::RequireAuth);
-        test(TrustState::ZeroLimit);
-        test(TrustState::ReachedLimit);
-        test(TrustState::NearLimit);
-        test(TrustState::NoTrustLine);
+        test(RequireAuth);
+        test(ZeroLimit);
+        test(ReachedLimit);
+        test(NearLimit);
+        test(NoTrustLine);
     }
 
     void
@@ -1711,24 +1711,24 @@ class LoanBroker_test : public beast::unit_test::suite
         Account const broker("issuer");
         Account const dest("destination");
 
-        enum class MPTState {
+        enum 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 MPTState::RequireAuth: {
+                    case RequireAuth: {
                         auto tester = MPTTester(
                             {.env = env,
                              .issuer = issuer,
@@ -1742,7 +1742,7 @@ class LoanBroker_test : public beast::unit_test::suite
                             {.account = issuer, .holder = dest, .flags = tfMPTUnauthorize});
                         return tester;
                     }
-                    case MPTState::ReachedMAX: {
+                    case ReachedMAX: {
                         auto tester = MPTTester(
                             {.env = env,
                              .issuer = issuer,
@@ -1753,7 +1753,7 @@ class LoanBroker_test : public beast::unit_test::suite
                         BEAST_EXPECT(env.balance(issuer, tester) == tester(-4'000));
                         return tester;
                     }
-                    case MPTState::NoMPT: {
+                    case NoMPT: {
                         return MPTTester(
                             {.env = env,
                              .issuer = issuer,
@@ -1785,7 +1785,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 == MPTState::ReachedMAX ? TER(tesSUCCESS) : tecNO_AUTH;
+            TER const err = MPTState == ReachedMAX ? TER(tesSUCCESS) : tecNO_AUTH;
             BEAST_EXPECT(env.ter() == err);
             env.close();
 
@@ -1811,9 +1811,9 @@ class LoanBroker_test : public beast::unit_test::suite
             env.close();
         };
 
-        test(MPTState::RequireAuth);
-        test(MPTState::ReachedMAX);
-        test(MPTState::NoMPT);
+        test(RequireAuth);
+        test(ReachedMAX);
+        test(NoMPT);
     }
 
     void
diff --git a/src/test/app/Loan_test.cpp b/src/test/app/Loan_test.cpp
index f50a7f71d3..3fe727e368 100644
--- a/src/test/app/Loan_test.cpp
+++ b/src/test/app/Loan_test.cpp
@@ -154,7 +154,7 @@ protected:
         [[nodiscard]] Number
         maxCoveredLoanValue(Number const& currentDebt) const
         {
-            NumberRoundModeGuard const mg(Number::rounding_mode::downward);
+            NumberRoundModeGuard const mg(Number::downward);
             auto debtLimit = coverDeposit * tenthBipsPerUnity.value() / coverRateMin.value();
 
             return debtLimit - currentDebt;
@@ -590,7 +590,7 @@ protected:
                  : std::max(broker.vaultScale(env), state.principalOutstanding.exponent())));
         BEAST_EXPECT(state.paymentInterval == 600);
         {
-            NumberRoundModeGuard const mg(Number::rounding_mode::upward);
+            NumberRoundModeGuard const mg(Number::upward);
             BEAST_EXPECT(
                 state.totalValue ==
                 roundToAsset(
@@ -913,8 +913,8 @@ protected:
         }
 
         // Include the service fee
-        STAmount const totalDue = roundToScale(
-            roundedPeriodicPayment + serviceFee, state.loanScale, Number::rounding_mode::upward);
+        STAmount const totalDue =
+            roundToScale(roundedPeriodicPayment + serviceFee, state.loanScale, Number::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::rounding_mode::upward);
+                NumberRoundModeGuard const mg(Number::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::rounding_mode::upward);
+                        NumberRoundModeGuard const mg(Number::upward);
                         auto const rawPayoff =
                             startingPayments * (state.periodicPayment + broker.asset(2).value());
                         STAmount payoffAmount{broker.asset, rawPayoff};
@@ -2519,25 +2519,21 @@ protected:
                 BEAST_EXPECT(
                     roundedPeriodicPayment ==
                     roundToScale(
-                        broker.asset(
-                            Number(8333457002039338267, -17), Number::rounding_mode::upward),
+                        broker.asset(Number(8333457002039338267, -17), Number::upward),
                         state.loanScale,
-                        Number::rounding_mode::upward));
+                        Number::upward));
                 // 83334570.01162141
                 // Include the service fee
                 STAmount const totalDue = roundToScale(
-                    roundedPeriodicPayment + serviceFee,
-                    state.loanScale,
-                    Number::rounding_mode::upward);
+                    roundedPeriodicPayment + serviceFee, state.loanScale, Number::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::rounding_mode::upward),
+                        broker.asset(Number(8533457002039338267, -17), Number::upward),
                         state.loanScale,
-                        Number::rounding_mode::upward));
+                        Number::upward));
 
                 {
                     auto const raw = computeTheoreticalLoanState(
@@ -2565,9 +2561,9 @@ protected:
                 BEAST_EXPECT(
                     transactionAmount ==
                     roundToScale(
-                        broker.asset(Number(9533457002039400, -14), Number::rounding_mode::upward),
+                        broker.asset(Number(9533457002039400, -14), Number::upward),
                         state.loanScale,
-                        Number::rounding_mode::upward));
+                        Number::upward));
 
                 auto const initialState = state;
                 xrpl::detail::PaymentComponents totalPaid{
@@ -2655,16 +2651,11 @@ protected:
                     BEAST_EXPECT(
                         state.paymentRemaining < 12 ||
                         roundToAsset(
-                            broker.asset,
-                            deltas.principal,
-                            state.loanScale,
-                            Number::rounding_mode::upward) ==
+                            broker.asset, deltas.principal, state.loanScale, Number::upward) ==
                             roundToScale(
-                                broker.asset(
-                                    Number(8333228691531218890, -17),
-                                    Number::rounding_mode::upward),
+                                broker.asset(Number(8333228691531218890, -17), Number::upward),
                                 state.loanScale,
-                                Number::rounding_mode::upward));
+                                Number::upward));
                     BEAST_EXPECT(
                         paymentComponents.trackedPrincipalDelta >= beast::zero &&
                         paymentComponents.trackedPrincipalDelta <= state.principalOutstanding);
@@ -5248,7 +5239,7 @@ protected:
 
             // pay all but the last payment
             {
-                NumberRoundModeGuard const mg{Number::rounding_mode::upward};
+                NumberRoundModeGuard const mg{Number::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 681d2f2577..a1c57ccbc2 100644
--- a/src/test/app/MPToken_test.cpp
+++ b/src/test/app/MPToken_test.cpp
@@ -4182,18 +4182,18 @@ class MPToken_test : public beast::unit_test::suite
 
         // Holders are locked
         {
-            enum class LockType { Global, Individual, None };
+            enum LockType { Global, Individual, None };
             struct TestArg
             {
                 Account src;
                 Account dst;
                 Account offerOwner;
-                LockType srcFlag = LockType::None;
-                LockType dstFlag = LockType::None;
-                LockType offerFlagBuy = LockType::None;
-                LockType offerFlagSell = LockType::None;
-                LockType globalFlagBuy = LockType::None;
-                LockType globalFlagSell = LockType::None;
+                LockType srcFlag = None;
+                LockType dstFlag = None;
+                LockType offerFlagBuy = None;
+                LockType offerFlagSell = None;
+                LockType globalFlagBuy = None;
+                LockType globalFlagSell = None;
                 TER err = tesSUCCESS;
                 std::optional<TER> errIOU = std::nullopt;
             };
@@ -4238,11 +4238,11 @@ class MPToken_test : public beast::unit_test::suite
             };
             auto lock = [&]<typename Token>(
                             Env& env, Account const& account, Token& token, LockType lock) {
-                if (lock == LockType::None)
+                if (lock == None)
                     return;
                 if constexpr (std::is_same_v<Token, IOU>)
                 {
-                    if (lock == LockType::Global)
+                    if (lock == Global)
                     {
                         env(fset(gw, asfGlobalFreeze));
                     }
@@ -4254,7 +4254,7 @@ class MPToken_test : public beast::unit_test::suite
                 }
                 else if constexpr (std::is_same_v<Token, MPTTester>)
                 {
-                    if (lock == LockType::Global)
+                    if (lock == Global)
                     {
                         token.set({.flags = tfMPTLock});
                     }
@@ -4303,33 +4303,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 = LockType::Individual, .err = tecPATH_DRY},
+                    {.src = alice, .dst = carol, .offerOwner = bob, .srcFlag = Individual, .err = tecPATH_DRY},
                     // dst can receive IOU even if the account is frozen
-                    {.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},
+                    {.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},
                     // offer's owner can receive IOU even if the account is frozen
-                    {.src = alice, .dst = carol, .offerOwner = bob, .offerFlagBuy = LockType::Individual, .err =
+                    {.src = alice, .dst = carol, .offerOwner = bob, .offerFlagBuy = Individual, .err =
                     tecPATH_PARTIAL, .errIOU = tesSUCCESS},
-                    {.src = alice, .dst = carol, .offerOwner = bob, .offerFlagSell = LockType::Individual, .err = tecPATH_PARTIAL},
+                    {.src = alice, .dst = carol, .offerOwner = bob, .offerFlagSell = Individual, .err = tecPATH_PARTIAL},
                     // src, dst are a holder, offer's owner is an issuer
-                    {.src = alice, .dst = carol, .offerOwner = gw, .srcFlag = LockType::Individual, .err = tecPATH_DRY},
+                    {.src = alice, .dst = carol, .offerOwner = gw, .srcFlag = Individual, .err = tecPATH_DRY},
                     // dst can receive IOU even if the account is frozen
-                    {.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 = 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 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 = LockType::Individual, .err = tecPATH_DRY, .errIOU = tesSUCCESS},
+                    {.src = gw, .dst = carol, .offerOwner = bob, .dstFlag = 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 = LockType::Individual, .err = tecPATH_PARTIAL, .errIOU = tesSUCCESS},
-                    {.src = gw, .dst = carol, .offerOwner = bob, .offerFlagSell = LockType::Individual, .err = tecPATH_PARTIAL},
+                    {.src = gw, .dst = carol, .offerOwner = bob, .offerFlagBuy = Individual, .err = tecPATH_PARTIAL, .errIOU = tesSUCCESS},
+                    {.src = gw, .dst = carol, .offerOwner = bob, .offerFlagSell = Individual, .err = tecPATH_PARTIAL},
                     // dst is issuer, src and offer's owner are a holder
-                    {.src = alice, .dst = gw, .offerOwner = bob, .srcFlag = LockType::Individual, .err = tecPATH_DRY},
+                    {.src = alice, .dst = gw, .offerOwner = bob, .srcFlag = Individual, .err = tecPATH_DRY},
                     // offer's owner can receive IOU even if the account is frozen
-                    {.src = alice, .dst = gw, .offerOwner = bob, .offerFlagBuy = LockType::Individual, .err = tecPATH_PARTIAL,
+                    {.src = alice, .dst = gw, .offerOwner = bob, .offerFlagBuy = Individual, .err = tecPATH_PARTIAL,
                      .errIOU = tesSUCCESS},
-                    {.src = alice, .dst = gw, .offerOwner = bob, .offerFlagSell = LockType::Individual, .err = tecPATH_PARTIAL},
+                    {.src = alice, .dst = gw, .offerOwner = bob, .offerFlagSell = Individual, .err = tecPATH_PARTIAL},
             };
             // clang-format on
 
diff --git a/src/test/app/NFTokenBurn_test.cpp b/src/test/app/NFTokenBurn_test.cpp
index efb255ea2d..08d7b4305e 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 class Volume : bool {
+    enum 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 == Volume::noisy)
+                    if (vol == 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 a1527e8601..5764e87f76 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 class Volume : bool {
+    enum 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 == Volume::noisy)
+                    if (vol == 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::AcctStringType::base58Seed, std::string(seed));
+                    accounts.emplace_back(Account::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::AcctStringType::base58Seed, std::string(seed));
+                    accounts.emplace_back(Account::base58Seed, std::string(seed));
                 env.fund(XRP(10000), account);
 
                 // Do not close the ledger inside the loop.  If accounts are
@@ -624,8 +624,7 @@ 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::AcctStringType::base58Seed, std::string(seed));
+            Account const& account = accounts.emplace_back(Account::base58Seed, std::string(seed));
             env.fund(XRP(10000), account);
 
             // Do not close the ledger inside the loop.  If accounts are
@@ -788,8 +787,7 @@ 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::AcctStringType::base58Seed, std::string(seed));
+            Account const& account = accounts.emplace_back(Account::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 f67c2ce9c2..b07fe043d2 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 class preAuthType { noPreAuth, acctPreAuth };
+        enum 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=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},
+            {.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},
             //---------------- 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=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},
+            {.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},
         };
         // 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 == preAuthType::acctPreAuth)
+            if (t.preAuth == acctPreAuth)
                 MUSD.authorize({.account = acct});
             env.close();
 
@@ -2120,7 +2120,7 @@ public:
                 BEAST_EXPECT(acctOffer[sfTakerPays] == USD(leftover));
             }
 
-            if (t.preAuth == preAuthType::noPreAuth)
+            if (t.preAuth == noPreAuth)
             {
                 if (t.balanceUsd.value().signum() != 0)
                 {
diff --git a/src/test/app/Offer_test.cpp b/src/test/app/Offer_test.cpp
index 78bdd3fef2..0c00c91f63 100644
--- a/src/test/app/Offer_test.cpp
+++ b/src/test/app/Offer_test.cpp
@@ -2228,7 +2228,7 @@ public:
         auto const f = env.current()->fees().base;
 
         // To keep things simple all offers are 1 : 1 for XRP : USD.
-        enum class preTrustType { noPreTrust, gwPreTrust, acctPreTrust };
+        enum preTrustType { noPreTrust, gwPreTrust, acctPreTrust };
         struct TestData
         {
             std::string account;      // Account operated on
@@ -2246,45 +2246,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=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},
+            {.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},
             //---------------- Pre-established trust lines ---------------------
-            {.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="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="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},
+            {.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},
         };
         // clang-format on
 
@@ -2305,14 +2305,14 @@ public:
             std::uint32_t const gwOfferSeq = env.seq(gw) - 1;
 
             // Optionally pre-establish a trustline between gw and acct.
-            if (t.preTrust == preTrustType::gwPreTrust)
+            if (t.preTrust == 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 == preTrustType::acctPreTrust)
+            if (t.preTrust == acctPreTrust)
                 env(trust(acct, USD(1)));
             env.close();
 
@@ -2340,7 +2340,7 @@ public:
                 BEAST_EXPECT(acctOffer[sfTakerPays] == USD(leftover));
             }
 
-            if (t.preTrust == preTrustType::noPreTrust)
+            if (t.preTrust == noPreTrust)
             {
                 if (t.balanceUsd.value().signum() != 0)
                 {
@@ -2675,7 +2675,7 @@ public:
         auto const f = env.current()->fees().base;
 
         // To keep things simple all offers are 1 : 1 for XRP : USD.
-        enum class preTrustType { noPreTrust, gwPreTrust, acctPreTrust };
+        enum 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 e6d27de415..505d052faa 100644
--- a/src/test/app/Path_test.cpp
+++ b/src/test/app/Path_test.cpp
@@ -132,7 +132,7 @@ public:
         void
         signal()
         {
-            std::scoped_lock const lk(mutex_);
+            std::lock_guard const lk(mutex_);
             signaled_ = true;
             cv_.notify_all();
         }
diff --git a/src/test/app/XChain_test.cpp b/src/test/app/XChain_test.cpp
index c790895921..3f49ab42bb 100644
--- a/src/test/app/XChain_test.cpp
+++ b/src/test/app/XChain_test.cpp
@@ -4025,7 +4025,7 @@ private:
         ChainStateTrack b_;
     };
 
-    enum class SmState {
+    enum SmState {
         st_initial,
         st_claim_id_created,
         st_attesting,
@@ -4034,6 +4034,8 @@ private:
         st_closed,
     };
 
+    enum Act_Flags { af_a2b = 1 << 0 };
+
     // --------------------------------------------------
     template <class T>
     class SmBase
@@ -4167,7 +4169,7 @@ private:
                 st.spend(dstDoor(), reward, num_attestors);
                 st.transfer(dstDoor(), cr.to, cr.amt);
                 st.env.env_.memoize(cr.to);
-                sm_state = SmState::st_completed;
+                sm_state = st_completed;
             };
 
             counters.create_callbacks[cr.claim_id - 1] = std::move(complete_cb);
@@ -4178,12 +4180,12 @@ private:
         {
             switch (sm_state)
             {
-                case SmState::st_initial:
+                case st_initial:
                     cr.claim_id = issue_account_create();
-                    sm_state = SmState::st_attesting;
+                    sm_state = st_attesting;
                     break;
 
-                case SmState::st_attesting:
+                case st_attesting:
                     attest(time, rnd);
                     break;
 
@@ -4191,14 +4193,14 @@ private:
                     assert(0);
                     break;
 
-                case SmState::st_completed:
+                case st_completed:
                     break;  // will get this once
             }
             return sm_state;
         }
 
     private:
-        SmState sm_state{SmState::st_initial};
+        SmState sm_state{st_initial};
         AccountCreate cr;
     };
 
@@ -4327,36 +4329,35 @@ private:
         {
             switch (sm_state)
             {
-                case SmState::st_initial:
+                case st_initial:
                     xfer.claim_id = create_claim_id();
-                    sm_state = SmState::st_claim_id_created;
+                    sm_state = st_claim_id_created;
                     break;
 
-                case SmState::st_claim_id_created:
+                case st_claim_id_created:
                     commit();
-                    sm_state = SmState::st_attesting;
+                    sm_state = st_attesting;
                     break;
 
-                case SmState::st_attesting:
+                case st_attesting:
                     if (attest(time, rnd))
                     {
-                        sm_state = xfer.with_claim == WithClaim::yes ? SmState::st_attested
-                                                                     : SmState::st_completed;
+                        sm_state = xfer.with_claim == WithClaim::yes ? st_attested : st_completed;
                     }
                     else
                     {
-                        sm_state = SmState::st_attesting;
+                        sm_state = st_attesting;
                     }
                     break;
 
-                case SmState::st_attested:
+                case st_attested:
                     assert(xfer.with_claim == WithClaim::yes);
                     claim();
-                    sm_state = SmState::st_completed;
+                    sm_state = st_completed;
                     break;
 
                 default:
-                case SmState::st_completed:
+                case st_completed:
                     assert(0);  // should have been removed
                     break;
             }
@@ -4365,7 +4366,7 @@ private:
 
     private:
         Transfer xfer;
-        SmState sm_state{SmState::st_initial};
+        SmState sm_state{st_initial};
     };
 
     // --------------------------------------------------
@@ -4412,7 +4413,7 @@ public:
                     return sm.advance(time, rnd);
                 };
                 auto& [t, sm] = *it;
-                if (t <= time && std::visit(vis, sm) == SmState::st_completed)
+                if (t <= time && std::visit(vis, sm) == st_completed)
                 {
                     it = sm_.erase(it);
                 }
diff --git a/src/test/basics/IOUAmount_test.cpp b/src/test/basics/IOUAmount_test.cpp
index 5c01445e31..95362c7545 100644
--- a/src/test/basics/IOUAmount_test.cpp
+++ b/src/test/basics/IOUAmount_test.cpp
@@ -156,8 +156,7 @@ public:
             BEAST_EXPECTS(result == expected, ss.str());
         };
 
-        for (auto const mantissaSize :
-             {MantissaRange::mantissa_scale::small, MantissaRange::mantissa_scale::large})
+        for (auto const mantissaSize : {MantissaRange::small, MantissaRange::large})
         {
             NumberMantissaScaleGuard const mg(mantissaSize);
 
diff --git a/src/test/basics/Number_test.cpp b/src/test/basics/Number_test.cpp
index 607ae004b1..cc7ccaa8c2 100644
--- a/src/test/basics/Number_test.cpp
+++ b/src/test/basics/Number_test.cpp
@@ -75,21 +75,20 @@ public:
 
         test(
             Number{std::numeric_limits<std::int64_t>::min()},
-            scale == MantissaRange::mantissa_scale::small
+            scale == MantissaRange::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::mantissa_scale::small ? Number{-9'223'372'036'854'776, 3}
-                                                          : Number{-9'223'372'036'854'775'807},
+            scale == MantissaRange::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::mantissa_scale::small
-                    ? 9'223'372'036'854'776
-                    : std::numeric_limits<std::int64_t>::max(),
+                scale == MantissaRange::small ? 9'223'372'036'854'776
+                                              : std::numeric_limits<std::int64_t>::max(),
                 18 - Number::mantissaLog()},
             __LINE__);
         caught = false;
@@ -208,7 +207,7 @@ public:
                 BEAST_EXPECTS(result == z, ss.str());
             }
         };
-        if (scale == MantissaRange::mantissa_scale::small)
+        if (scale == MantissaRange::small)
         {
             test(cSmall);
         }
@@ -304,7 +303,7 @@ public:
                 BEAST_EXPECTS(result == z, ss.str());
             }
         };
-        if (scale == MantissaRange::mantissa_scale::small)
+        if (scale == MantissaRange::small)
         {
             test(cSmall);
         }
@@ -331,7 +330,7 @@ public:
             }
         };
         auto tests = [&](auto const& cSmall, auto const& cLarge) {
-            if (scale == MantissaRange::mantissa_scale::small)
+            if (scale == MantissaRange::small)
             {
                 test(cSmall);
             }
@@ -342,7 +341,7 @@ public:
         };
         auto const maxMantissa = Number::maxMantissa();
 
-        saveNumberRoundMode const save{Number::setround(Number::rounding_mode::to_nearest)};
+        saveNumberRoundMode const save{Number::setround(Number::to_nearest)};
         {
             auto const cSmall = std::to_array<Case>({
                 {Number{7}, Number{8}, Number{56}},
@@ -408,7 +407,7 @@ public:
             });
             tests(cSmall, cLarge);
         }
-        Number::setround(Number::rounding_mode::towards_zero);
+        Number::setround(Number::towards_zero);
         testcase << "test_mul " << to_string(Number::getMantissaScale()) << " towards_zero";
         {
             auto const cSmall = std::to_array<Case>(
@@ -475,7 +474,7 @@ public:
                 });
             tests(cSmall, cLarge);
         }
-        Number::setround(Number::rounding_mode::downward);
+        Number::setround(Number::downward);
         testcase << "test_mul " << to_string(Number::getMantissaScale()) << " downward";
         {
             auto const cSmall = std::to_array<Case>(
@@ -542,7 +541,7 @@ public:
                 });
             tests(cSmall, cLarge);
         }
-        Number::setround(Number::rounding_mode::upward);
+        Number::setround(Number::upward);
         testcase << "test_mul " << to_string(Number::getMantissaScale()) << " upward";
         {
             auto const cSmall = std::to_array<Case>(
@@ -643,7 +642,7 @@ public:
         };
         auto const maxMantissa = Number::maxMantissa();
         auto tests = [&](auto const& cSmall, auto const& cLarge) {
-            if (scale == MantissaRange::mantissa_scale::small)
+            if (scale == MantissaRange::small)
             {
                 test(cSmall);
             }
@@ -652,7 +651,7 @@ public:
                 test(cLarge);
             }
         };
-        saveNumberRoundMode const save{Number::setround(Number::rounding_mode::to_nearest)};
+        saveNumberRoundMode const save{Number::setround(Number::to_nearest)};
         {
             auto const cSmall = std::to_array<Case>(
                 {{Number{1}, Number{2}, Number{5, -1}},
@@ -690,7 +689,7 @@ public:
             tests(cSmall, cLarge);
         }
         testcase << "test_div " << to_string(Number::getMantissaScale()) << " towards_zero";
-        Number::setround(Number::rounding_mode::towards_zero);
+        Number::setround(Number::towards_zero);
         {
             auto const cSmall = std::to_array<Case>(
                 {{Number{1}, Number{2}, Number{5, -1}},
@@ -728,7 +727,7 @@ public:
             tests(cSmall, cLarge);
         }
         testcase << "test_div " << to_string(Number::getMantissaScale()) << " downward";
-        Number::setround(Number::rounding_mode::downward);
+        Number::setround(Number::downward);
         {
             auto const cSmall = std::to_array<Case>(
                 {{Number{1}, Number{2}, Number{5, -1}},
@@ -766,7 +765,7 @@ public:
             tests(cSmall, cLarge);
         }
         testcase << "test_div " << to_string(Number::getMantissaScale()) << " upward";
-        Number::setround(Number::rounding_mode::upward);
+        Number::setround(Number::upward);
         {
             auto const cSmall = std::to_array<Case>(
                 {{Number{1}, Number{2}, Number{5, -1}},
@@ -835,7 +834,7 @@ public:
         /*
         auto tests = [&](auto const& cSmall, auto const& cLarge) {
             test(cSmall);
-            if (scale != MantissaRange::mantissa_scale::small)
+            if (scale != MantissaRange::small)
                 test(cLarge);
         };
         */
@@ -865,9 +864,9 @@ public:
              Number{false, 55'108'98747006743627, -14, Number::normalized{}}},
         });
         test(cSmall);
-        if (Number::getMantissaScale() != MantissaRange::mantissa_scale::small)
+        if (Number::getMantissaScale() != MantissaRange::small)
         {
-            NumberRoundModeGuard const mg(Number::rounding_mode::towards_zero);
+            NumberRoundModeGuard const mg(Number::towards_zero);
             test(cLarge);
         }
         bool caught = false;
@@ -1028,7 +1027,7 @@ public:
     {
         testcase << "test_to_integer " << to_string(Number::getMantissaScale());
         using Case = std::tuple<Number, std::int64_t>;
-        saveNumberRoundMode const save{Number::setround(Number::rounding_mode::to_nearest)};
+        saveNumberRoundMode const save{Number::setround(Number::to_nearest)};
         {
             Case const c[]{
                 {Number{0}, 0},
@@ -1065,8 +1064,8 @@ public:
                 BEAST_EXPECT(j == y);
             }
         }
-        auto prev_mode = Number::setround(Number::rounding_mode::towards_zero);
-        BEAST_EXPECT(prev_mode == Number::rounding_mode::to_nearest);
+        auto prev_mode = Number::setround(Number::towards_zero);
+        BEAST_EXPECT(prev_mode == Number::to_nearest);
         {
             Case const c[]{
                 {Number{0}, 0},
@@ -1103,8 +1102,8 @@ public:
                 BEAST_EXPECT(j == y);
             }
         }
-        prev_mode = Number::setround(Number::rounding_mode::downward);
-        BEAST_EXPECT(prev_mode == Number::rounding_mode::towards_zero);
+        prev_mode = Number::setround(Number::downward);
+        BEAST_EXPECT(prev_mode == Number::towards_zero);
         {
             Case const c[]{
                 {Number{0}, 0},
@@ -1141,8 +1140,8 @@ public:
                 BEAST_EXPECT(j == y);
             }
         }
-        prev_mode = Number::setround(Number::rounding_mode::upward);
-        BEAST_EXPECT(prev_mode == Number::rounding_mode::downward);
+        prev_mode = Number::setround(Number::upward);
+        BEAST_EXPECT(prev_mode == Number::downward);
         {
             Case const c[]{
                 {Number{0}, 0},
@@ -1237,13 +1236,13 @@ public:
 
         switch (scale)
         {
-            case MantissaRange::mantissa_scale::small:
+            case MantissaRange::small:
 
                 test(Number::min(), "1e-32753");
                 test(Number::max(), "9999999999999999e32768");
                 test(Number::lowest(), "-9999999999999999e32768");
                 {
-                    NumberRoundModeGuard const mg(Number::rounding_mode::towards_zero);
+                    NumberRoundModeGuard const mg(Number::towards_zero);
 
                     auto const maxMantissa = Number::maxMantissa();
                     BEAST_EXPECT(maxMantissa == 9'999'999'999'999'999);
@@ -1266,14 +1265,14 @@ public:
                         "9223372036854775e3");
                 }
                 break;
-            case MantissaRange::mantissa_scale::large:
+            case MantissaRange::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::rounding_mode::towards_zero);
+                    NumberRoundModeGuard const mg(Number::towards_zero);
 
                     auto const maxMantissa = Number::maxMantissa();
                     BEAST_EXPECT(maxMantissa == 9'999'999'999'999'999'999ULL);
@@ -1349,19 +1348,19 @@ public:
         NumberSO const stNumberSO{true};
         Issue const issue;
         Number const n{7'518'783'80596, -5};
-        saveNumberRoundMode const save{Number::setround(Number::rounding_mode::to_nearest)};
+        saveNumberRoundMode const save{Number::setround(Number::to_nearest)};
         auto res2 = STAmount{issue, n};
         BEAST_EXPECT(res2 == STAmount{7518784});
 
-        Number::setround(Number::rounding_mode::towards_zero);
+        Number::setround(Number::towards_zero);
         res2 = STAmount{issue, n};
         BEAST_EXPECT(res2 == STAmount{7518783});
 
-        Number::setround(Number::rounding_mode::downward);
+        Number::setround(Number::downward);
         res2 = STAmount{issue, n};
         BEAST_EXPECT(res2 == STAmount{7518783});
 
-        Number::setround(Number::rounding_mode::upward);
+        Number::setround(Number::upward);
         res2 = STAmount{issue, n};
         BEAST_EXPECT(res2 == STAmount{7518784});
     }
@@ -1401,87 +1400,87 @@ public:
         std::map<Number, NumberRoundings> const expected{
             // Positive numbers
             {Number{13, -1},
-             {{Number::rounding_mode::to_nearest, 1},
-              {Number::rounding_mode::towards_zero, 1},
-              {Number::rounding_mode::downward, 1},
-              {Number::rounding_mode::upward, 2}}},
+             {{Number::to_nearest, 1},
+              {Number::towards_zero, 1},
+              {Number::downward, 1},
+              {Number::upward, 2}}},
             {Number{23, -1},
-             {{Number::rounding_mode::to_nearest, 2},
-              {Number::rounding_mode::towards_zero, 2},
-              {Number::rounding_mode::downward, 2},
-              {Number::rounding_mode::upward, 3}}},
+             {{Number::to_nearest, 2},
+              {Number::towards_zero, 2},
+              {Number::downward, 2},
+              {Number::upward, 3}}},
             {Number{15, -1},
-             {{Number::rounding_mode::to_nearest, 2},
-              {Number::rounding_mode::towards_zero, 1},
-              {Number::rounding_mode::downward, 1},
-              {Number::rounding_mode::upward, 2}}},
+             {{Number::to_nearest, 2},
+              {Number::towards_zero, 1},
+              {Number::downward, 1},
+              {Number::upward, 2}}},
             {Number{25, -1},
-             {{Number::rounding_mode::to_nearest, 2},
-              {Number::rounding_mode::towards_zero, 2},
-              {Number::rounding_mode::downward, 2},
-              {Number::rounding_mode::upward, 3}}},
+             {{Number::to_nearest, 2},
+              {Number::towards_zero, 2},
+              {Number::downward, 2},
+              {Number::upward, 3}}},
             {Number{152, -2},
-             {{Number::rounding_mode::to_nearest, 2},
-              {Number::rounding_mode::towards_zero, 1},
-              {Number::rounding_mode::downward, 1},
-              {Number::rounding_mode::upward, 2}}},
+             {{Number::to_nearest, 2},
+              {Number::towards_zero, 1},
+              {Number::downward, 1},
+              {Number::upward, 2}}},
             {Number{252, -2},
-             {{Number::rounding_mode::to_nearest, 3},
-              {Number::rounding_mode::towards_zero, 2},
-              {Number::rounding_mode::downward, 2},
-              {Number::rounding_mode::upward, 3}}},
+             {{Number::to_nearest, 3},
+              {Number::towards_zero, 2},
+              {Number::downward, 2},
+              {Number::upward, 3}}},
             {Number{17, -1},
-             {{Number::rounding_mode::to_nearest, 2},
-              {Number::rounding_mode::towards_zero, 1},
-              {Number::rounding_mode::downward, 1},
-              {Number::rounding_mode::upward, 2}}},
+             {{Number::to_nearest, 2},
+              {Number::towards_zero, 1},
+              {Number::downward, 1},
+              {Number::upward, 2}}},
             {Number{27, -1},
-             {{Number::rounding_mode::to_nearest, 3},
-              {Number::rounding_mode::towards_zero, 2},
-              {Number::rounding_mode::downward, 2},
-              {Number::rounding_mode::upward, 3}}},
+             {{Number::to_nearest, 3},
+              {Number::towards_zero, 2},
+              {Number::downward, 2},
+              {Number::upward, 3}}},
 
             // Negative numbers
             {Number{-13, -1},
-             {{Number::rounding_mode::to_nearest, -1},
-              {Number::rounding_mode::towards_zero, -1},
-              {Number::rounding_mode::downward, -2},
-              {Number::rounding_mode::upward, -1}}},
+             {{Number::to_nearest, -1},
+              {Number::towards_zero, -1},
+              {Number::downward, -2},
+              {Number::upward, -1}}},
             {Number{-23, -1},
-             {{Number::rounding_mode::to_nearest, -2},
-              {Number::rounding_mode::towards_zero, -2},
-              {Number::rounding_mode::downward, -3},
-              {Number::rounding_mode::upward, -2}}},
+             {{Number::to_nearest, -2},
+              {Number::towards_zero, -2},
+              {Number::downward, -3},
+              {Number::upward, -2}}},
             {Number{-15, -1},
-             {{Number::rounding_mode::to_nearest, -2},
-              {Number::rounding_mode::towards_zero, -1},
-              {Number::rounding_mode::downward, -2},
-              {Number::rounding_mode::upward, -1}}},
+             {{Number::to_nearest, -2},
+              {Number::towards_zero, -1},
+              {Number::downward, -2},
+              {Number::upward, -1}}},
             {Number{-25, -1},
-             {{Number::rounding_mode::to_nearest, -2},
-              {Number::rounding_mode::towards_zero, -2},
-              {Number::rounding_mode::downward, -3},
-              {Number::rounding_mode::upward, -2}}},
+             {{Number::to_nearest, -2},
+              {Number::towards_zero, -2},
+              {Number::downward, -3},
+              {Number::upward, -2}}},
             {Number{-152, -2},
-             {{Number::rounding_mode::to_nearest, -2},
-              {Number::rounding_mode::towards_zero, -1},
-              {Number::rounding_mode::downward, -2},
-              {Number::rounding_mode::upward, -1}}},
+             {{Number::to_nearest, -2},
+              {Number::towards_zero, -1},
+              {Number::downward, -2},
+              {Number::upward, -1}}},
             {Number{-252, -2},
-             {{Number::rounding_mode::to_nearest, -3},
-              {Number::rounding_mode::towards_zero, -2},
-              {Number::rounding_mode::downward, -3},
-              {Number::rounding_mode::upward, -2}}},
+             {{Number::to_nearest, -3},
+              {Number::towards_zero, -2},
+              {Number::downward, -3},
+              {Number::upward, -2}}},
             {Number{-17, -1},
-             {{Number::rounding_mode::to_nearest, -2},
-              {Number::rounding_mode::towards_zero, -1},
-              {Number::rounding_mode::downward, -2},
-              {Number::rounding_mode::upward, -1}}},
+             {{Number::to_nearest, -2},
+              {Number::towards_zero, -1},
+              {Number::downward, -2},
+              {Number::upward, -1}}},
             {Number{-27, -1},
-             {{Number::rounding_mode::to_nearest, -3},
-              {Number::rounding_mode::towards_zero, -2},
-              {Number::rounding_mode::downward, -3},
-              {Number::rounding_mode::upward, -2}}},
+             {{Number::to_nearest, -3},
+              {Number::towards_zero, -2},
+              {Number::downward, -3},
+              {Number::upward, -2}}},
         };
 
         for (auto const& [num, roundings] : expected)
@@ -1492,8 +1491,8 @@ public:
                 auto const res = static_cast<std::int64_t>(num);
                 BEAST_EXPECTS(
                     res == val,
-                    to_string(num) + " with mode " + std::to_string(static_cast<int>(mode)) +
-                        " expected " + std::to_string(val) + " got " + std::to_string(res));
+                    to_string(num) + " with mode " + std::to_string(mode) + " expected " +
+                        std::to_string(val) + " got " + std::to_string(res));
             }
         }
     }
@@ -1509,7 +1508,7 @@ public:
         Number const ten{10};
         BEAST_EXPECT(ten.exponent() <= 0);
 
-        if (scale == MantissaRange::mantissa_scale::small)
+        if (scale == MantissaRange::small)
         {
             BEAST_EXPECT(std::numeric_limits<std::int64_t>::max() > INITIAL_XRP.drops());
             BEAST_EXPECT(Number::maxMantissa() < INITIAL_XRP.drops());
@@ -1538,7 +1537,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::rounding_mode::towards_zero);
+            NumberRoundModeGuard const mg(Number::towards_zero);
 
             auto const maxMantissa = Number::maxMantissa();
             Number const max = Number{false, maxMantissa, 0, Number::normalized{}};
@@ -1554,8 +1553,7 @@ public:
     void
     run() override
     {
-        for (auto const scale :
-             {MantissaRange::mantissa_scale::small, MantissaRange::mantissa_scale::large})
+        for (auto const scale : {MantissaRange::small, MantissaRange::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 206fdfc8b1..dfd20eced0 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::scoped_lock const lk{mtx};
+                    std::lock_guard 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 bb1bcb0c0f..a3987e8136 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::NegativeUNLModify::ToDisable, txSet);
+        vote.addTx(seq, toDisableKey, NegativeUNLVote::ToDisable, txSet);
         BEAST_EXPECT(countTx(txSet) == 1);
-        vote.addTx(seq, toReEnableKey, NegativeUNLVote::NegativeUNLModify::ToReEnable, txSet);
+        vote.addTx(seq, toReEnableKey, NegativeUNLVote::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 9696451f6a..38bafe08fd 100644
--- a/src/test/core/Coroutine_test.cpp
+++ b/src/test/core/Coroutine_test.cpp
@@ -43,7 +43,7 @@ public:
         void
         signal()
         {
-            std::scoped_lock const lk(mutex_);
+            std::lock_guard 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 e8a9f21816..a5b579e810 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::scoped_lock const lk{mut};
+            std::lock_guard const lk{mut};
             if (--count == 0)
                 cv.notify_all();
         }
diff --git a/src/test/jtx/AMMTest.h b/src/test/jtx/AMMTest.h
index ffb186e0d6..8f46ef6f59 100644
--- a/src/test/jtx/AMMTest.h
+++ b/src/test/jtx/AMMTest.h
@@ -140,7 +140,7 @@ protected:
         void
         signal()
         {
-            std::scoped_lock const lk(mutex_);
+            std::lock_guard const lk(mutex_);
             signaled_ = true;
             cv_.notify_all();
         }
diff --git a/src/test/jtx/Account.h b/src/test/jtx/Account.h
index a30b974522..c702bcffec 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 class AcctStringType { base58Seed, other };
+    enum 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 491a341540..0e9598decd 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::scoped_lock const lock(strmMutex_);
+            std::lock_guard const lock(strmMutex_);
             strm_ << text;
         }
 
         void
         writeAlways(beast::severities::Severity level, std::string const& text) override
         {
-            std::scoped_lock const lock(strmMutex_);
+            std::lock_guard const lock(strmMutex_);
             strm_ << text;
         }
     };
diff --git a/src/test/jtx/TestHelpers.h b/src/test/jtx/TestHelpers.h
index ae52c50b89..e3119f4c71 100644
--- a/src/test/jtx/TestHelpers.h
+++ b/src/test/jtx/TestHelpers.h
@@ -464,7 +464,7 @@ public:
     void
     signal()
     {
-        std::scoped_lock const lk(mutex_);
+        std::lock_guard const lk(mutex_);
         signaled_ = true;
         cv_.notify_all();
     }
diff --git a/src/test/jtx/directory.h b/src/test/jtx/directory.h
index 08d8fef73e..0940c23623 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 class Error {
+enum Error {
     DirectoryRootNotFound,
     DirectoryTooSmall,
     DirectoryPageDuplicate,
diff --git a/src/test/jtx/impl/AMMTest.cpp b/src/test/jtx/impl/AMMTest.cpp
index dbd8b690f7..24d831be7d 100644
--- a/src/test/jtx/impl/AMMTest.cpp
+++ b/src/test/jtx/impl/AMMTest.cpp
@@ -137,7 +137,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::mantissa_scale::small};
+        NumberMantissaScaleGuard const sg{xrpl::MantissaRange::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 e93e6c6068..4e09940487 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 == AcctStringType::base58Seed)
+        if (stringType == base58Seed)
         {
             std::optional<Seed> const seed = parseBase58<Seed>(name);
             if (!seed.has_value())
@@ -68,15 +68,12 @@ Account::fromCache(AcctStringType stringType, std::string name, KeyType type)
 }
 
 Account::Account(std::string name, KeyType type)
-    : Account(fromCache(Account::AcctStringType::other, std::move(name), type))
+    : Account(fromCache(Account::other, std::move(name), type))
 {
 }
 
 Account::Account(AcctStringType stringType, std::string base58SeedStr)
-    : Account(fromCache(
-          Account::AcctStringType::base58Seed,
-          std::move(base58SeedStr),
-          KeyType::secp256k1))
+    : Account(fromCache(Account::base58Seed, std::move(base58SeedStr), KeyType::secp256k1))
 {
 }
 
diff --git a/src/test/jtx/impl/WSClient.cpp b/src/test/jtx/impl/WSClient.cpp
index 72f9e25b7c..a7db5e4302 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::scoped_lock const lock(m_);
+            std::lock_guard const lock(m_);
             msgs_.push_front(m);
             cv_.notify_all();
         }
@@ -318,7 +318,7 @@ private:
     void
     on_read_done()
     {
-        std::scoped_lock const lock(m0_);
+        std::lock_guard 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 0d545bd6f4..ac4d81bdfb 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>(Error::DirectoryRootNotFound);
+            res = Unexpected<Error>(DirectoryRootNotFound);
             return false;
         }
 
@@ -44,26 +44,26 @@ bumpLastPage(
         auto const lastIndex = sleRoot->getFieldU64(sfIndexPrevious);
         if (lastIndex == 0)
         {
-            res = Unexpected<Error>(Error::DirectoryTooSmall);
+            res = Unexpected<Error>(DirectoryTooSmall);
             return false;
         }
 
         if (sb.exists(keylet::page(directory, newLastPage)))
         {
-            res = Unexpected<Error>(Error::DirectoryPageDuplicate);
+            res = Unexpected<Error>(DirectoryPageDuplicate);
             return false;
         }
 
         if (lastIndex >= newLastPage)
         {
-            res = Unexpected<Error>(Error::InvalidLastPage);
+            res = Unexpected<Error>(InvalidLastPage);
             return false;
         }
 
         auto slePage = sb.peek(keylet::page(directory, lastIndex));
         if (!slePage)
         {
-            res = Unexpected<Error>(Error::DirectoryPageNotFound);
+            res = Unexpected<Error>(DirectoryPageNotFound);
             return false;
         }
 
@@ -94,7 +94,7 @@ bumpLastPage(
             auto slePrev = sb.peek(keylet::page(directory, *prevIndex));
             if (!slePrev)
             {
-                res = Unexpected<Error>(Error::DirectoryPageNotFound);
+                res = Unexpected<Error>(DirectoryPageNotFound);
                 return false;
             }
             slePrev->setFieldU64(sfIndexNext, newLastPage);
@@ -109,7 +109,7 @@ bumpLastPage(
             {
                 if (!adjust(sb, key, newLastPage))
                 {
-                    res = Unexpected<Error>(Error::AdjustmentError);
+                    res = Unexpected<Error>(AdjustmentError);
                     return false;
                 }
             }
diff --git a/src/test/jtx/impl/ledgerStateFixes.cpp b/src/test/jtx/impl/ledgerStateFixes.cpp
index bc19915957..99cd03cbb6 100644
--- a/src/test/jtx/impl/ledgerStateFixes.cpp
+++ b/src/test/jtx/impl/ledgerStateFixes.cpp
@@ -6,8 +6,6 @@
 #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.
@@ -16,8 +14,7 @@ nftPageLinks(jtx::Account const& acct, jtx::Account const& owner)
 {
     Json::Value jv;
     jv[sfAccount.jsonName] = acct.human();
-    jv[sfLedgerFixType.jsonName] =
-        static_cast<std::uint16_t>(LedgerStateFix::FixType::nfTokenPageLink);
+    jv[sfLedgerFixType.jsonName] = LedgerStateFix::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 a756eb312f..0dc2cb6e74 100644
--- a/src/test/ledger/PaymentSandbox_test.cpp
+++ b/src/test/ledger/PaymentSandbox_test.cpp
@@ -126,23 +126,21 @@ 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, FreezeHandling::fhIGNORE_FREEZE, j);
+            auto const startingAmount =
+                accountHolds(av, alice, iss.currency, iss.account, fhIGNORE_FREEZE, j);
             {
                 auto r = accountSend(av, gw1, alice, toCredit, j);
                 BEAST_EXPECT(isTesSuccess(r));
             }
             BEAST_EXPECT(
-                accountHolds(
-                    av, alice, iss.currency, iss.account, FreezeHandling::fhIGNORE_FREEZE, j) ==
+                accountHolds(av, alice, iss.currency, iss.account, 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, FreezeHandling::fhIGNORE_FREEZE, j) ==
+                accountHolds(av, alice, iss.currency, iss.account, fhIGNORE_FREEZE, j) ==
                 startingAmount + toCredit - toDebit);
         }
 
@@ -151,19 +149,17 @@ 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, FreezeHandling::fhIGNORE_FREEZE, j);
+            auto const startingAmount =
+                accountHolds(av, alice, iss.currency, iss.account, fhIGNORE_FREEZE, j);
 
             directSendNoFee(av, gw1, alice, toCredit, true, j);
             BEAST_EXPECT(
-                accountHolds(
-                    av, alice, iss.currency, iss.account, FreezeHandling::fhIGNORE_FREEZE, j) ==
+                accountHolds(av, alice, iss.currency, iss.account, fhIGNORE_FREEZE, j) ==
                 startingAmount + toCredit);
 
             directSendNoFee(av, alice, gw1, toDebit, true, j);
             BEAST_EXPECT(
-                accountHolds(
-                    av, alice, iss.currency, iss.account, FreezeHandling::fhIGNORE_FREEZE, j) ==
+                accountHolds(av, alice, iss.currency, iss.account, fhIGNORE_FREEZE, j) ==
                 startingAmount + toCredit - toDebit);
         }
 
@@ -173,16 +169,15 @@ 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, FreezeHandling::fhIGNORE_FREEZE, j);
+            auto const startingAmount =
+                accountHolds(pv, alice, iss.currency, iss.account, fhIGNORE_FREEZE, j);
 
             {
                 auto r = accountSend(pv, gw1, alice, toCredit, j);
                 BEAST_EXPECT(isTesSuccess(r));
             }
             BEAST_EXPECT(
-                accountHolds(
-                    pv, alice, iss.currency, iss.account, FreezeHandling::fhIGNORE_FREEZE, j) ==
+                accountHolds(pv, alice, iss.currency, iss.account, fhIGNORE_FREEZE, j) ==
                 startingAmount);
 
             {
@@ -190,8 +185,7 @@ class PaymentSandbox_test : public beast::unit_test::suite
                 BEAST_EXPECT(isTesSuccess(r));
             }
             BEAST_EXPECT(
-                accountHolds(
-                    pv, alice, iss.currency, iss.account, FreezeHandling::fhIGNORE_FREEZE, j) ==
+                accountHolds(pv, alice, iss.currency, iss.account, fhIGNORE_FREEZE, j) ==
                 startingAmount - toDebit);
         }
 
@@ -201,13 +195,12 @@ 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, FreezeHandling::fhIGNORE_FREEZE, j);
+            auto const startingAmount =
+                accountHolds(pv, alice, iss.currency, iss.account, fhIGNORE_FREEZE, j);
 
             directSendNoFee(pv, gw1, alice, toCredit, true, j);
             BEAST_EXPECT(
-                accountHolds(
-                    pv, alice, iss.currency, iss.account, FreezeHandling::fhIGNORE_FREEZE, j) ==
+                accountHolds(pv, alice, iss.currency, iss.account, fhIGNORE_FREEZE, j) ==
                 startingAmount);
         }
 
@@ -217,13 +210,12 @@ 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, FreezeHandling::fhIGNORE_FREEZE, j);
+            auto const startingAmount =
+                accountHolds(pv, alice, iss.currency, iss.account, fhIGNORE_FREEZE, j);
 
             BEAST_EXPECT(redeemIOU(pv, alice, toDebit, iss, j) == tesSUCCESS);
             BEAST_EXPECT(
-                accountHolds(
-                    pv, alice, iss.currency, iss.account, FreezeHandling::fhIGNORE_FREEZE, j) ==
+                accountHolds(pv, alice, iss.currency, iss.account, fhIGNORE_FREEZE, j) ==
                 startingAmount - toDebit);
         }
 
@@ -233,13 +225,12 @@ 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, FreezeHandling::fhIGNORE_FREEZE, j);
+            auto const startingAmount =
+                accountHolds(pv, alice, iss.currency, iss.account, fhIGNORE_FREEZE, j);
 
             BEAST_EXPECT(issueIOU(pv, alice, toCredit, iss, j) == tesSUCCESS);
             BEAST_EXPECT(
-                accountHolds(
-                    pv, alice, iss.currency, iss.account, FreezeHandling::fhIGNORE_FREEZE, j) ==
+                accountHolds(pv, alice, iss.currency, iss.account, fhIGNORE_FREEZE, j) ==
                 startingAmount);
         }
 
@@ -249,40 +240,29 @@ 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, FreezeHandling::fhIGNORE_FREEZE, j);
+            auto const startingAmount =
+                accountHolds(pv, alice, iss.currency, iss.account, fhIGNORE_FREEZE, j);
 
             {
                 auto r = accountSend(pv, gw1, alice, toCredit, j);
                 BEAST_EXPECT(isTesSuccess(r));
             }
             BEAST_EXPECT(
-                accountHolds(
-                    pv, alice, iss.currency, iss.account, FreezeHandling::fhIGNORE_FREEZE, j) ==
+                accountHolds(pv, alice, iss.currency, iss.account, fhIGNORE_FREEZE, j) ==
                 startingAmount);
 
             {
                 PaymentSandbox pv2(&pv);
                 BEAST_EXPECT(
-                    accountHolds(
-                        pv2,
-                        alice,
-                        iss.currency,
-                        iss.account,
-                        FreezeHandling::fhIGNORE_FREEZE,
-                        j) == startingAmount);
+                    accountHolds(pv2, alice, iss.currency, iss.account, 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,
-                        FreezeHandling::fhIGNORE_FREEZE,
-                        j) == startingAmount);
+                    accountHolds(pv2, alice, iss.currency, iss.account, fhIGNORE_FREEZE, j) ==
+                    startingAmount);
             }
 
             {
@@ -290,8 +270,7 @@ class PaymentSandbox_test : public beast::unit_test::suite
                 BEAST_EXPECT(isTesSuccess(r));
             }
             BEAST_EXPECT(
-                accountHolds(
-                    pv, alice, iss.currency, iss.account, FreezeHandling::fhIGNORE_FREEZE, j) ==
+                accountHolds(pv, alice, iss.currency, iss.account, fhIGNORE_FREEZE, j) ==
                 startingAmount - toDebit);
         }
     }
@@ -333,8 +312,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(), FreezeHandling::fhZERO_IF_FROZEN, j));
+            return toAmount<XRPAmount>(
+                accountHolds(view, id, xrpCurrency(), xrpAccount(), 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 e0d757c0d3..cf2e478889 100644
--- a/src/test/ledger/View_test.cpp
+++ b/src/test/ledger/View_test.cpp
@@ -787,12 +787,7 @@ class View_test : public beast::unit_test::suite
             BEAST_EXPECT(
                 USD(0) ==
                 accountHolds(
-                    *env.closed(),
-                    alice,
-                    USD.currency,
-                    gw,
-                    FreezeHandling::fhZERO_IF_FROZEN,
-                    env.journal));
+                    *env.closed(), alice, USD.currency, gw, fhZERO_IF_FROZEN, env.journal));
 
             // Thaw gw and try again.
             env(fclear(gw, asfGlobalFreeze));
@@ -811,26 +806,14 @@ 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,
-                    FreezeHandling::fhZERO_IF_FROZEN,
-                    env.journal));
+                accountHolds(*env.closed(), bob, USD.currency, gw, 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,
-                    FreezeHandling::fhZERO_IF_FROZEN,
-                    env.journal));
+                accountHolds(*env.closed(), bob, USD.currency, gw, fhZERO_IF_FROZEN, env.journal));
         }
         {
             // accountHolds().
@@ -841,32 +824,17 @@ class View_test : public beast::unit_test::suite
             BEAST_EXPECT(
                 EUR(0) ==
                 accountHolds(
-                    *env.closed(),
-                    carol,
-                    EUR.currency,
-                    gw,
-                    FreezeHandling::fhZERO_IF_FROZEN,
-                    env.journal));
+                    *env.closed(), carol, EUR.currency, gw, fhZERO_IF_FROZEN, env.journal));
 
             // But carol does have USD.
             BEAST_EXPECT(
                 USD(50) ==
                 accountHolds(
-                    *env.closed(),
-                    carol,
-                    USD.currency,
-                    gw,
-                    FreezeHandling::fhZERO_IF_FROZEN,
-                    env.journal));
+                    *env.closed(), carol, USD.currency, gw, 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(),
-                FreezeHandling::fhZERO_IF_FROZEN,
-                env.journal);
+                *env.closed(), carol, xrpCurrency(), xrpAccount(), fhZERO_IF_FROZEN, env.journal);
             // carol's XRP balance:              10000
             // base reserve:                      -200
             // 1 trust line times its reserve: 1 * -50
@@ -883,35 +851,28 @@ class View_test : public beast::unit_test::suite
             BEAST_EXPECT(
                 XRP(0) ==
                 accountHolds(
-                    *env.closed(),
-                    carol,
-                    xrpCurrency(),
-                    gw,
-                    FreezeHandling::fhZERO_IF_FROZEN,
-                    env.journal));
+                    *env.closed(), carol, xrpCurrency(), gw, fhZERO_IF_FROZEN, env.journal));
         }
         {
             // accountFunds().
             // Gateways have whatever funds they claim to have.
-            auto const gwUSD = accountFunds(
-                *env.closed(), gw, USD(314159), FreezeHandling::fhZERO_IF_FROZEN, env.journal);
+            auto const gwUSD =
+                accountFunds(*env.closed(), gw, USD(314159), fhZERO_IF_FROZEN, env.journal);
             BEAST_EXPECT(gwUSD == USD(314159));
 
             // carol has funds from the gateway.
-            auto carolsUSD = accountFunds(
-                *env.closed(), carol, USD(0), FreezeHandling::fhZERO_IF_FROZEN, env.journal);
+            auto carolsUSD =
+                accountFunds(*env.closed(), carol, USD(0), 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), FreezeHandling::fhZERO_IF_FROZEN, env.journal);
+            carolsUSD = accountFunds(*env.closed(), carol, USD(0), fhZERO_IF_FROZEN, env.journal);
             BEAST_EXPECT(carolsUSD == USD(0));
 
             // ... unless the query ignores the FROZEN state.
-            carolsUSD = accountFunds(
-                *env.closed(), carol, USD(0), FreezeHandling::fhIGNORE_FREEZE, env.journal);
+            carolsUSD = accountFunds(*env.closed(), carol, USD(0), 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 8ea32517d5..e527942629 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 NodeObjectType::hotLEDGER;
+                        return hotLEDGER;
                     case 1:
-                        return NodeObjectType::hotACCOUNT_NODE;
+                        return hotACCOUNT_NODE;
                     case 2:
-                        return NodeObjectType::hotTRANSACTION_NODE;
+                        return hotTRANSACTION_NODE;
                     case 3:
-                        return NodeObjectType::hotUNKNOWN;
+                        return hotUNKNOWN;
                     default:
                         // will never happen, but make static analysis tool happy.
-                        return NodeObjectType::hotUNKNOWN;
+                        return hotUNKNOWN;
                 }
             }();
 
@@ -140,9 +140,9 @@ public:
 
             Status const status = backend.fetch(batch[i]->getHash(), &object);
 
-            BEAST_EXPECT(status == Status::ok);
+            BEAST_EXPECT(status == ok);
 
-            if (status == Status::ok)
+            if (status == ok)
             {
                 BEAST_EXPECT(object != nullptr);
 
@@ -160,7 +160,7 @@ public:
 
             Status const status = backend.fetch(batch[i]->getHash(), &object);
 
-            BEAST_EXPECT(status == Status::notFound);
+            BEAST_EXPECT(status == notFound);
         }
     }
 
diff --git a/src/test/nodestore/Timing_test.cpp b/src/test/nodestore/Timing_test.cpp
index 1145bc80f4..cc9881dbac 100644
--- a/src/test/nodestore/Timing_test.cpp
+++ b/src/test/nodestore/Timing_test.cpp
@@ -77,8 +77,6 @@ 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_;
@@ -137,8 +135,6 @@ 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
@@ -682,7 +678,7 @@ public:
     void
     run() override
     {
-        testcase("Timing", beast::unit_test::abort_t::abort_on_fail);
+        testcase("Timing", beast::unit_test::abort_on_fail);
 
         /*  Parameters:
 
diff --git a/src/test/nodestore/import_test.cpp b/src/test/nodestore/import_test.cpp
index 359f27ef7d..1341b98894 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_t::abort_on_fail) << arg();
+        testcase(beast::unit_test::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 e42d4ffe75..c1db5262d0 100644
--- a/src/test/overlay/TMGetObjectByHash_test.cpp
+++ b/src/test/overlay/TMGetObjectByHash_test.cpp
@@ -158,8 +158,7 @@ class TMGetObjectByHash_test : public beast::unit_test::suite
             hashes.push_back(hash);
 
             Blob data(100, static_cast<unsigned char>(i % 256));
-            nodeStore.store(
-                NodeObjectType::hotLEDGER, std::move(data), hash, nodeStore.earliestLedgerSeq());
+            nodeStore.store(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 1a650655f2..21f3482ab5 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 class State { On, Off, WaitReset };
-    enum class EventType { LinkDown = 0, PeerDisconnected = 1 };
+    enum State { On, Off, WaitReset };
+    enum 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,8 +938,7 @@ protected:
     void
     random(bool log)
     {
-        std::unordered_map<EventType, Event> events{
-            {EventType::LinkDown, {}}, {EventType::PeerDisconnected, {}}};
+        std::unordered_map<EventType, Event> events{{LinkDown, {}}, {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 42959000a1..02c9312732 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::scoped_lock const lock(mutex_);
+            std::lock_guard const lock(mutex_);
             list_.emplace(child.get(), child);
         }
 
         void
         remove(Child* child)
         {
-            std::scoped_lock const lock(mutex_);
+            std::lock_guard 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::scoped_lock const lock(mutex_);
+                std::lock_guard 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 f9f1ff1373..f0cbf805f3 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)::IsMemberResult::none);
+            BEAST_EXPECT(subject.isMember("foo") == decltype(subject)::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)::IsMemberResult::all);
-                BEAST_EXPECT(s1.isMember("Two") == decltype(s1)::IsMemberResult::none);
+                BEAST_EXPECT(s1.isMember("One") == decltype(s1)::all);
+                BEAST_EXPECT(s1.isMember("Two") == decltype(s1)::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)::IsMemberResult::some);
-                BEAST_EXPECT(s2.isMember("Two") == decltype(s2)::IsMemberResult::some);
+                BEAST_EXPECT(s2.isMember("One") == decltype(s2)::some);
+                BEAST_EXPECT(s2.isMember("Two") == decltype(s2)::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)::IsMemberResult::some);
-                BEAST_EXPECT(s3.isMember("Two") == decltype(s3)::IsMemberResult::none);
+                BEAST_EXPECT(s3.isMember("One") == decltype(s3)::some);
+                BEAST_EXPECT(s3.isMember("Two") == decltype(s3)::none);
             }
         }
 
diff --git a/src/test/protocol/STNumber_test.cpp b/src/test/protocol/STNumber_test.cpp
index e2c1a91e64..156f5b42aa 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::rounding_mode::towards_zero);
+                NumberRoundModeGuard const mg(Number::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::mantissa_scale::small)
+                if (Number::getMantissaScale() == MantissaRange::small)
                 {
                     BEAST_EXPECT(
                         numberFromJson(sfNumber, maxInt) ==
@@ -280,8 +280,7 @@ struct STNumber_test : public beast::unit_test::suite
     {
         static_assert(!std::is_convertible_v<STNumber*, Number*>);
 
-        for (auto const scale :
-             {MantissaRange::mantissa_scale::small, MantissaRange::mantissa_scale::large})
+        for (auto const scale : {MantissaRange::small, MantissaRange::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 71b483425b..d0764d7399 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::Type::seq};
+        bool const expectSeq{type == SeqProxy::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::Type::seq};
-        static constexpr SeqProxy::Type ticket{SeqProxy::Type::ticket};
+        static constexpr SeqProxy::Type seq{SeqProxy::seq};
+        static constexpr SeqProxy::Type ticket{SeqProxy::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 53fb81e436..f6da313b22 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) == Disposition::warn)
+                if (c.charge(fee) == warn)
                 {
                     if (limited)
                     {
@@ -145,7 +145,7 @@ public:
                     return;
                 }
 
-                if (c.charge(fee) == Disposition::drop)
+                if (c.charge(fee) == 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() != Disposition::drop)
+            if (c.disposition() != drop)
             {
                 if (limited)
                 {
@@ -185,7 +185,7 @@ public:
                 ++logic.clock();
                 logic.periodicActivity();
                 Consumer const c(logic.newInboundEndpoint(addr));
-                if (c.disposition() != Disposition::drop)
+                if (c.disposition() != drop)
                 {
                     readmitted = true;
                     break;
diff --git a/src/test/rpc/AMMInfo_test.cpp b/src/test/rpc/AMMInfo_test.cpp
index 726d23db1d..876c9b66f1 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 class TestAccount { None, Alice, Bogie };
+        enum TestAccount { None, Alice, Bogie };
         auto accountId = [&](AMM const& ammAlice, TestAccount v) -> std::optional<AccountID> {
-            if (v == TestAccount::Alice)
+            if (v == Alice)
             {
                 return ammAlice.ammAccount();
             }
-            if (v == TestAccount::Bogie)
+            if (v == 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, 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}};
+                {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}};
 
         // 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, 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}};
+                {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}};
 
         // 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 == TestAccount::Bogie ? std::string("Account malformed.")
-                                                : std::string("Invalid parameters.")));
+                    (acct == 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 ea8c498619..f4473c0aa3 100644
--- a/src/test/rpc/GetAggregatePrice_test.cpp
+++ b/src/test/rpc/GetAggregatePrice_test.cpp
@@ -177,8 +177,7 @@ public:
             auto const all = testable_amendments();
             for (auto const& feats : {all - featureSingleAssetVault - featureLendingProtocol, all})
             {
-                for (auto const mantissaSize :
-                     {MantissaRange::mantissa_scale::small, MantissaRange::mantissa_scale::large})
+                for (auto const mantissaSize : {MantissaRange::small, MantissaRange::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/RPCCall_test.cpp b/src/test/rpc/RPCCall_test.cpp
index 409ba660d8..3ece97344c 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 class Exception { no_exception = 0, bad_cast };
+    enum 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::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "account_channels",
     "params" : [
@@ -87,7 +87,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {"account_channels",
       "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
       "rD5MbavGfiSC5m7mkxy1FANuT7s3HxqpoF"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "account_channels",
     "params" : [
@@ -103,7 +103,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {"account_channels",
       "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
       "r9emE59aTWb85t64dAebKrxYMBTpzK5yR7"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "account_channels",
     "params" : [
@@ -119,7 +119,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {"account_channels",
       "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
       "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "account_channels",
     "params" : [
@@ -136,7 +136,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
       "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
       "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "account_channels",
     "params" : [
@@ -154,7 +154,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
       "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
       "90210"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "account_channels",
     "params" : [
@@ -171,7 +171,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "account_channels",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "account_channels",
     "params" : [
@@ -189,7 +189,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
       "current",
       "extra"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "account_channels",
     "params" : [
@@ -223,7 +223,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"account_currencies: minimal 1.",
      __LINE__,
      {"account_currencies", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "account_currencies",
     "params" : [
@@ -236,7 +236,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"account_currencies: minimal 2.",
      __LINE__,
      {"account_currencies", "racb4o3DrdYxuCfyVa6vsLb7vgju9RFbBr"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "account_currencies",
     "params" : [
@@ -293,7 +293,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "account_currencies",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+        RPCCallTestData::no_exception,
         R"({
     "method" : "account_currencies",
     "params" : [
@@ -357,7 +357,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"account_info: minimal.",
      __LINE__,
      {"account_info", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "account_info",
     "params" : [
@@ -400,7 +400,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {"account_info",
       "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
       "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "account_info",
     "params" : [
@@ -430,7 +430,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "account_info",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+        RPCCallTestData::no_exception,
         R"({
     "method" : "account_info",
     "params" : [
@@ -480,7 +480,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"account_lines: minimal.",
      __LINE__,
      {"account_lines", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "account_lines",
     "params" : [
@@ -493,7 +493,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"account_lines: peer.",
      __LINE__,
      {"account_lines", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "account_lines",
     "params" : [
@@ -510,7 +510,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
       "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
       "888888888"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "account_lines",
     "params" : [
@@ -528,7 +528,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
       "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
       "closed"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "account_lines",
     "params" : [
@@ -546,7 +546,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
       "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
       "FFFFEEEEDDDDCCCCBBBBAAAA9999888877776666555544443333222211110000"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "account_lines",
     "params" : [
@@ -563,7 +563,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "account_lines",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "account_lines",
     "params" : [
@@ -582,7 +582,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
       "12345678",
       "current"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "account_lines",
     "params" : [
@@ -603,7 +603,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "12345678",
       "current",
       "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "account_lines",
     "params" : [
@@ -624,7 +624,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "current",
       "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
       "validated"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+        RPCCallTestData::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::Exception::no_exception,
+        RPCCallTestData::no_exception,
         R"({
     "method" : "account_lines",
     "params" : [
@@ -680,7 +680,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
          "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
          "not_a_ledger"},
-        RPCCallTestData::Exception::no_exception,
+        RPCCallTestData::no_exception,
         R"({
     "method" : "account_lines",
     "params" : [
@@ -699,7 +699,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"account_objects: minimal.",
      __LINE__,
      {"account_objects", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "account_objects",
     "params" : [
@@ -742,7 +742,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {"account_objects",
       "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
       "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "account_objects",
     "params" : [
@@ -772,7 +772,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "account_objects",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "account_objects",
     "params" : [
@@ -793,7 +793,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "extra1",
          "extra2",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "account_objects",
     "params" : [
@@ -814,7 +814,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "extra2",
          "extra3",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "account_objects",
     "params" : [
@@ -835,7 +835,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "extra3",
          "extra4",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+        RPCCallTestData::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::Exception::no_exception,
+        RPCCallTestData::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::Exception::no_exception,
+        RPCCallTestData::no_exception,
         R"({
     "method" : "account_objects",
     "params" : [
@@ -907,7 +907,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"account_offers: minimal.",
      __LINE__,
      {"account_offers", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "account_offers",
     "params" : [
@@ -950,7 +950,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {"account_offers",
       "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
       "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "account_offers",
     "params" : [
@@ -980,7 +980,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "account_offers",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "account_offers",
     "params" : [
@@ -1015,7 +1015,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "extra2",
          "extra3",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+        RPCCallTestData::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::Exception::no_exception,
+        RPCCallTestData::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::Exception::no_exception,
+        RPCCallTestData::no_exception,
         R"({
     "method" : "account_offers",
     "params" : [
@@ -1087,7 +1087,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"account_tx: minimal.",
      __LINE__,
      {"account_tx", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "account_tx",
     "params" : [
@@ -1152,7 +1152,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "binary",
       "count",
       "descending"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "account_tx",
     "params" : [
@@ -1193,7 +1193,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "count",
       "descending",
       "binary"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "account_tx",
     "params" : [
@@ -1236,7 +1236,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "45",
       "descending",
       "count"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "account_tx",
     "params" : [
@@ -1257,7 +1257,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "account_tx",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "account_tx",
     "params" : [
@@ -1280,7 +1280,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "descending",
       "count",
       "binary"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+        RPCCallTestData::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::Exception::no_exception,
+        RPCCallTestData::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::Exception::no_exception,
+        RPCCallTestData::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::Exception::bad_cast,
+        RPCCallTestData::bad_cast,
         R"()",
     },
     {
@@ -1364,7 +1364,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
         "account_tx: non-integer max.",
         __LINE__,
         {"account_tx", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "-1", "counts"},
-        RPCCallTestData::Exception::bad_cast,
+        RPCCallTestData::bad_cast,
         R"()",
     },
     {
@@ -1372,7 +1372,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
         "account_tx: non-integer offset.",
         __LINE__,
         {"account_tx", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "-1", "-1", "decending"},
-        RPCCallTestData::Exception::bad_cast,
+        RPCCallTestData::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::Exception::bad_cast,
+        RPCCallTestData::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::Exception::bad_cast,
+     RPCCallTestData::bad_cast,
      R"()"},
 
     // book_offers
@@ -1406,7 +1406,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "USD",
          "EUR",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "book_offers",
     "params" : [
@@ -1428,7 +1428,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "USD/rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
          "EUR/rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "book_offers",
     "params" : [
@@ -1473,7 +1473,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "EUR",
       "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
       "666"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "book_offers",
     "params" : [
@@ -1498,7 +1498,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "EUR/rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
       "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
       "current"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "book_offers",
     "params" : [
@@ -1523,7 +1523,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "EUR/rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
       "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
       "ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "book_offers",
     "params" : [
@@ -1552,7 +1552,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789",
          "200",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "book_offers",
     "params" : [
@@ -1583,7 +1583,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "200",
       "0",
       "MyMarker"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "book_offers",
     "params" : [
@@ -1609,7 +1609,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "book_offers",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "book_offers",
     "params" : [
@@ -1631,7 +1631,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "0",
       "MyMarker",
       "extra"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "book_offers",
     "params" : [
@@ -1650,7 +1650,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "/rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
          "EUR/rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "book_offers",
     "params" : [
@@ -1668,7 +1668,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "USD/rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
          "/rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "book_offers",
     "params" : [
@@ -1705,7 +1705,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "EUR/rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
       "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
       "not_a_ledger"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "book_offers",
     "params" : [
@@ -1734,7 +1734,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789",
          "not_a_number",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "book_offers",
     "params" : [
@@ -1753,7 +1753,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "can_delete",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "can_delete",
     "params" : [
@@ -1768,7 +1768,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "can_delete",
          "4294967295",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "can_delete",
     "params" : [
@@ -1784,7 +1784,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "can_delete",
          "FEDCBA9876543210FEDCBA9876543210FEDCBA9876543210FEDCBA9876543210",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "can_delete",
     "params" : [
@@ -1800,7 +1800,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "can_delete",
          "always",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "can_delete",
     "params" : [
@@ -1816,7 +1816,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "can_delete",
          "never",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "can_delete",
     "params" : [
@@ -1832,7 +1832,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "can_delete",
          "now",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "can_delete",
     "params" : [
@@ -1859,7 +1859,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"can_delete: invalid argument.",
      __LINE__,
      {"can_delete", "invalid"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "can_delete",
     "params" : [
@@ -1876,7 +1876,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "can_delete",
          "4294967296",
      },
-     RPCCallTestData::Exception::bad_cast,
+     RPCCallTestData::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::Exception::bad_cast,
+     RPCCallTestData::bad_cast,
      R"()"},
 
     // channel_authorize
@@ -1896,7 +1896,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "secret_can_be_anything",
       "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
       "18446744073709551615"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "channel_authorize",
     "params" : [
@@ -1915,7 +1915,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "secret_can_be_anything",
          "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "channel_authorize",
     "params" : [
@@ -1934,7 +1934,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "2000",
       "whatever",
       "whenever"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "channel_authorize",
     "params" : [
@@ -1952,7 +1952,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
       "2000",
       "whatever"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "channel_authorize",
     "params" : [
@@ -1969,7 +1969,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "secret_can_be_anything",
       "123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
       "2000"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "channel_authorize",
     "params" : [
@@ -1986,7 +1986,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "secret_can_be_anything",
       "10123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
       "2000"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "channel_authorize",
     "params" : [
@@ -2003,7 +2003,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "secret_can_be_anything",
       "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEZ",
       "2000"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "channel_authorize",
     "params" : [
@@ -2020,7 +2020,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "secret_can_be_anything",
       "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
       "-1"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "channel_authorize",
     "params" : [
@@ -2037,7 +2037,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "secret_can_be_anything",
       "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
       "18446744073709551616"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "channel_authorize",
     "params" : [
@@ -2058,7 +2058,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
       "0",
       "DEADBEEF"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "channel_verify",
     "params" : [
@@ -2078,7 +2078,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
       "18446744073709551615",
       "DEADBEEF"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "channel_verify",
     "params" : [
@@ -2096,7 +2096,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {"channel_verify",
       "aB4BXXLuPu8DpVuyq1DBiu3SrPdtK9AYZisKhu8mvkoiUD8J9Gov",
       "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "channel_verify",
     "params" : [
@@ -2115,7 +2115,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "2000",
       "DEADBEEF",
       "Whatever"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "channel_verify",
     "params" : [
@@ -2133,7 +2133,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
       "2000",
       "DEADBEEF"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "channel_verify",
     "params" : [
@@ -2151,7 +2151,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
       "2000",
       "DEADBEEF"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "channel_verify",
     "params" : [
@@ -2169,7 +2169,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "10123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
       "2000",
       "DEADBEEF"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "channel_verify",
     "params" : [
@@ -2187,7 +2187,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
       "2000",
       "DEADBEEF"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "channel_verify",
     "params" : [
@@ -2205,7 +2205,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
       "-1",
       "DEADBEEF"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "channel_verify",
     "params" : [
@@ -2223,7 +2223,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
       "18446744073709551616",
       "DEADBEEF"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "channel_verify",
     "params" : [
@@ -2241,7 +2241,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
       "40000000",
       "ThisIsNotHexadecimal"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "channel_verify",
     "params" : [
@@ -2263,7 +2263,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "connect",
          "ThereIsNoCheckingOnTheIPFormat",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "connect",
     "params" : [
@@ -2276,7 +2276,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"connect: ip and port.",
      __LINE__,
      {"connect", "ThereIsNoCheckingOnTheIPFormat", "6561"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "connect",
     "params" : [
@@ -2292,7 +2292,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "connect",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "connect",
     "params" : [
@@ -2306,7 +2306,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"connect: too many arguments.",
      __LINE__,
      {"connect", "ThereIsNoCheckingOnTheIPFormat", "6561", "extra"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "connect",
     "params" : [
@@ -2325,7 +2325,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "ThereIsNoCheckingOnTheIPFormat",
          "-1",
      },
-     RPCCallTestData::Exception::bad_cast,
+     RPCCallTestData::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::Exception::bad_cast,
+     RPCCallTestData::bad_cast,
      R"()"},
 
     // consensus_info
@@ -2345,7 +2345,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "consensus_info",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "consensus_info",
     "params" : [
@@ -2378,7 +2378,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "source_account_NotValidated",
          "destination_account_NotValidated",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "deposit_authorized",
     "params" : [
@@ -2395,7 +2395,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "source_account_NotValidated",
       "destination_account_NotValidated",
       "validated"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "deposit_authorized",
     "params" : [
@@ -2421,7 +2421,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "cred6",
       "cred7",
       "cred8"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "deposit_authorized",
     "params" : [
@@ -2440,7 +2440,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "source_account_NotValidated",
       "destination_account_NotValidated",
       "ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "deposit_authorized",
     "params" : [
@@ -2458,7 +2458,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "deposit_authorized",
          "source_account_NotValidated",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "deposit_authorized",
     "params" : [
@@ -2484,7 +2484,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "cred7",
       "cred8",
       "too_much"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "deposit_authorized",
     "params" : [
@@ -2503,7 +2503,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "destination_account_NotValidated",
          "NotALedger",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "deposit_authorized",
     "params" : [
@@ -2523,7 +2523,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "feature",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "feature",
     "params" : [
@@ -2535,7 +2535,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"feature: with name.",
      __LINE__,
      {"feature", "featureNameOrHexIsNotValidated"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "feature",
     "params" : [
@@ -2551,7 +2551,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "FEDCBA9876543210FEDCBA9876543210FEDCBA9876543210FEDCBA9876543210FEDCBA98"
       "76543210",
       "accept"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "feature",
     "params" : [
@@ -2565,7 +2565,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"feature: reject.",
      __LINE__,
      {"feature", "0", "reject"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "feature",
     "params" : [
@@ -2579,7 +2579,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"feature: too many arguments.",
      __LINE__,
      {"feature", "featureNameOrHexIsNotValidated", "accept", "anotherArg"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "feature",
     "params" : [
@@ -2597,7 +2597,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "featureNameOrHexIsNotValidated",
          "veto",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "feature",
     "params" : [
@@ -2616,7 +2616,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "fetch_info",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "fetch_info",
     "params" : [
@@ -2628,7 +2628,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"fetch_info: clear.",
      __LINE__,
      {"fetch_info", "clear"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "fetch_info",
     "params" : [
@@ -2671,7 +2671,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"gateway_balances: minimal.",
      __LINE__,
      {"gateway_balances", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "gateway_balances",
     "params" : [
@@ -2714,7 +2714,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {"gateway_balances",
       "0123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUV",
       "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "gateway_balances",
     "params" : [
@@ -2770,7 +2770,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "gateway_balances",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "gateway_balances",
     "params" : [
@@ -2784,7 +2784,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"gateway_balances: empty first argument.",
      __LINE__,
      {"gateway_balances", ""},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "gateway_balances",
     "params" : [
@@ -2801,7 +2801,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "gateway_balances",
          "890765",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "gateway_balances",
     "params" : [
@@ -2818,7 +2818,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "gateway_balances",
          "current",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "gateway_balances",
     "params" : [
@@ -2835,7 +2835,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "gateway_balances",
          "0123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUV",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "gateway_balances",
     "params" : [
@@ -2854,7 +2854,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "get_counts",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "get_counts",
     "params" : [
@@ -2896,12 +2896,12 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "get_counts",
          "-1",
      },
-     RPCCallTestData::Exception::bad_cast,
+     RPCCallTestData::bad_cast,
      R"()"},
     {"get_counts: count too large.",
      __LINE__,
      {"get_counts", "4294967296"},
-     RPCCallTestData::Exception::bad_cast,
+     RPCCallTestData::bad_cast,
      R"()"},
 
     // json
@@ -2913,7 +2913,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "command",
          R"({"json_argument":true})",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "command",
     "params" : [
@@ -2931,7 +2931,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "command",
          R"({})",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "command",
     "params" : [
@@ -2944,7 +2944,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"json: too few arguments.",
      __LINE__,
      {"json", "command"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "json",
     "params" : [
@@ -2976,7 +2976,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "command",
          R"(["arg1","arg2"])",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "json",
     "params" : [
@@ -2994,7 +2994,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "command",
          R"({"json_argument":true,})",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "id" : "A1",
     "jsonrpc" : "2.0",
@@ -3042,7 +3042,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
         "params" : [{"inner_arg" : "yup"}]
         })",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "json2",
     "params" : [
@@ -3094,7 +3094,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
         "params" : [{"inner_arg" : "yup"}]}
         ])",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "json2",
    "params" : [
@@ -3116,7 +3116,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "json2",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "id" : "A1",
     "jsonrpc" : "2.0",
@@ -3302,7 +3302,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "json2",
          R"([])",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "json2",
     "params" : [
@@ -3342,7 +3342,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
             }
         ])",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "json2",
     "params" : [
@@ -3365,7 +3365,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
         "params" : true
         })",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
    "id" : "A1",
    "jsonrpc" : "2.0",
@@ -3388,7 +3388,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ledger: minimal.",
      __LINE__,
      {"ledger"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "ledger",
     "params" : [
@@ -3400,7 +3400,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ledger: ledger index.",
      __LINE__,
      {"ledger", "4294967295"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "ledger",
     "params" : [
@@ -3413,7 +3413,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ledger: text ledger index.",
      __LINE__,
      {"ledger", "validated"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "ledger",
     "params" : [
@@ -3426,7 +3426,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ledger: ledger hash.",
      __LINE__,
      {"ledger", "ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "ledger",
     "params" : [
@@ -3439,7 +3439,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ledger: full.",
      __LINE__,
      {"ledger", "current", "full"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "ledger",
     "params" : [
@@ -3453,7 +3453,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ledger: tx.",
      __LINE__,
      {"ledger", "closed", "tx"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "ledger",
     "params" : [
@@ -3468,7 +3468,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ledger: too many arguments.",
      __LINE__,
      {"ledger", "4294967295", "spare"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "ledger",
     "params" : [
@@ -3481,7 +3481,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ledger: ledger index too small.",
      __LINE__,
      {"ledger", "-1"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "ledger",
     "params" : [
@@ -3494,7 +3494,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ledger: ledger index too big.",
      __LINE__,
      {"ledger", "4294967296"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "ledger",
     "params" : [
@@ -3507,7 +3507,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ledger: invalid ledger text.",
      __LINE__,
      {"ledger", "latest"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "ledger",
     "params" : [
@@ -3520,7 +3520,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ledger: unsupported final argument.",
      __LINE__,
      {"ledger", "current", "expand"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "ledger",
     "params" : [
@@ -3536,7 +3536,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ledger_closed: minimal.",
      __LINE__,
      {"ledger_closed"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "ledger_closed",
     "params" : [
@@ -3565,7 +3565,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ledger_current: minimal.",
      __LINE__,
      {"ledger_current"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "ledger_current",
     "params" : [
@@ -3594,7 +3594,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ledger_header: ledger index.",
      __LINE__,
      {"ledger_header", "4294967295"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "ledger_header",
     "params" : [
@@ -3607,7 +3607,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ledger_header: ledger hash.",
      __LINE__,
      {"ledger_header", "ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "ledger_header",
     "params" : [
@@ -3622,7 +3622,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "ledger_header",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "ledger_header",
     "params" : [
@@ -3692,7 +3692,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ledger_request: ledger index.",
      __LINE__,
      {"ledger_request", "4294967295"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "ledger_request",
     "params" : [
@@ -3705,7 +3705,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ledger_request: ledger hash.",
      __LINE__,
      {"ledger_request", "ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "ledger_request",
     "params" : [
@@ -3720,7 +3720,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "ledger_request",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "ledger_request",
     "params" : [
@@ -3792,7 +3792,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "log_level",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "log_level",
     "params" : [
@@ -3804,7 +3804,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"log_level: fatal.",
      __LINE__,
      {"log_level", "fatal"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "log_level",
     "params" : [
@@ -3817,7 +3817,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"log_level: error.",
      __LINE__,
      {"log_level", "error"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "log_level",
     "params" : [
@@ -3830,7 +3830,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"log_level: warn.",
      __LINE__,
      {"log_level", "warn"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "log_level",
     "params" : [
@@ -3843,7 +3843,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"log_level: debug.",
      __LINE__,
      {"log_level", "debug"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "log_level",
     "params" : [
@@ -3856,7 +3856,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"log_level: trace.",
      __LINE__,
      {"log_level", "trace"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "log_level",
     "params" : [
@@ -3911,7 +3911,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"log_level: invalid severity.",
      __LINE__,
      {"log_level", "err"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "log_level",
     "params" : [
@@ -3928,7 +3928,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "fatal",
          "partition_name",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "log_level",
     "params" : [
@@ -3947,7 +3947,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "logrotate",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "logrotate",
     "params" : [
@@ -3959,7 +3959,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"logrotate: too many arguments.",
      __LINE__,
      {"logrotate", "extra"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "logrotate",
     "params" : [
@@ -3976,7 +3976,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"owner_info: minimal.",
      __LINE__,
      {"owner_info", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "owner_info",
     "params" : [
@@ -4019,7 +4019,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {"owner_info",
       "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
       "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "owner_info",
     "params" : [
@@ -4049,7 +4049,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "owner_info",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "owner_info",
     "params" : [
@@ -4069,7 +4069,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "extra1",
          "extra2",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+        RPCCallTestData::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::Exception::no_exception,
+        RPCCallTestData::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::Exception::no_exception,
+        RPCCallTestData::no_exception,
         R"({
     "method" : "owner_info",
     "params" : [
@@ -4143,7 +4143,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "peers",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "peers",
     "params" : [
@@ -4155,7 +4155,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"peers: too many arguments.",
      __LINE__,
      {"peers", "extra"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "peer_reservations_del",
     "params" : [
@@ -4276,7 +4276,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "ping",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "ping",
     "params" : [
@@ -4288,7 +4288,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ping: too many arguments.",
      __LINE__,
      {"ping", "extra"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "ping",
     "params" : [
@@ -4307,7 +4307,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "print",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "print",
     "params" : [
@@ -4320,7 +4320,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      "print: extra argument.",
      __LINE__,
      {"print", "extra"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "print",
     "params" : [
@@ -4333,7 +4333,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"print: too many arguments.",
      __LINE__,
      {"print", "extra1", "extra2"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "print",
     "params" : [
@@ -4352,7 +4352,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "random",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "random",
     "params" : [
@@ -4364,7 +4364,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"random: too many arguments.",
      __LINE__,
      {"random", "extra"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "random",
     "params" : [
@@ -4384,7 +4384,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "ripple_path_find",
          R"({"json_argument":true})",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "ripple_path_find",
     "params" : [
@@ -4444,7 +4444,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "ripple_path_find",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "ripple_path_find",
     "params" : [
@@ -4475,7 +4475,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "ripple_path_find",
          R"({"json_argument":true,})",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "ripple_path_find",
     "params" : [
@@ -4538,7 +4538,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "my_secret",
          R"({"json_argument":true})",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "sign",
     "params" : [
@@ -4571,7 +4571,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"sign: too few arguments.",
      __LINE__,
      {"sign", "contents_of_blob"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
         "method" : "sign",
         "params" : [
@@ -4609,7 +4609,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "offline",
       "CounterpartySignature",
       "extra"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "sign",
     "params" : [
@@ -4627,7 +4627,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "my_secret",
          R"({"json_argument":true,})",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
         "method" : "sign",
         "params" : [
@@ -4667,7 +4667,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "my_secret",
          R"({"json_argument":true})",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "sign_for",
     "params" : [
@@ -4688,7 +4688,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "my_secret",
       R"({"json_argument":true})",
       "offline"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "sign_for",
     "params" : [
@@ -4710,7 +4710,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
          "my_secret",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "sign_for",
     "params" : [
@@ -4729,7 +4729,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       R"({"json_argument":true})",
       "offline",
       "extra"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "sign_for",
     "params" : [
@@ -4748,7 +4748,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "my_secret",
          R"({"json_argument":true,})",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "sign_for",
     "params" : [
@@ -4766,7 +4766,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "my_secret",
       R"({"json_argument":true})",
       "ofline"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "submit",
     "params" : [
@@ -4800,7 +4800,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "my_secret",
          R"({"json_argument":true})",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "submit",
     "params" : [
@@ -4818,7 +4818,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "submit",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
         "method" : "submit",
         "params" : [
@@ -4874,7 +4874,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "offline",
       "CounterpartySignature",
       "extra"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "submit",
     "params" : [
@@ -4892,7 +4892,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "my_secret",
          R"({"json_argument":true,})",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
         "method" : "submit",
         "params" : [
@@ -4930,7 +4930,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "submit_multisigned",
          R"({"json_argument":true})",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "submit_multisigned",
     "params" : [
@@ -4947,7 +4947,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "submit_multisigned",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "submit_multisigned",
     "params" : [
@@ -4978,7 +4978,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "submit_multisigned",
          R"({"json_argument":true,})",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "submit_multisigned",
     "params" : [
@@ -4998,7 +4998,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "server_info",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "server_info",
     "params" : [
@@ -5010,7 +5010,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"server_info: counters.",
      __LINE__,
      {"server_info", "counters"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "server_info",
     "params" : [
@@ -5054,7 +5054,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "server_state",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "server_state",
     "params" : [
@@ -5066,7 +5066,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"server_state: counters.",
      __LINE__,
      {"server_state", "counters"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "server_state",
     "params" : [
@@ -5110,7 +5110,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "stop",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "stop",
     "params" : [
@@ -5122,7 +5122,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"stop: too many arguments.",
      __LINE__,
      {"stop", "extra"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "stop",
     "params" : [
@@ -5141,7 +5141,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {"transaction_entry",
       "0123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUV",
       "4294967295"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "transaction_entry",
     "params" : [
@@ -5157,7 +5157,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {"transaction_entry",
       "0123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUV",
       "current"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "transaction_entry",
     "params" : [
@@ -5173,7 +5173,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {"transaction_entry",
       "0123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUV",
       "VUTSRQPONMLKJIHGFEDCBA9876543210VUTSRQPONMLKJIHGFEDCBA9876543210"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "transaction_entry",
     "params" : [
@@ -5190,7 +5190,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "transaction_entry",
          "0123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUV",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "transaction_entry",
     "params" : [
@@ -5207,7 +5207,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "0123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUV",
       "validated",
       "extra"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "transaction_entry",
     "params" : [
@@ -5225,7 +5225,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUV",
          "validated",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "transaction_entry",
     "params" : [
@@ -5243,7 +5243,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "0123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUVW",
          "validated",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "transaction_entry",
     "params" : [
@@ -5261,7 +5261,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "0123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUV",
          "0",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "transaction_entry",
     "params" : [
@@ -5279,7 +5279,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "0123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUV",
          "4294967296",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "transaction_entry",
     "params" : [
@@ -5297,7 +5297,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "0123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUV",
          "VUTSRQPONMLKJIHGFEDCBA9876543210VUTSRQPONMLKJIHGFEDCBA987654321",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "transaction_entry",
     "params" : [
@@ -5315,7 +5315,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "0123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUV",
          "VUTSRQPONMLKJIHGFEDCBA9876543210VUTSRQPONMLKJIHGFEDCBA9876543210Z",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "transaction_entry",
     "params" : [
@@ -5332,7 +5332,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"tx: ctid. minimal",
      __LINE__,
      {"tx", "FFFFFFFFFFFFFFFF", "1", "2"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "tx",
     "params" : [
@@ -5347,7 +5347,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"tx: ctid. binary",
      __LINE__,
      {"tx", "FFFFFFFFFFFFFFFF", "binary", "1", "2"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "tx",
     "params" : [
@@ -5363,7 +5363,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"tx: minimal.",
      __LINE__,
      {"tx", "transaction_hash_is_not_validated"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "tx",
     "params" : [
@@ -5392,7 +5392,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "tx",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "tx",
     "params" : [
@@ -5436,7 +5436,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"tx_history: minimal.",
      __LINE__,
      {"tx_history", "0"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "tx_history",
     "params" : [
@@ -5451,7 +5451,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "tx_history",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::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::Exception::bad_cast,
+        RPCCallTestData::bad_cast,
         R"()",
     },
     {
@@ -5489,7 +5489,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
         "tx_history: start too big.",
         __LINE__,
         {"tx_history", "4294967296"},
-        RPCCallTestData::Exception::bad_cast,
+        RPCCallTestData::bad_cast,
         R"()",
     },
     {
@@ -5497,7 +5497,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
         "tx_history: start not integer.",
         __LINE__,
         {"tx_history", "beginning"},
-        RPCCallTestData::Exception::bad_cast,
+        RPCCallTestData::bad_cast,
         R"()",
     },
 
@@ -5508,7 +5508,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "unl_list",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "unl_list",
     "params" : [
@@ -5539,7 +5539,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "validation_create",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "validation_create",
     "params" : [
@@ -5583,7 +5583,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "version",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "version",
     "params" : [
@@ -5595,7 +5595,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"version: too many arguments.",
      __LINE__,
      {"version", "extra"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "version",
     "params" : [
@@ -5614,7 +5614,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "wallet_propose",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "wallet_propose",
     "params" : [
@@ -5656,7 +5656,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"internal: minimal.",
      __LINE__,
      {"internal", "command_name"},
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "internal",
     "params" : [
@@ -5686,7 +5686,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "internal",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "internal",
     "params" : [
@@ -5705,7 +5705,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "path_find",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "path_find",
     "params" : [
@@ -5738,7 +5738,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "subscribe",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "subscribe",
     "params" : [
@@ -5771,7 +5771,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "unsubscribe",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "unsubscribe",
     "params" : [
@@ -5804,7 +5804,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "unknown_command",
      },
-     RPCCallTestData::Exception::no_exception,
+     RPCCallTestData::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::Exception::no_exception,
+     RPCCallTestData::no_exception,
      R"({
     "method" : "unknown_command",
     "params" : [
@@ -5884,7 +5884,7 @@ public:
             }
             catch (std::bad_cast const&)
             {
-                if ((rpcCallTest.throwsWhat == RPCCallTestData::Exception::bad_cast) &&
+                if ((rpcCallTest.throwsWhat == RPCCallTestData::bad_cast) &&
                     (std::strlen(expVersioned) == 0))
                 {
                     pass();
@@ -5913,8 +5913,7 @@ public:
             rmErrorCode(exp);
 
             // Pass if we didn't expect a throw and we got what we expected.
-            if ((rpcCallTest.throwsWhat == RPCCallTestData::Exception::no_exception) &&
-                (got == exp))
+            if ((rpcCallTest.throwsWhat == RPCCallTestData::no_exception) && (got == exp))
             {
                 pass();
             }
diff --git a/src/test/shamap/FetchPack_test.cpp b/src/test/shamap/FetchPack_test.cpp
index a68b0442d0..cd3bc99fa8 100644
--- a/src/test/shamap/FetchPack_test.cpp
+++ b/src/test/shamap/FetchPack_test.cpp
@@ -33,8 +33,6 @@ 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 3f05bc2c57..08910b5c5d 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 b0b3807dd3..f4cbb5baa0 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::scoped_lock const lock(log_mutex);
+    std::lock_guard 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 1dffece1da..a09110ca43 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::scoped_lock const l{m_};
+    std::lock_guard const l{m_};
     return results_.total;
 }
 
@@ -175,7 +175,7 @@ template <bool IsParent>
 std::size_t
 multi_runner_base<IsParent>::inner::suites() const
 {
-    std::scoped_lock const l{m_};
+    std::lock_guard const l{m_};
     return results_.suites;
 }
 
@@ -197,7 +197,7 @@ template <bool IsParent>
 void
 multi_runner_base<IsParent>::inner::add(results const& r)
 {
-    std::scoped_lock const l{m_};
+    std::lock_guard const l{m_};
     results_.merge(r);
 }
 
@@ -206,7 +206,7 @@ template <class S>
 void
 multi_runner_base<IsParent>::inner::print_results(S& s)
 {
-    std::scoped_lock const l{m_};
+    std::lock_guard 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::scoped_lock const l{inner_->m_};
+    std::lock_guard 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 4ccedf9498..0f675955de 100644
--- a/src/test/unit_test/multi_runner.h
+++ b/src/test/unit_test/multi_runner.h
@@ -59,8 +59,6 @@ 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/basics/Mutex.cpp b/src/tests/libxrpl/basics/Mutex.cpp
index 260bd49da1..e91781c463 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, scoped_lock)
+TEST_F(MutexDifferentLockTypesTest, lock_guard)
 {
     Mutex<int> m(0);
     {
diff --git a/src/tests/libxrpl/helpers/Account.cpp b/src/tests/libxrpl/helpers/Account.cpp
deleted file mode 100644
index 736ae0a24b..0000000000
--- a/src/tests/libxrpl/helpers/Account.cpp
+++ /dev/null
@@ -1,19 +0,0 @@
-#include <helpers/Account.h>
-
-#include <xrpl/protocol/KeyType.h>
-#include <xrpl/protocol/PublicKey.h>
-#include <xrpl/protocol/SecretKey.h>
-#include <xrpl/protocol/Seed.h>
-
-namespace xrpl::test {
-
-Account const Account::master{"masterpassphrase"};
-
-Account::Account(std::string_view name, KeyType type)
-    : name_(name)
-    , keyPair_(generateKeyPair(type, generateSeed(name_)))
-    , id_(calcAccountID(keyPair_.first))
-{
-}
-
-}  // namespace xrpl::test
diff --git a/src/tests/libxrpl/helpers/Account.h b/src/tests/libxrpl/helpers/Account.h
deleted file mode 100644
index 9c3ad19bbb..0000000000
--- a/src/tests/libxrpl/helpers/Account.h
+++ /dev/null
@@ -1,81 +0,0 @@
-#pragma once
-
-#include <xrpl/protocol/AccountID.h>
-#include <xrpl/protocol/KeyType.h>
-#include <xrpl/protocol/PublicKey.h>
-#include <xrpl/protocol/SecretKey.h>
-
-#include <string>
-#include <string_view>
-#include <utility>
-
-namespace xrpl::test {
-
-/**
- * @brief A test account with cryptographic keys.
- *
- * Generates keys deterministically from a name, making tests reproducible.
- * The same name always produces the same AccountID and keys.
- */
-class Account
-{
-public:
-    /**
-     * @brief The master account that holds all XRP in genesis.
-     *
-     * This account is created in the genesis ledger with all 100 billion XRP.
-     * It uses the well-known seed "masterpassphrase".
-     */
-    static Account const master;
-
-    /**
-     * @brief Create an account from a name.
-     *
-     * Keys are derived deterministically from the name.
-     *
-     * @param name Human-readable name for the account.
-     * @param type Key type to use (defaults to secp256k1).
-     */
-    explicit Account(std::string_view name, KeyType type = KeyType::secp256k1);
-
-    /** @brief Return the human-readable name. */
-    std::string const&
-    name() const noexcept
-    {
-        return name_;
-    }
-
-    /** @brief Return the AccountID. */
-    AccountID const&
-    id() const noexcept
-    {
-        return id_;
-    }
-
-    /** @brief Return the public key. */
-    PublicKey const&
-    pk() const noexcept
-    {
-        return keyPair_.first;
-    }
-
-    /** @brief Return the secret key. */
-    SecretKey const&
-    sk() const noexcept
-    {
-        return keyPair_.second;
-    }
-
-    /** @brief Implicit conversion to AccountID. */
-    operator AccountID const&() const noexcept
-    {
-        return id_;
-    }
-
-private:
-    std::string name_;
-    std::pair<PublicKey, SecretKey> keyPair_;
-    AccountID id_;
-};
-
-}  // namespace xrpl::test
diff --git a/src/tests/libxrpl/helpers/IOU.h b/src/tests/libxrpl/helpers/IOU.h
deleted file mode 100644
index 1e845f5ae6..0000000000
--- a/src/tests/libxrpl/helpers/IOU.h
+++ /dev/null
@@ -1,132 +0,0 @@
-#pragma once
-
-#include <xrpl/basics/Number.h>
-#include <xrpl/protocol/Asset.h>
-#include <xrpl/protocol/Issue.h>
-#include <xrpl/protocol/STAmount.h>
-#include <xrpl/protocol/UintTypes.h>
-
-#include <helpers/Account.h>
-
-#include <concepts>
-#include <string>
-#include <string_view>
-#include <type_traits>
-
-namespace xrpl::test {
-
-/**
- * @brief Represents an IOU (issued currency) for testing.
- *
- * Provides a clear, explicit API for creating currencies issued by an account.
- * This replaces the cryptic `Account::operator[]` from the jtx framework.
- *
- * @code
- *     Account gw("gateway");
- *     IOU USD("USD", gw);
- *
- *     auto issue = USD.issue();      // Get the Issue
- *     auto asset = USD.asset();      // Get the Asset
- *     auto amt = USD.amount(100);    // Get STAmount of 100 USD
- * @endcode
- */
-class IOU
-{
-public:
-    /**
-     * @brief Construct an IOU from a currency code and issuing account.
-     * @param currencyCode A 3-character ISO currency code (e.g., "USD").
-     * @param issuer The account that issues this currency.
-     */
-    IOU(std::string_view currencyCode, Account const& issuer)
-        : currency_(to_currency(std::string(currencyCode))), issuer_(issuer.id())
-    {
-        XRPL_ASSERT(!isXRP(currency_), "IOU: currency code must not resolve to XRP");
-    }
-
-    /**
-     * @brief Construct an IOU from a Currency and issuing account.
-     * @param currency The Currency object.
-     * @param issuer The account that issues this currency.
-     */
-    IOU(Currency currency, Account const& issuer)
-        : currency_(std::move(currency)), issuer_(issuer.id())
-    {
-        XRPL_ASSERT(!isXRP(currency_), "IOU: currency code must not resolve to XRP");
-    }
-
-    /**
-     * @brief Get the Issue (currency + issuer pair).
-     * @return An Issue object representing this IOU.
-     */
-    [[nodiscard]] Issue
-    issue() const
-    {
-        return Issue{currency_, issuer_};
-    }
-
-    /**
-     * @brief Get the Asset.
-     * @return An Asset object representing this IOU.
-     */
-    [[nodiscard]] Asset
-    asset() const
-    {
-        return Asset{issue()};
-    }
-
-    /**
-     * @brief Create an STAmount of this IOU.
-     *
-     * Works with any arithmetic type (int, double, etc.) by converting
-     * to string and parsing. This matches the jtx IOU behaviour.
-     *
-     * @tparam T An arithmetic type.
-     * @param value The amount as any arithmetic type.
-     * @return An STAmount representing value units of this IOU.
-     */
-    template <typename T>
-        requires std::is_arithmetic_v<T>
-    [[nodiscard]] STAmount
-    amount(T value) const
-    {
-        return amountFromString(issue(), to_string(value));
-    }
-
-    /**
-     * @brief Create an STAmount of this IOU from a Number.
-     * @param value The amount as a Number.
-     * @return An STAmount representing value units of this IOU.
-     */
-    [[nodiscard]] STAmount
-    amount(Number const& value) const
-    {
-        return STAmount{issue(), value};
-    }
-
-    /**
-     * @brief Get the currency.
-     * @return The currency.
-     */
-    [[nodiscard]] Currency const&
-    currency() const
-    {
-        return currency_;
-    }
-
-    /**
-     * @brief Get the issuer account ID.
-     * @return The issuer's AccountID.
-     */
-    [[nodiscard]] AccountID const&
-    issuer() const
-    {
-        return issuer_;
-    }
-
-private:
-    Currency currency_;
-    AccountID issuer_;
-};
-
-}  // namespace xrpl::test
diff --git a/src/tests/libxrpl/helpers/TestFamily.h b/src/tests/libxrpl/helpers/TestFamily.h
deleted file mode 100644
index 98c5a379e4..0000000000
--- a/src/tests/libxrpl/helpers/TestFamily.h
+++ /dev/null
@@ -1,111 +0,0 @@
-#pragma once
-
-#include <xrpl/basics/chrono.h>
-#include <xrpl/nodestore/DummyScheduler.h>
-#include <xrpl/nodestore/Manager.h>
-#include <xrpl/shamap/Family.h>
-
-#include <memory>
-
-namespace xrpl {
-namespace test {
-
-/** Test implementation of Family for unit tests.
-
-    Uses an in-memory NodeStore database and simple caches.
-    The missingNode methods throw since tests shouldn't encounter missing nodes.
-*/
-class TestFamily : public Family
-{
-private:
-    std::unique_ptr<NodeStore::Database> db_;
-    TestStopwatch clock_;
-    std::shared_ptr<FullBelowCache> fbCache_;
-    std::shared_ptr<TreeNodeCache> tnCache_;
-    NodeStore::DummyScheduler scheduler_;
-    beast::Journal j_;
-
-public:
-    explicit TestFamily(beast::Journal j)
-        : fbCache_(std::make_shared<FullBelowCache>("TestFamily full below cache", clock_, j))
-        , tnCache_(
-              std::make_shared<TreeNodeCache>(
-                  "TestFamily tree node cache",
-                  65536,
-                  std::chrono::minutes{1},
-                  clock_,
-                  j))
-        , j_(j)
-    {
-        Section config;
-        config.set("type", "memory");
-        config.set("path", "TestFamily");
-        db_ = NodeStore::Manager::instance().make_Database(megabytes(4), scheduler_, 1, config, j);
-    }
-
-    NodeStore::Database&
-    db() override
-    {
-        return *db_;
-    }
-
-    NodeStore::Database const&
-    db() const override
-    {
-        return *db_;
-    }
-
-    beast::Journal const&
-    journal() override
-    {
-        return j_;
-    }
-
-    std::shared_ptr<FullBelowCache>
-    getFullBelowCache() override
-    {
-        return fbCache_;
-    }
-
-    std::shared_ptr<TreeNodeCache>
-    getTreeNodeCache() override
-    {
-        return tnCache_;
-    }
-
-    void
-    sweep() override
-    {
-        fbCache_->sweep();
-        tnCache_->sweep();
-    }
-
-    void
-    missingNodeAcquireBySeq(std::uint32_t refNum, uint256 const& nodeHash) override
-    {
-        Throw<std::runtime_error>("TestFamily: missing node (by seq)");
-    }
-
-    void
-    missingNodeAcquireByHash(uint256 const& refHash, std::uint32_t refNum) override
-    {
-        Throw<std::runtime_error>("TestFamily: missing node (by hash)");
-    }
-
-    void
-    reset() override
-    {
-        fbCache_->reset();
-        tnCache_->reset();
-    }
-
-    /** Access the test clock for time manipulation in tests. */
-    TestStopwatch&
-    clock()
-    {
-        return clock_;
-    }
-};
-
-}  // namespace test
-}  // namespace xrpl
diff --git a/src/tests/libxrpl/helpers/TestServiceRegistry.h b/src/tests/libxrpl/helpers/TestServiceRegistry.h
deleted file mode 100644
index 4f39124087..0000000000
--- a/src/tests/libxrpl/helpers/TestServiceRegistry.h
+++ /dev/null
@@ -1,378 +0,0 @@
-#pragma once
-
-#include <xrpl/basics/Log.h>
-#include <xrpl/basics/chrono.h>
-#include <xrpl/core/HashRouter.h>
-#include <xrpl/core/NetworkIDService.h>
-#include <xrpl/core/ServiceRegistry.h>
-#include <xrpl/ledger/PendingSaves.h>
-#include <xrpl/server/LoadFeeTrack.h>
-
-#include <boost/asio/io_context.hpp>
-
-#include <helpers/TestFamily.h>
-#include <helpers/TestSink.h>
-
-#include <optional>
-#include <stdexcept>
-
-namespace xrpl {
-namespace test {
-
-/** Logs implementation that creates TestSink instances. */
-class TestLogs : public Logs
-{
-public:
-    explicit TestLogs(beast::severities::Severity level = beast::severities::kWarning) : Logs(level)
-    {
-    }
-
-    std::unique_ptr<beast::Journal::Sink>
-    makeSink(std::string const&, beast::severities::Severity threshold) override
-    {
-        return std::make_unique<TestSink>(threshold);
-    }
-};
-
-/** Simple NetworkIDService implementation for tests. */
-class TestNetworkIDService final : public NetworkIDService
-{
-public:
-    explicit TestNetworkIDService(std::uint32_t networkID = 0) : networkID_(networkID)
-    {
-    }
-
-    [[nodiscard]] std::uint32_t
-    getNetworkID() const noexcept override
-    {
-        return networkID_;
-    }
-
-private:
-    std::uint32_t networkID_;
-};
-
-/** Test implementation of ServiceRegistry for unit tests.
-
-    This class provides real implementations for services that can be
-    instantiated from libxrpl (such as Logs, io_context, caches), and
-    throws std::logic_error for services that require the full Application.
-
-    Tests can subclass this to provide additional services they need.
-*/
-class TestServiceRegistry : public ServiceRegistry
-{
-    TestLogs logs_{beast::severities::kWarning};
-    boost::asio::io_context io_context_;
-    TestFamily family_{logs_.journal("TestFamily")};
-    LoadFeeTrack feeTrack_{logs_.journal("LoadFeeTrack")};
-    TestNetworkIDService networkIDService_;
-    HashRouter hashRouter_{HashRouter::Setup{}, stopwatch()};
-    NodeCache tempNodeCache_{
-        "TempNodeCache",
-        16384,
-        std::chrono::minutes{1},
-        stopwatch(),
-        logs_.journal("TaggedCache")};
-    CachedSLEs cachedSLEs_{
-        "CachedSLEs",
-        16384,
-        std::chrono::minutes{1},
-        stopwatch(),
-        logs_.journal("TaggedCache")};
-    PendingSaves pendingSaves_;
-    std::optional<uint256> trapTxID_;
-
-public:
-    TestServiceRegistry() = default;
-    ~TestServiceRegistry() override = default;
-
-    // Core infrastructure services
-    CollectorManager&
-    getCollectorManager() override
-    {
-        throw std::logic_error("TestServiceRegistry::getCollectorManager() not implemented");
-    }
-
-    Family&
-    getNodeFamily() override
-    {
-        return family_;
-    }
-
-    TimeKeeper&
-    getTimeKeeper() override
-    {
-        throw std::logic_error("TestServiceRegistry::timeKeeper() not implemented");
-    }
-
-    JobQueue&
-    getJobQueue() override
-    {
-        throw std::logic_error("TestServiceRegistry::getJobQueue() not implemented");
-    }
-
-    NodeCache&
-    getTempNodeCache() override
-    {
-        return tempNodeCache_;
-    }
-
-    CachedSLEs&
-    getCachedSLEs() override
-    {
-        return cachedSLEs_;
-    }
-
-    NetworkIDService&
-    getNetworkIDService() override
-    {
-        return networkIDService_;
-    }
-
-    // Protocol and validation services
-    AmendmentTable&
-    getAmendmentTable() override
-    {
-        throw std::logic_error("TestServiceRegistry::getAmendmentTable() not implemented");
-    }
-
-    HashRouter&
-    getHashRouter() override
-    {
-        return hashRouter_;
-    }
-
-    LoadFeeTrack&
-    getFeeTrack() override
-    {
-        return feeTrack_;
-    }
-
-    LoadManager&
-    getLoadManager() override
-    {
-        throw std::logic_error("TestServiceRegistry::getLoadManager() not implemented");
-    }
-
-    RCLValidations&
-    getValidations() override
-    {
-        throw std::logic_error("TestServiceRegistry::getValidations() not implemented");
-    }
-
-    ValidatorList&
-    getValidators() override
-    {
-        throw std::logic_error("TestServiceRegistry::validators() not implemented");
-    }
-
-    ValidatorSite&
-    getValidatorSites() override
-    {
-        throw std::logic_error("TestServiceRegistry::validatorSites() not implemented");
-    }
-
-    ManifestCache&
-    getValidatorManifests() override
-    {
-        throw std::logic_error("TestServiceRegistry::validatorManifests() not implemented");
-    }
-
-    ManifestCache&
-    getPublisherManifests() override
-    {
-        throw std::logic_error("TestServiceRegistry::publisherManifests() not implemented");
-    }
-
-    // Network services
-    Overlay&
-    getOverlay() override
-    {
-        throw std::logic_error("TestServiceRegistry::overlay() not implemented");
-    }
-
-    Cluster&
-    getCluster() override
-    {
-        throw std::logic_error("TestServiceRegistry::cluster() not implemented");
-    }
-
-    PeerReservationTable&
-    getPeerReservations() override
-    {
-        throw std::logic_error("TestServiceRegistry::peerReservations() not implemented");
-    }
-
-    Resource::Manager&
-    getResourceManager() override
-    {
-        throw std::logic_error("TestServiceRegistry::getResourceManager() not implemented");
-    }
-
-    // Storage services
-    NodeStore::Database&
-    getNodeStore() override
-    {
-        throw std::logic_error("TestServiceRegistry::getNodeStore() not implemented");
-    }
-
-    SHAMapStore&
-    getSHAMapStore() override
-    {
-        throw std::logic_error("TestServiceRegistry::getSHAMapStore() not implemented");
-    }
-
-    RelationalDatabase&
-    getRelationalDatabase() override
-    {
-        throw std::logic_error("TestServiceRegistry::getRelationalDatabase() not implemented");
-    }
-
-    // Ledger services
-    InboundLedgers&
-    getInboundLedgers() override
-    {
-        throw std::logic_error("TestServiceRegistry::getInboundLedgers() not implemented");
-    }
-
-    InboundTransactions&
-    getInboundTransactions() override
-    {
-        throw std::logic_error("TestServiceRegistry::getInboundTransactions() not implemented");
-    }
-
-    TaggedCache<uint256, AcceptedLedger>&
-    getAcceptedLedgerCache() override
-    {
-        throw std::logic_error("TestServiceRegistry::getAcceptedLedgerCache() not implemented");
-    }
-
-    LedgerMaster&
-    getLedgerMaster() override
-    {
-        throw std::logic_error("TestServiceRegistry::getLedgerMaster() not implemented");
-    }
-
-    LedgerCleaner&
-    getLedgerCleaner() override
-    {
-        throw std::logic_error("TestServiceRegistry::getLedgerCleaner() not implemented");
-    }
-
-    LedgerReplayer&
-    getLedgerReplayer() override
-    {
-        throw std::logic_error("TestServiceRegistry::getLedgerReplayer() not implemented");
-    }
-
-    PendingSaves&
-    getPendingSaves() override
-    {
-        return pendingSaves_;
-    }
-
-    OpenLedger&
-    getOpenLedger() override
-    {
-        throw std::logic_error("TestServiceRegistry::openLedger() not implemented");
-    }
-
-    OpenLedger const&
-    getOpenLedger() const override
-    {
-        throw std::logic_error("TestServiceRegistry::openLedger() const not implemented");
-    }
-
-    // Transaction and operation services
-    NetworkOPs&
-    getOPs() override
-    {
-        throw std::logic_error("TestServiceRegistry::getOPs() not implemented");
-    }
-
-    OrderBookDB&
-    getOrderBookDB() override
-    {
-        throw std::logic_error("TestServiceRegistry::getOrderBookDB() not implemented");
-    }
-
-    TransactionMaster&
-    getMasterTransaction() override
-    {
-        throw std::logic_error("TestServiceRegistry::getMasterTransaction() not implemented");
-    }
-
-    TxQ&
-    getTxQ() override
-    {
-        throw std::logic_error("TestServiceRegistry::getTxQ() not implemented");
-    }
-
-    PathRequestManager&
-    getPathRequestManager() override
-    {
-        throw std::logic_error("TestServiceRegistry::getPathRequestManager() not implemented");
-    }
-
-    // Server services
-    ServerHandler&
-    getServerHandler() override
-    {
-        throw std::logic_error("TestServiceRegistry::getServerHandler() not implemented");
-    }
-
-    perf::PerfLog&
-    getPerfLog() override
-    {
-        throw std::logic_error("TestServiceRegistry::getPerfLog() not implemented");
-    }
-
-    // Configuration and state
-    bool
-    isStopping() const override
-    {
-        return false;
-    }
-
-    beast::Journal
-    getJournal(std::string const& name) override
-    {
-        return logs_.journal(name);
-    }
-
-    boost::asio::io_context&
-    getIOContext() override
-    {
-        return io_context_;
-    }
-
-    Logs&
-    getLogs() override
-    {
-        return logs_;
-    }
-
-    std::optional<uint256> const&
-    getTrapTxID() const override
-    {
-        return trapTxID_;
-    }
-
-    DatabaseCon&
-    getWalletDB() override
-    {
-        throw std::logic_error("TestServiceRegistry::getWalletDB() not implemented");
-    }
-
-    // Temporary: Get the underlying Application
-    Application&
-    getApp() override
-    {
-        throw std::logic_error(
-            "TestServiceRegistry::app() not implemented - no Application available in tests");
-    }
-};
-
-}  // namespace test
-}  // namespace xrpl
diff --git a/src/tests/libxrpl/helpers/TxTest.cpp b/src/tests/libxrpl/helpers/TxTest.cpp
deleted file mode 100644
index d88f700356..0000000000
--- a/src/tests/libxrpl/helpers/TxTest.cpp
+++ /dev/null
@@ -1,252 +0,0 @@
-#include <helpers/TxTest.h>
-
-#include <xrpl/basics/base_uint.h>
-#include <xrpl/basics/chrono.h>
-#include <xrpl/basics/contract.h>
-#include <xrpl/ledger/ApplyView.h>
-#include <xrpl/ledger/CanonicalTXSet.h>
-#include <xrpl/ledger/Ledger.h>
-#include <xrpl/ledger/OpenView.h>
-#include <xrpl/ledger/ReadView.h>
-#include <xrpl/protocol/AccountID.h>
-#include <xrpl/protocol/Feature.h>
-#include <xrpl/protocol/Fees.h>
-#include <xrpl/protocol/Indexes.h>
-#include <xrpl/protocol/SField.h>
-#include <xrpl/protocol/STLedgerEntry.h>
-#include <xrpl/protocol/STTx.h>
-#include <xrpl/protocol/TER.h>
-#include <xrpl/protocol_autogen/ledger_entries/AccountRoot.h>
-#include <xrpl/protocol_autogen/ledger_entries/RippleState.h>
-#include <xrpl/protocol_autogen/transactions/AccountSet.h>
-#include <xrpl/protocol_autogen/transactions/Payment.h>
-#include <xrpl/tx/apply.h>
-
-#include <helpers/Account.h>
-#include <helpers/IOU.h>
-
-#include <cstdint>
-#include <memory>
-#include <optional>
-#include <stdexcept>
-#include <utility>
-#include <vector>
-
-namespace xrpl::test {
-
-//------------------------------------------------------------------------------
-// Feature helpers
-//------------------------------------------------------------------------------
-
-FeatureBitset
-allFeatures()
-{
-    static FeatureBitset const features = [] {
-        auto const& sa = allAmendments();
-        std::vector<uint256> feats;
-        feats.reserve(sa.size());
-        for ([[maybe_unused]] auto const& [name, _] : sa)
-        {
-            if (auto const f = getRegisteredFeature(name); f.has_value())
-                feats.push_back(*f);
-        }
-        return FeatureBitset(feats);
-    }();
-    return features;
-}
-
-//------------------------------------------------------------------------------
-// TxTest
-//------------------------------------------------------------------------------
-
-TxTest::TxTest(std::optional<FeatureBitset> features)
-{
-    // Convert FeatureBitset to unordered_set for Rules constructor
-    auto const featureBits = features.value_or(allFeatures());
-    foreachFeature(featureBits, [&](uint256 const& f) { featureSet_.insert(f); });
-
-    // Create rules with the specified features
-    rules_.emplace(featureSet_);
-
-    // Default fees for testing
-    Fees const fees{XRPAmount{10}, XRPAmount{10000000}, XRPAmount{2000000}};
-
-    // Create a genesis ledger as the base
-    closedLedger_ = std::make_shared<Ledger>(
-        create_genesis,
-        // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
-        *rules_,
-        fees,
-        std::vector<uint256>{featureSet_.begin(), featureSet_.end()},
-        registry_.getNodeFamily());
-
-    // Initialize time from the genesis ledger
-    now_ = closedLedger_->header().closeTime;
-
-    // Create an open view on top of the genesis ledger
-    openLedger_ =
-        std::make_shared<OpenView>(open_ledger, closedLedger_.get(), *rules_, closedLedger_);
-}
-
-bool
-TxTest::isEnabled(uint256 const& feature) const
-{
-    // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
-    return rules_->enabled(feature);
-}
-
-Rules const&
-TxTest::getRules() const
-{
-    // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
-    return *rules_;
-}
-
-[[nodiscard]] TxResult
-TxTest::submit(std::shared_ptr<STTx const> stx)
-{
-    auto result = apply(registry_, *openLedger_, *stx, tapNONE, registry_.getJournal("apply"));
-
-    // Track successfully applied transactions for canonical reordering on close
-    // We make a copy since the TransactionBase doesn't own the STTx
-    if (result.applied)
-        pendingTxs_.push_back(stx);
-
-    return TxResult{
-        .ter = result.ter,
-        .applied = result.applied,
-        .metadata = std::move(result).metadata,
-        .tx = std::move(stx)};
-}
-
-void
-TxTest::createAccount(Account const& account, XRPAmount xrp, uint32_t accountFlags)
-{
-    auto const paymentTer =
-        submit(transactions::PaymentBuilder{Account::master, account, xrp}, Account::master).ter;
-
-    if (paymentTer != tesSUCCESS)
-    {
-        throw std::runtime_error("TxTest::createAccount: failed to create account");
-    }
-
-    close();
-
-    if (accountFlags != 0)
-    {
-        auto const accountSetTer =
-            submit(transactions::AccountSetBuilder{account}.setSetFlag(accountFlags), account).ter;
-        if (accountSetTer != tesSUCCESS)
-        {
-            throw std::runtime_error("TxTest::createAccount: failed to set account flags");
-        }
-        close();
-    }
-}
-
-ledger_entries::AccountRoot
-TxTest::getAccountRoot(AccountID const& id) const
-{
-    auto const sle = getOpenLedger().read(keylet::account(id));
-    if (!sle)
-        Throw<std::runtime_error>("TxTest::getAccountRoot: account not found");
-    return ledger_entries::AccountRoot{std::const_pointer_cast<SLE const>(sle)};
-}
-
-OpenView&
-TxTest::getOpenLedger()
-{
-    return *openLedger_;
-}
-
-OpenView const&
-TxTest::getOpenLedger() const
-{
-    return *openLedger_;
-}
-
-ReadView const&
-TxTest::getClosedLedger() const
-{
-    return *closedLedger_;
-}
-
-void
-TxTest::close()
-{
-    // Build a new closed ledger from the previous closed ledger,
-    // similar to how buildLedgerImpl works:
-    // 1. Create a new Ledger from the previous closed ledger
-    // 2. Re-apply transactions in canonical order
-    // 3. Mark it as accepted/immutable
-
-    auto const& prevLedger = *closedLedger_;
-
-    auto const ledgerCloseTime = now_ + prevLedger.header().closeTimeResolution;
-
-    now_ = ledgerCloseTime;
-
-    auto newLedger = std::make_shared<Ledger>(prevLedger, ledgerCloseTime);
-
-    CanonicalTXSet txSet(prevLedger.header().hash);
-    for (auto const& tx : pendingTxs_)
-        txSet.insert(tx);
-
-    {
-        OpenView accum(&*newLedger);
-        for (auto const& [key, tx] : txSet)
-        {
-            auto result = apply(registry_, accum, *tx, tapNONE, registry_.getJournal("apply"));
-            if (!result.applied)
-            {
-                throw std::runtime_error("TxTest::close: failed to apply transaction");
-            }
-        }
-        accum.apply(*newLedger);
-    }
-
-    newLedger->setAccepted(ledgerCloseTime, newLedger->header().closeTimeResolution, true);
-
-    closedLedger_ = newLedger;
-
-    pendingTxs_.clear();
-
-    openLedger_ =
-        // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
-        std::make_shared<OpenView>(open_ledger, closedLedger_.get(), *rules_, closedLedger_);
-}
-
-void
-TxTest::advanceTime(NetClock::duration duration)
-{
-    now_ += duration;
-}
-
-NetClock::time_point
-TxTest::getCloseTime() const
-{
-    return now_;
-}
-
-STAmount
-TxTest::getBalance(AccountID const& account, IOU const& iou) const
-{
-    auto const sle = openLedger_->read(keylet::line(account, iou.issue()));
-    if (!sle)
-        return STAmount{iou.issue(), 0};
-
-    auto const rippleState = ledger_entries::RippleState{sle};
-
-    auto balance = rippleState.getBalance();
-    if (iou.issue().account == account)
-    {
-        throw std::logic_error("TxTest::getBalance: account is issuer");
-    }
-
-    balance.get<Issue>().account = iou.issue().account;
-    if (account > iou.issue().account)
-        balance.negate();
-    return balance;
-}
-
-}  // namespace xrpl::test
diff --git a/src/tests/libxrpl/helpers/TxTest.h b/src/tests/libxrpl/helpers/TxTest.h
deleted file mode 100644
index 864b19c399..0000000000
--- a/src/tests/libxrpl/helpers/TxTest.h
+++ /dev/null
@@ -1,364 +0,0 @@
-#pragma once
-
-#include <xrpl/basics/Number.h>
-#include <xrpl/basics/chrono.h>
-#include <xrpl/beast/utility/Journal.h>
-#include <xrpl/core/ServiceRegistry.h>
-#include <xrpl/ledger/ApplyViewImpl.h>
-#include <xrpl/ledger/Ledger.h>
-#include <xrpl/ledger/OpenView.h>
-#include <xrpl/protocol/Feature.h>
-#include <xrpl/protocol/LedgerFormats.h>
-#include <xrpl/protocol/Rules.h>
-#include <xrpl/protocol/STTx.h>
-#include <xrpl/protocol/TER.h>
-#include <xrpl/protocol/TxFlags.h>
-#include <xrpl/protocol/XRPAmount.h>
-#include <xrpl/protocol_autogen/TransactionBuilderBase.h>
-#include <xrpl/protocol_autogen/ledger_entries/AccountRoot.h>
-#include <xrpl/tx/applySteps.h>
-
-#include <helpers/Account.h>
-#include <helpers/IOU.h>
-#include <helpers/TestServiceRegistry.h>
-
-#include <cmath>
-#include <concepts>
-#include <memory>
-#include <optional>
-#include <stdexcept>
-#include <type_traits>
-#include <unordered_set>
-#include <vector>
-
-namespace xrpl::test {
-
-//------------------------------------------------------------------------------
-// Amount helpers
-//------------------------------------------------------------------------------
-
-/**
- * @brief Convert XRP to drops (integral types).
- * @param xrp The amount in XRP.
- * @return The equivalent amount in drops as XRPAmount.
- */
-template <std::integral T>
-constexpr XRPAmount
-XRP(T xrp)
-{
-    return XRPAmount{static_cast<std::int64_t>(xrp) * DROPS_PER_XRP.drops()};
-}
-
-/**
- * @brief Convert XRP to drops (floating point types).
- * @param xrp The amount in XRP (may be fractional).
- * @return The equivalent amount in drops as XRPAmount.
- */
-template <std::floating_point T>
-XRPAmount
-XRP(T xrp)
-{
-    return XRPAmount{static_cast<std::int64_t>(std::round(xrp * DROPS_PER_XRP.drops()))};
-}
-
-/**
- * @brief Convert XRP to drops (Number type).
- * @param xrp The amount in XRP as a Number.
- * @return The equivalent amount in drops as XRPAmount.
- */
-inline XRPAmount
-XRP(Number const& xrp)
-{
-    return XRPAmount{static_cast<std::int64_t>(xrp * DROPS_PER_XRP.drops())};
-}
-
-//------------------------------------------------------------------------------
-// Flag helpers
-//------------------------------------------------------------------------------
-
-/**
- * @brief Convert AccountSet flag (asf) to LedgerState flag (lsf).
- * @param asf The AccountSet flag value.
- * @return The corresponding LedgerState flag.
- * @throws std::runtime_error if the flag is not supported.
- *
- * Supported flags:
- *   asfRequireDest, asfRequireAuth, asfDisallowXRP, asfDisableMaster,
- *   asfNoFreeze, asfGlobalFreeze, asfDefaultRipple, asfDepositAuth,
- *   asfAllowTrustLineClawback, asfDisallowIncomingCheck,
- *   asfDisallowIncomingNFTokenOffer, asfDisallowIncomingPayChan,
- *   asfDisallowIncomingTrustline, asfAllowTrustLineLocking
- */
-constexpr std::uint32_t
-asfToLsf(std::uint32_t asf)
-{
-    switch (asf)
-    {
-        case asfRequireDest:
-            return lsfRequireDestTag;
-        case asfRequireAuth:
-            return lsfRequireAuth;
-        case asfDisallowXRP:
-            return lsfDisallowXRP;
-        case asfDisableMaster:
-            return lsfDisableMaster;
-        case asfNoFreeze:
-            return lsfNoFreeze;
-        case asfGlobalFreeze:
-            return lsfGlobalFreeze;
-        case asfDefaultRipple:
-            return lsfDefaultRipple;
-        case asfDepositAuth:
-            return lsfDepositAuth;
-        case asfAllowTrustLineClawback:
-            return lsfAllowTrustLineClawback;
-        case asfDisallowIncomingCheck:
-            return lsfDisallowIncomingCheck;
-        case asfDisallowIncomingNFTokenOffer:
-            return lsfDisallowIncomingNFTokenOffer;
-        case asfDisallowIncomingPayChan:
-            return lsfDisallowIncomingPayChan;
-        case asfDisallowIncomingTrustline:
-            return lsfDisallowIncomingTrustline;
-        case asfAllowTrustLineLocking:
-            return lsfAllowTrustLineLocking;
-        default:
-            throw std::runtime_error("Unknown asf flag");
-    }
-}
-
-//------------------------------------------------------------------------------
-// Feature helpers
-//------------------------------------------------------------------------------
-
-/**
- * @brief Returns all testable amendments.
- * @note This is similar to jtx::testable_amendments() but for the TxTest framework.
- */
-FeatureBitset
-allFeatures();
-
-//------------------------------------------------------------------------------
-// TxResult
-//------------------------------------------------------------------------------
-
-/**
- * @brief Result of a transaction submission in TxTest.
- *
- * Contains the TER code, whether the transaction was applied,
- * optional metadata, and a reference to the submitted transaction.
- * Use standard gtest macros (EXPECT_EQ, EXPECT_TRUE, etc.) to verify results.
- */
-struct TxResult
-{
-    TER ter;                        /**< The transaction engine result code. */
-    bool applied;                   /**< Whether the transaction was applied to the ledger. */
-    std::optional<TxMeta> metadata; /**< Transaction metadata, if available. */
-    std::shared_ptr<STTx const> tx; /**< Pointer to the submitted transaction. */
-};
-
-/**
- * @brief A lightweight transaction testing harness.
- *
- * Unlike the JTx framework which requires a full Application and RPC layer,
- * TxTest applies transactions directly to an OpenView using the transactor
- * pipeline (preflight -> preclaim -> doApply).
- *
- * This makes it suitable for:
- * - Unit testing individual transactors
- * - Testing transaction validation logic
- * - Fast, focused tests without full server infrastructure
- *
- * @code
- *     TxTest env;
- *     env.submit(paymentTx).expectSuccess();
- *     env.submit(badTx).expectTer(tecNO_ENTRY);
- * @endcode
- */
-class TxTest
-{
-public:
-    /**
-     * @brief Construct a TxTest environment.
-     *
-     * Creates a genesis ledger and an open view on top of it.
-     *
-     * @param features Optional set of features to enable. If not specified,
-     *                 uses all testable amendments.
-     */
-    explicit TxTest(std::optional<FeatureBitset> features = std::nullopt);
-
-    /**
-     * @brief Check if a feature is enabled.
-     * @param feature The feature to check.
-     * @return True if the feature is enabled.
-     */
-    [[nodiscard]] bool
-    isEnabled(uint256 const& feature) const;
-
-    /**
-     * @brief Get the current rules.
-     * @return The current consensus rules.
-     */
-    [[nodiscard]] Rules const&
-    getRules() const;
-
-    /**
-     * @brief Submit a transaction from a builder.
-     *
-     * Convenience overload that accepts transaction builders.
-     * Automatically sets sequence and fee before submission.
-     *
-     * @tparam T A type derived from TransactionBuilderBase.
-     * @param builder The transaction builder.
-     * @param signer The account to sign with.
-     * @return TxResult containing the result code, applied status, and metadata.
-     */
-    template <typename T>
-        requires std::
-            derived_from<std::decay_t<T>, transactions::TransactionBuilderBase<std::decay_t<T>>>
-        [[nodiscard]] TxResult
-        submit(T&& builder, Account const& signer)
-    {
-        auto const& obj = builder.getSTObject();
-        auto accountId = obj[sfAccount];
-        // Only set sequence if not using a ticket (ticket sets sequence to 0)
-        if (!obj.isFieldPresent(sfTicketSequence))
-        {
-            builder.setSequence(getAccountRoot(accountId).getSequence());
-        }
-        else
-        {
-            builder.setSequence(0);
-        }
-        builder.setFee(XRPAmount(10));
-        return submit(builder.build(signer.pk(), signer.sk()).getSTTx());
-    }
-
-    /**
-     * @brief Submit a transaction to the open ledger.
-     *
-     * Applies the transaction through the full transactor pipeline:
-     * preflight -> preclaim -> doApply -> invariant checks
-     *
-     * Invariant checks are automatically run after doApply. If any
-     * invariant fails, the result will be tecINVARIANT_FAILED.
-     *
-     * @param stx The transaction to submit.
-     * @return TxResult containing the result code, applied status, and metadata.
-     */
-    [[nodiscard]] TxResult
-    submit(std::shared_ptr<STTx const> stx);
-
-    /**
-     * @brief Create a new account in the ledger.
-     *
-     * Sends a Payment from the master account to create and fund the account.
-     * Closes the ledger after creation. If accountFlags is non-zero, submits
-     * an AccountSet transaction and closes again.
-     *
-     * @param account The account to create.
-     * @param xrp The initial XRP balance.
-     * @param accountFlags Optional account flags to set. Defaults to 0
-     *        (no flags).
-     */
-    void
-    createAccount(Account const& account, XRPAmount xrp, uint32_t accountFlags = 0);
-
-    /**
-     * @brief Get the account root object from the current open ledger.
-     * @param id The account ID.
-     * @return The AccountRoot ledger entry.
-     * @throws std::runtime_error if the account does not exist.
-     * @todo Once we make keylet strongly typed, we can ditch this method.
-     */
-    [[nodiscard]] ledger_entries::AccountRoot
-    getAccountRoot(AccountID const& id) const;
-
-    /**
-     * @brief Get the current open ledger view.
-     * @return A mutable reference to the open ledger.
-     */
-    [[nodiscard]] OpenView&
-    getOpenLedger();
-
-    /**
-     * @brief Get the current open ledger view (const).
-     * @return A const reference to the open ledger.
-     */
-    [[nodiscard]] OpenView const&
-    getOpenLedger() const;
-
-    /**
-     * @brief Get the closed (base) ledger view.
-     * @return A const reference to the closed ledger.
-     */
-    [[nodiscard]] ReadView const&
-    getClosedLedger() const;
-
-    /**
-     * @brief Close the current ledger.
-     *
-     * Creates a new closed ledger from the current open ledger.
-     * All pending transactions are re-applied in canonical order.
-     */
-    void
-    close();
-
-    /**
-     * @brief Advance time without closing the ledger.
-     *
-     * Useful for testing time-dependent features like escrow release
-     * times or offer expirations.
-     *
-     * @param duration The amount of time to advance.
-     */
-    void
-    advanceTime(NetClock::duration duration);
-
-    /**
-     * @brief Get the current ledger close time.
-     * @return The current close time.
-     */
-    [[nodiscard]] NetClock::time_point
-    getCloseTime() const;
-
-    /**
-     * @brief Get the balance of an IOU for an account.
-     *
-     * Returns the balance from the perspective of the specified account.
-     * If the trust line doesn't exist, returns zero.
-     *
-     * @param account The account to check.
-     * @param iou The IOU to check the balance for.
-     * @return The balance as an STAmount.
-     * @todo Once we make keylet strongly typed, we can ditch this method.
-     */
-    [[nodiscard]] STAmount
-    getBalance(AccountID const& account, IOU const& iou) const;
-
-    /**
-     * @brief Get the service registry.
-     * @return A reference to the service registry.
-     */
-    ServiceRegistry&
-    getServiceRegistry()
-    {
-        return registry_;
-    }
-
-private:
-    TestServiceRegistry registry_;
-    std::unordered_set<uint256, beast::uhash<>> featureSet_;
-    std::optional<Rules> rules_;
-    std::shared_ptr<Ledger const> closedLedger_;
-    std::shared_ptr<OpenView> openLedger_;
-
-    /** Transactions submitted to the open ledger, for canonical reordering on close. */
-    std::vector<std::shared_ptr<STTx const>> pendingTxs_;
-
-    /** Current time (can be advanced arbitrarily for testing). */
-    NetClock::time_point now_;
-};
-
-}  // namespace xrpl::test
diff --git a/src/tests/libxrpl/json/Writer.cpp b/src/tests/libxrpl/json/Writer.cpp
index 71fead1b69..a21f27199f 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::CollectionType::array);
+    writer->startRoot(Writer::array);
     writer->finish();
     checkOutputAndReset("[]");
 
-    writer->startRoot(Writer::CollectionType::object);
+    writer->startRoot(Writer::object);
     writer->finish();
     checkOutputAndReset("{}");
 }
@@ -112,7 +112,7 @@ TEST_F(WriterFixture, escaping)
 
 TEST_F(WriterFixture, array)
 {
-    writer->startRoot(Writer::CollectionType::array);
+    writer->startRoot(Writer::array);
     writer->append(12);
     writer->finish();
     checkOutputAndReset("[12]");
@@ -120,7 +120,7 @@ TEST_F(WriterFixture, array)
 
 TEST_F(WriterFixture, long_array)
 {
-    writer->startRoot(Writer::CollectionType::array);
+    writer->startRoot(Writer::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::CollectionType::array);
-    writer->startAppend(Writer::CollectionType::array);
+    writer->startRoot(Writer::array);
+    writer->startAppend(Writer::array);
     writer->finish();
     writer->finish();
     checkOutputAndReset("[[]]");
@@ -139,7 +139,7 @@ TEST_F(WriterFixture, embedded_array_simple)
 
 TEST_F(WriterFixture, object)
 {
-    writer->startRoot(Writer::CollectionType::object);
+    writer->startRoot(Writer::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::CollectionType::object);
+    writer->startRoot(Writer::object);
     writer->set("hello", "world");
-    writer->startSet(Writer::CollectionType::array, "array");
+    writer->startSet(Writer::array, "array");
     writer->append(true);
     writer->append(12);
-    writer->startAppend(Writer::CollectionType::array);
-    writer->startAppend(Writer::CollectionType::object);
+    writer->startAppend(Writer::array);
+    writer->startAppend(Writer::object);
     writer->set("goodbye", "cruel world.");
-    writer->startSet(Writer::CollectionType::array, "subarray");
+    writer->startSet(Writer::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::CollectionType::object);
+    writer->startRoot(Writer::object);
     writer->set("hello", value);
     writer->finish();
     checkOutputAndReset(R"({"hello":{"foo":23}})");
diff --git a/src/tests/libxrpl/tx/AccountSet.cpp b/src/tests/libxrpl/tx/AccountSet.cpp
deleted file mode 100644
index 3dbe7a4903..0000000000
--- a/src/tests/libxrpl/tx/AccountSet.cpp
+++ /dev/null
@@ -1,804 +0,0 @@
-#include <xrpl/protocol_autogen/transactions/AccountSet.h>
-
-#include <xrpl/basics/Slice.h>
-#include <xrpl/basics/base_uint.h>
-#include <xrpl/beast/utility/Zero.h>
-#include <xrpl/core/ServiceRegistry.h>
-#include <xrpl/ledger/helpers/DirectoryHelpers.h>
-#include <xrpl/protocol/Indexes.h>
-#include <xrpl/protocol/KeyType.h>
-#include <xrpl/protocol/LedgerFormats.h>
-#include <xrpl/protocol/Quality.h>
-#include <xrpl/protocol/Rate.h>
-#include <xrpl/protocol/SField.h>
-#include <xrpl/protocol/STArray.h>
-#include <xrpl/protocol/STObject.h>
-#include <xrpl/protocol/STTx.h>
-#include <xrpl/protocol/SecretKey.h>
-#include <xrpl/protocol/TER.h>
-#include <xrpl/protocol/TxFlags.h>
-#include <xrpl/protocol_autogen/ledger_entries/AccountRoot.h>
-#include <xrpl/protocol_autogen/transactions/Payment.h>
-#include <xrpl/protocol_autogen/transactions/SetRegularKey.h>
-#include <xrpl/protocol_autogen/transactions/SignerListSet.h>
-#include <xrpl/protocol_autogen/transactions/TicketCreate.h>
-#include <xrpl/protocol_autogen/transactions/TrustSet.h>
-
-#include <gtest/gtest.h>
-#include <helpers/Account.h>
-#include <helpers/IOU.h>
-#include <helpers/TxTest.h>
-
-#include <algorithm>
-#include <cstddef>
-#include <cstdint>
-#include <initializer_list>
-#include <limits>
-#include <memory>
-#include <string>
-#include <string_view>
-#include <utility>
-#include <vector>
-
-namespace xrpl::test {
-
-TEST(AccountSet, NullAccountSet)
-{
-    TxTest env;
-
-    Account const alice("alice");
-    env.createAccount(alice, XRP(10));
-
-    auto& view = env.getOpenLedger();
-
-    // ask for the ledger entry - account root, to check its flags
-    auto sle = view.read(keylet::account(alice));
-
-    EXPECT_NE(sle, nullptr);
-    ledger_entries::AccountRoot const accountRoot(sle);
-    EXPECT_EQ(accountRoot.getFlags(), 0);
-}
-
-TEST(AccountSet, MostFlags)
-{
-    Account const alice("alice");
-
-    TxTest env;
-    env.createAccount(alice, XRP(10000));
-
-    // Give alice a regular key so she can legally set and clear
-    // her asfDisableMaster flag.
-    Account const aliceRegularKey{"aliceRegularKey", KeyType::secp256k1};
-
-    env.createAccount(aliceRegularKey, XRP(10000));
-    env.close();
-
-    EXPECT_EQ(
-        env.submit(transactions::SetRegularKeyBuilder{alice}.setRegularKey(aliceRegularKey), alice)
-            .ter,
-        tesSUCCESS);
-    env.close();
-
-    auto testFlags = [&alice, &aliceRegularKey, &env](
-                         std::initializer_list<std::uint32_t> goodFlags) {
-        std::uint32_t const orig_flags = env.getAccountRoot(alice).getFlags();
-        for (std::uint32_t flag{1u}; flag < std::numeric_limits<std::uint32_t>::digits; ++flag)
-        {
-            if (flag == asfNoFreeze)
-            {
-                // The asfNoFreeze flag can't be cleared.  It is tested
-                // elsewhere.
-                continue;
-            }
-            if (flag == asfAuthorizedNFTokenMinter)
-            {
-                // The asfAuthorizedNFTokenMinter flag requires the
-                // presence or absence of the sfNFTokenMinter field in
-                // the transaction.  It is tested elsewhere.
-                continue;
-            }
-
-            if (flag == asfDisallowIncomingCheck || flag == asfDisallowIncomingPayChan ||
-                flag == asfDisallowIncomingNFTokenOffer || flag == asfDisallowIncomingTrustline)
-            {
-                // These flags are part of the DisallowIncoming amendment
-                // and are tested elsewhere
-                continue;
-            }
-            if (flag == asfAllowTrustLineClawback)
-            {
-                // The asfAllowTrustLineClawback flag can't be cleared.  It
-                // is tested elsewhere.
-                continue;
-            }
-            if (flag == asfAllowTrustLineLocking)
-            {
-                // These flags are part of the AllowTokenLocking amendment
-                // and are tested elsewhere
-                continue;
-            }
-            if (std::ranges::find(goodFlags, flag) != goodFlags.end())
-            {
-                // Good flag
-                EXPECT_FALSE(env.getAccountRoot(alice).isFlag(asfToLsf(flag)));
-
-                EXPECT_EQ(
-                    env.submit(transactions::AccountSetBuilder{alice}.setSetFlag(flag), alice).ter,
-                    tesSUCCESS);
-                env.close();
-
-                EXPECT_TRUE(env.getAccountRoot(alice).isFlag(asfToLsf(flag)));
-
-                EXPECT_EQ(
-                    env.submit(
-                           transactions::AccountSetBuilder{alice}.setClearFlag(flag),
-                           aliceRegularKey)
-                        .ter,
-                    tesSUCCESS);
-                env.close();
-
-                EXPECT_FALSE(env.getAccountRoot(alice).isFlag(asfToLsf(flag)));
-
-                std::uint32_t const now_flags = env.getAccountRoot(alice).getFlags();
-                EXPECT_EQ(now_flags, orig_flags);
-            }
-            else
-            {
-                // Bad flag
-                EXPECT_EQ(env.getAccountRoot(alice).getFlags(), orig_flags);
-                EXPECT_EQ(
-                    env.submit(transactions::AccountSetBuilder{alice}.setSetFlag(flag), alice).ter,
-                    tesSUCCESS);
-                env.close();
-                EXPECT_EQ(env.getAccountRoot(alice).getFlags(), orig_flags);
-
-                EXPECT_EQ(
-                    env.submit(
-                           transactions::AccountSetBuilder{alice}.setClearFlag(flag),
-                           aliceRegularKey)
-                        .ter,
-                    tesSUCCESS);
-                env.close();
-                EXPECT_EQ(env.getAccountRoot(alice).getFlags(), orig_flags);
-            }
-        }
-    };
-    testFlags({
-        asfRequireDest,
-        asfRequireAuth,
-        asfDisallowXRP,
-        asfGlobalFreeze,
-        asfDisableMaster,
-        asfDefaultRipple,
-        asfDepositAuth,
-    });
-}
-
-TEST(AccountSet, SetAndResetAccountTxnID)
-{
-    TxTest env;
-    Account const alice("alice");
-
-    env.createAccount(alice, XRP(10000));
-
-    std::uint32_t const orig_flags = env.getAccountRoot(alice).getFlags();
-
-    // asfAccountTxnID is special and not actually set as a flag,
-    // so we check the field presence instead
-    EXPECT_FALSE(env.getAccountRoot(alice).hasAccountTxnID());
-
-    EXPECT_EQ(
-        env.submit(transactions::AccountSetBuilder{alice}.setSetFlag(asfAccountTxnID), alice).ter,
-        tesSUCCESS);
-    env.close();
-
-    EXPECT_TRUE(env.getAccountRoot(alice).hasAccountTxnID());
-
-    EXPECT_EQ(
-        env.submit(transactions::AccountSetBuilder{alice}.setClearFlag(asfAccountTxnID), alice).ter,
-        tesSUCCESS);
-    env.close();
-
-    EXPECT_FALSE(env.getAccountRoot(alice).hasAccountTxnID());
-
-    std::uint32_t const now_flags = env.getAccountRoot(alice).getFlags();
-    EXPECT_EQ(now_flags, orig_flags);
-}
-
-TEST(AccountSet, SetNoFreeze)
-{
-    TxTest env;
-    Account const alice("alice");
-    Account const eric("eric");
-
-    env.createAccount(alice, XRP(10000));
-    env.close();
-
-    // Set eric as alice's regular key (eric doesn't need to be funded)
-    EXPECT_EQ(
-        env.submit(transactions::SetRegularKeyBuilder{alice}.setRegularKey(eric), alice).ter,
-        tesSUCCESS);
-    env.close();
-
-    // Verify alice doesn't have NoFreeze flag
-    EXPECT_FALSE(env.getAccountRoot(alice).isFlag(lsfNoFreeze));
-
-    // Setting NoFreeze with regular key should fail - requires master key
-    EXPECT_EQ(
-        env.submit(transactions::AccountSetBuilder{alice}.setSetFlag(asfNoFreeze), eric).ter,
-        tecNEED_MASTER_KEY);
-    env.close();
-
-    // Setting NoFreeze with master key should succeed
-    EXPECT_EQ(
-        env.submit(transactions::AccountSetBuilder{alice}.setSetFlag(asfNoFreeze), alice).ter,
-        tesSUCCESS);
-    env.close();
-
-    // Verify alice now has NoFreeze flag
-    EXPECT_TRUE(env.getAccountRoot(alice).isFlag(lsfNoFreeze));
-
-    // Try to clear NoFreeze - transaction succeeds but flag remains set
-    EXPECT_EQ(
-        env.submit(transactions::AccountSetBuilder{alice}.setClearFlag(asfNoFreeze), alice).ter,
-        tesSUCCESS);
-    env.close();
-
-    // Verify flag is still set (NoFreeze cannot be cleared once set)
-    EXPECT_TRUE(env.getAccountRoot(alice).isFlag(lsfNoFreeze));
-}
-
-TEST(AccountSet, Domain)
-{
-    TxTest env;
-    Account const alice("alice");
-
-    env.createAccount(alice, XRP(10000));
-    env.close();
-
-    // The Domain field is represented as the hex string of the lowercase
-    // ASCII of the domain. For example, the domain example.com would be
-    // represented as "6578616d706c652e636f6d".
-    //
-    // To remove the Domain field from an account, send an AccountSet with
-    // the Domain set to an empty string.
-    std::string const domain = "example.com";
-
-    // Set domain
-    EXPECT_EQ(
-        env.submit(transactions::AccountSetBuilder{alice}.setDomain(makeSlice(domain)), alice).ter,
-        tesSUCCESS);
-    env.close();
-
-    EXPECT_TRUE(env.getAccountRoot(alice).hasDomain());
-    // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
-    EXPECT_EQ(*env.getAccountRoot(alice).getDomain(), makeSlice(domain));
-
-    // Clear domain by setting empty
-    EXPECT_EQ(
-        env.submit(transactions::AccountSetBuilder{alice}.setDomain(Slice{}), alice).ter,
-        tesSUCCESS);
-    env.close();
-
-    EXPECT_FALSE(env.getAccountRoot(alice).hasDomain());
-
-    // The upper limit on the length is 256 bytes
-    // (defined as DOMAIN_BYTES_MAX in SetAccount)
-    // test the edge cases: 255, 256, 257.
-    std::size_t const maxLength = 256;
-    for (std::size_t len = maxLength - 1; len <= maxLength + 1; ++len)
-    {
-        std::string const domain2 = std::string(len - domain.length() - 1, 'a') + "." + domain;
-
-        EXPECT_EQ(domain2.length(), len);
-
-        if (len <= maxLength)
-        {
-            EXPECT_EQ(
-                env.submit(
-                       transactions::AccountSetBuilder{alice}.setDomain(makeSlice(domain2)), alice)
-                    .ter,
-                tesSUCCESS);
-            env.close();
-
-            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
-            EXPECT_EQ(*env.getAccountRoot(alice).getDomain(), makeSlice(domain2));
-        }
-        else
-        {
-            EXPECT_EQ(
-                env.submit(
-                       transactions::AccountSetBuilder{alice}.setDomain(makeSlice(domain2)), alice)
-                    .ter,
-                telBAD_DOMAIN);
-            env.close();
-        }
-    }
-}
-
-TEST(AccountSet, MessageKey)
-{
-    TxTest env;
-    Account const alice("alice");
-
-    env.createAccount(alice, XRP(10000));
-    env.close();
-
-    // Generate a random ed25519 key pair for the message key
-    auto const rkp = randomKeyPair(KeyType::ed25519);
-
-    // Set the message key
-    EXPECT_EQ(
-        env.submit(transactions::AccountSetBuilder{alice}.setMessageKey(rkp.first.slice()), alice)
-            .ter,
-        tesSUCCESS);
-    env.close();
-
-    EXPECT_TRUE(env.getAccountRoot(alice).hasMessageKey());
-    // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
-    EXPECT_EQ(*env.getAccountRoot(alice).getMessageKey(), rkp.first.slice());
-
-    // Clear the message key by setting to empty
-    EXPECT_EQ(
-        env.submit(transactions::AccountSetBuilder{alice}.setMessageKey(Slice{}), alice).ter,
-        tesSUCCESS);
-    env.close();
-
-    EXPECT_FALSE(env.getAccountRoot(alice).hasMessageKey());
-
-    // Try to set an invalid public key - should fail
-    using namespace std::string_literals;
-    EXPECT_EQ(
-        env.submit(
-               transactions::AccountSetBuilder{alice}.setMessageKey(
-                   makeSlice("NOT_REALLY_A_PUBKEY"s)),
-               alice)
-            .ter,
-        telBAD_PUBLIC_KEY);
-}
-
-TEST(AccountSet, WalletID)
-{
-    TxTest env;
-    Account const alice("alice");
-
-    env.createAccount(alice, XRP(10000));
-    env.close();
-
-    std::string_view const locator =
-        "9633EC8AF54F16B5286DB1D7B519EF49EEFC050C0C8AC4384F1D88ACD1BFDF05";
-    uint256 locatorHash{};
-    EXPECT_TRUE(locatorHash.parseHex(locator));
-
-    // Set the wallet locator
-    EXPECT_EQ(
-        env.submit(transactions::AccountSetBuilder{alice}.setWalletLocator(locatorHash), alice).ter,
-        tesSUCCESS);
-    env.close();
-
-    EXPECT_TRUE(env.getAccountRoot(alice).hasWalletLocator());
-    // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
-    EXPECT_EQ(*env.getAccountRoot(alice).getWalletLocator(), locatorHash);
-
-    // Clear the wallet locator by setting to zero
-    EXPECT_EQ(
-        env.submit(transactions::AccountSetBuilder{alice}.setWalletLocator(beast::zero), alice).ter,
-        tesSUCCESS);
-    env.close();
-
-    EXPECT_FALSE(env.getAccountRoot(alice).hasWalletLocator());
-}
-
-TEST(AccountSet, EmailHash)
-{
-    TxTest env;
-    Account const alice("alice");
-
-    env.createAccount(alice, XRP(10000));
-    env.close();
-
-    std::string_view const mh = "5F31A79367DC3137FADA860C05742EE6";
-    uint128 emailHash{};
-    EXPECT_TRUE(emailHash.parseHex(mh));
-
-    // Set the email hash
-    EXPECT_EQ(
-        env.submit(transactions::AccountSetBuilder{alice}.setEmailHash(emailHash), alice).ter,
-        tesSUCCESS);
-    env.close();
-
-    EXPECT_TRUE(env.getAccountRoot(alice).hasEmailHash());
-    // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
-    EXPECT_EQ(*env.getAccountRoot(alice).getEmailHash(), emailHash);
-
-    // Clear the email hash by setting to zero
-    EXPECT_EQ(
-        env.submit(transactions::AccountSetBuilder{alice}.setEmailHash(beast::zero), alice).ter,
-        tesSUCCESS);
-    env.close();
-
-    EXPECT_FALSE(env.getAccountRoot(alice).hasEmailHash());
-}
-
-TEST(AccountSet, TransferRate)
-{
-    struct TestCase
-    {
-        double set;
-        TER code;
-        double get;
-    };
-
-    // Test data: {rate to set, expected TER, expected stored rate}
-    std::vector<TestCase> const testData = {
-        {1.0, tesSUCCESS, 1.0},
-        {1.1, tesSUCCESS, 1.1},
-        {2.0, tesSUCCESS, 2.0},
-        {2.1, temBAD_TRANSFER_RATE, 2.0},  // > 2.0 is invalid
-        {0.0, tesSUCCESS, 1.0},            // 0 clears the rate (default = 1.0)
-        {2.0, tesSUCCESS, 2.0},
-        {0.9, temBAD_TRANSFER_RATE, 2.0},  // < 1.0 is invalid
-    };
-
-    TxTest env;
-    Account const alice("alice");
-
-    env.createAccount(alice, XRP(10000));
-    env.close();
-
-    for (auto const& r : testData)
-    {
-        auto const rateValue = static_cast<std::uint32_t>(QUALITY_ONE * r.set);
-
-        EXPECT_EQ(
-            env.submit(transactions::AccountSetBuilder{alice}.setTransferRate(rateValue), alice)
-                .ter,
-            r.code);
-        env.close();
-
-        // If the field is not present, expect the default value (1.0)
-        if (!env.getAccountRoot(alice).hasTransferRate())
-        {
-            EXPECT_EQ(r.get, 1.0);
-        }
-        else
-        {
-            // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
-            EXPECT_EQ(
-                *env.getAccountRoot(alice).getTransferRate(),
-                static_cast<std::uint32_t>(r.get * QUALITY_ONE));
-        }
-    }
-}
-
-TEST(AccountSet, BadInputs)
-{
-    TxTest env;
-    Account const alice("alice");
-
-    env.createAccount(alice, XRP(10000));
-    env.close();
-
-    // Setting and clearing the same flag is invalid
-    EXPECT_EQ(
-        env.submit(
-               transactions::AccountSetBuilder{alice}
-                   .setSetFlag(asfDisallowXRP)
-                   .setClearFlag(asfDisallowXRP),
-               alice)
-            .ter,
-        temINVALID_FLAG);
-
-    EXPECT_EQ(
-        env.submit(
-               transactions::AccountSetBuilder{alice}
-                   .setSetFlag(asfRequireAuth)
-                   .setClearFlag(asfRequireAuth),
-               alice)
-            .ter,
-        temINVALID_FLAG);
-
-    EXPECT_EQ(
-        env.submit(
-               transactions::AccountSetBuilder{alice}
-                   .setSetFlag(asfRequireDest)
-                   .setClearFlag(asfRequireDest),
-               alice)
-            .ter,
-        temINVALID_FLAG);
-
-    // Setting asf flag while also using corresponding tf flag is invalid
-    EXPECT_EQ(
-        env.submit(
-               transactions::AccountSetBuilder{alice}
-                   .setSetFlag(asfDisallowXRP)
-                   .setFlags(tfAllowXRP),
-               alice)
-            .ter,
-        temINVALID_FLAG);
-
-    EXPECT_EQ(
-        env.submit(
-               transactions::AccountSetBuilder{alice}
-                   .setSetFlag(asfRequireAuth)
-                   .setFlags(tfOptionalAuth),
-               alice)
-            .ter,
-        temINVALID_FLAG);
-
-    EXPECT_EQ(
-        env.submit(
-               transactions::AccountSetBuilder{alice}
-                   .setSetFlag(asfRequireDest)
-                   .setFlags(tfOptionalDestTag),
-               alice)
-            .ter,
-        temINVALID_FLAG);
-
-    // Using invalid flags (mask) is invalid
-    EXPECT_EQ(
-        env.submit(
-               transactions::AccountSetBuilder{alice}
-                   .setSetFlag(asfRequireDest)
-                   .setFlags(tfAccountSetMask),
-               alice)
-            .ter,
-        temINVALID_FLAG);
-
-    // Disabling master key without an alternative key is invalid
-    EXPECT_EQ(
-        env.submit(transactions::AccountSetBuilder{alice}.setSetFlag(asfDisableMaster), alice).ter,
-        tecNO_ALTERNATIVE_KEY);
-}
-
-TEST(AccountSet, RequireAuthWithDir)
-{
-    TxTest env;
-    Account const alice("alice");
-    Account const bob("bob");
-
-    env.createAccount(alice, XRP(10000));
-    env.close();
-
-    // alice should have an empty directory
-    EXPECT_TRUE(dirIsEmpty(env.getClosedLedger(), keylet::ownerDir(alice.id())));
-
-    // Give alice a signer list, then there will be stuff in the directory
-    // Build the SignerEntries array
-    STArray signerEntries(1);
-    {
-        signerEntries.push_back(STObject::makeInnerObject(sfSignerEntry));
-        STObject& entry = signerEntries.back();
-        entry[sfAccount] = bob.id();
-        entry[sfSignerWeight] = std::uint16_t{1};
-    }
-
-    EXPECT_EQ(
-        env.submit(
-               transactions::SignerListSetBuilder{alice, 1}.setSignerEntries(signerEntries), alice)
-            .ter,
-        tesSUCCESS);
-    env.close();
-
-    EXPECT_FALSE(dirIsEmpty(env.getClosedLedger(), keylet::ownerDir(alice.id())));
-
-    // Setting RequireAuth should fail because alice has owner objects
-    EXPECT_EQ(
-        env.submit(transactions::AccountSetBuilder{alice}.setSetFlag(asfRequireAuth), alice).ter,
-        tecOWNERS);
-
-    // Remove the signer list (quorum = 0, no entries)
-    EXPECT_EQ(env.submit(transactions::SignerListSetBuilder{alice, 0}, alice).ter, tesSUCCESS);
-    env.close();
-
-    EXPECT_TRUE(dirIsEmpty(env.getClosedLedger(), keylet::ownerDir(alice.id())));
-
-    // Now setting RequireAuth should succeed
-    EXPECT_EQ(
-        env.submit(transactions::AccountSetBuilder{alice}.setSetFlag(asfRequireAuth), alice).ter,
-        tesSUCCESS);
-}
-
-TEST(AccountSet, Ticket)
-{
-    TxTest env;
-    Account const alice("alice");
-
-    env.createAccount(alice, XRP(10000));
-    env.close();
-
-    // Get alice's current sequence - the ticket will be created at seq + 1
-    std::uint32_t const aliceSeqBefore = env.getAccountRoot(alice.id()).getSequence();
-    std::uint32_t const ticketSeq = aliceSeqBefore + 1;
-
-    // Create a ticket
-    EXPECT_EQ(env.submit(transactions::TicketCreateBuilder{alice, 1}, alice).ter, tesSUCCESS);
-    env.close();
-
-    // Verify alice has 1 owner object (the ticket)
-    EXPECT_EQ(env.getAccountRoot(alice.id()).getOwnerCount(), 1u);
-    // Verify ticket exists
-    EXPECT_TRUE(env.getClosedLedger().exists(keylet::ticket(alice.id(), ticketSeq)));
-
-    // Try using a ticket that alice doesn't have
-    EXPECT_EQ(
-        env.submit(transactions::AccountSetBuilder{alice}.setTicketSequence(ticketSeq + 1), alice)
-            .ter,
-        terPRE_TICKET);
-    env.close();
-
-    // Verify ticket still exists
-    EXPECT_TRUE(env.getClosedLedger().exists(keylet::ticket(alice.id(), ticketSeq)));
-
-    // Get alice's sequence before using the ticket
-    std::uint32_t const aliceSeq = env.getAccountRoot(alice.id()).getSequence();
-
-    // Actually use alice's ticket (noop AccountSet)
-    EXPECT_EQ(
-        env.submit(transactions::AccountSetBuilder{alice}.setTicketSequence(ticketSeq), alice).ter,
-        tesSUCCESS);
-    env.close();
-
-    // Verify ticket is consumed (no owner objects)
-    EXPECT_EQ(env.getAccountRoot(alice.id()).getOwnerCount(), 0u);
-    EXPECT_FALSE(env.getClosedLedger().exists(keylet::ticket(alice.id(), ticketSeq)));
-
-    // Verify alice's sequence did NOT advance (ticket use doesn't increment seq)
-    EXPECT_EQ(env.getAccountRoot(alice.id()).getSequence(), aliceSeq);
-
-    // Try re-using a ticket that alice already used
-    EXPECT_EQ(
-        env.submit(transactions::AccountSetBuilder{alice}.setTicketSequence(ticketSeq), alice).ter,
-        tefNO_TICKET);
-}
-
-TEST(AccountSet, BadSigningKey)
-{
-    TxTest env;
-    Account const alice("alice");
-
-    env.createAccount(alice, XRP(10000));
-    env.close();
-
-    // Build a valid transaction first, then corrupt the signing key
-    auto stx = transactions::AccountSetBuilder{alice}
-                   .setSequence(env.getAccountRoot(alice.id()).getSequence())
-                   .setFee(XRPAmount{10})
-                   .build(alice.pk(), alice.sk())
-                   .getSTTx();
-
-    // Create a copy with a bad signing key
-    STObject obj = *stx;
-    obj.setFieldVL(sfSigningPubKey, makeSlice(std::string("badkey")));
-
-    auto result = env.submit(std::make_shared<STTx>(std::move(obj)));
-    EXPECT_EQ(result.ter, temBAD_SIGNATURE);
-    EXPECT_FALSE(result.applied);
-}
-
-TEST(AccountSet, Gateway)
-{
-    Account const alice("alice");
-    Account const bob("bob");
-    Account const gw("gateway");
-    IOU const USD("USD", gw);
-
-    // Test gateway with a variety of allowed transfer rates
-    for (double transferRate = 1.0; transferRate <= 2.0; transferRate += 0.03125)
-    {
-        TxTest env;
-
-        env.createAccount(gw, XRP(10000), asfDefaultRipple);
-        env.createAccount(alice, XRP(10000), asfDefaultRipple);
-        env.createAccount(bob, XRP(10000), asfDefaultRipple);
-        env.close();
-
-        // Set up trust lines: alice and bob trust gw for USD
-        EXPECT_EQ(
-            env.submit(transactions::TrustSetBuilder{alice}.setLimitAmount(USD.amount(10)), alice)
-                .ter,
-            tesSUCCESS);
-        EXPECT_EQ(
-            env.submit(transactions::TrustSetBuilder{bob}.setLimitAmount(USD.amount(10)), bob).ter,
-            tesSUCCESS);
-        env.close();
-
-        // Set transfer rate on the gateway
-        EXPECT_EQ(
-            env.submit(
-                   transactions::AccountSetBuilder{gw}.setTransferRate(
-                       static_cast<std::uint32_t>(transferRate * QUALITY_ONE)),
-                   gw)
-                .ter,
-            tesSUCCESS);
-        env.close();
-
-        // Calculate the amount with transfer rate applied
-        auto const amount = USD.amount(1);
-        Rate const rate(static_cast<std::uint32_t>(transferRate * QUALITY_ONE));
-        auto const amountWithRate = multiply(amount, rate);
-
-        // Gateway pays alice 10 USD
-        EXPECT_EQ(
-            env.submit(transactions::PaymentBuilder{gw, alice, USD.amount(10)}, gw).ter,
-            tesSUCCESS);
-        env.close();
-
-        // Alice pays bob 1 USD (with sendmax to cover transfer fee)
-        EXPECT_EQ(
-            env.submit(
-                   transactions::PaymentBuilder{alice, bob, USD.amount(1)}.setSendMax(
-                       USD.amount(10)),
-                   alice)
-                .ter,
-            tesSUCCESS);
-        env.close();
-
-        // Check balances
-        EXPECT_EQ(env.getBalance(alice.id(), USD), USD.amount(10) - amountWithRate);
-        EXPECT_EQ(env.getBalance(bob.id(), USD), USD.amount(1));
-    }
-
-    // Test out-of-bounds legacy transfer rates (4.0 and 4.294967295)
-    // These require direct ledger modification since the transactor blocks them
-    for (std::uint32_t const transferRate : {4000000000U, 4294967295U})
-    {
-        TxTest env;
-        env.createAccount(gw, XRP(10000), asfDefaultRipple);
-        env.createAccount(alice, XRP(10000), asfDefaultRipple);
-        env.createAccount(bob, XRP(10000), asfDefaultRipple);
-        env.close();
-
-        // Set up trust lines
-        EXPECT_EQ(
-            env.submit(transactions::TrustSetBuilder{alice}.setLimitAmount(USD.amount(10)), alice)
-                .ter,
-            tesSUCCESS);
-        EXPECT_EQ(
-            env.submit(transactions::TrustSetBuilder{bob}.setLimitAmount(USD.amount(10)), bob).ter,
-            tesSUCCESS);
-        env.close();
-
-        // Set an acceptable transfer rate first (we'll hack it later)
-        EXPECT_EQ(
-            env.submit(
-                   transactions::AccountSetBuilder{gw}.setTransferRate(
-                       static_cast<std::uint32_t>(2.0 * QUALITY_ONE)),
-                   gw)
-                .ter,
-            tesSUCCESS);
-        env.close();
-
-        // Directly modify the ledger to set an out-of-bounds transfer rate
-        // This bypasses the transactor's validation
-        auto& view = env.getOpenLedger();
-        auto slePtr = view.read(keylet::account(gw.id()));
-        ASSERT_NE(slePtr, nullptr);
-        auto sleCopy = std::make_shared<SLE>(*slePtr);
-        (*sleCopy)[sfTransferRate] = transferRate;
-        view.rawReplace(sleCopy);
-
-        // Calculate the amount with the legacy transfer rate
-        auto const amount = USD.amount(1);
-        auto const amountWithRate = multiply(amount, Rate(transferRate));
-
-        // Gateway pays alice 10 USD
-        EXPECT_EQ(
-            env.submit(transactions::PaymentBuilder{gw, alice, USD.amount(10)}, gw).ter,
-            tesSUCCESS);
-
-        // Alice pays bob 1 USD
-        EXPECT_EQ(
-            env.submit(
-                   transactions::PaymentBuilder{alice, bob, amount}.setSendMax(USD.amount(10)),
-                   alice)
-                .ter,
-            tesSUCCESS);
-
-        // Check balances
-        EXPECT_EQ(env.getBalance(alice.id(), USD), USD.amount(10) - amountWithRate);
-        EXPECT_EQ(env.getBalance(bob.id(), USD), amount);
-    }
-}
-
-}  // namespace xrpl::test
diff --git a/src/xrpld/app/ledger/AccountStateSF.cpp b/src/xrpld/app/ledger/AccountStateSF.cpp
index bca527d3d0..d5fa5d83ff 100644
--- a/src/xrpld/app/ledger/AccountStateSF.cpp
+++ b/src/xrpld/app/ledger/AccountStateSF.cpp
@@ -19,8 +19,7 @@ AccountStateSF::gotNode(
     Blob&& nodeData,
     SHAMapNodeType) const
 {
-    db_.store(
-        NodeObjectType::hotACCOUNT_NODE, std::move(nodeData), nodeHash.as_uint256(), ledgerSeq);
+    db_.store(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 322ad85e23..bf9d478c40 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::scoped_lock const sl(m_lock);
+        std::lock_guard const sl(m_lock);
         m_heldLedger = std::move(ledger);
     }
 
@@ -36,14 +36,14 @@ public:
     std::shared_ptr<Ledger const>
     get()
     {
-        std::scoped_lock const sl(m_lock);
+        std::lock_guard const sl(m_lock);
         return m_heldLedger;
     }
 
     bool
     empty()
     {
-        std::scoped_lock const sl(m_lock);
+        std::lock_guard 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 62970eab15..1bd4530d6d 100644
--- a/src/xrpld/app/ledger/LedgerMaster.h
+++ b/src/xrpld/app/ledger/LedgerMaster.h
@@ -387,7 +387,7 @@ private:
     void
     collect_metrics()
     {
-        std::scoped_lock const lock(m_mutex);
+        std::lock_guard 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 9ea544c79b..ce2acb0699 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::scoped_lock const lock(mtx_);
+        std::lock_guard<std::mutex> const lock(mtx_);
         return tasks_.size();
     }
 
     std::size_t
     deltasSize() const
     {
-        std::scoped_lock const lock(mtx_);
+        std::lock_guard<std::mutex> const lock(mtx_);
         return deltas_.size();
     }
 
     std::size_t
     skipListsSize() const
     {
-        std::scoped_lock const lock(mtx_);
+        std::lock_guard<std::mutex> const lock(mtx_);
         return skipLists_.size();
     }
 
diff --git a/src/xrpld/app/ledger/LedgerToJson.h b/src/xrpld/app/ledger/LedgerToJson.h
index 91878c3c1b..53985f343b 100644
--- a/src/xrpld/app/ledger/LedgerToJson.h
+++ b/src/xrpld/app/ledger/LedgerToJson.h
@@ -23,8 +23,6 @@ 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 d55c9c97e3..5b1d611b44 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 class Result { success, failure, retry };
+    enum 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 4bfa982082..1c64c5e6fa 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::scoped_lock const sl(mLock);
+        std::lock_guard 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::scoped_lock const sl(mLock);
+    std::lock_guard const sl(mLock);
 
     if (book.domain)
     {
@@ -253,7 +253,7 @@ OrderBookDBImpl::getBooksByTakerPays(Asset const& asset, std::optional<uint256>
     std::vector<Book> ret;
 
     {
-        std::scoped_lock const sl(mLock);
+        std::lock_guard 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::scoped_lock const sl(mLock);
+    std::lock_guard 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::scoped_lock const sl(mLock);
+    std::lock_guard 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::scoped_lock const sl(mLock);
+    std::lock_guard const sl(mLock);
     auto ret = getBookListeners(book);
 
     if (!ret)
@@ -331,7 +331,7 @@ BookListeners::pointer
 OrderBookDBImpl::getBookListeners(Book const& book)
 {
     BookListeners::pointer ret;
-    std::scoped_lock const sl(mLock);
+    std::lock_guard 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::scoped_lock const sl(mLock);
+    std::lock_guard 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 201a2204a5..e2ec3ca7b6 100644
--- a/src/xrpld/app/ledger/TransactionStateSF.cpp
+++ b/src/xrpld/app/ledger/TransactionStateSF.cpp
@@ -24,8 +24,7 @@ TransactionStateSF::gotNode(
     XRPL_ASSERT(
         type != SHAMapNodeType::tnTRANSACTION_NM,
         "xrpl::TransactionStateSF::gotNode : valid input");
-    db_.store(
-        NodeObjectType::hotTRANSACTION_NODE, std::move(nodeData), nodeHash.as_uint256(), ledgerSeq);
+    db_.store(hotTRANSACTION_NODE, std::move(nodeData), nodeHash.as_uint256(), ledgerSeq);
 }
 
 std::optional<Blob>
diff --git a/src/xrpld/app/ledger/detail/InboundLedger.cpp b/src/xrpld/app/ledger/detail/InboundLedger.cpp
index 52636d08c6..a65fae2ff3 100644
--- a/src/xrpld/app/ledger/detail/InboundLedger.cpp
+++ b/src/xrpld/app/ledger/detail/InboundLedger.cpp
@@ -53,8 +53,6 @@ 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
@@ -278,8 +276,7 @@ InboundLedger::tryDB(NodeStore::Database& srcDB)
             if (std::addressof(dstDB) != std::addressof(srcDB))
             {
                 Blob blob{nodeObject->getData()};
-                dstDB.store(
-                    NodeObjectType::hotLEDGER, std::move(blob), hash_, mLedger->header().seq);
+                dstDB.store(hotLEDGER, std::move(blob), hash_, mLedger->header().seq);
             }
         }
         else
@@ -297,7 +294,7 @@ InboundLedger::tryDB(NodeStore::Database& srcDB)
 
             // Store the ledger header in the ledger's database
             mLedger->stateMap().family().db().store(
-                NodeObjectType::hotLEDGER, std::move(*data), hash_, mLedger->header().seq);
+                hotLEDGER, std::move(*data), hash_, mLedger->header().seq);
         }
 
         if (mSeq == 0)
@@ -823,7 +820,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(NodeObjectType::hotLEDGER, std::move(s.modData()), hash_, mSeq);
+    f->db().store(hotLEDGER, std::move(s.modData()), hash_, mSeq);
 
     if (mLedger->header().txHash.isZero())
         mHaveTransactions = true;
@@ -1024,7 +1021,7 @@ InboundLedger::gotData(
     std::weak_ptr<Peer> peer,
     std::shared_ptr<protocol::TMLedgerData> const& data)
 {
-    std::scoped_lock const sl(mReceivedDataLock);
+    std::lock_guard const sl(mReceivedDataLock);
 
     if (isDone())
         return false;
@@ -1236,7 +1233,7 @@ InboundLedger::runData()
         data.clear();
 
         {
-            std::scoped_lock const sl(mReceivedDataLock);
+            std::lock_guard 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 a882f5be73..2207308737 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::scoped_lock const lock(fetchRateMutex_);
+        std::lock_guard const lock(fetchRateMutex_);
         return 60 * fetchRate_.value(m_clock.now());
     }
 
@@ -293,7 +293,7 @@ public:
     void
     onLedgerFetched() override
     {
-        std::scoped_lock const lock(fetchRateMutex_);
+        std::lock_guard 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 cbf0ac04d5..56c9c633f4 100644
--- a/src/xrpld/app/ledger/detail/InboundTransactions.cpp
+++ b/src/xrpld/app/ledger/detail/InboundTransactions.cpp
@@ -27,8 +27,6 @@
 
 namespace xrpl {
 
-// Need to be named before converting
-// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
 enum {
     // Ideal number of peers to start with
     startPeers = 2,
@@ -79,7 +77,7 @@ public:
     getAcquire(uint256 const& hash)
     {
         {
-            std::scoped_lock const sl(mLock);
+            std::lock_guard const sl(mLock);
 
             auto it = m_map.find(hash);
 
@@ -95,7 +93,7 @@ public:
         TransactionAcquire::pointer ta;
 
         {
-            std::scoped_lock const sl(mLock);
+            std::lock_guard const sl(mLock);
 
             if (auto it = m_map.find(hash); it != m_map.end())
             {
@@ -178,7 +176,7 @@ public:
         bool isNew = true;
 
         {
-            std::scoped_lock const sl(mLock);
+            std::lock_guard const sl(mLock);
 
             auto& inboundSet = m_map[hash];
 
@@ -203,7 +201,7 @@ public:
     void
     newRound(std::uint32_t seq) override
     {
-        std::scoped_lock const lock(mLock);
+        std::lock_guard const lock(mLock);
 
         // Protect zero set from expiration
         m_zeroSet.mSeq = seq;
@@ -234,7 +232,7 @@ public:
     void
     stop() override
     {
-        std::scoped_lock const lock(mLock);
+        std::lock_guard 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 d500c8ee7b..850b60f4ed 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::scoped_lock const lock(mutex_);
+            std::lock_guard const lock(mutex_);
             shouldExit_ = true;
             wakeup_.notify_one();
         }
@@ -114,7 +114,7 @@ public:
     void
     onWrite(beast::PropertyStream::Map& map) override
     {
-        std::scoped_lock const lock(mutex_);
+        std::lock_guard const lock(mutex_);
 
         if (maxRange_ == 0)
         {
@@ -146,7 +146,7 @@ public:
         app_.getLedgerMaster().getFullValidatedRange(minRange, maxRange);
 
         {
-            std::scoped_lock const lock(mutex_);
+            std::lock_guard const lock(mutex_);
 
             maxRange_ = maxRange;
             minRange_ = minRange;
@@ -376,7 +376,7 @@ private:
     doLedgerCleaner()
     {
         auto shouldExit = [this] {
-            std::scoped_lock const lock(mutex_);
+            std::lock_guard const lock(mutex_);
             return shouldExit_;
         };
 
@@ -397,7 +397,7 @@ private:
             }
 
             {
-                std::scoped_lock const lock(mutex_);
+                std::lock_guard const lock(mutex_);
                 if ((minRange_ > maxRange_) || (maxRange_ == 0) || (minRange_ == 0))
                 {
                     minRange_ = maxRange_ = 0;
@@ -425,7 +425,7 @@ private:
             if (fail)
             {
                 {
-                    std::scoped_lock const lock(mutex_);
+                    std::lock_guard const lock(mutex_);
                     ++failures_;
                 }
                 // Wait for acquiring to catch up to us
@@ -434,7 +434,7 @@ private:
             else
             {
                 {
-                    std::scoped_lock const lock(mutex_);
+                    std::lock_guard const lock(mutex_);
                     if (ledgerIndex == minRange_)
                         ++minRange_;
                     if (ledgerIndex == maxRange_)
diff --git a/src/xrpld/app/ledger/detail/LedgerReplayer.cpp b/src/xrpld/app/ledger/detail/LedgerReplayer.cpp
index 8f5d38132c..7779132b39 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::scoped_lock const lock(mtx_);
+    std::lock_guard<std::mutex> const lock(mtx_);
     tasks_.clear();
 }
 
@@ -61,7 +61,7 @@ LedgerReplayer::replay(
     std::shared_ptr<SkipListAcquire> skipList;
     bool newSkipList = false;
     {
-        std::scoped_lock const lock(mtx_);
+        std::lock_guard<std::mutex> 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::scoped_lock const lock(mtx_);
+                std::lock_guard<std::mutex> const lock(mtx_);
                 if (app_.isStopping())
                     return;
                 auto i = deltas_.find(*skipListItem);
@@ -169,7 +169,7 @@ LedgerReplayer::gotSkipList(
 {
     std::shared_ptr<SkipListAcquire> skipList = {};
     {
-        std::scoped_lock const lock(mtx_);
+        std::lock_guard<std::mutex> 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::scoped_lock const lock(mtx_);
+        std::lock_guard<std::mutex> 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::scoped_lock const lock(mtx_);
+        std::lock_guard<std::mutex> 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::scoped_lock const lock(mtx_);
+        std::lock_guard<std::mutex> 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 2d244942e7..8ba45fb515 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,
-                FreezeHandling::fhIGNORE_FREEZE,
+                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 6cc83261d1..83d9c61c3c 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::scoped_lock const lock(m_lock);
+        std::lock_guard 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::scoped_lock const lock(m_lock);
+            std::lock_guard 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::scoped_lock const lock(m_lock);
+        std::lock_guard 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::scoped_lock const lock(m_lock);
+        std::lock_guard 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 20ddf27237..5db4e23e1e 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::scoped_lock const lock(modify_mutex_);
+    std::lock_guard const lock(modify_mutex_);
     return current_->txCount() == 0;
 }
 
 std::shared_ptr<OpenView const>
 OpenLedger::current() const
 {
-    std::scoped_lock const lock(current_mutex_);
+    std::lock_guard const lock(current_mutex_);
     return current_;
 }
 
 bool
 OpenLedger::modify(modify_type const& f)
 {
-    std::scoped_lock const lock1(modify_mutex_);
+    std::lock_guard const lock1(modify_mutex_);
     auto next = std::make_shared<OpenView>(*current_);
     auto const changed = f(*next, j_);
     if (changed)
     {
-        std::scoped_lock const lock2(current_mutex_);
+        std::lock_guard 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::scoped_lock const lock1(modify_mutex_);
+    std::lock_guard 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::scoped_lock const lock2(current_mutex_);
+    std::lock_guard 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 686d33ce63..b38c413344 100644
--- a/src/xrpld/app/ledger/detail/TransactionAcquire.cpp
+++ b/src/xrpld/app/ledger/detail/TransactionAcquire.cpp
@@ -31,8 +31,6 @@ 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 bc0b7ca4ab..798c29dc05 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(TransStatus::COMMITTED, ledger, tseq, netID);
+    txn->setStatus(COMMITTED, ledger, tseq, netID);
     return true;
 }
 
@@ -130,7 +130,7 @@ TransactionMaster::fetch(
     else
     {
         if (uCommitLedger != 0u)
-            iTx->setStatus(TransStatus::COMMITTED, uCommitLedger);
+            iTx->setStatus(COMMITTED, uCommitLedger);
 
         txn = iTx->getSTransaction();
     }
diff --git a/src/xrpld/app/main/LoadManager.cpp b/src/xrpld/app/main/LoadManager.cpp
index 4f9023dbc5..84c57ad360 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::scoped_lock const sl(mutex_);
+    std::lock_guard 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::scoped_lock const sl(mutex_);
+    std::lock_guard const sl(mutex_);
     lastHeartbeat_ = heartbeat;
 }
 
@@ -70,7 +70,7 @@ void
 LoadManager::stop()
 {
     {
-        std::scoped_lock const lock(mutex_);
+        std::lock_guard 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 c774c77253..3da6e3a2ad 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::mode_t::automatch, s);
+                selectors_.emplace_back(beast::unit_test::selector::automatch, s);
         });
     }
 
diff --git a/src/xrpld/app/misc/NegativeUNLVote.cpp b/src/xrpld/app/misc/NegativeUNLVote.cpp
index c733de3bd3..8db726ff48 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), NegativeUNLModify::ToDisable, initialSet);
+            addTx(seq, nidToKeyMap.at(n), 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), NegativeUNLModify::ToReEnable, initialSet);
+            addTx(seq, nidToKeyMap.at(n), 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 == NegativeUNLModify::ToDisable ? 1 : 0);
+        obj.setFieldU8(sfUNLModifyDisabling, modify == ToDisable ? 1 : 0);
         obj.setFieldU32(sfLedgerSequence, seq);
         obj.setFieldVL(sfUNLModifyValidator, vp.slice());
     });
@@ -132,8 +132,7 @@ NegativeUNLVote::addTx(
         JLOG(j_.debug()) << "N-UNL: ledger seq=" << seq
                          << ", add a ttUNL_MODIFY Tx with txID: " << negUnlTx.getTransactionID()
                          << ", the validator to "
-                         << (modify == NegativeUNLModify::ToDisable ? "disable: " : "re-enable: ")
-                         << vp;
+                         << (modify == ToDisable ? "disable: " : "re-enable: ") << vp;
     }
 }
 
@@ -309,7 +308,7 @@ NegativeUNLVote::findAllCandidates(
 void
 NegativeUNLVote::newValidators(LedgerIndex seq, hash_set<NodeID> const& nowTrusted)
 {
-    std::scoped_lock const lock(mutex_);
+    std::lock_guard const lock(mutex_);
     for (auto const& n : nowTrusted)
     {
         if (!newValidators_.contains(n))
@@ -323,7 +322,7 @@ NegativeUNLVote::newValidators(LedgerIndex seq, hash_set<NodeID> const& nowTrust
 void
 NegativeUNLVote::purgeNewValidators(LedgerIndex seq)
 {
-    std::scoped_lock const lock(mutex_);
+    std::lock_guard 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 02e84ccca1..2cc63cf8c5 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 class NegativeUNLModify {
+    enum 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/SHAMapStoreImp.cpp b/src/xrpld/app/misc/SHAMapStoreImp.cpp
index 3a6cb1742d..518d9f6b14 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::scoped_lock const lock(mutex_);
+    std::lock_guard const lock(mutex_);
     initStateDB(sqlDb_, config, dbName);
 }
 
 LedgerIndex
 SHAMapStoreImp::SavedStateDB::getCanDelete()
 {
-    std::scoped_lock const lock(mutex_);
+    std::lock_guard const lock(mutex_);
 
     return xrpl::getCanDelete(sqlDb_);
 }
@@ -60,7 +60,7 @@ SHAMapStoreImp::SavedStateDB::getCanDelete()
 LedgerIndex
 SHAMapStoreImp::SavedStateDB::setCanDelete(LedgerIndex canDelete)
 {
-    std::scoped_lock const lock(mutex_);
+    std::lock_guard const lock(mutex_);
 
     return xrpl::setCanDelete(sqlDb_, canDelete);
 }
@@ -68,7 +68,7 @@ SHAMapStoreImp::SavedStateDB::setCanDelete(LedgerIndex canDelete)
 SavedState
 SHAMapStoreImp::SavedStateDB::getState()
 {
-    std::scoped_lock const lock(mutex_);
+    std::lock_guard const lock(mutex_);
 
     return xrpl::getSavedState(sqlDb_);
 }
@@ -76,14 +76,14 @@ SHAMapStoreImp::SavedStateDB::getState()
 void
 SHAMapStoreImp::SavedStateDB::setState(SavedState const& state)
 {
-    std::scoped_lock const lock(mutex_);
+    std::lock_guard const lock(mutex_);
     xrpl::setSavedState(sqlDb_, state);
 }
 
 void
 SHAMapStoreImp::SavedStateDB::setLastRotated(LedgerIndex seq)
 {
-    std::scoped_lock const lock(mutex_);
+    std::lock_guard const lock(mutex_);
     xrpl::setLastRotated(sqlDb_, seq);
 }
 
@@ -209,7 +209,7 @@ void
 SHAMapStoreImp::onLedgerClosed(std::shared_ptr<Ledger const> const& ledger)
 {
     {
-        std::scoped_lock const lock(mutex_);
+        std::lock_guard 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() == HealthResult::stopping)
+        if (healthWait() == stopping)
             return false;
     }
 
@@ -290,7 +290,7 @@ SHAMapStoreImp::run()
         }
 
         bool const readyToRotate = validatedSeq >= lastRotated + deleteInterval_ &&
-            canDelete_ >= lastRotated - 1 && healthWait() == HealthResult::keepGoing;
+            canDelete_ >= lastRotated - 1 && healthWait() == keepGoing;
 
         // will delete up to (not including) lastRotated
         if (readyToRotate)
@@ -302,7 +302,7 @@ SHAMapStoreImp::run()
                                   << ledgerMaster_->getValidatedLedgerAge().count() << 's';
 
             clearPrior(lastRotated);
-            if (healthWait() == HealthResult::stopping)
+            if (healthWait() == stopping)
                 return;
 
             JLOG(journal_.debug()) << "copying ledger " << validatedSeq;
@@ -324,7 +324,7 @@ SHAMapStoreImp::run()
                 continue;
             }
 
-            if (healthWait() == HealthResult::stopping)
+            if (healthWait() == 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() == HealthResult::stopping)
+            if (healthWait() == 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() == HealthResult::stopping)
+            if (healthWait() == stopping)
                 return;
 
             lastRotated = validatedSeq;
@@ -506,7 +506,7 @@ SHAMapStoreImp::clearSql(
         min = *m;
     }
 
-    if (min > lastRotated || healthWait() == HealthResult::stopping)
+    if (min > lastRotated || healthWait() == 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() == HealthResult::stopping)
+        if (healthWait() == stopping)
             return;
         if (min < lastRotated)
             std::this_thread::sleep_for(backOff_);
-        if (healthWait() == HealthResult::stopping)
+        if (healthWait() == 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() == HealthResult::stopping)
+    if (healthWait() == 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() == HealthResult::stopping)
+    if (healthWait() == 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() == HealthResult::stopping)
+    if (healthWait() == 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() == HealthResult::stopping)
+    if (healthWait() == stopping)
         return;
 }
 
@@ -615,7 +615,7 @@ SHAMapStoreImp::healthWait()
         lock.lock();
     }
 
-    return stop_ ? HealthResult::stopping : HealthResult::keepGoing;
+    return stop_ ? stopping : keepGoing;
 }
 
 void
@@ -624,7 +624,7 @@ SHAMapStoreImp::stop()
     if (thread_.joinable())
     {
         {
-            std::scoped_lock const lock(mutex_);
+            std::lock_guard 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 22cb06c0e4..08e3dd70eb 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() == HealthResult::stopping)
+            if (!(++check % checkHealthInterval_) && healthWait() == stopping)
                 return true;
         }
 
@@ -201,7 +201,7 @@ private:
      *
      * @return Whether the server is stopping.
      */
-    enum class HealthResult { stopping, keepGoing };
+    enum HealthResult { stopping, keepGoing };
     [[nodiscard]] HealthResult
     healthWait();
 
diff --git a/src/xrpld/app/misc/Transaction.h b/src/xrpld/app/misc/Transaction.h
index 43ef2094fe..40e0a3d10d 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 class TransStatus {
+enum 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 = TransStatus::INVALID;
+    TransStatus mStatus = 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 c3dddd12ba..ce32755db1 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::scoped_lock<std::mutex> const&) const;
+        std::lock_guard<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::scoped_lock<std::mutex> const& lock);
+        std::lock_guard<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::scoped_lock<std::mutex> const& lock);
+        std::lock_guard<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 ee6f14ed4c..2c7900465c 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 scoped_lock = std::scoped_lock<decltype(mutex_)>;
+    using lock_guard = std::lock_guard<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,
-        scoped_lock const&);
+        lock_guard 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,
-        scoped_lock const&);
+        lock_guard const&);
 
     static void
     buildBlobInfos(
@@ -804,7 +804,7 @@ private:
     /** Get the filename used for caching UNLs
      */
     boost::filesystem::path
-    getCacheFileName(scoped_lock const&, PublicKey const& pubKey) const;
+    getCacheFileName(lock_guard 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(scoped_lock const& lock, PublicKey const& pubKey) const;
+    cacheValidatorFile(lock_guard 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(
-        scoped_lock const&,
+        lock_guard 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(scoped_lock const&, PublicKey const& publisherKey, PublisherStatus reason);
+    removePublisherList(lock_guard 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 308b8f72bc..ab82ae168d 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::scoped_lock<std::mutex> const&);
+    load(std::vector<std::string> const& siteURIs, std::lock_guard<std::mutex> const&);
 
     /// Queue next site to be fetched
     /// lock over site_mutex_ and state_mutex_ required
     void
-    setTimer(std::scoped_lock<std::mutex> const&, std::scoped_lock<std::mutex> const&);
+    setTimer(std::lock_guard<std::mutex> const&, std::lock_guard<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::scoped_lock<std::mutex> const&);
+        std::lock_guard<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::scoped_lock<std::mutex> const&);
+        std::lock_guard<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::scoped_lock<std::mutex> const&);
+        std::lock_guard<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::scoped_lock<std::mutex> const&);
+    missingSite(std::lock_guard<std::mutex> const&);
 };
 
 }  // namespace xrpl
diff --git a/src/xrpld/app/misc/detail/AmendmentTable.cpp b/src/xrpld/app/misc/detail/AmendmentTable.cpp
index 1eee034a16..65342dac2f 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::scoped_lock<std::mutex> const& lock)
+    trustChanged(hash_set<PublicKey> const& allTrusted, std::lock_guard<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::scoped_lock<std::mutex> const& lock)
+        std::lock_guard<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::scoped_lock<std::mutex> const& lock) const
+    getVotes(Rules const& rules, std::lock_guard<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::scoped_lock<std::mutex> const& lock)
+        std::lock_guard<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::scoped_lock<std::mutex> const& lock);
+    add(uint256 const& amendment, std::lock_guard<std::mutex> const& lock);
 
     // Finds existing state.  Must be called with mutex_ locked.
     AmendmentState*
-    get(uint256 const& amendment, std::scoped_lock<std::mutex> const& lock);
+    get(uint256 const& amendment, std::lock_guard<std::mutex> const& lock);
 
     AmendmentState const*
-    get(uint256 const& amendment, std::scoped_lock<std::mutex> const& lock) const;
+    get(uint256 const& amendment, std::lock_guard<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::scoped_lock<std::mutex> const& lock) const;
+        std::lock_guard<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::scoped_lock lock(mutex_);
+    std::lock_guard 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::scoped_lock<std::mutex> const&)
+AmendmentTableImpl::add(uint256 const& amendmentHash, std::lock_guard<std::mutex> const&)
 {
     // call with the mutex held
     return amendmentMap_[amendmentHash];
 }
 
 AmendmentState*
-AmendmentTableImpl::get(uint256 const& amendmentHash, std::scoped_lock<std::mutex> const& lock)
+AmendmentTableImpl::get(uint256 const& amendmentHash, std::lock_guard<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::scoped_lock<std::mutex> const&) const
+AmendmentTableImpl::get(uint256 const& amendmentHash, std::lock_guard<std::mutex> const&) const
 {
     // call with the mutex held
     auto ret = amendmentMap_.find(amendmentHash);
@@ -661,7 +661,7 @@ AmendmentTableImpl::get(uint256 const& amendmentHash, std::scoped_lock<std::mute
 uint256
 AmendmentTableImpl::find(std::string const& name) const
 {
-    std::scoped_lock const lock(mutex_);
+    std::lock_guard const lock(mutex_);
 
     for (auto const& e : amendmentMap_)
     {
@@ -688,7 +688,7 @@ AmendmentTableImpl::persistVote(
 bool
 AmendmentTableImpl::veto(uint256 const& amendment)
 {
-    std::scoped_lock const lock(mutex_);
+    std::lock_guard 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::scoped_lock const lock(mutex_);
+    std::lock_guard 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::scoped_lock const lock(mutex_);
+    std::lock_guard 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::scoped_lock const lock(mutex_);
+    std::lock_guard 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::scoped_lock const lock(mutex_);
+    std::lock_guard 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::scoped_lock const lock(mutex_);
+    std::lock_guard const lock(mutex_);
     return unsupportedEnabled_;
 }
 
 std::optional<NetClock::time_point>
 AmendmentTableImpl::firstUnsupportedExpected() const
 {
-    std::scoped_lock const lock(mutex_);
+    std::lock_guard const lock(mutex_);
     return firstUnsupportedExpected_;
 }
 
@@ -769,7 +769,7 @@ AmendmentTableImpl::doValidation(std::set<uint256> const& enabled) const
     std::vector<uint256> amendments;
 
     {
-        std::scoped_lock const lock(mutex_);
+        std::lock_guard 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::scoped_lock const lock(mutex_);
+    std::lock_guard 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::scoped_lock const lock(mutex_);
+    std::lock_guard 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::scoped_lock const lock(mutex_);
+    std::lock_guard 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::scoped_lock const lock(mutex_);
+    std::lock_guard const lock(mutex_);
     previousTrustedVotes_.trustChanged(allTrusted, lock);
 }
 
@@ -947,7 +947,7 @@ AmendmentTableImpl::injectJson(
     uint256 const& id,
     AmendmentState const& fs,
     bool isAdmin,
-    std::scoped_lock<std::mutex> const&) const
+    std::lock_guard<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::scoped_lock const lock(mutex_);
+        std::lock_guard 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::scoped_lock const lock(mutex_);
+        std::lock_guard 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 34a9613171..758f560835 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 = TransStatus::NEW;
+    mStatus = NEW;
 }
 
 //
@@ -78,22 +78,22 @@ Transaction::sqlTransactionStatus(boost::optional<std::string> const& status)
     switch (static_cast<TxnSql>(c))
     {
         case TxnSql::txnSqlNew:
-            return TransStatus::NEW;
+            return NEW;
         case TxnSql::txnSqlConflict:
-            return TransStatus::CONFLICTED;
+            return CONFLICTED;
         case TxnSql::txnSqlHeld:
-            return TransStatus::HELD;
+            return HELD;
         case TxnSql::txnSqlValidated:
-            return TransStatus::COMMITTED;
+            return COMMITTED;
         case TxnSql::txnSqlIncluded:
-            return TransStatus::INCLUDED;
+            return INCLUDED;
         default:
             XRPL_ASSERT(
                 c == TxnSql::txnSqlUnknown,
                 "xrpl::Transaction::sqlTransactionStatus : unknown transaction status");
     }
 
-    return TransStatus::INVALID;
+    return INVALID;
 }
 
 Transaction::pointer
diff --git a/src/xrpld/app/misc/detail/ValidatorList.cpp b/src/xrpld/app/misc/detail/ValidatorList.cpp
index b9a32f1463..8a62a71972 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::scoped_lock const lock{mutex_};
+    std::lock_guard 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::scoped_lock const&, PublicKey const& pubKey) const
+ValidatorList::getCacheFileName(ValidatorList::lock_guard const&, PublicKey const& pubKey) const
 {
     return dataPath_ / (filePrefix_ + strHex(pubKey));
 }
@@ -366,7 +366,7 @@ ValidatorList::buildFileData(
 }
 
 void
-ValidatorList::cacheValidatorFile(ValidatorList::scoped_lock const& lock, PublicKey const& pubKey)
+ValidatorList::cacheValidatorFile(ValidatorList::lock_guard const& lock, PublicKey const& pubKey)
     const
 {
     if (dataPath_.empty())
@@ -982,7 +982,7 @@ ValidatorList::applyLists(
         1)
         return PublisherListStats{ListDisposition::unsupported_version};
 
-    std::scoped_lock const lock{mutex_};
+    std::lock_guard 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::scoped_lock const&)
+    ValidatorList::lock_guard 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::scoped_lock const& lock)
+    ValidatorList::lock_guard const& lock)
 {
     using namespace std::string_literals;
 
@@ -1286,7 +1286,7 @@ ValidatorList::loadLists()
     using namespace boost::filesystem;
     using namespace boost::system::errc;
 
-    std::scoped_lock const lock{mutex_};
+    std::lock_guard 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::scoped_lock const& lock,
+    ValidatorList::lock_guard const& lock,
     Json::Value& list,
     Manifest manifest,
     std::string const& blob,
@@ -1494,7 +1494,7 @@ ValidatorList::localPublicKey() const
 
 bool
 ValidatorList::removePublisherList(
-    ValidatorList::scoped_lock const&,
+    ValidatorList::lock_guard const&,
     PublicKey const& publisherKey,
     PublisherStatus reason)
 {
@@ -1901,7 +1901,7 @@ ValidatorList::updateTrusted(
     if (timeKeeper_.now() > closeTime + 30s)
         closeTime = timeKeeper_.now();
 
-    std::scoped_lock const lock{mutex_};
+    std::lock_guard 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::scoped_lock const lock{mutex_};
+    std::lock_guard const lock{mutex_};
     negativeUNL_ = negUnl;
 }
 
diff --git a/src/xrpld/app/misc/detail/ValidatorSite.cpp b/src/xrpld/app/misc/detail/ValidatorSite.cpp
index 4c05ce5f09..557a4e4f25 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::scoped_lock<std::mutex> const& lock_sites)
+ValidatorSite::missingSite(std::lock_guard<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::scoped_lock const lock{sites_mutex_};
+    std::lock_guard 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::scoped_lock<std::mutex> const& lock_sites)
+    std::lock_guard<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::scoped_lock const l0{sites_mutex_};
-    std::scoped_lock const l1{state_mutex_};
+    std::lock_guard const l0{sites_mutex_};
+    std::lock_guard const l1{state_mutex_};
     if (timer_.expiry() == clock_type::time_point{})
         setTimer(l0, l1);
 }
@@ -219,8 +219,8 @@ ValidatorSite::stop()
 
 void
 ValidatorSite::setTimer(
-    std::scoped_lock<std::mutex> const& site_lock,
-    std::scoped_lock<std::mutex> const& state_lock)
+    std::lock_guard<std::mutex> const& site_lock,
+    std::lock_guard<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::scoped_lock<std::mutex> const& sites_lock)
+    std::lock_guard<std::mutex> const& sites_lock)
 {
     fetching_ = true;
     sites_[siteIdx].activeResource = resource;
     std::shared_ptr<detail::Work> sp;
     auto timeoutCancel = [this]() {
-        std::scoped_lock const lock_state{state_mutex_};
+        std::lock_guard 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::scoped_lock const lock_state{state_mutex_};
+    std::lock_guard 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::scoped_lock const lock_site{sites_mutex_};
+        std::lock_guard 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::scoped_lock const lock_state{state_mutex_};
+    std::lock_guard 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::scoped_lock const lock{sites_mutex_};
+        std::lock_guard 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::scoped_lock<std::mutex> const& sites_lock)
+    std::lock_guard<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::scoped_lock<std::mutex> const& sites_lock)
+    std::lock_guard<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::scoped_lock lock_sites{sites_mutex_};
+    std::lock_guard lock_sites{sites_mutex_};
     {
         if (endpoint != endpoint_type{})
             sites_[siteIdx].lastRequestEndpoint = endpoint;
@@ -617,7 +617,7 @@ ValidatorSite::onSiteFetch(
         sites_[siteIdx].activeResource.reset();
     }
 
-    std::scoped_lock const lock_state{state_mutex_};
+    std::lock_guard 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::scoped_lock const lock_sites{sites_mutex_};
+    std::lock_guard const lock_sites{sites_mutex_};
     {
         try
         {
@@ -657,7 +657,7 @@ ValidatorSite::onTextFetch(
         sites_[siteIdx].activeResource.reset();
     }
 
-    std::scoped_lock const lock_state{state_mutex_};
+    std::lock_guard 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::scoped_lock const lock{sites_mutex_};
+        std::lock_guard 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 c698c7ca76..f1b5f4edc3 100644
--- a/src/xrpld/app/rdb/backend/detail/Node.cpp
+++ b/src/xrpld/app/rdb/backend/detail/Node.cpp
@@ -249,8 +249,7 @@ saveValidatedLedger(
         Serializer s(128);
         s.add32(HashPrefix::ledgerMaster);
         addRaw(ledger->header(), s);
-        app.getNodeStore().store(
-            NodeObjectType::hotLEDGER, std::move(s.modData()), ledger->header().hash, seq);
+        app.getNodeStore().store(hotLEDGER, std::move(s.modData()), ledger->header().hash, seq);
     }
 
     std::shared_ptr<AcceptedLedger> aLedger;
diff --git a/src/xrpld/consensus/ConsensusParms.h b/src/xrpld/consensus/ConsensusParms.h
index 7b9ec5dcff..c8b79c4de9 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 class AvalancheState { init, mid, late, stuck };
+    enum AvalancheState { init, mid, late, stuck };
     struct AvalancheCutoff
     {
         int const consensusTime;
@@ -121,18 +121,14 @@ struct ConsensusParms
     std::map<AvalancheState, AvalancheCutoff> const avalancheCutoffs{
         // {state, {time, percent, nextState}},
         // Initial state: 50% of nodes must vote yes
-        {AvalancheState::init,
-         {.consensusTime = 0, .consensusPct = 50, .next = AvalancheState::mid}},
+        {init, {.consensusTime = 0, .consensusPct = 50, .next = mid}},
         // mid-consensus starts after 50% of the previous round time, and
         // requires 65% yes
-        {AvalancheState::mid,
-         {.consensusTime = 50, .consensusPct = 65, .next = AvalancheState::late}},
+        {mid, {.consensusTime = 50, .consensusPct = 65, .next = late}},
         // late consensus starts after 85% time, and requires 70% yes
-        {AvalancheState::late,
-         {.consensusTime = 85, .consensusPct = 70, .next = AvalancheState::stuck}},
+        {late, {.consensusTime = 85, .consensusPct = 70, .next = stuck}},
         // we're stuck after 2x time, requires 95% yes votes
-        {AvalancheState::stuck,
-         {.consensusTime = 200, .consensusPct = 95, .next = AvalancheState::stuck}},
+        {stuck, {.consensusTime = 200, .consensusPct = 95, .next = 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 4320505d0f..9c30b6180d 100644
--- a/src/xrpld/consensus/DisputedTx.h
+++ b/src/xrpld/consensus/DisputedTx.h
@@ -60,6 +60,20 @@ public:
         return ourVote_;
     }
 
+    //! Number of peers voting to include the transaction.
+    [[nodiscard]] int
+    getYays() const
+    {
+        return yays_;
+    }
+
+    //! Number of peers voting to exclude the transaction.
+    [[nodiscard]] int
+    getNays() const
+    {
+        return nays_;
+    }
+
     //! Are we and our peers "stalled" where we probably won't change
     //! our vote?
     [[nodiscard]] bool
@@ -176,6 +190,20 @@ public:
     [[nodiscard]] Json::Value
     getJson() const;
 
+    //! Number of peers voting yes.
+    [[nodiscard]] int
+    getYays() const
+    {
+        return yays_;
+    }
+
+    //! Number of peers voting no.
+    [[nodiscard]] int
+    getNays() const
+    {
+        return nays_;
+    }
+
 private:
     int yays_{0};   //< Number of yes votes
     int nays_{0};   //< Number of no votes
@@ -185,7 +213,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::AvalancheState::init;
+    ConsensusParms::AvalancheState avalancheState_ = ConsensusParms::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 5edb1db77f..46b0ef0b32 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::scoped_lock<Mutex> const&, NodeID const& nodeID, Validation const& val)
+    removeTrie(std::lock_guard<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::scoped_lock<Mutex> const& lock)
+    checkAcquired(std::lock_guard<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::scoped_lock<Mutex> const&, NodeID const& nodeID, Ledger ledger)
+    updateTrie(std::lock_guard<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::scoped_lock<Mutex> const& lock,
+        std::lock_guard<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::scoped_lock<Mutex> const& lock, F&& f)
+    withTrie(std::lock_guard<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::scoped_lock<Mutex> const& lock, Pre&& pre, F&& f)
+    current(std::lock_guard<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::scoped_lock<Mutex> const&, ID const& ledgerID, Pre&& pre, F&& f)
+    byLedger(std::lock_guard<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::scoped_lock const lock{mutex_};
+        std::lock_guard const lock{mutex_};
         return localSeqEnforcer_(byLedger_.clock().now(), s, parms_);
     }
 
@@ -594,7 +594,7 @@ public:
             return ValStatus::stale;
 
         {
-            std::scoped_lock const lock{mutex_};
+            std::lock_guard 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::scoped_lock const lock{mutex_};
+        std::lock_guard 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::scoped_lock const lock{mutex_};
+            std::lock_guard 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::scoped_lock const lock{mutex_};
+        std::lock_guard const lock{mutex_};
 
         for (auto& [nodeId, validation] : current_)
         {
@@ -790,7 +790,7 @@ public:
     Json::Value
     getJsonTrie() const
     {
-        std::scoped_lock const lock{mutex_};
+        std::lock_guard const lock{mutex_};
         return trie_.getJson();
     }
 
@@ -809,7 +809,7 @@ public:
     std::optional<std::pair<Seq, ID>>
     getPreferred(Ledger const& curr)
     {
-        std::scoped_lock const lock{mutex_};
+        std::lock_guard 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::scoped_lock const lock{mutex_};
+        std::lock_guard 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::scoped_lock const lock{mutex_};
+        std::lock_guard 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::scoped_lock const lock{mutex_};
+        std::lock_guard 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::scoped_lock const lock{mutex_};
+        std::lock_guard const lock{mutex_};
         byLedger(
             lock,
             ledgerID,
@@ -1005,7 +1005,7 @@ public:
     getTrustedForLedger(ID const& ledgerID, Seq const& seq)
     {
         std::vector<WrappedValidationType> res;
-        std::scoped_lock const lock{mutex_};
+        std::lock_guard 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::scoped_lock const lock{mutex_};
+        std::lock_guard const lock{mutex_};
         byLedger(
             lock,
             ledgerID,
@@ -1055,7 +1055,7 @@ public:
     void
     flush()
     {
-        std::scoped_lock const lock{mutex_};
+        std::lock_guard const lock{mutex_};
         current_.clear();
     }
 
@@ -1080,7 +1080,7 @@ public:
         std::size_t laggards = 0;
 
         current(
-            std::scoped_lock{mutex_},
+            std::lock_guard{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::scoped_lock const lock{mutex_};
+        std::lock_guard const lock{mutex_};
         return current_.size();
     }
 
     std::size_t
     sizeOfSeqEnforcersCache() const
     {
-        std::scoped_lock const lock{mutex_};
+        std::lock_guard const lock{mutex_};
         return seqEnforcers_.size();
     }
 
     std::size_t
     sizeOfByLedgerCache() const
     {
-        std::scoped_lock const lock{mutex_};
+        std::lock_guard const lock{mutex_};
         return byLedger_.size();
     }
 
     std::size_t
     sizeOfBySequenceCache() const
     {
-        std::scoped_lock const lock{mutex_};
+        std::lock_guard const lock{mutex_};
         return bySequence_.size();
     }
 };
diff --git a/src/xrpld/overlay/detail/Cluster.cpp b/src/xrpld/overlay/detail/Cluster.cpp
index b15ed1859c..c74a9aa5bd 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::scoped_lock const lock(mutex_);
+    std::lock_guard 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::scoped_lock const lock(mutex_);
+    std::lock_guard const lock(mutex_);
 
     return nodes_.size();
 }
@@ -52,7 +52,7 @@ Cluster::update(
     std::uint32_t loadFee,
     NetClock::time_point reportTime)
 {
-    std::scoped_lock const lock(mutex_);
+    std::lock_guard 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::scoped_lock const lock(mutex_);
+    std::lock_guard 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 eb8add8666..f8d3fbc8ff 100644
--- a/src/xrpld/overlay/detail/Message.cpp
+++ b/src/xrpld/overlay/detail/Message.cpp
@@ -22,8 +22,7 @@ Message::Message(
     ::google::protobuf::Message const& message,
     protocol::MessageType type,
     std::optional<PublicKey> const& validator)
-    : category_(static_cast<std::size_t>(TrafficCount::categorize(message, type, false)))
-    , validatorKey_(validator)
+    : category_(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 d17a556dd8..f29d97cb11 100644
--- a/src/xrpld/overlay/detail/OverlayImpl.cpp
+++ b/src/xrpld/overlay/detail/OverlayImpl.cpp
@@ -92,8 +92,6 @@
 namespace xrpl {
 
 namespace CrawlOptions {
-// Need to be named before converting
-// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
 enum {
     Disabled = 0,
     Overlay = (1 << 0),
@@ -334,7 +332,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::scoped_lock const lock(mutex_);
+            std::lock_guard<decltype(mutex_)> const lock(mutex_);
             {
                 auto const result = m_peers.emplace(peer->slot(), peer);
                 XRPL_ASSERT(result.second, "xrpl::OverlayImpl::onHandoff : peer is inserted");
@@ -457,7 +455,7 @@ OverlayImpl::connect(beast::IP::Endpoint const& remote_endpoint)
         app_.getJournal("Peer"),
         *this);
 
-    std::scoped_lock const lock(mutex_);
+    std::lock_guard const lock(mutex_);
     list_.emplace(p.get(), p);
     p->run();
 }
@@ -471,7 +469,7 @@ OverlayImpl::add_active(std::shared_ptr<PeerImp> const& peer)
     beast::WrappedSink sink{journal_.sink(), peer->prefix()};
     beast::Journal const journal{sink};
 
-    std::scoped_lock const lock(mutex_);
+    std::lock_guard const lock(mutex_);
 
     {
         auto const result = m_peers.emplace(peer->slot(), peer);
@@ -499,7 +497,7 @@ OverlayImpl::add_active(std::shared_ptr<PeerImp> const& peer)
 void
 OverlayImpl::remove(std::shared_ptr<PeerFinder::Slot> const& slot)
 {
-    std::scoped_lock const lock(mutex_);
+    std::lock_guard 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);
@@ -586,7 +584,7 @@ OverlayImpl::start()
             });
     }
     auto const timer = std::make_shared<Timer>(*this);
-    std::scoped_lock const lock(mutex_);
+    std::lock_guard const lock(mutex_);
     list_.emplace(timer.get(), timer);
     timer_ = timer;
     timer->async_wait();
@@ -639,7 +637,7 @@ OverlayImpl::activate(std::shared_ptr<PeerImp> const& peer)
 
     // Now track this peer
     {
-        std::scoped_lock const lock(mutex_);
+        std::lock_guard 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");
@@ -655,7 +653,7 @@ OverlayImpl::activate(std::shared_ptr<PeerImp> const& peer)
 void
 OverlayImpl::onPeerDeactivate(Peer::id_t id)
 {
-    std::scoped_lock const lock(mutex_);
+    std::lock_guard const lock(mutex_);
     ids_.erase(id);
 }
 
@@ -734,7 +732,7 @@ OverlayImpl::reportOutboundTraffic(TrafficCount::category cat, int size)
 std::size_t
 OverlayImpl::size() const
 {
-    std::scoped_lock const lock(mutex_);
+    std::lock_guard const lock(mutex_);
     return ids_.size();
 }
 
@@ -1093,7 +1091,7 @@ OverlayImpl::getActivePeers(
     std::size_t& enabledInSkip) const
 {
     Overlay::PeerSequence ret;
-    std::scoped_lock const lock(mutex_);
+    std::lock_guard const lock(mutex_);
 
     active = ids_.size();
     disabled = enabledInSkip = 0;
@@ -1133,7 +1131,7 @@ OverlayImpl::checkTracking(std::uint32_t index)
 std::shared_ptr<Peer>
 OverlayImpl::findPeerByShortID(Peer::id_t const& id) const
 {
-    std::scoped_lock const lock(mutex_);
+    std::lock_guard const lock(mutex_);
     auto const iter = ids_.find(id);
     if (iter != ids_.end())
         return iter->second.lock();
@@ -1145,7 +1143,7 @@ OverlayImpl::findPeerByShortID(Peer::id_t const& id) const
 std::shared_ptr<Peer>
 OverlayImpl::findPeerByPublicKey(PublicKey const& pubKey)
 {
-    std::scoped_lock const lock(mutex_);
+    std::lock_guard 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_)
@@ -1206,7 +1204,7 @@ OverlayImpl::relay(protocol::TMValidation& m, uint256 const& uid, PublicKey cons
 std::shared_ptr<Message>
 OverlayImpl::getManifestsMessage()
 {
-    std::scoped_lock const g(manifestLock_);
+    std::lock_guard const g(manifestLock_);
 
     if (auto seq = app_.getValidatorManifests().sequence(); seq != manifestListSeq_)
     {
@@ -1325,7 +1323,7 @@ OverlayImpl::relay(
 void
 OverlayImpl::remove(Child& child)
 {
-    std::scoped_lock const lock(mutex_);
+    std::lock_guard const lock(mutex_);
     list_.erase(&child);
     if (list_.empty())
         cond_.notify_all();
@@ -1344,7 +1342,7 @@ OverlayImpl::stopChildren()
     // won't be called until vector<> children leaves scope.
     std::vector<std::shared_ptr<Child>> children;
     {
-        std::scoped_lock const lock(mutex_);
+        std::lock_guard const lock(mutex_);
         if (!work_)
             return;
         work_ = std::nullopt;
@@ -1379,7 +1377,7 @@ OverlayImpl::sendEndpoints()
     {
         std::shared_ptr<PeerImp> peer;
         {
-            std::scoped_lock const lock(mutex_);
+            std::lock_guard const lock(mutex_);
             auto const iter = m_peers.find(e.first);
             if (iter != m_peers.end())
                 peer = iter->second.lock();
@@ -1454,7 +1452,7 @@ OverlayImpl::updateSlotAndSquelch(
     for (auto id : peers)
     {
         slots_.updateSlotAndSquelch(key, validator, id, type, [&]() {
-            reportInboundTraffic(TrafficCount::category::squelch_ignored, 0);
+            reportInboundTraffic(TrafficCount::squelch_ignored, 0);
         });
     }
 }
@@ -1483,7 +1481,7 @@ OverlayImpl::updateSlotAndSquelch(
     }
 
     slots_.updateSlotAndSquelch(key, validator, peer, type, [&]() {
-        reportInboundTraffic(TrafficCount::category::squelch_ignored, 0);
+        reportInboundTraffic(TrafficCount::squelch_ignored, 0);
     });
 }
 
diff --git a/src/xrpld/overlay/detail/OverlayImpl.h b/src/xrpld/overlay/detail/OverlayImpl.h
index caccd35562..0c4990a6f4 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::scoped_lock const lock(mutex_);
+            std::lock_guard 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::scoped_lock const lock(m_statsMutex);
+        std::lock_guard 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.h b/src/xrpld/overlay/detail/PeerImp.h
index d2cf46e838..f2cca1407a 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::scoped_lock const sl(recentLock_);
+        std::lock_guard<std::mutex> 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::scoped_lock const sl(recentLock_);
+        std::lock_guard<std::mutex> 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::scoped_lock<std::mutex> const& lockedRecentLock);
+    addLedger(uint256 const& hash, std::lock_guard<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 6f004a3b39..f0e5f55a00 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::scoped_lock const lock(mutex_);
+        std::lock_guard 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::scoped_lock const lock(mutex_);
+    std::lock_guard 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::scoped_lock const lock(mutex_);
+    std::lock_guard 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::scoped_lock const lock(mutex_);
+    std::lock_guard 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 8597ca897c..736c3b76e3 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 class category : std::size_t;
+    enum 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 class category : std::size_t {
+    enum category : std::size_t {
         base,  // basic peer overhead, must be first
 
         cluster,    // cluster overhead
@@ -193,8 +193,7 @@ public:
     addCount(category cat, bool inbound, int bytes)
     {
         XRPL_ASSERT(
-            static_cast<std::size_t>(cat) <= static_cast<std::size_t>(category::unknown),
-            "xrpl::TrafficCount::addCount : valid category input");
+            cat <= category::unknown, "xrpl::TrafficCount::addCount : valid category input");
 
         auto it = counts_.find(cat);
 
@@ -228,62 +227,62 @@ public:
     to_string(category cat)
     {
         static std::unordered_map<category, std::string> const category_map = {
-            {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"}};
+            {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"}};
 
         if (auto it = category_map.find(cat); it != category_map.end())
             return it->second;
@@ -293,63 +292,63 @@ public:
 
 protected:
     std::unordered_map<category, TrafficStats> counts_{
-        {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}},
+        {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}},
     };
 };
 
diff --git a/src/xrpld/overlay/detail/Tuning.h b/src/xrpld/overlay/detail/Tuning.h
index 07cf2d2238..0471587fec 100644
--- a/src/xrpld/overlay/detail/Tuning.h
+++ b/src/xrpld/overlay/detail/Tuning.h
@@ -4,8 +4,6 @@
 
 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 2bcf5f2f2f..0a44c719f4 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::scoped_lock const lock(mutex);
+        std::lock_guard 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::scoped_lock const lock(mutex);
+    std::lock_guard 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::scoped_lock const lock(mutex);
+    std::lock_guard const lock(mutex);
     missingTx.addMetrics(missing);
 }
 
@@ -99,7 +99,7 @@ SingleMetrics::addMetrics(std::uint32_t val)
 Json::Value
 TxMetrics::json() const
 {
-    std::scoped_lock const l(mutex);
+    std::lock_guard const l(mutex);
 
     Json::Value ret(Json::objectValue);
 
diff --git a/src/xrpld/peerfinder/Slot.h b/src/xrpld/peerfinder/Slot.h
index e67df7ee17..5c459b25ea 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 class State { accept, connect, connected, active, closing };
+    enum 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 820d030b23..3bd23f85db 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::scoped_lock const lock(mutex_);
+    std::lock_guard 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::scoped_lock const lock(mutex_);
+        std::lock_guard 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::scoped_lock const lock(mutex_);
+    std::lock_guard 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 367caed54b..6d1221d331 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::State::connected || s.state() == Slot::State::accept,
+            s.state() == Slot::connected || s.state() == Slot::accept,
             "xrpl::PeerFinder::Counts::can_activate : valid input state");
 
         if (s.fixed() || s.reserved())
@@ -241,13 +241,13 @@ private:
 
         switch (s.state())
         {
-            case Slot::State::accept:
+            case Slot::accept:
                 XRPL_ASSERT(s.inbound(), "xrpl::PeerFinder::Counts::adjust : input is inbound");
                 adjustCounter(m_acceptCount, dir);
                 break;
 
-            case Slot::State::connect:
-            case Slot::State::connected:
+            case Slot::connect:
+            case Slot::connected:
                 XRPL_ASSERT(
                     !s.inbound(),
                     "xrpl::PeerFinder::Counts::adjust : input is not "
@@ -255,7 +255,7 @@ private:
                 adjustCounter(m_attempts, dir);
                 break;
 
-            case Slot::State::active:
+            case Slot::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::State::closing:
+            case Slot::closing:
                 adjustCounter(m_closingCount, dir);
                 break;
 
diff --git a/src/xrpld/peerfinder/detail/Logic.h b/src/xrpld/peerfinder/detail/Logic.h
index c7e6c7d1f2..9e2cbedc64 100644
--- a/src/xrpld/peerfinder/detail/Logic.h
+++ b/src/xrpld/peerfinder/detail/Logic.h
@@ -105,7 +105,7 @@ public:
     void
     load()
     {
-        std::scoped_lock const _(lock_);
+        std::lock_guard const _(lock_);
         bootcache_.load();
     }
 
@@ -118,7 +118,7 @@ public:
     void
     stop()
     {
-        std::scoped_lock const _(lock_);
+        std::lock_guard const _(lock_);
         stopping_ = true;
         if (fetchSource_ != nullptr)
             fetchSource_->cancel();
@@ -133,7 +133,7 @@ public:
     void
     config(Config const& c)
     {
-        std::scoped_lock const _(lock_);
+        std::lock_guard const _(lock_);
         config_ = c;
         counts_.onConfig(config_);
     }
@@ -141,7 +141,7 @@ public:
     Config
     config()
     {
-        std::scoped_lock const _(lock_);
+        std::lock_guard const _(lock_);
         return config_;
     }
 
@@ -154,7 +154,7 @@ public:
     void
     addFixedPeer(std::string const& name, std::vector<beast::IP::Endpoint> const& addresses)
     {
-        std::scoped_lock const _(lock_);
+        std::lock_guard const _(lock_);
 
         if (addresses.empty())
         {
@@ -196,7 +196,7 @@ public:
         if (ec == boost::asio::error::operation_aborted)
             return;
 
-        std::scoped_lock const _(lock_);
+        std::lock_guard 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::scoped_lock const _(lock_);
+        std::lock_guard 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::scoped_lock const _(lock_);
+        std::lock_guard 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::scoped_lock const _(lock_);
+        std::lock_guard const _(lock_);
 
         // The object must exist in our table
         XRPL_ASSERT(
@@ -350,7 +350,7 @@ public:
 
         // Update counts
         counts_.remove(*slot);
-        slot->state(Slot::State::connected);
+        slot->state(Slot::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::scoped_lock const _(lock_);
+        std::lock_guard 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::State::accept || slot->state() == Slot::State::connected,
+            slot->state() == Slot::accept || slot->state() == Slot::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::scoped_lock const _(lock_);
+        std::lock_guard 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::scoped_lock const _(lock_);
+        std::lock_guard 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::scoped_lock const _(lock_);
+        std::lock_guard 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::State::active)
+                        if (value.second->state() == Slot::active)
                             slots.emplace_back(value.second);
                     });
                 std::shuffle(slots.begin(), slots.end(), default_prng());
@@ -640,7 +640,7 @@ public:
     void
     once_per_second()
     {
-        std::scoped_lock const _(lock_);
+        std::lock_guard 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::scoped_lock const _(lock_);
+        std::lock_guard const _(lock_);
 
         // The object must exist in our table
         XRPL_ASSERT(
@@ -747,7 +747,7 @@ public:
 
         // Must be handshaked!
         XRPL_ASSERT(
-            slot->state() == Slot::State::active,
+            slot->state() == Slot::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::scoped_lock const _(lock_);
+        std::lock_guard 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::State::active)
+        if (slot->fixed() && !slot->inbound() && slot->state() != Slot::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::State::accept:
+            case Slot::accept:
                 JLOG(journal.trace()) << "Logic accept failed";
                 break;
 
-            case Slot::State::connect:
-            case Slot::State::connected:
+            case Slot::connect:
+            case Slot::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::State::active:
+            case Slot::active:
                 JLOG(journal.trace()) << "Logic close";
                 break;
 
-            case Slot::State::closing:
+            case Slot::closing:
                 JLOG(journal.trace()) << "Logic finished";
                 break;
 
@@ -930,7 +930,7 @@ public:
     void
     on_failure(SlotImp::ptr const& slot)
     {
-        std::scoped_lock const _(lock_);
+        std::lock_guard const _(lock_);
 
         bootcache_.on_failure(slot->remote_endpoint());
     }
@@ -1023,7 +1023,7 @@ public:
     addBootcacheAddresses(IPAddresses const& list)
     {
         int count(0);
-        std::scoped_lock const _(lock_);
+        std::lock_guard const _(lock_);
         for (auto const& addr : list)
         {
             if (bootcache_.insertStatic(addr))
@@ -1040,7 +1040,7 @@ public:
 
         {
             {
-                std::scoped_lock const _(lock_);
+                std::lock_guard const _(lock_);
                 if (stopping_)
                     return;
                 fetchSource_ = source;
@@ -1052,7 +1052,7 @@ public:
             source->fetch(results, m_journal);
 
             {
-                std::scoped_lock const _(lock_);
+                std::lock_guard const _(lock_);
                 if (stopping_)
                     return;
                 fetchSource_ = nullptr;
@@ -1123,7 +1123,7 @@ public:
     void
     onWrite(beast::PropertyStream::Map& map)
     {
-        std::scoped_lock const _(lock_);
+        std::lock_guard 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::State::accept:
+            case Slot::accept:
                 return "accept";
-            case Slot::State::connect:
+            case Slot::connect:
                 return "connect";
-            case Slot::State::connected:
+            case Slot::connected:
                 return "connected";
-            case Slot::State::active:
+            case Slot::active:
                 return "active";
-            case Slot::State::closing:
+            case Slot::closing:
                 return "closing";
             default:
                 break;
@@ -1201,7 +1201,7 @@ Logic<Checker>::onRedirects(
     FwdIter last,
     boost::asio::ip::tcp::endpoint const& remote_address)
 {
-    std::scoped_lock const _(lock_);
+    std::lock_guard 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 d2378a2fbb..2858586120 100644
--- a/src/xrpld/peerfinder/detail/PeerfinderManager.cpp
+++ b/src/xrpld/peerfinder/detail/PeerfinderManager.cpp
@@ -243,7 +243,7 @@ private:
     void
     collect_metrics()
     {
-        std::scoped_lock const lock(m_statsMutex);
+        std::lock_guard 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 e7cc751472..f763a154aa 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(State::accept)
+    , m_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(State::connect)
+    , m_state(connect)
     , m_remote_endpoint(std::move(remote_endpoint))
     , m_listening_port(unknownPort)
     , checked(true)
@@ -50,8 +50,7 @@ void
 SlotImp::state(State state_)
 {
     // Must go through activate() to set active state
-    XRPL_ASSERT(
-        state_ != State::active, "xrpl::PeerFinder::SlotImp::state : input state is not active");
+    XRPL_ASSERT(state_ != active, "xrpl::PeerFinder::SlotImp::state : input state is not active");
 
     // The state must be different
     XRPL_ASSERT(
@@ -61,18 +60,18 @@ SlotImp::state(State state_)
 
     // You can't transition into the initial states
     XRPL_ASSERT(
-        state_ != State::accept && state_ != State::connect,
+        state_ != accept && state_ != connect,
         "xrpl::PeerFinder::SlotImp::state : input state is not an initial");
 
     // Can only become connected from outbound connect state
     XRPL_ASSERT(
-        state_ != State::connected || (!m_inbound && m_state == State::connect),
+        state_ != connected || (!m_inbound && m_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_ != State::closing || m_state != State::connect,
+        state_ != closing || m_state != connect,
         "xrpl::PeerFinder::SlotImp::state : input state is not closing an "
         "invalid state");
 
@@ -84,10 +83,10 @@ SlotImp::activate(clock_type::time_point const& now)
 {
     // Can only become active from the accept or connected state
     XRPL_ASSERT(
-        m_state == State::accept || m_state == State::connected,
+        m_state == accept || m_state == connected,
         "xrpl::PeerFinder::SlotImp::activate : valid state");
 
-    m_state = State::active;
+    m_state = active;
     whenAcceptEndpoints = now;
 }
 
diff --git a/src/xrpld/peerfinder/detail/StoreSqdb.h b/src/xrpld/peerfinder/detail/StoreSqdb.h
index 1d5ce50184..626a82c932 100644
--- a/src/xrpld/peerfinder/detail/StoreSqdb.h
+++ b/src/xrpld/peerfinder/detail/StoreSqdb.h
@@ -15,8 +15,6 @@ 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 e166ae32b8..23a96a7374 100644
--- a/src/xrpld/peerfinder/detail/Tuning.h
+++ b/src/xrpld/peerfinder/detail/Tuning.h
@@ -6,8 +6,6 @@
 /** @{ */
 namespace xrpl::PeerFinder::Tuning {
 
-// Need to be named before converting
-// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
 enum {
     //---------------------------------------------------------
     //
@@ -63,8 +61,6 @@ 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 64950fc689..6b80d29cc6 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::scoped_lock const lock(proc.second.mutex);
+            std::lock_guard 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::scoped_lock const lock(proc.second.mutex);
+            std::lock_guard 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::scoped_lock const lock(jobsMutex_);
+        std::lock_guard const lock(jobsMutex_);
         return jobs_;
     }();
 
@@ -184,7 +184,7 @@ PerfLogImp::Counters::currentJson() const
     Json::Value methodsArray(Json::arrayValue);
     std::vector<MethodStart> methods;
     {
-        std::scoped_lock const lock(methodsMutex_);
+        std::lock_guard 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::scoped_lock const lock{counters_.jobsMutex_};
+        std::lock_guard 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::scoped_lock const lock(counter->second.mutex);
+        std::lock_guard const lock(counter->second.mutex);
         ++counter->second.value.started;
     }
-    std::scoped_lock const lock(counters_.methodsMutex_);
+    std::lock_guard 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::scoped_lock const lock(counters_.methodsMutex_);
+        std::lock_guard 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::scoped_lock const lock(counter->second.mutex);
+    std::lock_guard 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::scoped_lock const lock(counter->second.mutex);
+    std::lock_guard const lock(counter->second.mutex);
     ++counter->second.value.queued;
 }
 
@@ -400,11 +400,11 @@ PerfLogImp::jobStart(
     }
 
     {
-        std::scoped_lock const lock(counter->second.mutex);
+        std::lock_guard const lock(counter->second.mutex);
         ++counter->second.value.started;
         counter->second.value.queuedDuration += dur;
     }
-    std::scoped_lock const lock(counters_.jobsMutex_);
+    std::lock_guard 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::scoped_lock const lock(counter->second.mutex);
+        std::lock_guard const lock(counter->second.mutex);
         ++counter->second.value.finished;
         counter->second.value.runningDuration += dur;
     }
-    std::scoped_lock const lock(counters_.jobsMutex_);
+    std::lock_guard 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::scoped_lock const lock(counters_.jobsMutex_);
+    std::lock_guard 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::scoped_lock const lock(mutex_);
+    std::lock_guard const lock(mutex_);
     rotate_ = true;
     cond_.notify_one();
 }
@@ -463,7 +463,7 @@ PerfLogImp::stop()
     if (thread_.joinable())
     {
         {
-            std::scoped_lock const lock(mutex_);
+            std::lock_guard 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 28924ceb5f..bbe8fefc98 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::scoped_lock const sl(mLock);
+    std::lock_guard 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::scoped_lock const sl(mLock);
+    std::lock_guard 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 94d0ca87cf..d249409ffe 100644
--- a/src/xrpld/rpc/detail/Handler.h
+++ b/src/xrpld/rpc/detail/Handler.h
@@ -15,8 +15,6 @@ 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/Pathfinder.h b/src/xrpld/rpc/detail/Pathfinder.h
index b4380c04ca..964ec8c1d1 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 class NodeType {
+    enum 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 class PaymentType {
+    enum 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 f102f919c4..f9cd860908 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::scoped_lock const sl(mLock);
+        std::lock_guard 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::scoped_lock const sl(mLock);
+        std::lock_guard const sl(mLock);
 
         mUsername = strUsername;
     }
@@ -112,7 +112,7 @@ public:
     void
     setPassword(std::string const& strPassword) override
     {
-        std::scoped_lock const sl(mLock);
+        std::lock_guard const sl(mLock);
 
         mPassword = strPassword;
     }
@@ -130,7 +130,7 @@ private:
         {
             {
                 // Obtain the lock to manipulate the queue and change sending.
-                std::scoped_lock const sl(mLock);
+                std::lock_guard const sl(mLock);
 
                 if (mDeque.empty())
                 {
diff --git a/src/xrpld/rpc/detail/TransactionSign.cpp b/src/xrpld/rpc/detail/TransactionSign.cpp
index 7a60dc1f2c..85d5a62efc 100644
--- a/src/xrpld/rpc/detail/TransactionSign.cpp
+++ b/src/xrpld/rpc/detail/TransactionSign.cpp
@@ -700,7 +700,7 @@ transactionConstructImpl(
     {
         std::string reason;
         tpTrans = std::make_shared<Transaction>(stTx, reason, app);
-        if (tpTrans->getStatus() != TransStatus::NEW)
+        if (tpTrans->getStatus() != NEW)
         {
             ret.first = RPC::make_error(rpcINTERNAL, "Unable to construct transaction: " + reason);
             return ret;
diff --git a/src/xrpld/rpc/handlers/transaction/Submit.cpp b/src/xrpld/rpc/handlers/transaction/Submit.cpp
index 936579c276..73260c0661 100644
--- a/src/xrpld/rpc/handlers/transaction/Submit.cpp
+++ b/src/xrpld/rpc/handlers/transaction/Submit.cpp
@@ -107,7 +107,7 @@ doSubmit(RPC::JsonContext& context)
 
     std::string reason;
     auto transaction = std::make_shared<Transaction>(stTx, reason, context.app);
-    if (transaction->getStatus() != TransStatus::NEW)
+    if (transaction->getStatus() != NEW)
     {
         jvResult[jss::error] = "invalidTransaction";
         jvResult[jss::error_exception] = "fails local checks: " + reason;
diff --git a/src/xrpld/shamap/NodeFamily.cpp b/src/xrpld/shamap/NodeFamily.cpp
index bf1b598620..2c47515498 100644
--- a/src/xrpld/shamap/NodeFamily.cpp
+++ b/src/xrpld/shamap/NodeFamily.cpp
@@ -53,12 +53,12 @@ void
 NodeFamily::reset()
 {
     {
-        std::scoped_lock const lock(maxSeqMutex_);
+        std::lock_guard const lock(maxSeqMutex_);
         maxSeq_ = 0;
     }
 
-    (*fbCache_).reset();
-    (*tnCache_).reset();
+    fbCache_->reset();
+    tnCache_->reset();
 }
 
 void