diff --git a/.clang-tidy b/.clang-tidy
index 6a967532db..6a7005b464 100644
--- a/.clang-tidy
+++ b/.clang-tidy
@@ -7,6 +7,7 @@ Checks: "-*,
   bugprone-bad-signal-to-kill-thread,
   bugprone-bool-pointer-implicit-conversion,
   bugprone-casting-through-void,
+  bugprone-capturing-this-in-member-variable,
   bugprone-chained-comparison,
   bugprone-compare-pointer-to-member-virtual-function,
   bugprone-copy-constructor-init,
@@ -28,6 +29,7 @@ Checks: "-*,
   bugprone-misplaced-operator-in-strlen-in-alloc,
   bugprone-misplaced-pointer-arithmetic-in-alloc,
   bugprone-misplaced-widening-cast,
+  bugprone-misleading-setter-of-reference,
   bugprone-move-forwarding-reference,
   bugprone-multi-level-implicit-pointer-conversion,
   bugprone-multiple-new-in-one-expression,
@@ -85,6 +87,7 @@ Checks: "-*,
   cppcoreguidelines-pro-type-static-cast-downcast,
   cppcoreguidelines-rvalue-reference-param-not-moved,
   cppcoreguidelines-use-default-member-init,
+  cppcoreguidelines-use-enum-class,
   cppcoreguidelines-virtual-class-destructor,
   hicpp-ignored-remove-result,
   misc-const-correctness,
@@ -109,6 +112,7 @@ Checks: "-*,
   modernize-use-nodiscard,
   modernize-use-override,
   modernize-use-ranges,
+  modernize-use-scoped-lock,
   modernize-use-starts-ends-with,
   modernize-use-std-numbers,
   modernize-use-using,
@@ -122,6 +126,7 @@ Checks: "-*,
   performance-move-constructor-init,
   performance-no-automatic-move,
   performance-trivially-destructible,
+  readability-ambiguous-smartptr-reset-call,
   readability-avoid-nested-conditional-operator,
   readability-avoid-return-with-void-value,
   readability-braces-around-statements,
diff --git a/include/xrpl/basics/Log.h b/include/xrpl/basics/Log.h
index 58cca4f486..5c63166d93 100644
--- a/include/xrpl/basics/Log.h
+++ b/include/xrpl/basics/Log.h
@@ -15,6 +15,7 @@
 namespace xrpl {
 
 // DEPRECATED use beast::severities::Severity instead
+// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
 enum LogSeverity {
     lsINVALID = -1,  // used to indicate an invalid severity
     lsTRACE = 0,     // Very low-level progress information, details inside
@@ -207,6 +208,8 @@ public:
     fromString(std::string const& s);
 
 private:
+    // Need to be named before converting
+    // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
     enum {
         // Maximum line length for log messages.
         // If the message exceeds this length it will be truncated with
diff --git a/include/xrpl/basics/Mutex.hpp b/include/xrpl/basics/Mutex.hpp
index 5855ee2017..4432e27b4b 100644
--- a/include/xrpl/basics/Mutex.hpp
+++ b/include/xrpl/basics/Mutex.hpp
@@ -131,7 +131,7 @@ public:
      * @tparam LockType The type of lock to use
      * @return A lock on the mutex and a reference to the protected data
      */
-    template <template <typename...> typename LockType = std::lock_guard>
+    template <template <typename...> typename LockType = std::scoped_lock>
     Lock<ProtectedDataType const, LockType, MutexType>
     lock() const
     {
@@ -144,7 +144,7 @@ public:
      * @tparam LockType The type of lock to use
      * @return A lock on the mutex and a reference to the protected data
      */
-    template <template <typename...> typename LockType = std::lock_guard>
+    template <template <typename...> typename LockType = std::scoped_lock>
     Lock<ProtectedDataType, LockType, MutexType>
     lock()
     {
diff --git a/include/xrpl/basics/Number.h b/include/xrpl/basics/Number.h
index d14b17a042..b82cb628b9 100644
--- a/include/xrpl/basics/Number.h
+++ b/include/xrpl/basics/Number.h
@@ -70,7 +70,7 @@ isPowerOfTen(T value)
 struct MantissaRange
 {
     using rep = std::uint64_t;
-    enum mantissa_scale { small, large };
+    enum class mantissa_scale { small, large };
 
     explicit constexpr MantissaRange(mantissa_scale scale_)
         : min(getMin(scale_)), log(logTen(min).value_or(-1)), scale(scale_)
@@ -88,9 +88,9 @@ private:
     {
         switch (scale_)
         {
-            case small:
+            case mantissa_scale::small:
                 return 1'000'000'000'000'000ULL;
-            case large:
+            case mantissa_scale::large:
                 return 1'000'000'000'000'000'000ULL;
             default:
                 // Since this can never be called outside a non-constexpr
@@ -384,7 +384,7 @@ public:
     root2(Number f);
 
     // Thread local rounding control.  Default is to_nearest
-    enum rounding_mode { to_nearest, towards_zero, downward, upward };
+    enum class rounding_mode { to_nearest, towards_zero, downward, upward };
     static rounding_mode
     getround();
     // Returns previously set mode
@@ -443,14 +443,14 @@ private:
     static thread_local rounding_mode mode_;
     // The available ranges for mantissa
 
-    constexpr static MantissaRange smallRange{MantissaRange::small};
+    constexpr static MantissaRange smallRange{MantissaRange::mantissa_scale::small};
     static_assert(isPowerOfTen(smallRange.min));
     static_assert(smallRange.min == 1'000'000'000'000'000LL);
     static_assert(smallRange.max == 9'999'999'999'999'999LL);
     static_assert(smallRange.log == 15);
     static_assert(smallRange.min < maxRep);
     static_assert(smallRange.max < maxRep);
-    constexpr static MantissaRange largeRange{MantissaRange::large};
+    constexpr static MantissaRange largeRange{MantissaRange::mantissa_scale::large};
     static_assert(isPowerOfTen(largeRange.min));
     static_assert(largeRange.min == 1'000'000'000'000'000'000ULL);
     static_assert(largeRange.max == internalrep(9'999'999'999'999'999'999ULL));
@@ -759,9 +759,9 @@ to_string(MantissaRange::mantissa_scale const& scale)
 {
     switch (scale)
     {
-        case MantissaRange::small:
+        case MantissaRange::mantissa_scale::small:
             return "small";
-        case MantissaRange::large:
+        case MantissaRange::mantissa_scale::large:
             return "large";
         default:
             throw std::runtime_error("Bad scale");
diff --git a/include/xrpl/basics/SlabAllocator.h b/include/xrpl/basics/SlabAllocator.h
index 39be029b42..ddcc89d2da 100644
--- a/include/xrpl/basics/SlabAllocator.h
+++ b/include/xrpl/basics/SlabAllocator.h
@@ -92,7 +92,7 @@ class SlabAllocator
             std::uint8_t* ret = nullptr;  // NOLINT(misc-const-correctness)
 
             {
-                std::lock_guard const l(m_);
+                std::scoped_lock const l(m_);
 
                 ret = l_;
 
@@ -121,7 +121,7 @@ class SlabAllocator
         {
             XRPL_ASSERT(own(ptr), "xrpl::SlabAllocator::SlabBlock::deallocate : own input");
 
-            std::lock_guard const l(m_);
+            std::scoped_lock const l(m_);
 
             // Use memcpy to avoid unaligned UB
             // (will optimize to equivalent code)
diff --git a/include/xrpl/basics/TaggedCache.h b/include/xrpl/basics/TaggedCache.h
index 8cb0c6bfdf..95703f0633 100644
--- a/include/xrpl/basics/TaggedCache.h
+++ b/include/xrpl/basics/TaggedCache.h
@@ -166,7 +166,7 @@ public:
 
 private:
     SharedPointerType
-    initialFetch(key_type const& key, std::lock_guard<mutex_type> const& l);
+    initialFetch(key_type const& key, std::scoped_lock<mutex_type> const& l);
 
     void
     collect_metrics();
@@ -266,7 +266,7 @@ private:
         typename KeyValueCacheType::map_type& partition,
         SweptPointersVector& stuffToSweep,
         std::atomic<int>& allRemovals,
-        std::lock_guard<std::recursive_mutex> const&);
+        std::scoped_lock<std::recursive_mutex> const&);
 
     [[nodiscard]] std::thread
     sweepHelper(
@@ -275,7 +275,7 @@ private:
         typename KeyOnlyCacheType::map_type& partition,
         SweptPointersVector&,
         std::atomic<int>& allRemovals,
-        std::lock_guard<std::recursive_mutex> const&);
+        std::scoped_lock<std::recursive_mutex> const&);
 
     beast::Journal m_journal;
     clock_type& m_clock;
diff --git a/include/xrpl/basics/TaggedCache.ipp b/include/xrpl/basics/TaggedCache.ipp
index 6879ad435d..67c80b554e 100644
--- a/include/xrpl/basics/TaggedCache.ipp
+++ b/include/xrpl/basics/TaggedCache.ipp
@@ -69,7 +69,7 @@ inline std::size_t
 TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
     size() const
 {
-    std::lock_guard lock(m_mutex);
+    std::scoped_lock lock(m_mutex);
     return m_cache.size();
 }
 
@@ -86,7 +86,7 @@ inline int
 TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
     getCacheSize() const
 {
-    std::lock_guard lock(m_mutex);
+    std::scoped_lock lock(m_mutex);
     return m_cache_count;
 }
 
@@ -103,7 +103,7 @@ inline int
 TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
     getTrackSize() const
 {
-    std::lock_guard lock(m_mutex);
+    std::scoped_lock lock(m_mutex);
     return m_cache.size();
 }
 
@@ -120,7 +120,7 @@ inline float
 TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
     getHitRate()
 {
-    std::lock_guard lock(m_mutex);
+    std::scoped_lock lock(m_mutex);
     auto const total = static_cast<float>(m_hits + m_misses);
     return m_hits * (100.0f / std::max(1.0f, total));
 }
@@ -138,7 +138,7 @@ inline void
 TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
     clear()
 {
-    std::lock_guard lock(m_mutex);
+    std::scoped_lock lock(m_mutex);
     m_cache.clear();
     m_cache_count = 0;
 }
@@ -156,7 +156,7 @@ inline void
 TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
     reset()
 {
-    std::lock_guard lock(m_mutex);
+    std::scoped_lock lock(m_mutex);
     m_cache.clear();
     m_cache_count = 0;
     m_hits = 0;
@@ -177,7 +177,7 @@ inline bool
 TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
     touch_if_exists(KeyComparable const& key)
 {
-    std::lock_guard lock(m_mutex);
+    std::scoped_lock lock(m_mutex);
     auto const iter(m_cache.find(key));
     if (iter == m_cache.end())
     {
@@ -212,7 +212,7 @@ TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash,
 
     auto const start = std::chrono::steady_clock::now();
     {
-        std::lock_guard lock(m_mutex);
+        std::scoped_lock lock(m_mutex);
 
         if (m_target_size == 0 || (static_cast<int>(m_cache.size()) <= m_target_size))
         {
@@ -269,7 +269,7 @@ TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash,
 {
     // Remove from cache, if !valid, remove from map too. Returns true if
     // removed from cache
-    std::lock_guard lock(m_mutex);
+    std::scoped_lock lock(m_mutex);
 
     auto cit = m_cache.find(key);
 
@@ -309,7 +309,7 @@ TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash,
 {
     // Return canonical value, store if needed, refresh in cache
     // Return values: true=we had the data already
-    std::lock_guard lock(m_mutex);
+    std::scoped_lock lock(m_mutex);
 
     auto cit = m_cache.find(key);
 
@@ -423,7 +423,7 @@ inline SharedPointerType
 TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
     fetch(key_type const& key)
 {
-    std::lock_guard<mutex_type> l(m_mutex);
+    std::scoped_lock<mutex_type> l(m_mutex);
     auto ret = initialFetch(key, l);
     if (!ret)
         ++m_misses;
@@ -474,7 +474,7 @@ inline auto
 TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
     insert(key_type const& key) -> std::enable_if_t<IsKeyCache, ReturnType>
 {
-    std::lock_guard lock(m_mutex);
+    std::scoped_lock lock(m_mutex);
     clock_type::time_point const now(m_clock.now());
     auto [it, inserted] = m_cache.emplace(
         std::piecewise_construct, std::forward_as_tuple(key), std::forward_as_tuple(now));
@@ -538,7 +538,7 @@ TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash,
     std::vector<key_type> v;
 
     {
-        std::lock_guard lock(m_mutex);
+        std::scoped_lock lock(m_mutex);
         v.reserve(m_cache.size());
         for (auto const& _ : m_cache)
             v.push_back(_.first);
@@ -560,7 +560,7 @@ inline double
 TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
     rate() const
 {
-    std::lock_guard lock(m_mutex);
+    std::scoped_lock lock(m_mutex);
     auto const tot = m_hits + m_misses;
     if (tot == 0)
         return 0;
@@ -582,7 +582,7 @@ TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash,
     fetch(key_type const& digest, Handler const& h)
 {
     {
-        std::lock_guard l(m_mutex);
+        std::scoped_lock l(m_mutex);
         if (auto ret = initialFetch(digest, l))
             return ret;
     }
@@ -591,7 +591,7 @@ TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash,
     if (!sle)
         return {};
 
-    std::lock_guard l(m_mutex);
+    std::scoped_lock l(m_mutex);
     ++m_misses;
     auto const [it, inserted] = m_cache.emplace(digest, Entry(m_clock.now(), std::move(sle)));
     if (!inserted)
@@ -611,7 +611,7 @@ template <
     class Mutex>
 inline SharedPointerType
 TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
-    initialFetch(key_type const& key, std::lock_guard<mutex_type> const& l)
+    initialFetch(key_type const& key, std::scoped_lock<mutex_type> const& l)
 {
     auto cit = m_cache.find(key);
     if (cit == m_cache.end())
@@ -655,7 +655,7 @@ TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash,
     {
         beast::insight::Gauge::value_type hit_rate(0);
         {
-            std::lock_guard lock(m_mutex);
+            std::scoped_lock lock(m_mutex);
             auto const total(m_hits + m_misses);
             if (total != 0)
                 hit_rate = (m_hits * 100) / total;
@@ -681,7 +681,7 @@ TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash,
         typename KeyValueCacheType::map_type& partition,
         SweptPointersVector& stuffToSweep,
         std::atomic<int>& allRemovals,
-        std::lock_guard<std::recursive_mutex> const&)
+        std::scoped_lock<std::recursive_mutex> const&)
 {
     return std::thread([&, this]() {
         int cacheRemovals = 0;
@@ -761,7 +761,7 @@ TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash,
         typename KeyOnlyCacheType::map_type& partition,
         SweptPointersVector&,
         std::atomic<int>& allRemovals,
-        std::lock_guard<std::recursive_mutex> const&)
+        std::scoped_lock<std::recursive_mutex> const&)
 {
     return std::thread([&, this]() {
         int cacheRemovals = 0;
diff --git a/include/xrpl/basics/hardened_hash.h b/include/xrpl/basics/hardened_hash.h
index 3ff14c22c8..2722a5a4a7 100644
--- a/include/xrpl/basics/hardened_hash.h
+++ b/include/xrpl/basics/hardened_hash.h
@@ -32,7 +32,7 @@ make_seed_pair() noexcept
         // state_t& operator=(state_t const&) = delete;
     };
     static state_t state;
-    std::lock_guard const lock(state.mutex);
+    std::scoped_lock const lock(state.mutex);
     return {state.dist(state.gen), state.dist(state.gen)};
 }
 
diff --git a/include/xrpl/basics/random.h b/include/xrpl/basics/random.h
index adf579442e..a4018b7e5f 100644
--- a/include/xrpl/basics/random.h
+++ b/include/xrpl/basics/random.h
@@ -60,7 +60,7 @@ default_prng()
     thread_local beast::xor_shift_engine engine = [] {
         std::uint64_t seed = 0;
         {
-            std::lock_guard const lk(m);
+            std::scoped_lock const lk(m);
             std::uniform_int_distribution<std::uint64_t> distribution{1};
             seed = distribution(seeder);
         }
diff --git a/include/xrpl/beast/asio/io_latency_probe.h b/include/xrpl/beast/asio/io_latency_probe.h
index dccb6d24b4..f85f399196 100644
--- a/include/xrpl/beast/asio/io_latency_probe.h
+++ b/include/xrpl/beast/asio/io_latency_probe.h
@@ -83,7 +83,7 @@ public:
     void
     sample_one(Handler&& handler)
     {
-        std::lock_guard const lock(m_mutex);
+        std::scoped_lock const lock(m_mutex);
         if (m_cancel)
             throw std::logic_error("io_latency_probe is canceled");
         boost::asio::post(
@@ -98,7 +98,7 @@ public:
     void
     sample(Handler&& handler)
     {
-        std::lock_guard const lock(m_mutex);
+        std::scoped_lock const lock(m_mutex);
         if (m_cancel)
             throw std::logic_error("io_latency_probe is canceled");
         boost::asio::post(
@@ -122,14 +122,14 @@ private:
     void
     addref()
     {
-        std::lock_guard const lock(m_mutex);
+        std::scoped_lock const lock(m_mutex);
         ++m_count;
     }
 
     void
     release()
     {
-        std::lock_guard const lock(m_mutex);
+        std::scoped_lock const lock(m_mutex);
         if (--m_count == 0)
             m_cond.notify_all();
     }
@@ -192,7 +192,7 @@ private:
             m_handler(elapsed);
 
             {
-                std::lock_guard const lock(m_probe->m_mutex);
+                std::scoped_lock const lock(m_probe->m_mutex);
                 if (m_probe->m_cancel)
                     return;
             }
diff --git a/include/xrpl/beast/test/yield_to.h b/include/xrpl/beast/test/yield_to.h
index 4723fb49b8..6c7f293122 100644
--- a/include/xrpl/beast/test/yield_to.h
+++ b/include/xrpl/beast/test/yield_to.h
@@ -115,7 +115,7 @@ enable_yield_to::spawn(F0&& f, FN&&... fn)
         boost::context::fixedsize_stack(2 * 1024 * 1024),
         [&](yield_context yield) {
             f(yield);
-            std::lock_guard const lock{m_};
+            std::scoped_lock const lock{m_};
             if (--running_ == 0)
                 cv_.notify_all();
         },
diff --git a/include/xrpl/beast/unit_test/match.h b/include/xrpl/beast/unit_test/match.h
index 084e2bc464..dbafd67da5 100644
--- a/include/xrpl/beast/unit_test/match.h
+++ b/include/xrpl/beast/unit_test/match.h
@@ -14,7 +14,7 @@ namespace beast::unit_test {
 class selector
 {
 public:
-    enum mode_t {
+    enum class mode_t {
         // Run all tests except manual ones
         all,
 
@@ -53,8 +53,8 @@ public:
 template <class>
 selector::selector(mode_t mode, std::string const& pattern) : mode_(mode), pat_(pattern)
 {
-    if (mode_ == automatch && pattern.empty())
-        mode_ = all;
+    if (mode_ == mode_t::automatch && pattern.empty())
+        mode_ = mode_t::all;
 }
 
 template <class>
@@ -63,18 +63,18 @@ selector::operator()(suite_info const& s)
 {
     switch (mode_)
     {
-        case automatch:
+        case mode_t::automatch:
             // suite or full name
             if (s.name() == pat_ || s.full_name() == pat_)
             {
-                mode_ = none;
+                mode_ = mode_t::none;
                 return true;
             }
 
             // check module
             if (pat_ == s.module())
             {
-                mode_ = module;
+                mode_ = mode_t::module;
                 library_ = s.library();
                 return !s.manual();
             }
@@ -82,7 +82,7 @@ selector::operator()(suite_info const& s)
             // check library
             if (pat_ == s.library())
             {
-                mode_ = library;
+                mode_ = mode_t::library;
                 return !s.manual();
             }
 
@@ -96,19 +96,19 @@ selector::operator()(suite_info const& s)
 
             return false;
 
-        case suite:
+        case mode_t::suite:
             return pat_ == s.name();
 
-        case module:
+        case mode_t::module:
             return pat_ == s.module() && !s.manual();
 
-        case library:
+        case mode_t::library:
             return pat_ == s.library() && !s.manual();
 
-        case none:
+        case mode_t::none:
             return false;
 
-        case all:
+        case mode_t::all:
         default:
             break;
     };
@@ -138,28 +138,28 @@ selector::operator()(suite_info const& s)
 inline selector
 match_auto(std::string const& name)
 {
-    return selector(selector::automatch, name);
+    return selector(selector::mode_t::automatch, name);
 }
 
 /** Return a predicate that matches all suites not marked manual. */
 inline selector
 match_all()
 {
-    return selector(selector::all);
+    return selector(selector::mode_t::all);
 }
 
 /** Returns a predicate that matches a specific suite. */
 inline selector
 match_suite(std::string const& name)
 {
-    return selector(selector::suite, name);
+    return selector(selector::mode_t::suite, name);
 }
 
 /** Returns a predicate that matches all suites in a library. */
 inline selector
 match_library(std::string const& name)
 {
-    return selector(selector::library, name);
+    return selector(selector::mode_t::library, name);
 }
 
 }  // namespace beast::unit_test
diff --git a/include/xrpl/beast/unit_test/reporter.h b/include/xrpl/beast/unit_test/reporter.h
index 066d628ea2..58bea93b2f 100644
--- a/include/xrpl/beast/unit_test/reporter.h
+++ b/include/xrpl/beast/unit_test/reporter.h
@@ -62,6 +62,8 @@ private:
     {
         using run_time = std::pair<std::string, typename clock_type::duration>;
 
+        // Need to be named before converting
+        // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
         enum { max_top = 10 };
 
         std::size_t suites = 0;
diff --git a/include/xrpl/beast/unit_test/runner.h b/include/xrpl/beast/unit_test/runner.h
index 2fdfbefa57..5601a8725f 100644
--- a/include/xrpl/beast/unit_test/runner.h
+++ b/include/xrpl/beast/unit_test/runner.h
@@ -231,7 +231,7 @@ template <class>
 void
 runner::testcase(std::string const& name)
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     // Name may not be empty
     BOOST_ASSERT(default_ || !name.empty());
     // Forgot to call pass or fail
@@ -247,7 +247,7 @@ template <class>
 void
 runner::pass()
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     if (default_)
         testcase("");
     on_pass();
@@ -258,7 +258,7 @@ template <class>
 void
 runner::fail(std::string const& reason)
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     if (default_)
         testcase("");
     on_fail(reason);
@@ -270,7 +270,7 @@ template <class>
 void
 runner::log(std::string const& s)
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     if (default_)
         testcase("");
     on_log(s);
diff --git a/include/xrpl/beast/unit_test/suite.h b/include/xrpl/beast/unit_test/suite.h
index a7b9d3bacb..c6967ecfe3 100644
--- a/include/xrpl/beast/unit_test/suite.h
+++ b/include/xrpl/beast/unit_test/suite.h
@@ -37,7 +37,7 @@ make_reason(String const& reason, char const* file, int line)
 
 class Thread;
 
-enum abort_t { no_abort_on_fail, abort_on_fail };
+enum class abort_t { no_abort_on_fail, abort_on_fail };
 
 /** A testsuite class.
 
@@ -127,7 +127,7 @@ private:
             @param abort Determines if suite continues running after a failure.
         */
         void
-        operator()(std::string const& name, abort_t abort = no_abort_on_fail);
+        operator()(std::string const& name, abort_t abort = abort_t::no_abort_on_fail);
 
         scoped_testcase
         operator()(abort_t abort);
@@ -363,14 +363,14 @@ public:
 inline void
 suite::testcase_t::operator()(std::string const& name, abort_t abort)
 {
-    suite_.abort_ = abort == abort_on_fail;
+    suite_.abort_ = abort == abort_t::abort_on_fail;
     suite_.runner_->testcase(name);
 }
 
 inline suite::scoped_testcase
 suite::testcase_t::operator()(abort_t abort)
 {
-    suite_.abort_ = abort == abort_on_fail;
+    suite_.abort_ = abort == abort_t::abort_on_fail;
     return {suite_, ss_};
 }
 
diff --git a/include/xrpl/beast/utility/Journal.h b/include/xrpl/beast/utility/Journal.h
index a056ce8d79..45b7b671cb 100644
--- a/include/xrpl/beast/utility/Journal.h
+++ b/include/xrpl/beast/utility/Journal.h
@@ -9,6 +9,8 @@ namespace beast {
 /** A namespace for easy access to logging severity values. */
 namespace severities {
 /** Severity level / threshold of a Journal message. */
+// Hundreds of usages via logging macros
+// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
 enum Severity {
     kAll = 0,
 
diff --git a/include/xrpl/core/ClosureCounter.h b/include/xrpl/core/ClosureCounter.h
index bcdfa7d673..76e52cb3cd 100644
--- a/include/xrpl/core/ClosureCounter.h
+++ b/include/xrpl/core/ClosureCounter.h
@@ -56,7 +56,7 @@ private:
         // a lock.  This removes a small timing window that occurs if the
         // waiting thread is handling a spurious wakeup when closureCount_
         // drops to zero.
-        std::lock_guard const lock{mutex_};
+        std::scoped_lock const lock{mutex_};
 
         // Update closureCount_.  Notify if stopping and closureCount_ == 0.
         if ((--closureCount_ == 0) && waitForClosures_)
@@ -170,7 +170,7 @@ public:
     {
         std::optional<Substitute<Closure>> ret;
 
-        std::lock_guard const lock{mutex_};
+        std::scoped_lock const lock{mutex_};
         if (!waitForClosures_)
             ret.emplace(*this, std::forward<Closure>(closure));
 
@@ -193,7 +193,7 @@ public:
     bool
     joined() const
     {
-        std::lock_guard const lock{mutex_};
+        std::scoped_lock const lock{mutex_};
         return waitForClosures_;
     }
 };
diff --git a/include/xrpl/core/Coro.ipp b/include/xrpl/core/Coro.ipp
index 38d921a658..2343f805a5 100644
--- a/include/xrpl/core/Coro.ipp
+++ b/include/xrpl/core/Coro.ipp
@@ -34,7 +34,7 @@ inline void
 JobQueue::Coro::yield() const
 {
     {
-        std::lock_guard lock(jq_.m_mutex);
+        std::scoped_lock lock(jq_.m_mutex);
         ++jq_.nSuspend_;
     }
     (*yield_)();
@@ -44,7 +44,7 @@ inline bool
 JobQueue::Coro::post()
 {
     {
-        std::lock_guard lk(mutex_run_);
+        std::scoped_lock lk(mutex_run_);
         running_ = true;
     }
 
@@ -55,7 +55,7 @@ JobQueue::Coro::post()
     }
 
     // The coroutine will not run.  Clean up running_.
-    std::lock_guard lk(mutex_run_);
+    std::scoped_lock lk(mutex_run_);
     running_ = false;
     cv_.notify_all();
     return false;
@@ -65,16 +65,16 @@ inline void
 JobQueue::Coro::resume()
 {
     {
-        std::lock_guard lk(mutex_run_);
+        std::scoped_lock lk(mutex_run_);
         running_ = true;
     }
     {
-        std::lock_guard lk(jq_.m_mutex);
+        std::scoped_lock lk(jq_.m_mutex);
         --jq_.nSuspend_;
     }
     auto saved = detail::getLocalValues().release();
     detail::getLocalValues().reset(&lvs_);
-    std::lock_guard lock(mutex_);
+    std::scoped_lock lock(mutex_);
     // A late resume() can arrive after the coroutine has already completed.
     // This is an expected (if rare) outcome of the race condition documented
     // in JobQueue.h:354-377 where post() schedules a resume job before the
@@ -89,7 +89,7 @@ JobQueue::Coro::resume()
     }
     detail::getLocalValues().release();
     detail::getLocalValues().reset(saved);
-    std::lock_guard lk(mutex_run_);
+    std::scoped_lock lk(mutex_run_);
     running_ = false;
     cv_.notify_all();
 }
@@ -113,7 +113,7 @@ JobQueue::Coro::expectEarlyExit()
         //
         // That said, since we're outside the Coro's stack, we need to
         // decrement the nSuspend that the Coro's call to yield caused.
-        std::lock_guard lock(jq_.m_mutex);
+        std::scoped_lock lock(jq_.m_mutex);
         --jq_.nSuspend_;
 #ifndef NDEBUG
         finished_ = true;
diff --git a/include/xrpl/core/Job.h b/include/xrpl/core/Job.h
index 9954fc4ba4..2fe5ab263c 100644
--- a/include/xrpl/core/Job.h
+++ b/include/xrpl/core/Job.h
@@ -11,6 +11,8 @@ namespace xrpl {
 // Note that this queue should only be used for CPU-bound jobs
 // It is primarily intended for signature checking
 
+// Protocol-wide
+// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
 enum JobType {
     // Special type indicating an invalid job - will go away soon.
     jtINVALID = -1,
diff --git a/include/xrpl/core/PeerReservationTable.h b/include/xrpl/core/PeerReservationTable.h
index 0d107e879c..80ad7196c3 100644
--- a/include/xrpl/core/PeerReservationTable.h
+++ b/include/xrpl/core/PeerReservationTable.h
@@ -67,7 +67,7 @@ public:
     bool
     contains(PublicKey const& nodeId)
     {
-        std::lock_guard const lock(this->mutex_);
+        std::scoped_lock const lock(this->mutex_);
         return table_.contains({.nodeId = nodeId, .description = {}});
     }
 
diff --git a/include/xrpl/core/detail/semaphore.h b/include/xrpl/core/detail/semaphore.h
index b3bee00588..38b7329ab1 100644
--- a/include/xrpl/core/detail/semaphore.h
+++ b/include/xrpl/core/detail/semaphore.h
@@ -55,7 +55,7 @@ public:
     void
     notify()
     {
-        std::lock_guard const lock{m_mutex};
+        std::scoped_lock const lock{m_mutex};
         ++m_count;
         m_cond.notify_one();
     }
@@ -76,7 +76,7 @@ public:
     bool
     try_wait()
     {
-        std::lock_guard lock{m_mutex};
+        std::scoped_lock lock{m_mutex};
         if (m_count == 0)
             return false;
         --m_count;
diff --git a/include/xrpl/json/Writer.h b/include/xrpl/json/Writer.h
index e348e57825..34c4e8458a 100644
--- a/include/xrpl/json/Writer.h
+++ b/include/xrpl/json/Writer.h
@@ -107,7 +107,7 @@ namespace Json {
 class Writer
 {
 public:
-    enum CollectionType { array, object };
+    enum class CollectionType { array, object };
 
     explicit Writer(Output const& output);
     Writer(Writer&&) noexcept;
diff --git a/include/xrpl/json/json_reader.h b/include/xrpl/json/json_reader.h
index d53569fb33..543f0cfb9c 100644
--- a/include/xrpl/json/json_reader.h
+++ b/include/xrpl/json/json_reader.h
@@ -70,6 +70,8 @@ public:
     static constexpr unsigned nest_limit{25};
 
 private:
+    // 53 files, protocol-wide
+    // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
     enum TokenType {
         tokenEndOfStream = 0,
         tokenObjectBegin,
diff --git a/include/xrpl/json/json_value.h b/include/xrpl/json/json_value.h
index 83b5142b27..def2696c5c 100644
--- a/include/xrpl/json/json_value.h
+++ b/include/xrpl/json/json_value.h
@@ -15,6 +15,8 @@ namespace Json {
 
 /** \brief Type of the value held by a Value object.
  */
+// Used throughout JSON layer
+// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
 enum ValueType {
     nullValue = 0,  ///< 'null' value
     intValue,       ///< signed integer value
@@ -147,6 +149,8 @@ private:
     class CZString
     {
     public:
+        // Stored as int field, implicit conversion
+        // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
         enum DuplicationPolicy { noDuplication = 0, duplicate, duplicateOnCopy };
         CZString(int index);
         CZString(char const* cstr, DuplicationPolicy allocate);
@@ -471,6 +475,8 @@ operator>=(Value const& x, Value const& y)
 class ValueAllocator
 {
 public:
+    // Need to be named before converting
+    // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
     enum { unknown = (unsigned)-1 };
 
     virtual ~ValueAllocator() = default;
diff --git a/include/xrpl/ledger/ApplyView.h b/include/xrpl/ledger/ApplyView.h
index bd38b57a58..0aea9813b9 100644
--- a/include/xrpl/ledger/ApplyView.h
+++ b/include/xrpl/ledger/ApplyView.h
@@ -7,6 +7,8 @@
 
 namespace xrpl {
 
+// Bitwise flag enum with existing operator overloads
+// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
 enum ApplyFlags : std::uint32_t {
     tapNONE = 0x00,
 
diff --git a/include/xrpl/ledger/PendingSaves.h b/include/xrpl/ledger/PendingSaves.h
index ff70d48bb9..a18292df68 100644
--- a/include/xrpl/ledger/PendingSaves.h
+++ b/include/xrpl/ledger/PendingSaves.h
@@ -31,7 +31,7 @@ public:
     bool
     startWork(LedgerIndex seq)
     {
-        std::lock_guard const lock(mutex_);
+        std::scoped_lock const lock(mutex_);
 
         auto it = map_.find(seq);
 
@@ -54,7 +54,7 @@ public:
     void
     finishWork(LedgerIndex seq)
     {
-        std::lock_guard const lock(mutex_);
+        std::scoped_lock const lock(mutex_);
 
         map_.erase(seq);
         await_.notify_all();
@@ -64,7 +64,7 @@ public:
     bool
     pending(LedgerIndex seq)
     {
-        std::lock_guard const lock(mutex_);
+        std::scoped_lock const lock(mutex_);
         return map_.contains(seq);
     }
 
@@ -117,7 +117,7 @@ public:
     std::map<LedgerIndex, bool>
     getSnapshot() const
     {
-        std::lock_guard const lock(mutex_);
+        std::scoped_lock const lock(mutex_);
 
         return map_;
     }
diff --git a/include/xrpl/ledger/helpers/AMMHelpers.h b/include/xrpl/ledger/helpers/AMMHelpers.h
index d261f9e018..9258d58fb6 100644
--- a/include/xrpl/ledger/helpers/AMMHelpers.h
+++ b/include/xrpl/ledger/helpers/AMMHelpers.h
@@ -28,7 +28,7 @@ reduceOffer(auto const& amount)
     static Number const reducedOfferPct(9999, -4);
 
     // Make sure the result is always less than amount or zero.
-    NumberRoundModeGuard const mg(Number::towards_zero);
+    NumberRoundModeGuard const mg(Number::rounding_mode::towards_zero);
     return amount * reducedOfferPct;
 }
 
@@ -180,7 +180,7 @@ getAMMOfferStartWithTakerGets(
     if (targetQuality.rate() == beast::zero)
         return std::nullopt;
 
-    NumberRoundModeGuard const mg(Number::to_nearest);
+    NumberRoundModeGuard const mg(Number::rounding_mode::to_nearest);
     auto const f = feeMult(tfee);
     auto const a = 1;
     auto const b = pool.in * (1 - 1 / f) / targetQuality.rate() - 2 * pool.out;
@@ -202,7 +202,7 @@ getAMMOfferStartWithTakerGets(
         // Round downward to minimize the offer and to maximize the quality.
         // This has the most impact when takerGets is XRP.
         auto const takerGets =
-            toAmount<TOut>(getAsset(pool.out), nTakerGetsProposed, Number::downward);
+            toAmount<TOut>(getAsset(pool.out), nTakerGetsProposed, Number::rounding_mode::downward);
         return TAmounts<TIn, TOut>{swapAssetOut(pool, takerGets, tfee), takerGets};
     };
 
@@ -247,7 +247,7 @@ getAMMOfferStartWithTakerPays(
     if (targetQuality.rate() == beast::zero)
         return std::nullopt;
 
-    NumberRoundModeGuard const mg(Number::to_nearest);
+    NumberRoundModeGuard const mg(Number::rounding_mode::to_nearest);
     auto const f = feeMult(tfee);
     auto const& a = f;
     auto const b = pool.in * (1 + f);
@@ -269,7 +269,7 @@ getAMMOfferStartWithTakerPays(
         // Round downward to minimize the offer and to maximize the quality.
         // This has the most impact when takerPays is XRP.
         auto const takerPays =
-            toAmount<TIn>(getAsset(pool.in), nTakerPaysProposed, Number::downward);
+            toAmount<TIn>(getAsset(pool.in), nTakerPaysProposed, Number::rounding_mode::downward);
         return TAmounts<TIn, TOut>{takerPays, swapAssetIn(pool, takerPays, tfee)};
     };
 
@@ -341,7 +341,8 @@ changeSpotPriceQuality(
                                 << " " << to_string(pool.out) << " " << quality << " " << tfee;
                 return std::nullopt;
             }
-            auto const takerPays = toAmount<TIn>(getAsset(pool.in), nTakerPays, Number::upward);
+            auto const takerPays =
+                toAmount<TIn>(getAsset(pool.in), nTakerPays, Number::rounding_mode::upward);
             // should not fail
             if (auto amounts = TAmounts<TIn, TOut>{takerPays, swapAssetIn(pool, takerPays, tfee)};
                 Quality{amounts} < quality &&
@@ -447,32 +448,32 @@ swapAssetIn(TAmounts<TIn, TOut> const& pool, TIn const& assetIn, std::uint16_t t
         // fee
         saveNumberRoundMode const _{Number::getround()};
 
-        Number::setround(Number::upward);
+        Number::setround(Number::rounding_mode::upward);
         auto const numerator = pool.in * pool.out;
         auto const fee = getFee(tfee);
 
-        Number::setround(Number::downward);
+        Number::setround(Number::rounding_mode::downward);
         auto const denom = pool.in + assetIn * (1 - fee);
 
         if (denom.signum() <= 0)
             return toAmount<TOut>(getAsset(pool.out), 0);
 
-        Number::setround(Number::upward);
+        Number::setround(Number::rounding_mode::upward);
         auto const ratio = numerator / denom;
 
-        Number::setround(Number::downward);
+        Number::setround(Number::rounding_mode::downward);
         auto const swapOut = pool.out - ratio;
 
         if (swapOut.signum() < 0)
             return toAmount<TOut>(getAsset(pool.out), 0);
 
-        return toAmount<TOut>(getAsset(pool.out), swapOut, Number::downward);
+        return toAmount<TOut>(getAsset(pool.out), swapOut, Number::rounding_mode::downward);
     }
 
     return toAmount<TOut>(
         getAsset(pool.out),
         pool.out - (pool.in * pool.out) / (pool.in + assetIn * feeMult(tfee)),
-        Number::downward);
+        Number::rounding_mode::downward);
 }
 
 /** Swap assetOut out of the pool and swap in a proportional amount
@@ -509,36 +510,36 @@ swapAssetOut(TAmounts<TIn, TOut> const& pool, TOut const& assetOut, std::uint16_
 
         saveNumberRoundMode const _{Number::getround()};
 
-        Number::setround(Number::upward);
+        Number::setround(Number::rounding_mode::upward);
         auto const numerator = pool.in * pool.out;
 
-        Number::setround(Number::downward);
+        Number::setround(Number::rounding_mode::downward);
         auto const denom = pool.out - assetOut;
         if (denom.signum() <= 0)
         {
             return toMaxAmount<TIn>(getAsset(pool.in));
         }
 
-        Number::setround(Number::upward);
+        Number::setround(Number::rounding_mode::upward);
         auto const ratio = numerator / denom;
         auto const numerator2 = ratio - pool.in;
         auto const fee = getFee(tfee);
 
-        Number::setround(Number::downward);
+        Number::setround(Number::rounding_mode::downward);
         auto const feeMult = 1 - fee;
 
-        Number::setround(Number::upward);
+        Number::setround(Number::rounding_mode::upward);
         auto const swapIn = numerator2 / feeMult;
         if (swapIn.signum() < 0)
             return toAmount<TIn>(getAsset(pool.in), 0);
 
-        return toAmount<TIn>(getAsset(pool.in), swapIn, Number::upward);
+        return toAmount<TIn>(getAsset(pool.in), swapIn, Number::rounding_mode::upward);
     }
 
     return toAmount<TIn>(
         getAsset(pool.in),
         ((pool.in * pool.out) / (pool.out - assetOut) - pool.in) / feeMult(tfee),
-        Number::upward);
+        Number::rounding_mode::upward);
 }
 
 /** Return square of n.
@@ -597,7 +598,8 @@ getLPTokenRounding(IsDeposit isDeposit)
 {
     // Minimize on deposit, maximize on withdraw to ensure
     // AMM invariant sqrt(poolAsset1 * poolAsset2) >= LPTokensBalance
-    return isDeposit == IsDeposit::Yes ? Number::downward : Number::upward;
+    return isDeposit == IsDeposit::Yes ? Number::rounding_mode::downward
+                                       : Number::rounding_mode::upward;
 }
 
 inline Number::rounding_mode
@@ -605,7 +607,8 @@ getAssetRounding(IsDeposit isDeposit)
 {
     // Maximize on deposit, minimize on withdraw to ensure
     // AMM invariant sqrt(poolAsset1 * poolAsset2) >= LPTokensBalance
-    return isDeposit == IsDeposit::Yes ? Number::upward : Number::downward;
+    return isDeposit == IsDeposit::Yes ? Number::rounding_mode::upward
+                                       : Number::rounding_mode::downward;
 }
 
 }  // namespace detail
diff --git a/include/xrpl/ledger/helpers/LendingHelpers.h b/include/xrpl/ledger/helpers/LendingHelpers.h
index 23b87de654..e1d8626b7c 100644
--- a/include/xrpl/ledger/helpers/LendingHelpers.h
+++ b/include/xrpl/ledger/helpers/LendingHelpers.h
@@ -19,7 +19,7 @@ loanPeriodicRate(TenthBips32 interestRate, std::uint32_t paymentInterval);
 inline Number
 roundPeriodicPayment(Asset const& asset, Number const& periodicPayment, std::int32_t scale)
 {
-    return roundToAsset(asset, periodicPayment, scale, Number::upward);
+    return roundToAsset(asset, periodicPayment, scale, Number::rounding_mode::upward);
 }
 
 /* Represents the breakdown of amounts to be paid and changes applied to the
diff --git a/include/xrpl/ledger/helpers/TokenHelpers.h b/include/xrpl/ledger/helpers/TokenHelpers.h
index c05308295a..8f83465da3 100644
--- a/include/xrpl/ledger/helpers/TokenHelpers.h
+++ b/include/xrpl/ledger/helpers/TokenHelpers.h
@@ -21,13 +21,13 @@ namespace xrpl {
 //------------------------------------------------------------------------------
 
 /** Controls the treatment of frozen account balances */
-enum FreezeHandling { fhIGNORE_FREEZE, fhZERO_IF_FROZEN };
+enum class FreezeHandling { fhIGNORE_FREEZE, fhZERO_IF_FROZEN };
 
 /** Controls the treatment of unauthorized MPT balances */
-enum AuthHandling { ahIGNORE_AUTH, ahZERO_IF_UNAUTHORIZED };
+enum class AuthHandling { ahIGNORE_AUTH, ahZERO_IF_UNAUTHORIZED };
 
 /** Controls whether to include the account's full spendable balance */
-enum SpendableHandling { shSIMPLE_BALANCE, shFULL_BALANCE };
+enum class SpendableHandling { shSIMPLE_BALANCE, shFULL_BALANCE };
 
 enum class WaiveTransferFee : bool { No = false, Yes };
 
@@ -135,7 +135,7 @@ accountHolds(
     AccountID const& issuer,
     FreezeHandling zeroIfFrozen,
     beast::Journal j,
-    SpendableHandling includeFullBalance = shSIMPLE_BALANCE);
+    SpendableHandling includeFullBalance = SpendableHandling::shSIMPLE_BALANCE);
 
 [[nodiscard]] STAmount
 accountHolds(
@@ -144,7 +144,7 @@ accountHolds(
     Issue const& issue,
     FreezeHandling zeroIfFrozen,
     beast::Journal j,
-    SpendableHandling includeFullBalance = shSIMPLE_BALANCE);
+    SpendableHandling includeFullBalance = SpendableHandling::shSIMPLE_BALANCE);
 
 [[nodiscard]] STAmount
 accountHolds(
@@ -154,7 +154,7 @@ accountHolds(
     FreezeHandling zeroIfFrozen,
     AuthHandling zeroIfUnauthorized,
     beast::Journal j,
-    SpendableHandling includeFullBalance = shSIMPLE_BALANCE);
+    SpendableHandling includeFullBalance = SpendableHandling::shSIMPLE_BALANCE);
 
 [[nodiscard]] STAmount
 accountHolds(
@@ -164,7 +164,7 @@ accountHolds(
     FreezeHandling zeroIfFrozen,
     AuthHandling zeroIfUnauthorized,
     beast::Journal j,
-    SpendableHandling includeFullBalance = shSIMPLE_BALANCE);
+    SpendableHandling includeFullBalance = SpendableHandling::shSIMPLE_BALANCE);
 
 // Returns the amount an account can spend of the currency type saDefault, or
 // returns saDefault if this account is the issuer of the currency in
diff --git a/include/xrpl/nodestore/NodeObject.h b/include/xrpl/nodestore/NodeObject.h
index 6397ea2e4e..8759f244d2 100644
--- a/include/xrpl/nodestore/NodeObject.h
+++ b/include/xrpl/nodestore/NodeObject.h
@@ -9,7 +9,7 @@
 namespace xrpl {
 
 /** The types of node objects. */
-enum NodeObjectType : std::uint32_t {
+enum class NodeObjectType : std::uint32_t {
     hotUNKNOWN = 0,
     hotLEDGER = 1,
     hotACCOUNT_NODE = 3,
diff --git a/include/xrpl/nodestore/Types.h b/include/xrpl/nodestore/Types.h
index 851cbcfb8b..cc7d345067 100644
--- a/include/xrpl/nodestore/Types.h
+++ b/include/xrpl/nodestore/Types.h
@@ -6,6 +6,8 @@
 
 namespace xrpl::NodeStore {
 
+// Need to be named before converting
+// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
 enum {
     // This is only used to pre-allocate the array for
     // batch objects and does not affect the amount written.
@@ -20,7 +22,7 @@ enum {
 };
 
 /** Return codes from Backend operations. */
-enum Status {
+enum class Status {
     ok = 0,
     notFound = 1,
     dataCorrupt = 2,
diff --git a/include/xrpl/nodestore/detail/codec.h b/include/xrpl/nodestore/detail/codec.h
index c159558f83..e127062b80 100644
--- a/include/xrpl/nodestore/detail/codec.h
+++ b/include/xrpl/nodestore/detail/codec.h
@@ -127,7 +127,7 @@ nodeobject_decompress(void const* in, std::size_t in_size, BufferFactory&& bf)
             ostream os(out, result.second);
             write<std::uint32_t>(os, 0);
             write<std::uint32_t>(os, 0);
-            write<std::uint8_t>(os, hotUNKNOWN);
+            write<std::uint8_t>(os, static_cast<std::uint8_t>(NodeObjectType::hotUNKNOWN));
             write<std::uint32_t>(os, static_cast<std::uint32_t>(HashPrefix::innerNode));
             if (mask == 0)
                 Throw<std::runtime_error>("nodeobject codec v1: empty inner node");
@@ -173,7 +173,7 @@ nodeobject_decompress(void const* in, std::size_t in_size, BufferFactory&& bf)
             ostream os(out, result.second);
             write<std::uint32_t>(os, 0);
             write<std::uint32_t>(os, 0);
-            write<std::uint8_t>(os, hotUNKNOWN);
+            write<std::uint8_t>(os, static_cast<std::uint8_t>(NodeObjectType::hotUNKNOWN));
             write<std::uint32_t>(os, static_cast<std::uint32_t>(HashPrefix::innerNode));
             write(os, is(512), 512);
             break;
@@ -307,7 +307,7 @@ filter_inner(void* in, std::size_t in_size)
             ostream os(in, 9);
             write<std::uint32_t>(os, 0);
             write<std::uint32_t>(os, 0);
-            write<std::uint8_t>(os, hotUNKNOWN);
+            write<std::uint8_t>(os, static_cast<std::uint8_t>(NodeObjectType::hotUNKNOWN));
         }
     }
 }
diff --git a/include/xrpl/protocol/ErrorCodes.h b/include/xrpl/protocol/ErrorCodes.h
index 2f16415bdf..ed7f898312 100644
--- a/include/xrpl/protocol/ErrorCodes.h
+++ b/include/xrpl/protocol/ErrorCodes.h
@@ -17,6 +17,8 @@ namespace xrpl {
 //
 // Please only append to this table. Do not "fill-in" gaps and do not re-use
 // or repurpose error code values.
+// Protocol-wide, 50+ files
+// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
 enum error_code_i {
     // -1 represents codes not listed in this enumeration
     rpcUNKNOWN = -1,
@@ -148,6 +150,8 @@ enum error_code_i {
 
     These values need to remain stable.
 */
+// Protocol-wide, 50+ files
+// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
 enum warning_code_i {
     warnRPC_UNSUPPORTED_MAJORITY = 1001,
     warnRPC_AMENDMENT_BLOCKED = 1002,
diff --git a/include/xrpl/protocol/LedgerFormats.h b/include/xrpl/protocol/LedgerFormats.h
index 009a96533a..77ef9fcf1d 100644
--- a/include/xrpl/protocol/LedgerFormats.h
+++ b/include/xrpl/protocol/LedgerFormats.h
@@ -29,6 +29,8 @@ namespace xrpl {
 
     @ingroup protocol
 */
+// Protocol-critical, hundreds of usages
+// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
 enum LedgerEntryType : std::uint16_t {
 
 #pragma push_macro("LEDGER_ENTRY")
@@ -214,6 +216,8 @@ enum LedgerEntryType : std::uint16_t {
 #define TO_VALUE(name, value) name = (value),
 #define NULL_NAME(name, values) values
 #define NULL_OUTPUT(name, value)
+// Bitwise flag enum
+// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
 enum LedgerSpecificFlags : std::uint32_t { XMACRO(NULL_NAME, TO_VALUE, NULL_OUTPUT) };
 
 // Create getter functions for each set of flags using Meyer's singleton pattern.
diff --git a/include/xrpl/protocol/MultiApiJson.h b/include/xrpl/protocol/MultiApiJson.h
index 6a86aa35b8..6b0c799a56 100644
--- a/include/xrpl/protocol/MultiApiJson.h
+++ b/include/xrpl/protocol/MultiApiJson.h
@@ -66,8 +66,7 @@ struct MultiApiJson
             a[key] = v;
     }
 
-    // Intentionally not using class enum here, MultivarJson is scope enough
-    enum IsMemberResult : int { none = 0, some, all };
+    enum class IsMemberResult : int { none = 0, some, all };
 
     [[nodiscard]] IsMemberResult
     isMember(char const* key) const
@@ -80,8 +79,8 @@ struct MultiApiJson
         }
 
         if (count == 0)
-            return none;
-        return count < size ? some : all;
+            return IsMemberResult::none;
+        return count < size ? IsMemberResult::some : IsMemberResult::all;
     }
 
     static constexpr struct visitor_t final
diff --git a/include/xrpl/protocol/Permissions.h b/include/xrpl/protocol/Permissions.h
index 4d26ba7cf8..3ce8918a16 100644
--- a/include/xrpl/protocol/Permissions.h
+++ b/include/xrpl/protocol/Permissions.h
@@ -16,6 +16,8 @@ namespace xrpl {
  * conflicts with TxType, the GranularPermissionType is always set to a value
  * greater than the maximum value of uint16.
  */
+// Macro-generated, complex
+// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
 enum GranularPermissionType : std::uint32_t {
 #pragma push_macro("PERMISSION")
 #undef PERMISSION
@@ -28,6 +30,9 @@ enum GranularPermissionType : std::uint32_t {
 #pragma pop_macro("PERMISSION")
 };
 
+// Injected bare enumerators (xrpl::delegable / xrpl::notDelegable) are required by preprocessor
+// tricks in tests and macro-generated code; enum class would break that.
+// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
 enum Delegation { delegable, notDelegable };
 
 class Permission
diff --git a/include/xrpl/protocol/SField.h b/include/xrpl/protocol/SField.h
index 7e42b9ec62..784de5511e 100644
--- a/include/xrpl/protocol/SField.h
+++ b/include/xrpl/protocol/SField.h
@@ -87,6 +87,8 @@ class STCurrency;
 #define TO_ENUM(name, value) name = (value),
 #define TO_MAP(name, value) {#name, value},
 
+// Protocol infrastructure, 39+ files
+// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
 enum SerializedTypeID { XMACRO(TO_ENUM) };
 
 static std::map<std::string, int> const sTypeMap = {XMACRO(TO_MAP)};
@@ -125,6 +127,8 @@ field_code(int id, int index)
 class SField
 {
 public:
+    // Need to be named before converting
+    // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
     enum {
         sMD_Never = 0x00,
         sMD_ChangeOrig = 0x01,     // original value when it changes
diff --git a/include/xrpl/protocol/SOTemplate.h b/include/xrpl/protocol/SOTemplate.h
index ca09fc3d71..3bfe07d049 100644
--- a/include/xrpl/protocol/SOTemplate.h
+++ b/include/xrpl/protocol/SOTemplate.h
@@ -11,6 +11,8 @@
 namespace xrpl {
 
 /** Kind of element in each entry of an SOTemplate. */
+// 2026 usages, 129 files
+// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
 enum SOEStyle {
     soeINVALID = -1,
     soeREQUIRED = 0,  // required
@@ -20,7 +22,8 @@ enum SOEStyle {
                       // constructed with STObject::makeInnerObject()
 };
 
-/** Amount fields that can support MPT */
+// Part of a Python-parsed DSL (transactions.macro); bare enumerator names required by the parser
+// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
 enum SOETxMPTIssue { soeMPTNone, soeMPTSupported, soeMPTNotSupported };
 
 //------------------------------------------------------------------------------
diff --git a/include/xrpl/protocol/STAmount.h b/include/xrpl/protocol/STAmount.h
index 06471df5c9..f681f811b7 100644
--- a/include/xrpl/protocol/STAmount.h
+++ b/include/xrpl/protocol/STAmount.h
@@ -319,7 +319,7 @@ STAmount::STAmount(
     : STBase(name), mAsset(asset), mValue(mantissa), mOffset(exponent), mIsNegative(negative)
 {
     // mValue is uint64, but needs to fit in the range of int64
-    if (Number::getMantissaScale() == MantissaRange::small)
+    if (Number::getMantissaScale() == MantissaRange::mantissa_scale::small)
     {
         XRPL_ASSERT(
             mValue <= std::numeric_limits<std::int64_t>::max(),
diff --git a/include/xrpl/protocol/STBase.h b/include/xrpl/protocol/STBase.h
index 0beefe45f6..7ebf22fe8f 100644
--- a/include/xrpl/protocol/STBase.h
+++ b/include/xrpl/protocol/STBase.h
@@ -18,6 +18,8 @@ struct JsonOptions
     using underlying_t = unsigned int;
     underlying_t value;
 
+    // Bitwise flags with operator~
+    // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
     enum values : underlying_t {
         // clang-format off
         none                        = 0b0000'0000,
diff --git a/include/xrpl/protocol/STObject.h b/include/xrpl/protocol/STObject.h
index d27112e17c..187bde6dae 100644
--- a/include/xrpl/protocol/STObject.h
+++ b/include/xrpl/protocol/STObject.h
@@ -413,9 +413,9 @@ public:
     class FieldErr;
 
 private:
-    enum WhichFields : bool {
+    enum class WhichFields : bool {
         // These values are carefully chosen to do the right thing if passed
-        // to SField::shouldInclude (bool)
+        // to SField::shouldInclude (bool) via static_cast<bool>
         omitSigningFields = false,
         withAllFields = true
     };
@@ -987,7 +987,7 @@ STObject::isFree() const
 inline void
 STObject::addWithoutSigningFields(Serializer& s) const
 {
-    add(s, omitSigningFields);
+    add(s, WhichFields::omitSigningFields);
 }
 
 // VFALCO NOTE does this return an expensive copy of an object with a
@@ -997,7 +997,7 @@ inline Serializer
 STObject::getSerializer() const
 {
     Serializer s;
-    add(s, withAllFields);
+    add(s, WhichFields::withAllFields);
     return s;
 }
 
diff --git a/include/xrpl/protocol/STPathSet.h b/include/xrpl/protocol/STPathSet.h
index 38f4668b5d..ce9a73523c 100644
--- a/include/xrpl/protocol/STPathSet.h
+++ b/include/xrpl/protocol/STPathSet.h
@@ -25,6 +25,8 @@ class STPathElement final : public CountedObject<STPathElement>
     std::size_t hash_value_;
 
 public:
+    // Bitwise values (typeCurrency | typeMPT)
+    // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
     enum Type {
         typeNone = 0x00,
         typeAccount = 0x01,   // Rippling through an account (vs taking an offer).
diff --git a/include/xrpl/protocol/SeqProxy.h b/include/xrpl/protocol/SeqProxy.h
index 86742bacc1..820004681d 100644
--- a/include/xrpl/protocol/SeqProxy.h
+++ b/include/xrpl/protocol/SeqProxy.h
@@ -35,7 +35,7 @@ namespace xrpl {
 class SeqProxy
 {
 public:
-    enum Type : std::uint8_t { seq = 0, ticket };
+    enum class Type : std::uint8_t { seq = 0, ticket };
 
 private:
     std::uint32_t value_;
@@ -67,13 +67,13 @@ public:
     [[nodiscard]] constexpr bool
     isSeq() const
     {
-        return type_ == seq;
+        return type_ == Type::seq;
     }
 
     [[nodiscard]] constexpr bool
     isTicket() const
     {
-        return type_ == ticket;
+        return type_ == Type::ticket;
     }
 
     // Occasionally it is convenient to be able to increase the value_
diff --git a/include/xrpl/protocol/TER.h b/include/xrpl/protocol/TER.h
index efec25962d..6494453b91 100644
--- a/include/xrpl/protocol/TER.h
+++ b/include/xrpl/protocol/TER.h
@@ -19,6 +19,8 @@ using TERUnderlyingType = int;
 
 //------------------------------------------------------------------------------
 
+// Protocol-critical, mixed with custom TER wrapper type, hundreds of usages
+// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
 enum TELcodes : TERUnderlyingType {
     // Note: Range is stable.
     // Exact numbers are used in ripple-binary-codec:
@@ -50,6 +52,8 @@ enum TELcodes : TERUnderlyingType {
 
 //------------------------------------------------------------------------------
 
+// Protocol-critical, mixed with custom TER wrapper type, hundreds of usages
+// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
 enum TEMcodes : TERUnderlyingType {
     // Note: Range is stable.
     // Exact numbers are used in ripple-binary-codec:
@@ -126,6 +130,8 @@ enum TEMcodes : TERUnderlyingType {
 
 //------------------------------------------------------------------------------
 
+// Protocol-critical, mixed with custom TER wrapper type, hundreds of usages
+// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
 enum TEFcodes : TERUnderlyingType {
     // Note: Range is stable.
     // Exact numbers are used in ripple-binary-codec:
@@ -170,6 +176,8 @@ enum TEFcodes : TERUnderlyingType {
 
 //------------------------------------------------------------------------------
 
+// Protocol-critical, mixed with custom TER wrapper type, hundreds of usages
+// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
 enum TERcodes : TERUnderlyingType {
     // Note: Range is stable.
     // Exact numbers are used in ripple-binary-codec:
@@ -214,6 +222,8 @@ enum TERcodes : TERUnderlyingType {
 
 //------------------------------------------------------------------------------
 
+// Protocol-critical, mixed with custom TER wrapper type, hundreds of usages
+// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
 enum TEScodes : TERUnderlyingType {
     // Note: Exact number must stay stable.  This code is stored by value
     // in metadata for historic transactions.
@@ -229,6 +239,8 @@ enum TEScodes : TERUnderlyingType {
 
 //------------------------------------------------------------------------------
 
+// Protocol-critical, mixed with custom TER wrapper type, hundreds of usages
+// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
 enum TECcodes : TERUnderlyingType {
     // Note: Exact numbers must stay stable.  These codes are stored by
     // value in metadata for historic transactions.
diff --git a/include/xrpl/protocol/TxFormats.h b/include/xrpl/protocol/TxFormats.h
index 563a28f39f..235fb7b16e 100644
--- a/include/xrpl/protocol/TxFormats.h
+++ b/include/xrpl/protocol/TxFormats.h
@@ -35,6 +35,8 @@ namespace xrpl {
     @ingroup protocol
 */
 // clang-format off
+// Protocol-critical, hundreds of usages
+// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
 enum TxType : std::uint16_t
 {
 
diff --git a/include/xrpl/resource/Disposition.h b/include/xrpl/resource/Disposition.h
index 22830ad470..59a1c3840a 100644
--- a/include/xrpl/resource/Disposition.h
+++ b/include/xrpl/resource/Disposition.h
@@ -3,7 +3,7 @@
 namespace xrpl::Resource {
 
 /** The disposition of a consumer after applying a load charge. */
-enum Disposition {
+enum class Disposition {
     /** No action required. */
     ok
 
diff --git a/include/xrpl/resource/detail/Entry.h b/include/xrpl/resource/detail/Entry.h
index 89f27b2672..2cbf06d5c3 100644
--- a/include/xrpl/resource/detail/Entry.h
+++ b/include/xrpl/resource/detail/Entry.h
@@ -39,7 +39,7 @@ struct Entry : public beast::List<Entry>::Node
     [[nodiscard]] bool
     isUnlimited() const
     {
-        return key->kind == kindUnlimited;
+        return key->kind == Kind::kindUnlimited;
     }
 
     // Balance including remote contributions
diff --git a/include/xrpl/resource/detail/Kind.h b/include/xrpl/resource/detail/Kind.h
index 74115ba7f1..5cbddce6bb 100644
--- a/include/xrpl/resource/detail/Kind.h
+++ b/include/xrpl/resource/detail/Kind.h
@@ -10,6 +10,6 @@ namespace xrpl::Resource {
  *                subjected to administrative restrictions, such as
  *                use of some RPC commands like "stop".
  */
-enum Kind { kindInbound, kindOutbound, kindUnlimited };
+enum class Kind { kindInbound, kindOutbound, kindUnlimited };
 
 }  // namespace xrpl::Resource
diff --git a/include/xrpl/resource/detail/Logic.h b/include/xrpl/resource/detail/Logic.h
index b775f0a965..3102a1f119 100644
--- a/include/xrpl/resource/detail/Logic.h
+++ b/include/xrpl/resource/detail/Logic.h
@@ -92,11 +92,11 @@ public:
         Entry* entry(nullptr);
 
         {
-            std::lock_guard const _(lock_);
+            std::scoped_lock const _(lock_);
             auto [resultIt, resultInserted] = table_.emplace(
                 std::piecewise_construct,
-                std::make_tuple(kindInbound, address.at_port(0)),  // Key
-                std::make_tuple(m_clock.now()));                   // Entry
+                std::make_tuple(Kind::kindInbound, address.at_port(0)),  // Key
+                std::make_tuple(m_clock.now()));                         // Entry
 
             entry = &resultIt->second;
             entry->key = &resultIt->first;
@@ -122,11 +122,11 @@ public:
         Entry* entry(nullptr);
 
         {
-            std::lock_guard const _(lock_);
+            std::scoped_lock const _(lock_);
             auto [resultIt, resultInserted] = table_.emplace(
                 std::piecewise_construct,
-                std::make_tuple(kindOutbound, address),  // Key
-                std::make_tuple(m_clock.now()));         // Entry
+                std::make_tuple(Kind::kindOutbound, address),  // Key
+                std::make_tuple(m_clock.now()));               // Entry
 
             entry = &resultIt->second;
             entry->key = &resultIt->first;
@@ -155,11 +155,11 @@ public:
         Entry* entry(nullptr);
 
         {
-            std::lock_guard const _(lock_);
+            std::scoped_lock const _(lock_);
             auto [resultIt, resultInserted] = table_.emplace(
                 std::piecewise_construct,
-                std::make_tuple(kindUnlimited, address.at_port(1)),  // Key
-                std::make_tuple(m_clock.now()));                     // Entry
+                std::make_tuple(Kind::kindUnlimited, address.at_port(1)),  // Key
+                std::make_tuple(m_clock.now()));                           // Entry
 
             entry = &resultIt->second;
             entry->key = &resultIt->first;
@@ -190,7 +190,7 @@ public:
         clock_type::time_point const now(m_clock.now());
 
         Json::Value ret(Json::objectValue);
-        std::lock_guard const _(lock_);
+        std::scoped_lock const _(lock_);
 
         for (auto& inboundEntry : inbound_)
         {
@@ -235,7 +235,7 @@ public:
         clock_type::time_point const now(m_clock.now());
 
         Gossip gossip;
-        std::lock_guard const _(lock_);
+        std::scoped_lock const _(lock_);
 
         gossip.items.reserve(inbound_.size());
 
@@ -260,7 +260,7 @@ public:
     {
         auto const elapsed = m_clock.now();
         {
-            std::lock_guard const _(lock_);
+            std::scoped_lock const _(lock_);
             auto [resultIt, resultInserted] = importTable_.emplace(
                 std::piecewise_construct,
                 std::make_tuple(origin),                                     // Key
@@ -317,7 +317,7 @@ public:
     void
     periodicActivity()
     {
-        std::lock_guard const _(lock_);
+        std::scoped_lock const _(lock_);
 
         auto const elapsed = m_clock.now();
 
@@ -375,7 +375,7 @@ public:
     void
     erase(Table::iterator iter)
     {
-        std::lock_guard const _(lock_);
+        std::scoped_lock const _(lock_);
         Entry& entry(iter->second);
         XRPL_ASSERT(entry.refcount == 0, "xrpl::Resource::Logic::erase : entry not used");
         inactive_.erase(inactive_.iterator_to(entry));
@@ -385,27 +385,27 @@ public:
     void
     acquire(Entry& entry)
     {
-        std::lock_guard const _(lock_);
+        std::scoped_lock const _(lock_);
         ++entry.refcount;
     }
 
     void
     release(Entry& entry)
     {
-        std::lock_guard const _(lock_);
+        std::scoped_lock const _(lock_);
         if (--entry.refcount == 0)
         {
             JLOG(m_journal.debug()) << "Inactive " << entry;
 
             switch (entry.key->kind)
             {
-                case kindInbound:
+                case Kind::kindInbound:
                     inbound_.erase(inbound_.iterator_to(entry));
                     break;
-                case kindOutbound:
+                case Kind::kindOutbound:
                     outbound_.erase(outbound_.iterator_to(entry));
                     break;
-                case kindUnlimited:
+                case Kind::kindUnlimited:
                     admin_.erase(admin_.iterator_to(entry));
                     break;
                 default:
@@ -443,7 +443,7 @@ public:
         if (!context.empty())
             context = " (" + context + ")";
 
-        std::lock_guard const _(lock_);
+        std::scoped_lock const _(lock_);
         clock_type::time_point const now(m_clock.now());
         int const balance(entry.add(fee.cost(), now));
         JLOG(getStream(fee.cost(), m_journal)) << "Charging " << entry << " for " << fee << context;
@@ -456,7 +456,7 @@ public:
         if (entry.isUnlimited())
             return false;
 
-        std::lock_guard const _(lock_);
+        std::scoped_lock const _(lock_);
         bool notify(false);
         auto const elapsed = m_clock.now();
         if (entry.balance(m_clock.now()) >= warningThreshold && elapsed != entry.lastWarningTime)
@@ -479,7 +479,7 @@ public:
         if (entry.isUnlimited())
             return false;
 
-        std::lock_guard const _(lock_);
+        std::scoped_lock const _(lock_);
         bool drop(false);
         clock_type::time_point const now(m_clock.now());
         int const balance(entry.balance(now));
@@ -501,7 +501,7 @@ public:
     int
     balance(Entry& entry)
     {
-        std::lock_guard const _(lock_);
+        std::scoped_lock const _(lock_);
         return entry.balance(m_clock.now());
     }
 
@@ -530,7 +530,7 @@ public:
     {
         clock_type::time_point const now(m_clock.now());
 
-        std::lock_guard const _(lock_);
+        std::scoped_lock const _(lock_);
 
         {
             beast::PropertyStream::Set s("inbound", map);
diff --git a/include/xrpl/resource/detail/Tuning.h b/include/xrpl/resource/detail/Tuning.h
index 1c903d8cd4..d5e872d16c 100644
--- a/include/xrpl/resource/detail/Tuning.h
+++ b/include/xrpl/resource/detail/Tuning.h
@@ -5,6 +5,8 @@
 namespace xrpl::Resource {
 
 /** Tunable constants. */
+// Need to be named before converting
+// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
 enum {
     // Balance at which a warning is issued
     warningThreshold = 5000
diff --git a/include/xrpl/server/LoadFeeTrack.h b/include/xrpl/server/LoadFeeTrack.h
index 6b9e96241c..e54ea4d280 100644
--- a/include/xrpl/server/LoadFeeTrack.h
+++ b/include/xrpl/server/LoadFeeTrack.h
@@ -35,28 +35,28 @@ public:
     setRemoteFee(std::uint32_t f)
     {
         JLOG(j_.trace()) << "setRemoteFee: " << f;
-        std::lock_guard const sl(lock_);
+        std::scoped_lock const sl(lock_);
         remoteTxnLoadFee_ = f;
     }
 
     std::uint32_t
     getRemoteFee() const
     {
-        std::lock_guard const sl(lock_);
+        std::scoped_lock const sl(lock_);
         return remoteTxnLoadFee_;
     }
 
     std::uint32_t
     getLocalFee() const
     {
-        std::lock_guard const sl(lock_);
+        std::scoped_lock const sl(lock_);
         return localTxnLoadFee_;
     }
 
     std::uint32_t
     getClusterFee() const
     {
-        std::lock_guard const sl(lock_);
+        std::scoped_lock const sl(lock_);
         return clusterTxnLoadFee_;
     }
 
@@ -69,14 +69,14 @@ public:
     std::uint32_t
     getLoadFactor() const
     {
-        std::lock_guard const sl(lock_);
+        std::scoped_lock const sl(lock_);
         return std::max({clusterTxnLoadFee_, localTxnLoadFee_, remoteTxnLoadFee_});
     }
 
     std::pair<std::uint32_t, std::uint32_t>
     getScalingFactors() const
     {
-        std::lock_guard const sl(lock_);
+        std::scoped_lock const sl(lock_);
 
         return std::make_pair(
             std::max(localTxnLoadFee_, remoteTxnLoadFee_),
@@ -87,7 +87,7 @@ public:
     setClusterFee(std::uint32_t fee)
     {
         JLOG(j_.trace()) << "setClusterFee: " << fee;
-        std::lock_guard const sl(lock_);
+        std::scoped_lock const sl(lock_);
         clusterTxnLoadFee_ = fee;
     }
 
@@ -99,14 +99,14 @@ public:
     bool
     isLoadedLocal() const
     {
-        std::lock_guard const sl(lock_);
+        std::scoped_lock const sl(lock_);
         return (raiseCount_ != 0) || (localTxnLoadFee_ != lftNormalFee);
     }
 
     bool
     isLoadedCluster() const
     {
-        std::lock_guard const sl(lock_);
+        std::scoped_lock const sl(lock_);
         return (raiseCount_ != 0) || (localTxnLoadFee_ != lftNormalFee) ||
             (clusterTxnLoadFee_ != lftNormalFee);
     }
diff --git a/include/xrpl/server/detail/BaseHTTPPeer.h b/include/xrpl/server/detail/BaseHTTPPeer.h
index a0f8e1f318..31820402ab 100644
--- a/include/xrpl/server/detail/BaseHTTPPeer.h
+++ b/include/xrpl/server/detail/BaseHTTPPeer.h
@@ -38,6 +38,8 @@ protected:
     using endpoint_type = boost::asio::ip::tcp::endpoint;
     using yield_context = boost::asio::yield_context;
 
+    // Need to be named before converting
+    // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
     enum {
         // Size of our read/write buffer
         bufferSize = 4 * 1024,
@@ -303,7 +305,7 @@ BaseHTTPPeer<Handler, Impl>::on_write(error_code const& ec, std::size_t bytes_tr
         return fail(ec, "write");
     bytes_out_ += bytes_transferred;
     {
-        std::lock_guard const lock(mutex_);
+        std::scoped_lock const lock(mutex_);
         wq2_.clear();
         wq2_.reserve(wq_.size());
         std::swap(wq2_, wq_);
@@ -395,7 +397,7 @@ BaseHTTPPeer<Handler, Impl>::write(void const* buf, std::size_t bytes)
     if (bytes == 0)
         return;
     if ([&] {
-            std::lock_guard const lock(mutex_);
+            std::scoped_lock const lock(mutex_);
             wq_.emplace_back(buf, bytes);
             return wq_.size() == 1 && wq2_.size() == 0;
         }())
@@ -449,7 +451,7 @@ BaseHTTPPeer<Handler, Impl>::complete()
     complete_ = true;
 
     {
-        std::lock_guard const lock(mutex_);
+        std::scoped_lock const lock(mutex_);
         if (!wq_.empty() && !wq2_.empty())
             return;
     }
@@ -484,7 +486,7 @@ BaseHTTPPeer<Handler, Impl>::close(bool graceful)
     {
         graceful_ = true;
         {
-            std::lock_guard const lock(mutex_);
+            std::scoped_lock const lock(mutex_);
             if (!wq_.empty() || !wq2_.empty())
                 return;
         }
diff --git a/include/xrpl/server/detail/ServerImpl.h b/include/xrpl/server/detail/ServerImpl.h
index 14d2b56fe4..2c3a8330e1 100644
--- a/include/xrpl/server/detail/ServerImpl.h
+++ b/include/xrpl/server/detail/ServerImpl.h
@@ -62,6 +62,8 @@ class ServerImpl : public Server
 private:
     using clock_type = std::chrono::system_clock;
 
+    // Need to be named before converting
+    // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
     enum { historySize = 100 };
 
     Handler& handler_;
diff --git a/include/xrpl/server/detail/io_list.h b/include/xrpl/server/detail/io_list.h
index 8c25a89f79..67e04d04b6 100644
--- a/include/xrpl/server/detail/io_list.h
+++ b/include/xrpl/server/detail/io_list.h
@@ -165,7 +165,7 @@ io_list::work::destroy()
         return;
     std::function<void(void)> f;
     {
-        std::lock_guard const lock(ios_->m_);
+        std::scoped_lock const lock(ios_->m_);
         ios_->map_.erase(this);
         if (--ios_->n_ == 0 && ios_->closed_)
         {
@@ -195,7 +195,7 @@ io_list::emplace(Args&&... args)
     auto sp = std::make_shared<T>(std::forward<Args>(args)...);
     decltype(sp) dead;
 
-    std::lock_guard const lock(m_);
+    std::scoped_lock const lock(m_);
     if (!closed_)
     {
         ++n_;
diff --git a/include/xrpl/shamap/FullBelowCache.h b/include/xrpl/shamap/FullBelowCache.h
index 6a6da1463a..e17a640672 100644
--- a/include/xrpl/shamap/FullBelowCache.h
+++ b/include/xrpl/shamap/FullBelowCache.h
@@ -22,6 +22,8 @@ private:
     using CacheType = KeyCache;
 
 public:
+    // Need to be named before converting
+    // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
     enum { defaultCacheTargetSize = 0 };
 
     using key_type = uint256;
diff --git a/include/xrpl/tx/Transactor.h b/include/xrpl/tx/Transactor.h
index e20ac70850..918bbe5da6 100644
--- a/include/xrpl/tx/Transactor.h
+++ b/include/xrpl/tx/Transactor.h
@@ -123,6 +123,8 @@ public:
     Transactor(Transactor const&) = delete;
     Transactor&
     operator=(Transactor const&) = delete;
+    // 68 transactor subclass files
+    // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
     enum ConsequencesFactoryType { Normal, Blocker, Custom };
 
     /** Process the transaction. */
diff --git a/include/xrpl/tx/applySteps.h b/include/xrpl/tx/applySteps.h
index 4f857bb7c1..dc4140956c 100644
--- a/include/xrpl/tx/applySteps.h
+++ b/include/xrpl/tx/applySteps.h
@@ -39,7 +39,7 @@ class TxConsequences
 public:
     /// Describes how the transaction affects subsequent
     /// transactions
-    enum Category {
+    enum class Category {
         /// Moves currency around, creates offers, etc.
         normal = 0,
         /// Affects the ability of subsequent transactions
diff --git a/include/xrpl/tx/invariants/InvariantCheckPrivilege.h b/include/xrpl/tx/invariants/InvariantCheckPrivilege.h
index 684e40c8cf..44131167b6 100644
--- a/include/xrpl/tx/invariants/InvariantCheckPrivilege.h
+++ b/include/xrpl/tx/invariants/InvariantCheckPrivilege.h
@@ -25,6 +25,8 @@ not have the relevant amendments enabled_. It's intentionally a pain in the neck
 so that bad code gets caught and fixed as early as possible.
 */
 
+// Bitwise flags, 86 files
+// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
 enum Privilege {
     noPriv = 0x0000,              // The transaction can not do any of the enumerated operations
     createAcct = 0x0001,          // The transaction can create a new ACCOUNT_ROOT object.
diff --git a/include/xrpl/tx/invariants/MPTInvariant.h b/include/xrpl/tx/invariants/MPTInvariant.h
index e3aa06016a..7f405814e7 100644
--- a/include/xrpl/tx/invariants/MPTInvariant.h
+++ b/include/xrpl/tx/invariants/MPTInvariant.h
@@ -35,10 +35,10 @@ public:
  */
 class ValidMPTPayment
 {
-    enum Order { Before = 0, After = 1 };
+    enum class Order { Before = 0, After = 1 };
     struct MPTData
     {
-        std::array<std::int64_t, After + 1> outstanding{};
+        std::array<std::int64_t, 2> outstanding{};
         // sum (MPT after - MPT before)
         std::int64_t mptAmount{0};
     };
diff --git a/include/xrpl/tx/paths/detail/Steps.h b/include/xrpl/tx/paths/detail/Steps.h
index b4d9d6e0b4..9b37f06ca9 100644
--- a/include/xrpl/tx/paths/detail/Steps.h
+++ b/include/xrpl/tx/paths/detail/Steps.h
@@ -21,7 +21,7 @@ class AMMContext;
 enum class DebtDirection { issues, redeems };
 enum class QualityDirection { in, out };
 enum class StrandDirection { forward, reverse };
-enum OfferCrossing { no = 0, yes = 1, sell = 2 };
+enum class OfferCrossing { no = 0, yes = 1, sell = 2 };
 
 inline bool
 redeems(DebtDirection dir)
diff --git a/include/xrpl/tx/paths/detail/StrandFlow.h b/include/xrpl/tx/paths/detail/StrandFlow.h
index ee23de27b3..03ec9cc871 100644
--- a/include/xrpl/tx/paths/detail/StrandFlow.h
+++ b/include/xrpl/tx/paths/detail/StrandFlow.h
@@ -665,7 +665,7 @@ flow(
             // the previous strand execution failed. It has to be reset
             // since this strand might not have AMM liquidity.
             ammContext.clear();
-            if (offerCrossing && limitQuality)
+            if (offerCrossing != OfferCrossing::no && limitQuality)
             {
                 auto const strandQ = qualityUpperBound(sb, *strand);
                 if (!strandQ || *strandQ < *limitQuality)
@@ -797,7 +797,8 @@ flow(
             // fixFillOrKill amendment:
             //   That case is handled here if tfSell is also not set; i.e,
             //   case 1.
-            if (!offerCrossing || (fillOrKillEnabled && offerCrossing != OfferCrossing::sell))
+            if (offerCrossing == OfferCrossing::no ||
+                (fillOrKillEnabled && offerCrossing != OfferCrossing::sell))
                 return {tecPATH_PARTIAL, actualIn, actualOut, std::move(ofrsToRmOnFail)};
         }
         else if (actualOut == beast::zero)
@@ -805,7 +806,7 @@ flow(
             return {tecPATH_DRY, std::move(ofrsToRmOnFail)};
         }
     }
-    if (offerCrossing &&
+    if (offerCrossing != OfferCrossing::no &&
         (!partialPayment && (!fillOrKillEnabled || offerCrossing == OfferCrossing::sell)))
     {
         // If we're offer crossing and partialPayment is *not* true, then
diff --git a/include/xrpl/tx/transactors/account/SignerListSet.h b/include/xrpl/tx/transactors/account/SignerListSet.h
index 1f1a68ccc8..12419076e3 100644
--- a/include/xrpl/tx/transactors/account/SignerListSet.h
+++ b/include/xrpl/tx/transactors/account/SignerListSet.h
@@ -18,8 +18,8 @@ class SignerListSet : public Transactor
 {
 private:
     // Values determined during preCompute for use later.
-    enum Operation { unknown, set, destroy };
-    Operation do_{unknown};
+    enum class Operation { unknown, set, destroy };
+    Operation do_{Operation::unknown};
     std::uint32_t quorum_{0};
     std::vector<SignerEntries::SignerEntry> signers_;
 
diff --git a/include/xrpl/tx/transactors/system/LedgerStateFix.h b/include/xrpl/tx/transactors/system/LedgerStateFix.h
index a236a52c74..da3cb33398 100644
--- a/include/xrpl/tx/transactors/system/LedgerStateFix.h
+++ b/include/xrpl/tx/transactors/system/LedgerStateFix.h
@@ -7,7 +7,7 @@ namespace xrpl {
 class LedgerStateFix : public Transactor
 {
 public:
-    enum FixType : std::uint16_t {
+    enum class FixType : std::uint16_t {
         nfTokenPageLink = 1,
     };
 
diff --git a/src/libxrpl/basics/Log.cpp b/src/libxrpl/basics/Log.cpp
index e855e1006b..eb93feaa3e 100644
--- a/src/libxrpl/basics/Log.cpp
+++ b/src/libxrpl/basics/Log.cpp
@@ -120,7 +120,7 @@ Logs::open(boost::filesystem::path const& pathToLogFile)
 beast::Journal::Sink&
 Logs::get(std::string const& name)
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     auto const result = sinks_.emplace(name, makeSink(name, thresh_));
     return *result.first->second;
 }
@@ -146,7 +146,7 @@ Logs::threshold() const
 void
 Logs::threshold(beast::severities::Severity thresh)
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     thresh_ = thresh;
     for (auto& sink : sinks_)
         sink.second->threshold(thresh);
@@ -156,7 +156,7 @@ std::vector<std::pair<std::string, std::string>>
 Logs::partition_severities() const
 {
     std::vector<std::pair<std::string, std::string>> list;
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     list.reserve(sinks_.size());
     for (auto const& [name, sink] : sinks_)
         list.emplace_back(name, toString(fromSeverity(sink->threshold())));
@@ -172,7 +172,7 @@ Logs::write(
 {
     std::string s;
     format(s, text, level, partition);
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     file_.writeln(s);
     if (!silent_)
         std::cerr << s << '\n';
@@ -184,7 +184,7 @@ Logs::write(
 std::string
 Logs::rotate()
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     bool const wasOpened = file_.closeAndReopen();
     if (wasOpened)
         return "The log file was closed and reopened.";
@@ -412,7 +412,7 @@ public:
     std::unique_ptr<beast::Journal::Sink>
     set(std::unique_ptr<beast::Journal::Sink> sink)
     {
-        std::lock_guard const _(m_);
+        std::scoped_lock const _(m_);
 
         using std::swap;
         swap(holder_, sink);
@@ -432,7 +432,7 @@ public:
     beast::Journal::Sink&
     get()
     {
-        std::lock_guard const _(m_);
+        std::scoped_lock const _(m_);
         return sink_.get();
     }
 };
diff --git a/src/libxrpl/basics/Number.cpp b/src/libxrpl/basics/Number.cpp
index 3b2b8670cb..ba444b77e0 100644
--- a/src/libxrpl/basics/Number.cpp
+++ b/src/libxrpl/basics/Number.cpp
@@ -27,7 +27,7 @@ using int128_t = __int128_t;
 
 namespace xrpl {
 
-thread_local Number::rounding_mode Number::mode_ = Number::to_nearest;
+thread_local Number::rounding_mode Number::mode_ = Number::rounding_mode::to_nearest;
 thread_local std::reference_wrapper<MantissaRange const> Number::range_ = largeRange;
 
 Number::rounding_mode
@@ -51,9 +51,10 @@ Number::getMantissaScale()
 void
 Number::setMantissaScale(MantissaRange::mantissa_scale scale)
 {
-    if (scale != MantissaRange::small && scale != MantissaRange::large)
+    if (scale != MantissaRange::mantissa_scale::small &&
+        scale != MantissaRange::mantissa_scale::large)
         LogicError("Unknown mantissa scale");
-    range_ = scale == MantissaRange::small ? smallRange : largeRange;
+    range_ = scale == MantissaRange::mantissa_scale::small ? smallRange : largeRange;
 }
 
 // Guard
@@ -176,10 +177,10 @@ Number::Guard::round() const noexcept
 {
     auto mode = Number::getround();
 
-    if (mode == towards_zero)
+    if (mode == rounding_mode::towards_zero)
         return -1;
 
-    if (mode == downward)
+    if (mode == rounding_mode::downward)
     {
         if (sbit_)
         {
@@ -189,7 +190,7 @@ Number::Guard::round() const noexcept
         return -1;
     }
 
-    if (mode == upward)
+    if (mode == rounding_mode::upward)
     {
         if (sbit_)
             return -1;
@@ -729,7 +730,7 @@ Number::operator/=(Number const& y)
     // f can be up to 10^(38-19) = 10^19 safely
     static_assert(smallRange.log == 15);
     static_assert(largeRange.log == 18);
-    bool const small = Number::getMantissaScale() == MantissaRange::small;
+    bool const small = Number::getMantissaScale() == MantissaRange::mantissa_scale::small;
     uint128_t const f = small ? 100'000'000'000'000'000 : 10'000'000'000'000'000'000ULL;
     XRPL_ASSERT_PARTS(f >= minMantissa * 10, "Number::operator/=", "factor expected size");
 
diff --git a/src/libxrpl/basics/ResolverAsio.cpp b/src/libxrpl/basics/ResolverAsio.cpp
index fc71666768..0443aa3502 100644
--- a/src/libxrpl/basics/ResolverAsio.cpp
+++ b/src/libxrpl/basics/ResolverAsio.cpp
@@ -177,7 +177,7 @@ public:
         if (m_stopped.exchange(false))
         {
             {
-                std::lock_guard const lk{m_mut};
+                std::scoped_lock const lk{m_mut};
                 m_asyncHandlersCompleted = false;
             }
             addReference();
diff --git a/src/libxrpl/beast/clock/basic_seconds_clock.cpp b/src/libxrpl/beast/clock/basic_seconds_clock.cpp
index 2b7ce57742..dc8f785974 100644
--- a/src/libxrpl/beast/clock/basic_seconds_clock.cpp
+++ b/src/libxrpl/beast/clock/basic_seconds_clock.cpp
@@ -42,7 +42,7 @@ seconds_clock_thread::~seconds_clock_thread()
     XRPL_ASSERT(
         thread_.joinable(), "beast::seconds_clock_thread::~seconds_clock_thread : thread joinable");
     {
-        std::lock_guard const lock(mut_);
+        std::scoped_lock const lock(mut_);
         stop_ = true;
     }  // publish stop_ asap so if waiting thread times-out, it will see it
     cv_.notify_one();
diff --git a/src/libxrpl/beast/insight/StatsDCollector.cpp b/src/libxrpl/beast/insight/StatsDCollector.cpp
index d11e85830f..a83a11d7d6 100644
--- a/src/libxrpl/beast/insight/StatsDCollector.cpp
+++ b/src/libxrpl/beast/insight/StatsDCollector.cpp
@@ -204,6 +204,8 @@ class StatsDCollectorImp : public StatsDCollector,
                            public std::enable_shared_from_this<StatsDCollectorImp>
 {
 private:
+    // Need to be named before converting
+    // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
     enum {
         // max_packet_size = 484
         max_packet_size = 1472
@@ -293,14 +295,14 @@ public:
     void
     add(StatsDMetricBase& metric)
     {
-        std::lock_guard const _(metricsLock_);
+        std::scoped_lock const _(metricsLock_);
         metrics_.push_back(metric);
     }
 
     void
     remove(StatsDMetricBase& metric)
     {
-        std::lock_guard const _(metricsLock_);
+        std::scoped_lock const _(metricsLock_);
         metrics_.erase(metrics_.iterator_to(metric));
     }
 
@@ -444,7 +446,7 @@ public:
             return;
         }
 
-        std::lock_guard const _(metricsLock_);
+        std::scoped_lock const _(metricsLock_);
 
         for (auto& m : metrics_)
             m.do_process();
diff --git a/src/libxrpl/beast/utility/beast_PropertyStream.cpp b/src/libxrpl/beast/utility/beast_PropertyStream.cpp
index ddfe075132..62c192bf64 100644
--- a/src/libxrpl/beast/utility/beast_PropertyStream.cpp
+++ b/src/libxrpl/beast/utility/beast_PropertyStream.cpp
@@ -158,7 +158,7 @@ PropertyStream::Source::Source(std::string name) : m_name(std::move(name)), item
 
 PropertyStream::Source::~Source()
 {
-    std::lock_guard const _(lock_);
+    std::scoped_lock const _(lock_);
     if (parent_ != nullptr)
         parent_->remove(*this);
     removeAll();
@@ -173,9 +173,7 @@ PropertyStream::Source::name() const
 void
 PropertyStream::Source::add(Source& source)
 {
-    std::lock(lock_, source.lock_);
-    std::lock_guard const lk1(lock_, std::adopt_lock);
-    std::lock_guard const lk2(source.lock_, std::adopt_lock);
+    std::scoped_lock const lock(lock_, source.lock_);
 
     XRPL_ASSERT(
         source.parent_ == nullptr, "beast::PropertyStream::Source::add : null source parent");
@@ -186,9 +184,7 @@ PropertyStream::Source::add(Source& source)
 void
 PropertyStream::Source::remove(Source& child)
 {
-    std::lock(lock_, child.lock_);
-    std::lock_guard const lk1(lock_, std::adopt_lock);
-    std::lock_guard const lk2(child.lock_, std::adopt_lock);
+    std::scoped_lock const lock(lock_, child.lock_);
 
     XRPL_ASSERT(
         child.parent_ == this, "beast::PropertyStream::Source::remove : child parent match");
@@ -199,10 +195,10 @@ PropertyStream::Source::remove(Source& child)
 void
 PropertyStream::Source::removeAll()
 {
-    std::lock_guard const _(lock_);
+    std::scoped_lock const _(lock_);
     for (auto iter = children_.begin(); iter != children_.end();)
     {
-        std::lock_guard const _cl((*iter)->lock_);
+        std::scoped_lock const _cl((*iter)->lock_);
         remove(*(*iter));
     }
 }
@@ -222,7 +218,7 @@ PropertyStream::Source::write(PropertyStream& stream)
     Map map(m_name, stream);
     onWrite(map);
 
-    std::lock_guard const _(lock_);
+    std::scoped_lock const _(lock_);
 
     for (auto& child : children_)
         child.source().write(stream);
@@ -324,7 +320,7 @@ PropertyStream::Source::find_one_deep(std::string const& name)
     if (found != nullptr)
         return found;
 
-    std::lock_guard const _(lock_);
+    std::scoped_lock const _(lock_);
     for (auto& s : children_)
     {
         found = s.source().find_one_deep(name);
@@ -355,7 +351,7 @@ PropertyStream::Source::find_path(std::string path)
 PropertyStream::Source*
 PropertyStream::Source::find_one(std::string const& name)
 {
-    std::lock_guard const _(lock_);
+    std::scoped_lock const _(lock_);
     for (auto& s : children_)
     {
         if (s.source().m_name == name)
diff --git a/src/libxrpl/core/HashRouter.cpp b/src/libxrpl/core/HashRouter.cpp
index 4175d83340..ecc2aa9f14 100644
--- a/src/libxrpl/core/HashRouter.cpp
+++ b/src/libxrpl/core/HashRouter.cpp
@@ -34,7 +34,7 @@ HashRouter::emplace(uint256 const& key) -> std::pair<Entry&, bool>
 void
 HashRouter::addSuppression(uint256 const& key)
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
 
     emplace(key);
 }
@@ -48,7 +48,7 @@ HashRouter::addSuppressionPeer(uint256 const& key, PeerShortID peer)
 std::pair<bool, std::optional<Stopwatch::time_point>>
 HashRouter::addSuppressionPeerWithStatus(uint256 const& key, PeerShortID peer)
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
 
     auto result = emplace(key);
     result.first.addPeer(peer);
@@ -58,7 +58,7 @@ HashRouter::addSuppressionPeerWithStatus(uint256 const& key, PeerShortID peer)
 bool
 HashRouter::addSuppressionPeer(uint256 const& key, PeerShortID peer, HashRouterFlags& flags)
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
 
     auto [s, created] = emplace(key);
     s.addPeer(peer);
@@ -73,7 +73,7 @@ HashRouter::shouldProcess(
     HashRouterFlags& flags,
     std::chrono::seconds tx_interval)
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
 
     auto result = emplace(key);
     auto& s = result.first;
@@ -85,7 +85,7 @@ HashRouter::shouldProcess(
 HashRouterFlags
 HashRouter::getFlags(uint256 const& key)
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
 
     return emplace(key).first.getFlags();
 }
@@ -95,7 +95,7 @@ HashRouter::setFlags(uint256 const& key, HashRouterFlags flags)
 {
     XRPL_ASSERT(static_cast<bool>(flags), "xrpl::HashRouter::setFlags : valid input");
 
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
 
     auto& s = emplace(key).first;
 
@@ -109,7 +109,7 @@ HashRouter::setFlags(uint256 const& key, HashRouterFlags flags)
 auto
 HashRouter::shouldRelay(uint256 const& key) -> std::optional<std::set<PeerShortID>>
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
 
     auto& s = emplace(key).first;
 
diff --git a/src/libxrpl/core/detail/JobQueue.cpp b/src/libxrpl/core/detail/JobQueue.cpp
index d55160f285..9e6756e0c0 100644
--- a/src/libxrpl/core/detail/JobQueue.cpp
+++ b/src/libxrpl/core/detail/JobQueue.cpp
@@ -39,7 +39,7 @@ JobQueue::JobQueue(
     job_count = m_collector->make_gauge("job_count");
 
     {
-        std::lock_guard const lock(m_mutex);
+        std::scoped_lock const lock(m_mutex);
 
         for (auto const& x : JobTypes::instance())
         {
@@ -65,7 +65,7 @@ JobQueue::~JobQueue()
 void
 JobQueue::collect()
 {
-    std::lock_guard const lock(m_mutex);
+    std::scoped_lock const lock(m_mutex);
     job_count = m_jobSet.size();
 }
 
@@ -91,7 +91,7 @@ JobQueue::addRefCountedJob(JobType type, std::string const& name, JobFunction co
         "requires no threads");
 
     {
-        std::lock_guard const lock(m_mutex);
+        std::scoped_lock const lock(m_mutex);
         auto result = m_jobSet.emplace(type, name, ++m_lastJob, data.load(), func);
         auto const& job = *result.first;
 
@@ -119,7 +119,7 @@ JobQueue::addRefCountedJob(JobType type, std::string const& name, JobFunction co
 int
 JobQueue::getJobCount(JobType t) const
 {
-    std::lock_guard const lock(m_mutex);
+    std::scoped_lock const lock(m_mutex);
 
     JobDataMap::const_iterator const c = m_jobData.find(t);
 
@@ -129,7 +129,7 @@ JobQueue::getJobCount(JobType t) const
 int
 JobQueue::getJobCountTotal(JobType t) const
 {
-    std::lock_guard const lock(m_mutex);
+    std::scoped_lock const lock(m_mutex);
 
     JobDataMap::const_iterator const c = m_jobData.find(t);
 
@@ -142,7 +142,7 @@ JobQueue::getJobCountGE(JobType t) const
     // return the number of jobs at this priority level or greater
     int ret = 0;
 
-    std::lock_guard const lock(m_mutex);
+    std::scoped_lock const lock(m_mutex);
 
     for (auto const& x : m_jobData)
     {
@@ -192,7 +192,7 @@ JobQueue::getJson(int c)
 
     Json::Value priorities = Json::arrayValue;
 
-    std::lock_guard const lock(m_mutex);
+    std::scoped_lock const lock(m_mutex);
 
     for (auto& x : m_jobData)
     {
@@ -349,7 +349,7 @@ JobQueue::processTask(int instance)
         {
             Job job;
             {
-                std::lock_guard const lock(m_mutex);
+                std::scoped_lock const lock(m_mutex);
                 getNextJob(job);
                 ++m_processCount;
             }
@@ -376,7 +376,7 @@ JobQueue::processTask(int instance)
     }
 
     {
-        std::lock_guard const lock(m_mutex);
+        std::scoped_lock const lock(m_mutex);
         // Job should be destroyed before stopping
         // otherwise destructors with side effects can access
         // parent objects that are already destroyed.
diff --git a/src/libxrpl/core/detail/LoadMonitor.cpp b/src/libxrpl/core/detail/LoadMonitor.cpp
index 2cf4e1f6ea..aea535fb81 100644
--- a/src/libxrpl/core/detail/LoadMonitor.cpp
+++ b/src/libxrpl/core/detail/LoadMonitor.cpp
@@ -108,7 +108,7 @@ LoadMonitor::addLoadSample(LoadEvent const& s)
 void
 LoadMonitor::addSamples(int count, std::chrono::milliseconds latency)
 {
-    std::lock_guard const sl(mutex_);
+    std::scoped_lock const sl(mutex_);
 
     update();
     mCounts += count;
@@ -140,7 +140,7 @@ LoadMonitor::isOverTarget(std::chrono::milliseconds avg, std::chrono::millisecon
 bool
 LoadMonitor::isOver()
 {
-    std::lock_guard const sl(mutex_);
+    std::scoped_lock const sl(mutex_);
 
     update();
 
@@ -157,7 +157,7 @@ LoadMonitor::getStats()
     using namespace std::chrono_literals;
     Stats stats;
 
-    std::lock_guard const sl(mutex_);
+    std::scoped_lock const sl(mutex_);
 
     update();
 
diff --git a/src/libxrpl/core/detail/Workers.cpp b/src/libxrpl/core/detail/Workers.cpp
index e7d63c0900..a6f8885a86 100644
--- a/src/libxrpl/core/detail/Workers.cpp
+++ b/src/libxrpl/core/detail/Workers.cpp
@@ -151,7 +151,7 @@ Workers::Worker::Worker(Workers& workers, std::string threadName, int const inst
 Workers::Worker::~Worker()
 {
     {
-        std::lock_guard const lock{mutex_};
+        std::scoped_lock const lock{mutex_};
         ++wakeCount_;
         shouldExit_ = true;
     }
@@ -163,7 +163,7 @@ Workers::Worker::~Worker()
 void
 Workers::Worker::notify()
 {
-    std::lock_guard const lock{mutex_};
+    std::scoped_lock const lock{mutex_};
     ++wakeCount_;
     wakeup_.notify_one();
 }
@@ -179,7 +179,7 @@ Workers::Worker::run()
         //
         if (++m_workers.m_activeCount == 1)
         {
-            std::lock_guard const lk{m_workers.m_mut};
+            std::scoped_lock const lk{m_workers.m_mut};
             m_workers.m_allPaused = false;
         }
 
@@ -226,7 +226,7 @@ Workers::Worker::run()
             // the predicate evaluation and the actual sleep.
             if (--m_workers.m_runningTaskCount == 0)
             {
-                std::lock_guard const lk{m_workers.m_mut};
+                std::scoped_lock const lk{m_workers.m_mut};
                 m_workers.m_cv.notify_all();
             }
         }
@@ -242,7 +242,7 @@ Workers::Worker::run()
         //
         if (--m_workers.m_activeCount == 0)
         {
-            std::lock_guard const lk{m_workers.m_mut};
+            std::scoped_lock const lk{m_workers.m_mut};
             m_workers.m_allPaused = true;
             m_workers.m_cv.notify_all();
         }
diff --git a/src/libxrpl/crypto/csprng.cpp b/src/libxrpl/crypto/csprng.cpp
index dc16c9ac64..7aef9b2831 100644
--- a/src/libxrpl/crypto/csprng.cpp
+++ b/src/libxrpl/crypto/csprng.cpp
@@ -43,7 +43,7 @@ csprng_engine::mix_entropy(void* buffer, std::size_t count)
             e = rd();
     }
 
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
 
     // We add data to the pool, but we conservatively assume that
     // it contributes no actual entropy.
@@ -60,7 +60,7 @@ csprng_engine::operator()(void* ptr, std::size_t count)
     // with thread support, so we don't need to grab a mutex.
     // https://mta.openssl.org/pipermail/openssl-users/2020-November/013146.html
 #if (OPENSSL_VERSION_NUMBER < 0x10100000L) || !defined(OPENSSL_THREADS)
-    std::lock_guard lock(mutex_);
+    std::scoped_lock lock(mutex_);
 #endif
 
     auto const result = RAND_bytes(reinterpret_cast<unsigned char*>(ptr), count);
diff --git a/src/libxrpl/json/Output.cpp b/src/libxrpl/json/Output.cpp
index e588d21d3c..31d74db7e0 100644
--- a/src/libxrpl/json/Output.cpp
+++ b/src/libxrpl/json/Output.cpp
@@ -45,7 +45,7 @@ outputJson(Json::Value const& value, Writer& writer)
         }
 
         case Json::arrayValue: {
-            writer.startRoot(Writer::array);
+            writer.startRoot(Writer::CollectionType::array);
             for (auto const& i : value)
             {
                 writer.rawAppend();
@@ -56,7 +56,7 @@ outputJson(Json::Value const& value, Writer& writer)
         }
 
         case Json::objectValue: {
-            writer.startRoot(Writer::object);
+            writer.startRoot(Writer::CollectionType::object);
             auto members = value.getMemberNames();
             for (auto const& tag : members)
             {
diff --git a/src/libxrpl/json/Writer.cpp b/src/libxrpl/json/Writer.cpp
index b4a85e0170..188f0749f0 100644
--- a/src/libxrpl/json/Writer.cpp
+++ b/src/libxrpl/json/Writer.cpp
@@ -81,7 +81,7 @@ public:
     void
     start(CollectionType ct)
     {
-        char const ch = (ct == array) ? openBracket : openBrace;
+        char const ch = (ct == CollectionType::array) ? openBracket : openBrace;
         output({&ch, 1});
         stack_.emplace(Collection{.type = ct});
     }
@@ -134,7 +134,9 @@ public:
         auto t = stack_.top().type;
         if (t != type)
         {
-            check(false, "Not an " + ((type == array ? "array: " : "object: ") + message));
+            check(
+                false,
+                "Not an " + ((type == CollectionType::array ? "array: " : "object: ") + message));
         }
         if (stack_.top().isFirst)
         {
@@ -171,7 +173,7 @@ public:
     {
         check(!empty(), "Empty stack in finish()");
 
-        auto isArray = stack_.top().type == array;
+        auto isArray = stack_.top().type == CollectionType::array;
         auto ch = isArray ? closeBracket : closeBrace;
         output_({&ch, 1});
         stack_.pop();
@@ -301,7 +303,7 @@ Writer::finishAll()
 void
 Writer::rawAppend()
 {
-    impl_->nextCollectionEntry(array, "append");
+    impl_->nextCollectionEntry(CollectionType::array, "append");
 }
 
 void
@@ -309,7 +311,7 @@ Writer::rawSet(std::string const& tag)
 {
     check(!tag.empty(), "Tag can't be empty");
 
-    impl_->nextCollectionEntry(object, "set");
+    impl_->nextCollectionEntry(CollectionType::object, "set");
     impl_->writeObjectTag(tag);
 }
 
@@ -322,14 +324,14 @@ Writer::startRoot(CollectionType type)
 void
 Writer::startAppend(CollectionType type)
 {
-    impl_->nextCollectionEntry(array, "startAppend");
+    impl_->nextCollectionEntry(CollectionType::array, "startAppend");
     impl_->start(type);
 }
 
 void
 Writer::startSet(CollectionType type, std::string const& key)
 {
-    impl_->nextCollectionEntry(object, "startSet");
+    impl_->nextCollectionEntry(CollectionType::object, "startSet");
     impl_->writeObjectTag(key);
     impl_->start(type);
 }
diff --git a/src/libxrpl/ledger/AcceptedLedgerTx.cpp b/src/libxrpl/ledger/AcceptedLedgerTx.cpp
index e609f5bdc8..21baa24323 100644
--- a/src/libxrpl/ledger/AcceptedLedgerTx.cpp
+++ b/src/libxrpl/ledger/AcceptedLedgerTx.cpp
@@ -62,8 +62,8 @@ AcceptedLedgerTx::AcceptedLedgerTx(
                 *ledger,
                 account,
                 amount,
-                fhIGNORE_FREEZE,
-                ahIGNORE_AUTH,
+                FreezeHandling::fhIGNORE_FREEZE,
+                AuthHandling::ahIGNORE_AUTH,
                 beast::Journal{beast::Journal::getNullSink()});
             mJson[jss::transaction][jss::owner_funds] = ownerFunds.getText();
         }
diff --git a/src/libxrpl/ledger/BookListeners.cpp b/src/libxrpl/ledger/BookListeners.cpp
index 36d02427bc..d922dc3a67 100644
--- a/src/libxrpl/ledger/BookListeners.cpp
+++ b/src/libxrpl/ledger/BookListeners.cpp
@@ -13,21 +13,21 @@ namespace xrpl {
 void
 BookListeners::addSubscriber(InfoSub::ref sub)
 {
-    std::lock_guard const sl(mLock);
+    std::scoped_lock const sl(mLock);
     mListeners[sub->getSeq()] = sub;
 }
 
 void
 BookListeners::removeSubscriber(std::uint64_t seq)
 {
-    std::lock_guard const sl(mLock);
+    std::scoped_lock const sl(mLock);
     mListeners.erase(seq);
 }
 
 void
 BookListeners::publish(MultiApiJson const& jvObj, hash_set<std::uint64_t>& havePublished)
 {
-    std::lock_guard const sl(mLock);
+    std::scoped_lock const sl(mLock);
     auto it = mListeners.cbegin();
 
     while (it != mListeners.cend())
diff --git a/src/libxrpl/ledger/CachedView.cpp b/src/libxrpl/ledger/CachedView.cpp
index 6bbe2d828b..bb7ff97153 100644
--- a/src/libxrpl/ledger/CachedView.cpp
+++ b/src/libxrpl/ledger/CachedView.cpp
@@ -30,7 +30,7 @@ CachedViewImpl::read(Keylet const& k) const
 
     auto const digest = [&]() -> std::optional<uint256> {
         {
-            std::lock_guard const lock(mutex_);
+            std::scoped_lock const lock(mutex_);
             auto const iter = map_.find(k.key);
             if (iter != map_.end())
             {
@@ -66,7 +66,7 @@ CachedViewImpl::read(Keylet const& k) const
         // Avoid acquiring this lock unless necessary. It is only necessary if
         // the key was not found in the map_. The lock is needed to add the key
         // and digest.
-        std::lock_guard const lock(mutex_);
+        std::scoped_lock const lock(mutex_);
         map_.emplace(k.key, *digest);
     }
     if (!sle || !k.check(*sle))
diff --git a/src/libxrpl/ledger/Ledger.cpp b/src/libxrpl/ledger/Ledger.cpp
index 18db482538..729f1ebce9 100644
--- a/src/libxrpl/ledger/Ledger.cpp
+++ b/src/libxrpl/ledger/Ledger.cpp
@@ -204,7 +204,7 @@ Ledger::Ledger(
         rawInsert(sle);
     }
 
-    stateMap_.flushDirty(hotACCOUNT_NODE);
+    stateMap_.flushDirty(NodeObjectType::hotACCOUNT_NODE);
     setImmutable();
 }
 
diff --git a/src/libxrpl/ledger/helpers/AMMHelpers.cpp b/src/libxrpl/ledger/helpers/AMMHelpers.cpp
index 94ca2469f7..cc91dcaaf4 100644
--- a/src/libxrpl/ledger/helpers/AMMHelpers.cpp
+++ b/src/libxrpl/ledger/helpers/AMMHelpers.cpp
@@ -46,7 +46,8 @@ STAmount
 ammLPTokens(STAmount const& asset1, STAmount const& asset2, Asset const& lptIssue)
 {
     // AMM invariant: sqrt(asset1 * asset2) >= LPTokensBalance
-    auto const rounding = isFeatureEnabled(fixAMMv1_3) ? Number::downward : Number::getround();
+    auto const rounding =
+        isFeatureEnabled(fixAMMv1_3) ? Number::rounding_mode::downward : Number::getround();
     NumberRoundModeGuard const g(rounding);
     auto const tokens = root2(asset1 * asset2);
     return toSTAmount(lptIssue, tokens);
@@ -77,7 +78,7 @@ lpTokensOut(
 
     // minimize tokens out
     auto const frac = (r - c) / (1 + c);
-    return multiply(lptAMMBalance, frac, Number::downward);
+    return multiply(lptAMMBalance, frac, Number::rounding_mode::downward);
 }
 
 /* Equation 4 solves equation 3 for b:
@@ -113,7 +114,7 @@ ammAssetIn(
 
     // maximize deposit
     auto const frac = solveQuadraticEq(a, b, c);
-    return multiply(asset1Balance, frac, Number::upward);
+    return multiply(asset1Balance, frac, Number::rounding_mode::upward);
 }
 
 /* Equation 7:
@@ -138,7 +139,7 @@ lpTokensIn(
 
     // maximize tokens in
     auto const frac = (c - root2(c * c - 4 * fr)) / 2;
-    return multiply(lptAMMBalance, frac, Number::upward);
+    return multiply(lptAMMBalance, frac, Number::rounding_mode::upward);
 }
 
 /* Equation 8 solves equation 7 for b:
@@ -168,7 +169,7 @@ ammAssetOut(
 
     // minimize withdraw
     auto const frac = (t1 * t1 - t1 * (2 - f)) / (t1 * f - 1);
-    return multiply(assetBalance, frac, Number::downward);
+    return multiply(assetBalance, frac, Number::rounding_mode::downward);
 }
 
 Number
diff --git a/src/libxrpl/ledger/helpers/LendingHelpers.cpp b/src/libxrpl/ledger/helpers/LendingHelpers.cpp
index caccca752d..a263791e39 100644
--- a/src/libxrpl/ledger/helpers/LendingHelpers.cpp
+++ b/src/libxrpl/ledger/helpers/LendingHelpers.cpp
@@ -93,8 +93,8 @@ loanPeriodicRate(TenthBips32 interestRate, std::uint32_t paymentInterval)
 bool
 isRounded(Asset const& asset, Number const& value, std::int32_t scale)
 {
-    return roundToAsset(asset, value, scale, Number::downward) ==
-        roundToAsset(asset, value, scale, Number::upward);
+    return roundToAsset(asset, value, scale, Number::rounding_mode::downward) ==
+        roundToAsset(asset, value, scale, Number::rounding_mode::upward);
 }
 
 namespace detail {
@@ -458,7 +458,11 @@ tryOverpayment(
     // preserved rounding errors. This ensures the loan's tracked state remains
     // consistent with its payment history.
     auto const principalOutstanding = std::clamp(
-        roundToAsset(asset, newTheoreticalState.principalOutstanding, loanScale, Number::upward),
+        roundToAsset(
+            asset,
+            newTheoreticalState.principalOutstanding,
+            loanScale,
+            Number::rounding_mode::upward),
         numZero,
         roundedOldState.principalOutstanding);
     auto const totalValueOutstanding = std::clamp(
@@ -466,7 +470,7 @@ tryOverpayment(
             asset,
             principalOutstanding + newTheoreticalState.interestOutstanding(),
             loanScale,
-            Number::upward),
+            Number::rounding_mode::upward),
         numZero,
         roundedOldState.valueOutstanding);
     auto const managementFeeOutstanding = std::clamp(
@@ -836,7 +840,8 @@ computeFullPayment(
     // Split the full payment interest into net interest (to vault) and
     // management fee (to broker), applying proper rounding.
     auto const [roundedFullInterest, roundedFullManagementFee] = [&]() {
-        auto const interest = roundToAsset(asset, fullPaymentInterest, loanScale, Number::downward);
+        auto const interest =
+            roundToAsset(asset, fullPaymentInterest, loanScale, Number::rounding_mode::downward);
         return computeInterestAndFeeParts(asset, interest, managementFeeRate, loanScale);
     }();
 
@@ -1286,7 +1291,7 @@ checkLoanGuards(
     // loan can't be amortized in the specified number of payments, raise an
     // error
     {
-        NumberRoundModeGuard const mg(Number::upward);
+        NumberRoundModeGuard const mg(Number::rounding_mode::upward);
 
         if (std::int64_t const computedPayments{
                 properties.loanState.valueOutstanding / roundedPayment};
@@ -1465,7 +1470,8 @@ computeManagementFee(
     TenthBips32 managementFeeRate,
     std::int32_t scale)
 {
-    return roundToAsset(asset, tenthBipsOfValue(value, managementFeeRate), scale, Number::downward);
+    return roundToAsset(
+        asset, tenthBipsOfValue(value, managementFeeRate), scale, Number::rounding_mode::downward);
 }
 
 /*
@@ -1519,7 +1525,8 @@ computeLoanProperties(
 
     auto const [totalValueOutstanding, loanScale] = [&]() {
         // only round up if there should be interest
-        NumberRoundModeGuard const mg(periodicRate == 0 ? Number::to_nearest : Number::upward);
+        NumberRoundModeGuard const mg(
+            periodicRate == 0 ? Number::rounding_mode::to_nearest : Number::rounding_mode::upward);
         // Use STAmount's internal rounding instead of roundToAsset, because
         // we're going to use this result to determine the scale for all the
         // other rounding.
@@ -1548,7 +1555,7 @@ computeLoanProperties(
     // validate that the principal fits in it, so to allow this function to
     // succeed, round it here, and let the caller do the validation.
     auto const roundedPrincipalOutstanding =
-        roundToAsset(asset, principalOutstanding, loanScale, Number::to_nearest);
+        roundToAsset(asset, principalOutstanding, loanScale, Number::rounding_mode::to_nearest);
 
     // Equation (31) from XLS-66 spec, Section A-2 Equation Glossary
     auto const totalInterestOutstanding = totalValueOutstanding - roundedPrincipalOutstanding;
diff --git a/src/libxrpl/ledger/helpers/TokenHelpers.cpp b/src/libxrpl/ledger/helpers/TokenHelpers.cpp
index d5f1d5eb39..15b3dc0953 100644
--- a/src/libxrpl/ledger/helpers/TokenHelpers.cpp
+++ b/src/libxrpl/ledger/helpers/TokenHelpers.cpp
@@ -165,7 +165,7 @@ getLineIfUsable(
         return nullptr;
     }
 
-    if (zeroIfFrozen == fhZERO_IF_FROZEN)
+    if (zeroIfFrozen == FreezeHandling::fhZERO_IF_FROZEN)
     {
         if (isFrozen(view, account, currency, issuer) ||
             isDeepFrozen(view, account, currency, issuer))
@@ -252,7 +252,7 @@ accountHolds(
         return {xrpLiquid(view, account, 0, j)};
     }
 
-    bool const returnSpendable = (includeFullBalance == shFULL_BALANCE);
+    bool const returnSpendable = (includeFullBalance == SpendableHandling::shFULL_BALANCE);
     if (returnSpendable && account == issuer)
     {
         // If the account is the issuer, then their limit is effectively
@@ -290,7 +290,7 @@ accountHolds(
     beast::Journal j,
     SpendableHandling includeFullBalance)
 {
-    bool const returnSpendable = (includeFullBalance == shFULL_BALANCE);
+    bool const returnSpendable = (includeFullBalance == SpendableHandling::shFULL_BALANCE);
     STAmount amount{mptIssue};
     auto const& issuer = mptIssue.getIssuer();
     bool const mptokensV2 = view.rules().enabled(featureMPTokensV2);
@@ -317,7 +317,7 @@ accountHolds(
     {
         amount.clear(mptIssue);
     }
-    else if (zeroIfFrozen == fhZERO_IF_FROZEN && isFrozen(view, account, mptIssue))
+    else if (zeroIfFrozen == FreezeHandling::fhZERO_IF_FROZEN && isFrozen(view, account, mptIssue))
     {
         amount.clear(mptIssue);
     }
@@ -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 == ahZERO_IF_UNAUTHORIZED &&
+        if (zeroIfUnauthorized == AuthHandling::ahZERO_IF_UNAUTHORIZED &&
             view.rules().enabled(featureSingleAssetVault))
         {
             if (auto const err = requireAuth(view, mptIssue, account, AuthType::StrongAuth);
                 !isTesSuccess(err))
                 amount.clear(mptIssue);
         }
-        else if (zeroIfUnauthorized == ahZERO_IF_UNAUTHORIZED)
+        else if (zeroIfUnauthorized == AuthHandling::ahZERO_IF_UNAUTHORIZED)
         {
             auto const sleIssuance = view.read(keylet::mptIssuance(mptIssue.getMptID()));
 
@@ -401,7 +401,13 @@ accountFunds(
         [&](Issue const&) { return accountFunds(view, id, saDefault, freezeHandling, j); },
         [&](MPTIssue const&) {
             return accountHolds(
-                view, id, saDefault.asset(), freezeHandling, authHandling, j, shFULL_BALANCE);
+                view,
+                id,
+                saDefault.asset(),
+                freezeHandling,
+                authHandling,
+                j,
+                SpendableHandling::shFULL_BALANCE);
         });
 }
 
diff --git a/src/libxrpl/nodestore/BatchWriter.cpp b/src/libxrpl/nodestore/BatchWriter.cpp
index 9da6f504a9..b05c80ff00 100644
--- a/src/libxrpl/nodestore/BatchWriter.cpp
+++ b/src/libxrpl/nodestore/BatchWriter.cpp
@@ -47,7 +47,7 @@ BatchWriter::store(std::shared_ptr<NodeObject> const& object)
 int
 BatchWriter::getWriteLoad()
 {
-    std::lock_guard const sl(mWriteMutex);
+    std::scoped_lock const sl(mWriteMutex);
 
     return std::max(mWriteLoad, static_cast<int>(mWriteSet.size()));
 }
@@ -68,7 +68,7 @@ BatchWriter::writeBatch()
         set.reserve(batchWritePreallocationSize);
 
         {
-            std::lock_guard const sl(mWriteMutex);
+            std::scoped_lock const sl(mWriteMutex);
 
             mWriteSet.swap(set);
             XRPL_ASSERT(
diff --git a/src/libxrpl/nodestore/Database.cpp b/src/libxrpl/nodestore/Database.cpp
index ee8d2f56aa..fa69cba517 100644
--- a/src/libxrpl/nodestore/Database.cpp
+++ b/src/libxrpl/nodestore/Database.cpp
@@ -143,7 +143,7 @@ void
 Database::stop()
 {
     {
-        std::lock_guard const lock(readLock_);
+        std::scoped_lock const lock(readLock_);
 
         if (!readStopping_.exchange(true, std::memory_order_relaxed))
         {
@@ -179,7 +179,7 @@ Database::asyncFetch(
     std::uint32_t ledgerSeq,
     std::function<void(std::shared_ptr<NodeObject> const&)>&& cb)
 {
-    std::lock_guard const lock(readLock_);
+    std::scoped_lock const lock(readLock_);
 
     if (!isStopping())
     {
diff --git a/src/libxrpl/nodestore/DatabaseNodeImp.cpp b/src/libxrpl/nodestore/DatabaseNodeImp.cpp
index 7722f711bb..1bb5f32308 100644
--- a/src/libxrpl/nodestore/DatabaseNodeImp.cpp
+++ b/src/libxrpl/nodestore/DatabaseNodeImp.cpp
@@ -48,7 +48,7 @@ DatabaseNodeImp::fetchNodeObject(
     bool duplicate)
 {
     std::shared_ptr<NodeObject> nodeObject = nullptr;
-    Status status = ok;
+    Status status = Status::ok;
 
     try
     {
@@ -63,15 +63,15 @@ DatabaseNodeImp::fetchNodeObject(
 
     switch (status)
     {
-        case ok:
-        case notFound:
+        case Status::ok:
+        case Status::notFound:
             break;
-        case dataCorrupt:
+        case Status::dataCorrupt:
             JLOG(j_.fatal()) << "fetchNodeObject " << hash << ": nodestore data is corrupted";
             break;
         default:
             JLOG(j_.warn()) << "fetchNodeObject " << hash << ": backend returns unknown result "
-                            << status;
+                            << static_cast<int>(status);
             break;
     }
 
diff --git a/src/libxrpl/nodestore/DatabaseRotatingImp.cpp b/src/libxrpl/nodestore/DatabaseRotatingImp.cpp
index ef7431f5a3..de34af7773 100644
--- a/src/libxrpl/nodestore/DatabaseRotatingImp.cpp
+++ b/src/libxrpl/nodestore/DatabaseRotatingImp.cpp
@@ -53,7 +53,7 @@ DatabaseRotatingImp::rotate(
     // deleted.
     std::shared_ptr<NodeStore::Backend> oldArchiveBackend;
     {
-        std::lock_guard const lock(mutex_);
+        std::scoped_lock const lock(mutex_);
 
         archiveBackend_->setDeletePath();
         oldArchiveBackend = std::move(archiveBackend_);
@@ -70,14 +70,14 @@ DatabaseRotatingImp::rotate(
 std::string
 DatabaseRotatingImp::getName() const
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     return writableBackend_->getName();
 }
 
 std::int32_t
 DatabaseRotatingImp::getWriteLoad() const
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     return writableBackend_->getWriteLoad();
 }
 
@@ -85,7 +85,7 @@ void
 DatabaseRotatingImp::importDatabase(Database& source)
 {
     auto const backend = [&] {
-        std::lock_guard const lock(mutex_);
+        std::scoped_lock const lock(mutex_);
         return writableBackend_;
     }();
 
@@ -95,7 +95,7 @@ DatabaseRotatingImp::importDatabase(Database& source)
 void
 DatabaseRotatingImp::sync()
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     writableBackend_->sync();
 }
 
@@ -105,7 +105,7 @@ DatabaseRotatingImp::store(NodeObjectType type, Blob&& data, uint256 const& hash
     auto nObj = NodeObject::createObject(type, std::move(data), hash);
 
     auto const backend = [&] {
-        std::lock_guard const lock(mutex_);
+        std::scoped_lock const lock(mutex_);
         return writableBackend_;
     }();
 
@@ -121,7 +121,7 @@ DatabaseRotatingImp::fetchNodeObject(
     bool duplicate)
 {
     auto fetch = [&](std::shared_ptr<Backend> const& backend) {
-        Status status = ok;
+        Status status = Status::ok;
         std::shared_ptr<NodeObject> nodeObject;
         try
         {
@@ -135,14 +135,14 @@ DatabaseRotatingImp::fetchNodeObject(
 
         switch (status)
         {
-            case ok:
-            case notFound:
+            case Status::ok:
+            case Status::notFound:
                 break;
-            case dataCorrupt:
+            case Status::dataCorrupt:
                 JLOG(j_.fatal()) << "Corrupt NodeObject #" << hash;
                 break;
             default:
-                JLOG(j_.warn()) << "Unknown status=" << status;
+                JLOG(j_.warn()) << "Unknown status=" << static_cast<int>(status);
                 break;
         }
 
@@ -153,7 +153,7 @@ DatabaseRotatingImp::fetchNodeObject(
     std::shared_ptr<NodeObject> nodeObject;
 
     auto [writable, archive] = [&] {
-        std::lock_guard const lock(mutex_);
+        std::scoped_lock const lock(mutex_);
         return std::make_pair(writableBackend_, archiveBackend_);
     }();
 
@@ -167,7 +167,7 @@ DatabaseRotatingImp::fetchNodeObject(
         {
             {
                 // Refresh the writable backend pointer
-                std::lock_guard const lock(mutex_);
+                std::scoped_lock const lock(mutex_);
                 writable = writableBackend_;
             }
 
@@ -187,7 +187,7 @@ void
 DatabaseRotatingImp::for_each(std::function<void(std::shared_ptr<NodeObject>)> f)
 {
     auto [writable, archive] = [&] {
-        std::lock_guard const lock(mutex_);
+        std::scoped_lock const lock(mutex_);
         return std::make_pair(writableBackend_, archiveBackend_);
     }();
 
diff --git a/src/libxrpl/nodestore/DecodedBlob.cpp b/src/libxrpl/nodestore/DecodedBlob.cpp
index 1d60f2af86..437aef24da 100644
--- a/src/libxrpl/nodestore/DecodedBlob.cpp
+++ b/src/libxrpl/nodestore/DecodedBlob.cpp
@@ -25,7 +25,7 @@ DecodedBlob::DecodedBlob(void const* key, void const* value, int valueBytes)
 
     m_success = false;
     m_key = key;
-    m_objectType = hotUNKNOWN;
+    m_objectType = NodeObjectType::hotUNKNOWN;
     m_objectData = nullptr;
     m_dataBytes = std::max(0, valueBytes - 9);
 
@@ -46,10 +46,10 @@ DecodedBlob::DecodedBlob(void const* key, void const* value, int valueBytes)
             default:
                 break;
 
-            case hotUNKNOWN:
-            case hotLEDGER:
-            case hotACCOUNT_NODE:
-            case hotTRANSACTION_NODE:
+            case NodeObjectType::hotUNKNOWN:
+            case NodeObjectType::hotLEDGER:
+            case NodeObjectType::hotACCOUNT_NODE:
+            case NodeObjectType::hotTRANSACTION_NODE:
                 m_success = true;
                 break;
         }
diff --git a/src/libxrpl/nodestore/ManagerImp.cpp b/src/libxrpl/nodestore/ManagerImp.cpp
index 40a48f0875..1420bf3997 100644
--- a/src/libxrpl/nodestore/ManagerImp.cpp
+++ b/src/libxrpl/nodestore/ManagerImp.cpp
@@ -96,14 +96,14 @@ ManagerImp::make_Database(
 void
 ManagerImp::insert(Factory& factory)
 {
-    std::lock_guard const _(mutex_);
+    std::scoped_lock const _(mutex_);
     list_.push_back(&factory);
 }
 
 void
 ManagerImp::erase(Factory& factory)
 {
-    std::lock_guard const _(mutex_);
+    std::scoped_lock const _(mutex_);
     auto const iter =
         std::ranges::find_if(list_, [&factory](Factory* other) { return other == &factory; });
     XRPL_ASSERT(iter != list_.end(), "xrpl::NodeStore::ManagerImp::erase : valid input");
@@ -113,7 +113,7 @@ ManagerImp::erase(Factory& factory)
 Factory*
 ManagerImp::find(std::string const& name)
 {
-    std::lock_guard const _(mutex_);
+    std::scoped_lock const _(mutex_);
     auto const iter = std::ranges::find_if(
         list_, [&name](Factory* other) { return boost::iequals(name, other->getName()); });
     if (iter == list_.end())
diff --git a/src/libxrpl/nodestore/backend/MemoryFactory.cpp b/src/libxrpl/nodestore/backend/MemoryFactory.cpp
index abf25013ce..ef07ebe957 100644
--- a/src/libxrpl/nodestore/backend/MemoryFactory.cpp
+++ b/src/libxrpl/nodestore/backend/MemoryFactory.cpp
@@ -59,7 +59,7 @@ public:
     MemoryDB&
     open(std::string const& path)
     {
-        std::lock_guard const _(mutex_);
+        std::scoped_lock const _(mutex_);
         auto const result =
             map_.emplace(std::piecewise_construct, std::make_tuple(path), std::make_tuple());
         MemoryDB& db = result.first->second;
@@ -134,16 +134,16 @@ public:
     {
         XRPL_ASSERT(db_, "xrpl::NodeStore::MemoryBackend::fetch : non-null database");
 
-        std::lock_guard const _(db_->mutex);
+        std::scoped_lock const _(db_->mutex);
 
         Map::iterator const iter = db_->table.find(hash);
         if (iter == db_->table.end())
         {
             pObject->reset();
-            return notFound;
+            return Status::notFound;
         }
         *pObject = iter->second;
-        return ok;
+        return Status::ok;
     }
 
     std::pair<std::vector<std::shared_ptr<NodeObject>>, Status>
@@ -155,7 +155,7 @@ public:
         {
             std::shared_ptr<NodeObject> nObj;
             Status const status = fetch(h, &nObj);
-            if (status != ok)
+            if (status != Status::ok)
             {
                 results.push_back({});
             }
@@ -165,14 +165,14 @@ public:
             }
         }
 
-        return {results, ok};
+        return {results, Status::ok};
     }
 
     void
     store(std::shared_ptr<NodeObject> const& object) override
     {
         XRPL_ASSERT(db_, "xrpl::NodeStore::MemoryBackend::store : non-null database");
-        std::lock_guard const _(db_->mutex);
+        std::scoped_lock const _(db_->mutex);
         db_->table.emplace(object->getHash(), object);
     }
 
diff --git a/src/libxrpl/nodestore/backend/NuDBFactory.cpp b/src/libxrpl/nodestore/backend/NuDBFactory.cpp
index 86540016da..18fe3c572e 100644
--- a/src/libxrpl/nodestore/backend/NuDBFactory.cpp
+++ b/src/libxrpl/nodestore/backend/NuDBFactory.cpp
@@ -207,7 +207,7 @@ public:
     Status
     fetch(uint256 const& hash, std::shared_ptr<NodeObject>* pno) override
     {
-        Status status = ok;
+        Status status = Status::ok;
         pno->reset();
         nudb::error_code ec;
         db_.fetch(
@@ -218,15 +218,15 @@ public:
                 DecodedBlob decoded(hash.data(), result.first, result.second);
                 if (!decoded.wasOk())
                 {
-                    status = dataCorrupt;
+                    status = Status::dataCorrupt;
                     return;
                 }
                 *pno = decoded.createObject();
-                status = ok;
+                status = Status::ok;
             },
             ec);
         if (ec == nudb::error::key_not_found)
-            return notFound;
+            return Status::notFound;
         if (ec)
             Throw<nudb::system_error>(ec);
         return status;
@@ -241,7 +241,7 @@ public:
         {
             std::shared_ptr<NodeObject> nObj;
             Status const status = fetch(h, &nObj);
-            if (status != ok)
+            if (status != Status::ok)
             {
                 results.push_back({});
             }
@@ -251,7 +251,7 @@ public:
             }
         }
 
-        return {results, ok};
+        return {results, Status::ok};
     }
 
     void
diff --git a/src/libxrpl/nodestore/backend/NullFactory.cpp b/src/libxrpl/nodestore/backend/NullFactory.cpp
index 02e6ca4dda..917ee3d8d0 100644
--- a/src/libxrpl/nodestore/backend/NullFactory.cpp
+++ b/src/libxrpl/nodestore/backend/NullFactory.cpp
@@ -49,7 +49,7 @@ public:
     Status
     fetch(uint256 const&, std::shared_ptr<NodeObject>*) override
     {
-        return notFound;
+        return Status::notFound;
     }
 
     std::pair<std::vector<std::shared_ptr<NodeObject>>, Status>
diff --git a/src/libxrpl/nodestore/backend/RocksDBFactory.cpp b/src/libxrpl/nodestore/backend/RocksDBFactory.cpp
index 86dff9240d..be2506ec6f 100644
--- a/src/libxrpl/nodestore/backend/RocksDBFactory.cpp
+++ b/src/libxrpl/nodestore/backend/RocksDBFactory.cpp
@@ -285,7 +285,7 @@ public:
         XRPL_ASSERT(m_db, "xrpl::NodeStore::RocksDBBackend::fetch : non-null database");
         pObject->reset();
 
-        Status status(ok);
+        Status status(Status::ok);
 
         rocksdb::ReadOptions const options;
         rocksdb::Slice const slice(std::bit_cast<char const*>(hash.data()), m_keyBytes);
@@ -306,22 +306,23 @@ public:
             {
                 // Decoding failed, probably corrupted!
                 //
-                status = dataCorrupt;
+                status = Status::dataCorrupt;
             }
         }
         else
         {
             if (getStatus.IsCorruption())
             {
-                status = dataCorrupt;
+                status = Status::dataCorrupt;
             }
             else if (getStatus.IsNotFound())
             {
-                status = notFound;
+                status = Status::notFound;
             }
             else
             {
-                status = Status(customCode + unsafe_cast<int>(getStatus.code()));
+                status = static_cast<Status>(
+                    static_cast<int>(Status::customCode) + unsafe_cast<int>(getStatus.code()));
 
                 JLOG(m_journal.error()) << getStatus.ToString();
             }
@@ -339,7 +340,7 @@ public:
         {
             std::shared_ptr<NodeObject> nObj;
             Status const status = fetch(h, &nObj);
-            if (status != ok)
+            if (status != Status::ok)
             {
                 results.push_back({});
             }
@@ -349,7 +350,7 @@ public:
             }
         }
 
-        return {results, ok};
+        return {results, Status::ok};
     }
 
     void
diff --git a/src/libxrpl/protocol/AccountID.cpp b/src/libxrpl/protocol/AccountID.cpp
index a89dc8fd11..ffebde2c1a 100644
--- a/src/libxrpl/protocol/AccountID.cpp
+++ b/src/libxrpl/protocol/AccountID.cpp
@@ -56,7 +56,7 @@ public:
         packed_spinlock sl(locks_, index % 64);
 
         {
-            std::lock_guard const lock(sl);
+            std::scoped_lock const lock(sl);
 
             // The check against the first character of the encoding ensures
             // that we don't mishandle the case of the all-zero account:
@@ -69,7 +69,7 @@ public:
         XRPL_ASSERT(ret.size() <= 38, "xrpl::detail::AccountIdCache : maximum result size");
 
         {
-            std::lock_guard const lock(sl);
+            std::scoped_lock const lock(sl);
             cache_[index].id = id;
             std::strcpy(cache_[index].encoding, ret.c_str());
         }
diff --git a/src/libxrpl/protocol/Rules.cpp b/src/libxrpl/protocol/Rules.cpp
index 7a8d0144bb..3e4649a27f 100644
--- a/src/libxrpl/protocol/Rules.cpp
+++ b/src/libxrpl/protocol/Rules.cpp
@@ -40,7 +40,9 @@ setCurrentTransactionRules(std::optional<Rules> r)
     // the value is needed. That could get expensive fast.
     bool const enableLargeNumbers =
         !r || (r->enabled(featureSingleAssetVault) || r->enabled(featureLendingProtocol));
-    Number::setMantissaScale(enableLargeNumbers ? MantissaRange::large : MantissaRange::small);
+    Number::setMantissaScale(
+        enableLargeNumbers ? MantissaRange::mantissa_scale::large
+                           : MantissaRange::mantissa_scale::small);
 
     *getCurrentTransactionRulesRef() = std::move(r);
 }
diff --git a/src/libxrpl/protocol/STAmount.cpp b/src/libxrpl/protocol/STAmount.cpp
index 89992b823c..654bcf1be4 100644
--- a/src/libxrpl/protocol/STAmount.cpp
+++ b/src/libxrpl/protocol/STAmount.cpp
@@ -1612,7 +1612,7 @@ mulRoundImpl(STAmount const& v1, STAmount const& v2, Asset const& asset, bool ro
     STAmount result = [&]() {
         // If appropriate, tell Number to round down.  This gives the desired
         // result from STAmount::canonicalize.
-        MightSaveRound const savedRound(Number::towards_zero);
+        MightSaveRound const savedRound(Number::rounding_mode::towards_zero);
         return STAmount(asset, amount, offset, resultNegative);
     }();
 
diff --git a/src/libxrpl/protocol/STNumber.cpp b/src/libxrpl/protocol/STNumber.cpp
index 25aa9eaa05..d506751f86 100644
--- a/src/libxrpl/protocol/STNumber.cpp
+++ b/src/libxrpl/protocol/STNumber.cpp
@@ -95,7 +95,7 @@ STNumber::add(Serializer& s) const
             // Json. Regardless, the only time we should be serializing an
             // STNumber is when the scale is large.
             XRPL_ASSERT_PARTS(
-                Number::getMantissaScale() == MantissaRange::large,
+                Number::getMantissaScale() == MantissaRange::mantissa_scale::large,
                 "xrpl::STNumber::add",
                 "STNumber only used with large mantissa scale");
 #endif
diff --git a/src/libxrpl/protocol/STObject.cpp b/src/libxrpl/protocol/STObject.cpp
index baece3ca56..9f032a0962 100644
--- a/src/libxrpl/protocol/STObject.cpp
+++ b/src/libxrpl/protocol/STObject.cpp
@@ -119,7 +119,7 @@ STObject::isDefault() const
 void
 STObject::add(Serializer& s) const
 {
-    add(s, withAllFields);  // just inner elements
+    add(s, WhichFields::withAllFields);  // just inner elements
 }
 
 STObject&
@@ -258,7 +258,7 @@ STObject::set(SerialIter& sit, int depth)
 
     // We want to ensure that the deserialized object does not contain any
     // duplicate fields. This is a key invariant:
-    auto const sf = getSortedFields(*this, withAllFields);
+    auto const sf = getSortedFields(*this, WhichFields::withAllFields);
 
     auto const dup = std::ranges::adjacent_find(sf, [](STBase const* lhs, STBase const* rhs) {
         return lhs->getFName() == rhs->getFName();
@@ -353,8 +353,8 @@ STObject::isEquivalent(STBase const& t) const
             });
     }
 
-    auto const sf1 = getSortedFields(*this, withAllFields);
-    auto const sf2 = getSortedFields(*v, withAllFields);
+    auto const sf1 = getSortedFields(*this, WhichFields::withAllFields);
+    auto const sf2 = getSortedFields(*v, WhichFields::withAllFields);
 
     return std::ranges::equal(sf1, sf2, [](STBase const* st1, STBase const* st2) {
         return (st1->getSType() == st2->getSType()) && st1->isEquivalent(*st2);
@@ -366,7 +366,7 @@ STObject::getHash(HashPrefix prefix) const
 {
     Serializer s;
     s.add32(prefix);
-    add(s, withAllFields);
+    add(s, WhichFields::withAllFields);
     return s.getSHA512Half();
 }
 
@@ -375,7 +375,7 @@ STObject::getSigningHash(HashPrefix prefix) const
 {
     Serializer s;
     s.add32(prefix);
-    add(s, omitSigningFields);
+    add(s, WhichFields::omitSigningFields);
     return s.getSHA512Half();
 }
 
diff --git a/src/libxrpl/protocol/STTx.cpp b/src/libxrpl/protocol/STTx.cpp
index 6da0d61b57..0dd567e6cc 100644
--- a/src/libxrpl/protocol/STTx.cpp
+++ b/src/libxrpl/protocol/STTx.cpp
@@ -203,7 +203,7 @@ STTx::getSeqProxy() const
         return SeqProxy::sequence(seq);
     }
 
-    return SeqProxy{SeqProxy::ticket, *ticketSeq};
+    return SeqProxy{SeqProxy::Type::ticket, *ticketSeq};
 }
 
 std::uint32_t
diff --git a/src/libxrpl/rdb/DatabaseCon.cpp b/src/libxrpl/rdb/DatabaseCon.cpp
index 5f4594b630..cc7692de78 100644
--- a/src/libxrpl/rdb/DatabaseCon.cpp
+++ b/src/libxrpl/rdb/DatabaseCon.cpp
@@ -30,7 +30,7 @@ public:
     std::shared_ptr<Checkpointer>
     fromId(std::uintptr_t id)
     {
-        std::lock_guard const l{mutex_};
+        std::scoped_lock const l{mutex_};
         auto it = checkpointers_.find(id);
         if (it != checkpointers_.end())
             return it->second;
@@ -40,7 +40,7 @@ public:
     void
     erase(std::uintptr_t id)
     {
-        std::lock_guard const lock{mutex_};
+        std::scoped_lock const lock{mutex_};
         checkpointers_.erase(id);
     }
 
@@ -50,7 +50,7 @@ public:
         JobQueue& jobQueue,
         ServiceRegistry& registry)
     {
-        std::lock_guard const lock{mutex_};
+        std::scoped_lock const lock{mutex_};
         auto const id = nextId_++;
         auto const r = makeCheckpointer(id, session, jobQueue, registry);
         checkpointers_[id] = r;
diff --git a/src/libxrpl/rdb/SociDB.cpp b/src/libxrpl/rdb/SociDB.cpp
index c6e40ae90b..1d69f1c984 100644
--- a/src/libxrpl/rdb/SociDB.cpp
+++ b/src/libxrpl/rdb/SociDB.cpp
@@ -238,7 +238,7 @@ public:
     schedule() override
     {
         {
-            std::lock_guard const lock(mutex_);
+            std::scoped_lock const lock(mutex_);
             if (running_)
                 return;
             running_ = true;
@@ -258,7 +258,7 @@ public:
                         self->checkpoint();
                 }))
         {
-            std::lock_guard const lock(mutex_);
+            std::scoped_lock const lock(mutex_);
             running_ = false;
         }
     }
@@ -286,7 +286,7 @@ public:
             JLOG(j_.trace()) << "WAL(" << fname << "): frames=" << log << ", written=" << ckpt;
         }
 
-        std::lock_guard const lock(mutex_);
+        std::scoped_lock const lock(mutex_);
         running_ = false;
     }
 
diff --git a/src/libxrpl/resource/Consumer.cpp b/src/libxrpl/resource/Consumer.cpp
index 3d03fa05db..c57344bd8f 100644
--- a/src/libxrpl/resource/Consumer.cpp
+++ b/src/libxrpl/resource/Consumer.cpp
@@ -78,7 +78,7 @@ Consumer::isUnlimited() const
 Disposition
 Consumer::disposition() const
 {
-    Disposition d = ok;
+    Disposition d = Disposition::ok;
     if ((m_logic != nullptr) && (m_entry != nullptr))
         d = m_logic->charge(*m_entry, Charge(0));
 
@@ -88,7 +88,7 @@ Consumer::disposition() const
 Disposition
 Consumer::charge(Charge const& what, std::string const& context)
 {
-    Disposition d = ok;
+    Disposition d = Disposition::ok;
 
     if ((m_logic != nullptr) && (m_entry != nullptr) && !m_entry->isUnlimited())
         d = m_logic->charge(*m_entry, what, context);
diff --git a/src/libxrpl/resource/ResourceManager.cpp b/src/libxrpl/resource/ResourceManager.cpp
index 6652c1a66b..e3f0ae8583 100644
--- a/src/libxrpl/resource/ResourceManager.cpp
+++ b/src/libxrpl/resource/ResourceManager.cpp
@@ -50,7 +50,7 @@ public:
     ~ManagerImp() override
     {
         {
-            std::lock_guard const lock(mutex_);
+            std::scoped_lock const lock(mutex_);
             stop_ = true;
             cond_.notify_one();
         }
diff --git a/src/libxrpl/server/InfoSub.cpp b/src/libxrpl/server/InfoSub.cpp
index 30686dfe7e..c426d44646 100644
--- a/src/libxrpl/server/InfoSub.cpp
+++ b/src/libxrpl/server/InfoSub.cpp
@@ -73,7 +73,7 @@ InfoSub::onSendEmpty()
 void
 InfoSub::insertSubAccountInfo(AccountID const& account, bool rt)
 {
-    std::lock_guard const sl(mLock);
+    std::scoped_lock const sl(mLock);
 
     if (rt)
     {
@@ -88,7 +88,7 @@ InfoSub::insertSubAccountInfo(AccountID const& account, bool rt)
 void
 InfoSub::deleteSubAccountInfo(AccountID const& account, bool rt)
 {
-    std::lock_guard const sl(mLock);
+    std::scoped_lock const sl(mLock);
 
     if (rt)
     {
@@ -103,14 +103,14 @@ InfoSub::deleteSubAccountInfo(AccountID const& account, bool rt)
 bool
 InfoSub::insertSubAccountHistory(AccountID const& account)
 {
-    std::lock_guard const sl(mLock);
+    std::scoped_lock const sl(mLock);
     return accountHistorySubscriptions_.insert(account).second;
 }
 
 void
 InfoSub::deleteSubAccountHistory(AccountID const& account)
 {
-    std::lock_guard const sl(mLock);
+    std::scoped_lock const sl(mLock);
     accountHistorySubscriptions_.erase(account);
 }
 
diff --git a/src/libxrpl/server/LoadFeeTrack.cpp b/src/libxrpl/server/LoadFeeTrack.cpp
index 53fbb8cb84..2fa7e1beba 100644
--- a/src/libxrpl/server/LoadFeeTrack.cpp
+++ b/src/libxrpl/server/LoadFeeTrack.cpp
@@ -16,7 +16,7 @@ namespace xrpl {
 bool
 LoadFeeTrack::raiseLocalFee()
 {
-    std::lock_guard const sl(lock_);
+    std::scoped_lock const sl(lock_);
 
     if (++raiseCount_ < 2)
         return false;
@@ -41,7 +41,7 @@ LoadFeeTrack::raiseLocalFee()
 bool
 LoadFeeTrack::lowerLocalFee()
 {
-    std::lock_guard const sl(lock_);
+    std::scoped_lock const sl(lock_);
     std::uint32_t const origFee = localTxnLoadFee_;
     raiseCount_ = 0;
 
diff --git a/src/libxrpl/shamap/SHAMap.cpp b/src/libxrpl/shamap/SHAMap.cpp
index b638efc383..837724babe 100644
--- a/src/libxrpl/shamap/SHAMap.cpp
+++ b/src/libxrpl/shamap/SHAMap.cpp
@@ -975,7 +975,7 @@ int
 SHAMap::unshare()
 {
     // Don't share nodes with parent map
-    return walkSubTree(false, hotUNKNOWN);
+    return walkSubTree(false, NodeObjectType::hotUNKNOWN);
 }
 
 int
diff --git a/src/libxrpl/shamap/SHAMapDelta.cpp b/src/libxrpl/shamap/SHAMapDelta.cpp
index d8162710be..e80f28d25f 100644
--- a/src/libxrpl/shamap/SHAMapDelta.cpp
+++ b/src/libxrpl/shamap/SHAMapDelta.cpp
@@ -344,7 +344,7 @@ SHAMap::walkMapParallel(std::vector<SHAMapMissingNode>& missingNodes, int maxMis
                             }
                             else
                             {
-                                std::lock_guard const l{m};
+                                std::scoped_lock const l{m};
                                 missingNodes.emplace_back(type_, node->getChildHash(i));
                                 if (--maxMissing <= 0)
                                     return;
@@ -354,7 +354,7 @@ SHAMap::walkMapParallel(std::vector<SHAMapMissingNode>& missingNodes, int maxMis
                 }
                 catch (SHAMapMissingNode const& e)
                 {
-                    std::lock_guard const l(m);
+                    std::scoped_lock const l(m);
                     exceptions.push_back(e);
                 }
             },
@@ -364,7 +364,7 @@ SHAMap::walkMapParallel(std::vector<SHAMapMissingNode>& missingNodes, int maxMis
     for (std::thread& worker : workers)
         worker.join();
 
-    std::lock_guard const l(m);
+    std::scoped_lock const l(m);
     if (exceptions.empty())
         return true;
     std::stringstream ss;
diff --git a/src/libxrpl/shamap/SHAMapInnerNode.cpp b/src/libxrpl/shamap/SHAMapInnerNode.cpp
index d3324e91d0..38300beadb 100644
--- a/src/libxrpl/shamap/SHAMapInnerNode.cpp
+++ b/src/libxrpl/shamap/SHAMapInnerNode.cpp
@@ -99,7 +99,7 @@ SHAMapInnerNode::clone(std::uint32_t cowid) const
     }
 
     spinlock sl(lock_);
-    std::lock_guard const lock(sl);
+    std::scoped_lock const lock(sl);
 
     if (thisIsSparse)
     {
@@ -333,7 +333,7 @@ SHAMapInnerNode::getChildPointer(int branch)
         *getChildIndex(branch);  // NOLINT(bugprone-unchecked-optional-access) assert above
 
     packed_spinlock sl(lock_, index);
-    std::lock_guard const lock(sl);
+    std::scoped_lock const lock(sl);
     return hashesAndChildren_.getChildren()[index].get();
 }
 
@@ -349,7 +349,7 @@ SHAMapInnerNode::getChild(int branch)
         *getChildIndex(branch);  // NOLINT(bugprone-unchecked-optional-access) assert above
 
     packed_spinlock sl(lock_, index);
-    std::lock_guard const lock(sl);
+    std::scoped_lock const lock(sl);
     return hashesAndChildren_.getChildren()[index];
 }
 
@@ -383,7 +383,7 @@ SHAMapInnerNode::canonicalizeChild(int branch, intr_ptr::SharedPtr<SHAMapTreeNod
         "hash do match");
 
     packed_spinlock sl(lock_, childIndex);
-    std::lock_guard const lock(sl);
+    std::scoped_lock const lock(sl);
 
     if (children[childIndex])
     {
diff --git a/src/libxrpl/shamap/SHAMapNodeID.cpp b/src/libxrpl/shamap/SHAMapNodeID.cpp
index c2d93f20ee..6116a997b6 100644
--- a/src/libxrpl/shamap/SHAMapNodeID.cpp
+++ b/src/libxrpl/shamap/SHAMapNodeID.cpp
@@ -16,6 +16,8 @@ namespace xrpl {
 static uint256 const&
 depthMask(unsigned int depth)
 {
+    // Need to be named before converting
+    // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
     enum { mask_size = 65 };
 
     struct masks_t
diff --git a/src/libxrpl/tx/applySteps.cpp b/src/libxrpl/tx/applySteps.cpp
index eb058e5ca6..a0667719c1 100644
--- a/src/libxrpl/tx/applySteps.cpp
+++ b/src/libxrpl/tx/applySteps.cpp
@@ -84,7 +84,7 @@ with_txn_type(Rules const& rules, TxType txnType, F&& f)
     else
     {
         // Without those features enabled, always use the old number rules.
-        mantissaScaleGuard.emplace(MantissaRange::small);
+        mantissaScaleGuard.emplace(MantissaRange::mantissa_scale::small);
     }
 
     switch (txnType)
@@ -130,7 +130,7 @@ template <class T>
 TxConsequences
 consequences_helper(PreflightContext const& ctx)
 {
-    return TxConsequences(ctx.tx, TxConsequences::blocker);
+    return TxConsequences(ctx.tx, TxConsequences::Category::blocker);
 };
 
 // For Transactor::Custom
@@ -279,7 +279,7 @@ TxConsequences::TxConsequences(STTx const& tx)
 
 TxConsequences::TxConsequences(STTx const& tx, Category category) : TxConsequences(tx)
 {
-    isBlocker_ = (category == blocker);
+    isBlocker_ = (category == Category::blocker);
 }
 
 TxConsequences::TxConsequences(STTx const& tx, XRPAmount potentialSpend) : TxConsequences(tx)
diff --git a/src/libxrpl/tx/invariants/AMMInvariant.cpp b/src/libxrpl/tx/invariants/AMMInvariant.cpp
index 30be382c91..af60f3fc55 100644
--- a/src/libxrpl/tx/invariants/AMMInvariant.cpp
+++ b/src/libxrpl/tx/invariants/AMMInvariant.cpp
@@ -146,8 +146,8 @@ ValidAMM::finalizeCreate(
             *ammAccount_,
             tx[sfAmount].asset(),
             tx[sfAmount2].asset(),
-            fhIGNORE_FREEZE,
-            ahIGNORE_AUTH,
+            FreezeHandling::fhIGNORE_FREEZE,
+            AuthHandling::ahIGNORE_AUTH,
             j);
         // Create invariant:
         // sqrt(amount * amount2) == LPTokens
@@ -210,7 +210,13 @@ ValidAMM::generalInvariant(
     // NOLINTBEGIN(bugprone-unchecked-optional-access) ammAccount_ and lptAMMBalanceAfter_ set
     // together in visitEntry; callers only invoke this inside else-of-if(!ammAccount_)
     auto const [amount, amount2] = ammPoolHolds(
-        view, *ammAccount_, tx[sfAsset], tx[sfAsset2], fhIGNORE_FREEZE, ahIGNORE_AUTH, j);
+        view,
+        *ammAccount_,
+        tx[sfAsset],
+        tx[sfAsset2],
+        FreezeHandling::fhIGNORE_FREEZE,
+        AuthHandling::ahIGNORE_AUTH,
+        j);
     // Deposit and Withdrawal invariant:
     // sqrt(amount * amount2) >= LPTokens
     // all balances are greater than zero
diff --git a/src/libxrpl/tx/invariants/InvariantCheck.cpp b/src/libxrpl/tx/invariants/InvariantCheck.cpp
index f2570d14e8..e97501f129 100644
--- a/src/libxrpl/tx/invariants/InvariantCheck.cpp
+++ b/src/libxrpl/tx/invariants/InvariantCheck.cpp
@@ -804,10 +804,17 @@ ValidClawback::finalize(
             AccountID const& holder = amount.getIssuer();
             STAmount const holderBalance = amount.asset().visit(
                 [&](Issue const& issue) {
-                    return accountHolds(view, holder, issue.currency, issuer, fhIGNORE_FREEZE, j);
+                    return accountHolds(
+                        view, holder, issue.currency, issuer, FreezeHandling::fhIGNORE_FREEZE, j);
                 },
                 [&](MPTIssue const& issue) {
-                    return accountHolds(view, issuer, issue, fhIGNORE_FREEZE, ahIGNORE_AUTH, j);
+                    return accountHolds(
+                        view,
+                        issuer,
+                        issue,
+                        FreezeHandling::fhIGNORE_FREEZE,
+                        AuthHandling::ahIGNORE_AUTH,
+                        j);
                 });
 
             if (holderBalance.signum() < 0)
diff --git a/src/libxrpl/tx/invariants/MPTInvariant.cpp b/src/libxrpl/tx/invariants/MPTInvariant.cpp
index e010b79b87..97db4aa385 100644
--- a/src/libxrpl/tx/invariants/MPTInvariant.cpp
+++ b/src/libxrpl/tx/invariants/MPTInvariant.cpp
@@ -18,6 +18,7 @@
 #include <xrpl/protocol/XRPAmount.h>
 #include <xrpl/tx/invariants/InvariantCheckPrivilege.h>
 
+#include <cstddef>
 #include <cstdint>
 #include <memory>
 
@@ -303,7 +304,7 @@ ValidMPTPayment::visitEntry(
                 overflow_ = true;
                 return false;
             }
-            data_[makeKey(sle)].outstanding[order] = outstanding;
+            data_[makeKey(sle)].outstanding[static_cast<std::size_t>(order)] = outstanding;
         }
         else if (type == ltMPTOKEN)
         {
@@ -317,7 +318,7 @@ ValidMPTPayment::visitEntry(
             }
             auto const res = static_cast<std::int64_t>(mptAmt + lockedAmt);
             // subtract before from after
-            if (order == Before)
+            if (order == Order::Before)
             {
                 data_[makeKey(sle)].mptAmount -= res;
             }
@@ -329,7 +330,7 @@ ValidMPTPayment::visitEntry(
         return true;
     };
 
-    if (before && !update(*before, Before))
+    if (before && !update(*before, Order::Before))
         return;
 
     if (after)
@@ -338,7 +339,7 @@ ValidMPTPayment::visitEntry(
         {
             overflow_ = (*after)[sfOutstandingAmount] > maxMPTAmount(*after);
         }
-        if (!update(*after, After))
+        if (!update(*after, Order::After))
             return;
     }
 }
@@ -364,15 +365,17 @@ ValidMPTPayment::finalize(
         for (auto const& [id, data] : data_)
         {
             (void)id;
+            constexpr auto iBefore = static_cast<std::size_t>(Order::Before);
+            constexpr auto iAfter = static_cast<std::size_t>(Order::After);
             bool const addOverflows =
-                (data.mptAmount > 0 && data.outstanding[Before] > (signedMax - data.mptAmount)) ||
-                (data.mptAmount < 0 && data.outstanding[Before] < (-signedMax - data.mptAmount));
+                (data.mptAmount > 0 && data.outstanding[iBefore] > (signedMax - data.mptAmount)) ||
+                (data.mptAmount < 0 && data.outstanding[iBefore] < (-signedMax - data.mptAmount));
             if (addOverflows ||
-                data.outstanding[After] != (data.outstanding[Before] + data.mptAmount))
+                data.outstanding[iAfter] != (data.outstanding[iBefore] + data.mptAmount))
             {
                 JLOG(j.fatal()) << "Invariant failed: invalid OutstandingAmount balance "
-                                << data.outstanding[Before] << " " << data.outstanding[After] << " "
-                                << data.mptAmount;
+                                << data.outstanding[iBefore] << " " << data.outstanding[iAfter]
+                                << " " << data.mptAmount;
                 return !enforce;
             }
         }
diff --git a/src/libxrpl/tx/paths/BookStep.cpp b/src/libxrpl/tx/paths/BookStep.cpp
index 49a5f48034..480a702dc9 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)
+    if (ctx.offerCrossing != OfferCrossing::no)
     {
         auto offerCrossingStep = std::make_unique<BookOfferCrossingStep<TIn, TOut>>(ctx, in, out);
         ter = offerCrossingStep->check(ctx);
diff --git a/src/libxrpl/tx/paths/DirectStep.cpp b/src/libxrpl/tx/paths/DirectStep.cpp
index a6f74c9c9f..c2ad818b73 100644
--- a/src/libxrpl/tx/paths/DirectStep.cpp
+++ b/src/libxrpl/tx/paths/DirectStep.cpp
@@ -479,8 +479,8 @@ template <class TDerived>
 std::pair<IOUAmount, DebtDirection>
 DirectStepI<TDerived>::maxPaymentFlow(ReadView const& sb) const
 {
-    auto const srcOwed =
-        toAmount<IOUAmount>(accountHolds(sb, src_, currency_, dst_, fhIGNORE_FREEZE, j_));
+    auto const srcOwed = toAmount<IOUAmount>(
+        accountHolds(sb, src_, currency_, dst_, FreezeHandling::fhIGNORE_FREEZE, j_));
 
     if (srcOwed.signum() > 0)
         return {srcOwed, DebtDirection::redeems};
@@ -496,7 +496,8 @@ DirectStepI<TDerived>::debtDirection(ReadView const& sb, StrandDirection dir) co
     if (dir == StrandDirection::forward && cache_)
         return cache_->srcDebtDir;
 
-    auto const srcOwed = accountHolds(sb, src_, currency_, dst_, fhIGNORE_FREEZE, j_);
+    auto const srcOwed =
+        accountHolds(sb, src_, currency_, dst_, FreezeHandling::fhIGNORE_FREEZE, j_);
     return srcOwed.signum() > 0 ? DebtDirection::redeems : DebtDirection::issues;
 }
 
@@ -930,7 +931,7 @@ make_DirectStepI(
 {
     TER ter = tefINTERNAL;
     std::unique_ptr<Step> r;
-    if (ctx.offerCrossing != 0u)
+    if (ctx.offerCrossing != OfferCrossing::no)
     {
         auto offerCrossingStep = std::make_unique<DirectIOfferCrossingStep>(ctx, src, dst, c);
         ter = offerCrossingStep->check(ctx);
diff --git a/src/libxrpl/tx/paths/MPTEndpointStep.cpp b/src/libxrpl/tx/paths/MPTEndpointStep.cpp
index a79df25479..3dbc4e30cf 100644
--- a/src/libxrpl/tx/paths/MPTEndpointStep.cpp
+++ b/src/libxrpl/tx/paths/MPTEndpointStep.cpp
@@ -382,8 +382,13 @@ MPTEndpointPaymentStep::check(StrandContext const& ctx, std::shared_ptr<const SL
 
     if (prevStep_ == nullptr)
     {
-        auto const owed =
-            accountFunds(ctx.view, src_, mptIssue_, fhIGNORE_FREEZE, ahIGNORE_AUTH, j_);
+        auto const owed = accountFunds(
+            ctx.view,
+            src_,
+            mptIssue_,
+            FreezeHandling::fhIGNORE_FREEZE,
+            AuthHandling::ahIGNORE_AUTH,
+            j_);
         // Already at MaximumAmount
         if (owed <= beast::zero)
             return tecPATH_DRY;
@@ -424,7 +429,8 @@ template <class TDerived>
 std::pair<MPTAmount, DebtDirection>
 MPTEndpointStep<TDerived>::maxPaymentFlow(ReadView const& sb) const
 {
-    auto const maxFlow = accountFunds(sb, src_, mptIssue_, fhIGNORE_FREEZE, ahIGNORE_AUTH, j_);
+    auto const maxFlow = accountFunds(
+        sb, src_, mptIssue_, FreezeHandling::fhIGNORE_FREEZE, AuthHandling::ahIGNORE_AUTH, j_);
 
     // From a holder to an issuer
     if (src_ != mptIssue_.getIssuer())
diff --git a/src/libxrpl/tx/paths/OfferStream.cpp b/src/libxrpl/tx/paths/OfferStream.cpp
index c2f2fed25b..67f9a294b7 100644
--- a/src/libxrpl/tx/paths/OfferStream.cpp
+++ b/src/libxrpl/tx/paths/OfferStream.cpp
@@ -266,8 +266,8 @@ TOfferStreamBase<TIn, TOut>::step()
             offer_.owner(),
             amount.out,
             offer_.assetOut(),
-            fhZERO_IF_FROZEN,
-            ahZERO_IF_UNAUTHORIZED,
+            FreezeHandling::fhZERO_IF_FROZEN,
+            AuthHandling::ahZERO_IF_UNAUTHORIZED,
             j_);
 
         // Check for unfunded offer
@@ -281,8 +281,8 @@ TOfferStreamBase<TIn, TOut>::step()
                 offer_.owner(),
                 amount.out,
                 offer_.assetOut(),
-                fhZERO_IF_FROZEN,
-                ahZERO_IF_UNAUTHORIZED,
+                FreezeHandling::fhZERO_IF_FROZEN,
+                AuthHandling::ahZERO_IF_UNAUTHORIZED,
                 j_);
 
             if (original_funds == *ownerFunds_)
@@ -306,8 +306,8 @@ TOfferStreamBase<TIn, TOut>::step()
                 offer_.owner(),
                 amount.out,
                 offer_.assetOut(),
-                fhZERO_IF_FROZEN,
-                ahZERO_IF_UNAUTHORIZED,
+                FreezeHandling::fhZERO_IF_FROZEN,
+                AuthHandling::ahZERO_IF_UNAUTHORIZED,
                 j_);
 
             if (original_funds == *ownerFunds_)
diff --git a/src/libxrpl/tx/paths/XRPEndpointStep.cpp b/src/libxrpl/tx/paths/XRPEndpointStep.cpp
index 95228ed158..2310f72f34 100644
--- a/src/libxrpl/tx/paths/XRPEndpointStep.cpp
+++ b/src/libxrpl/tx/paths/XRPEndpointStep.cpp
@@ -396,7 +396,7 @@ make_XRPEndpointStep(StrandContext const& ctx, AccountID const& acc)
 {
     TER ter = tefINTERNAL;
     std::unique_ptr<Step> r;
-    if (ctx.offerCrossing != 0u)
+    if (ctx.offerCrossing != OfferCrossing::no)
     {
         auto offerCrossingStep = std::make_unique<XRPEndpointOfferCrossingStep>(ctx, acc);
         ter = offerCrossingStep->check(ctx);
diff --git a/src/libxrpl/tx/transactors/account/AccountSet.cpp b/src/libxrpl/tx/transactors/account/AccountSet.cpp
index a892bd045c..e8555ecc04 100644
--- a/src/libxrpl/tx/transactors/account/AccountSet.cpp
+++ b/src/libxrpl/tx/transactors/account/AccountSet.cpp
@@ -39,19 +39,19 @@ AccountSet::makeTxConsequences(PreflightContext const& ctx)
     auto getTxConsequencesCategory = [](STTx const& tx) {
         if (std::uint32_t const uTxFlags = tx.getFlags();
             uTxFlags & (tfRequireAuth | tfOptionalAuth))
-            return TxConsequences::blocker;
+            return TxConsequences::Category::blocker;
 
         if (auto const uSetFlag = tx[~sfSetFlag]; uSetFlag &&
             (*uSetFlag == asfRequireAuth || *uSetFlag == asfDisableMaster ||
              *uSetFlag == asfAccountTxnID))
-            return TxConsequences::blocker;
+            return TxConsequences::Category::blocker;
 
         if (auto const uClearFlag = tx[~sfClearFlag]; uClearFlag &&
             (*uClearFlag == asfRequireAuth || *uClearFlag == asfDisableMaster ||
              *uClearFlag == asfAccountTxnID))
-            return TxConsequences::blocker;
+            return TxConsequences::Category::blocker;
 
-        return TxConsequences::normal;
+        return TxConsequences::Category::normal;
     };
 
     return TxConsequences{ctx.tx, getTxConsequencesCategory(ctx.tx)};
diff --git a/src/libxrpl/tx/transactors/account/SignerListSet.cpp b/src/libxrpl/tx/transactors/account/SignerListSet.cpp
index 87eb69e706..ee4cf583f4 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 = unknown;
+    Operation op = Operation::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 = set;
+        op = Operation::set;
     }
     else if ((quorum == 0) && !hasSignerEntries)
     {
-        op = destroy;
+        op = Operation::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) == unknown)
+    if (std::get<3>(result) == Operation::unknown)
     {
         // Neither a set nor a destroy.  Malformed.
         JLOG(ctx.j.trace()) << "Malformed transaction: Invalid signer set list format.";
         return temMALFORMED;
     }
 
-    if (std::get<3>(result) == set)
+    if (std::get<3>(result) == Operation::set)
     {
         // Validate our settings.
         auto const account = ctx.tx.getAccountID(sfAccount);
@@ -113,10 +113,10 @@ SignerListSet::doApply()
     // Perform the operation preCompute() decided on.
     switch (do_)
     {
-        case set:
+        case Operation::set:
             return replaceSignerList();
 
-        case destroy:
+        case Operation::destroy:
             return destroySignerList();
 
         default:
@@ -137,7 +137,7 @@ SignerListSet::preCompute()
         isTesSuccess(std::get<0>(result)),
         "xrpl::SignerListSet::preCompute : result is tesSUCCESS");
     XRPL_ASSERT(
-        std::get<3>(result) != unknown,
+        std::get<3>(result) != Operation::unknown,
         "xrpl::SignerListSet::preCompute : result is known operation");
 
     quorum_ = std::get<1>(result);
diff --git a/src/libxrpl/tx/transactors/check/CheckCash.cpp b/src/libxrpl/tx/transactors/check/CheckCash.cpp
index 4498a3cd8e..31bca0aa32 100644
--- a/src/libxrpl/tx/transactors/check/CheckCash.cpp
+++ b/src/libxrpl/tx/transactors/check/CheckCash.cpp
@@ -164,8 +164,8 @@ CheckCash::preclaim(PreclaimContext const& ctx)
                 ctx.view,
                 sleCheck->at(sfAccount),
                 value,
-                fhZERO_IF_FROZEN,
-                ahZERO_IF_UNAUTHORIZED,
+                FreezeHandling::fhZERO_IF_FROZEN,
+                AuthHandling::ahZERO_IF_UNAUTHORIZED,
                 ctx.j)};
 
             // Note that src will have one reserve's worth of additional XRP
diff --git a/src/libxrpl/tx/transactors/dex/OfferCreate.cpp b/src/libxrpl/tx/transactors/dex/OfferCreate.cpp
index 119f244185..1ce48145f3 100644
--- a/src/libxrpl/tx/transactors/dex/OfferCreate.cpp
+++ b/src/libxrpl/tx/transactors/dex/OfferCreate.cpp
@@ -192,8 +192,13 @@ OfferCreate::preclaim(PreclaimContext const& ctx)
 
     // Allow unfunded MPT for issuer (OutstandingAmount >= MaximumAmount)
     if ((!saTakerGets.holds<MPTIssue>() || saTakerGets.getIssuer() != id) &&
-        accountFunds(ctx.view, id, saTakerGets, fhZERO_IF_FROZEN, ahZERO_IF_UNAUTHORIZED, viewJ) <=
-            beast::zero)
+        accountFunds(
+            ctx.view,
+            id,
+            saTakerGets,
+            FreezeHandling::fhZERO_IF_FROZEN,
+            AuthHandling::ahZERO_IF_UNAUTHORIZED,
+            viewJ) <= beast::zero)
     {
         JLOG(ctx.j.debug()) << "delay: Offers must be at least partially funded.";
         return tecUNFUNDED_OFFER;
@@ -338,7 +343,12 @@ OfferCreate::flowCross(
         // cause a user's available balance to go to 0 (by causing it to dip
         // below the reserve) so we check this case again.
         STAmount const inStartBalance = accountFunds(
-            psb, account_, takerAmount.in, fhZERO_IF_FROZEN, ahZERO_IF_UNAUTHORIZED, j_);
+            psb,
+            account_,
+            takerAmount.in,
+            FreezeHandling::fhZERO_IF_FROZEN,
+            AuthHandling::ahZERO_IF_UNAUTHORIZED,
+            j_);
         // Allow unfunded MPT issuer
         auto const disallowUnfunded =
             !inStartBalance.holds<MPTIssue>() || inStartBalance.getIssuer() != account_;
@@ -448,7 +458,12 @@ OfferCreate::flowCross(
         if (isTesSuccess(result.result()))
         {
             STAmount const takerInBalance = accountFunds(
-                psb, account_, takerAmount.in, fhZERO_IF_FROZEN, ahZERO_IF_UNAUTHORIZED, j_);
+                psb,
+                account_,
+                takerAmount.in,
+                FreezeHandling::fhZERO_IF_FROZEN,
+                AuthHandling::ahZERO_IF_UNAUTHORIZED,
+                j_);
 
             if (disallowUnfunded && takerInBalance <= beast::zero)
             {
diff --git a/src/libxrpl/tx/transactors/escrow/EscrowCreate.cpp b/src/libxrpl/tx/transactors/escrow/EscrowCreate.cpp
index 9d16d41914..c112d3b349 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, fhIGNORE_FREEZE, ctx.j);
+    STAmount const spendableAmount = accountHolds(
+        ctx.view, account, issue.currency, issuer, FreezeHandling::fhIGNORE_FREEZE, ctx.j);
 
     // If the balance is less than or equal to 0, return tecINSUFFICIENT_FUNDS
     if (spendableAmount <= beast::zero)
@@ -305,7 +305,12 @@ escrowCreatePreclaimHelper<MPTIssue>(
         return ter;
 
     STAmount const spendableAmount = accountHolds(
-        ctx.view, account, amount.get<MPTIssue>(), fhIGNORE_FREEZE, ahIGNORE_AUTH, ctx.j);
+        ctx.view,
+        account,
+        amount.get<MPTIssue>(),
+        FreezeHandling::fhIGNORE_FREEZE,
+        AuthHandling::ahIGNORE_AUTH,
+        ctx.j);
 
     // If the balance is less than or equal to 0, return tecINSUFFICIENT_FUNDS
     if (spendableAmount <= beast::zero)
diff --git a/src/libxrpl/tx/transactors/lending/LoanBrokerCoverClawback.cpp b/src/libxrpl/tx/transactors/lending/LoanBrokerCoverClawback.cpp
index 36ff1cc2de..6dc57479e6 100644
--- a/src/libxrpl/tx/transactors/lending/LoanBrokerCoverClawback.cpp
+++ b/src/libxrpl/tx/transactors/lending/LoanBrokerCoverClawback.cpp
@@ -164,11 +164,11 @@ determineClawAmount(
 {
     auto const maxClawAmount = [&]() {
         // Always round the minimum required up
-        NumberRoundModeGuard const mg1(Number::upward);
+        NumberRoundModeGuard const mg1(Number::rounding_mode::upward);
         auto const minRequiredCover =
             tenthBipsOfValue(sleBroker[sfDebtTotal], TenthBips32(sleBroker[sfCoverRateMinimum]));
         // The subtraction probably won't round, but round down if it does.
-        NumberRoundModeGuard const mg2(Number::downward);
+        NumberRoundModeGuard const mg2(Number::rounding_mode::downward);
         return sleBroker[sfCoverAvailable] - minRequiredCover;
     }();
     if (maxClawAmount <= beast::zero)
@@ -295,8 +295,12 @@ LoanBrokerCoverClawback::preclaim(PreclaimContext const& ctx)
     // balance is actually there. It should always match `sfCoverAvailable`, so
     // if there isn't, this is an internal error.
     if (accountHolds(
-            ctx.view, brokerPseudoAccountID, vaultAsset, fhIGNORE_FREEZE, ahIGNORE_AUTH, ctx.j) <
-        clawAmount)
+            ctx.view,
+            brokerPseudoAccountID,
+            vaultAsset,
+            FreezeHandling::fhIGNORE_FREEZE,
+            AuthHandling::ahIGNORE_AUTH,
+            ctx.j) < clawAmount)
         return tecINTERNAL;  // tecINSUFFICIENT_FUNDS; LCOV_EXCL_LINE
 
     // Check if the vault asset issuer has the correct flags
diff --git a/src/libxrpl/tx/transactors/lending/LoanBrokerCoverWithdraw.cpp b/src/libxrpl/tx/transactors/lending/LoanBrokerCoverWithdraw.cpp
index 7061ec99c3..06f2e518ab 100644
--- a/src/libxrpl/tx/transactors/lending/LoanBrokerCoverWithdraw.cpp
+++ b/src/libxrpl/tx/transactors/lending/LoanBrokerCoverWithdraw.cpp
@@ -133,7 +133,7 @@ LoanBrokerCoverWithdraw::preclaim(PreclaimContext const& ctx)
     auto const minimumCover = [&]() {
         // Always round the minimum required up.
         // Applies to `tenthBipsOfValue` as well as `roundToAsset`.
-        NumberRoundModeGuard const mg(Number::upward);
+        NumberRoundModeGuard const mg(Number::rounding_mode::upward);
         return roundToAsset(
             vaultAsset,
             tenthBipsOfValue(currentDebtTotal, TenthBips32(sleBroker->at(sfCoverRateMinimum))),
diff --git a/src/libxrpl/tx/transactors/lending/LoanBrokerDelete.cpp b/src/libxrpl/tx/transactors/lending/LoanBrokerDelete.cpp
index 6b1abe45aa..8343b6e931 100644
--- a/src/libxrpl/tx/transactors/lending/LoanBrokerDelete.cpp
+++ b/src/libxrpl/tx/transactors/lending/LoanBrokerDelete.cpp
@@ -81,7 +81,8 @@ LoanBrokerDelete::preclaim(PreclaimContext const& ctx)
         // Delete. This check is purely defensive.
         auto const scale = getAssetsTotalScale(vault);
 
-        auto const rounded = roundToAsset(asset, debtTotal, scale, Number::towards_zero);
+        auto const rounded =
+            roundToAsset(asset, debtTotal, scale, Number::rounding_mode::towards_zero);
 
         if (rounded != beast::zero)
         {
diff --git a/src/libxrpl/tx/transactors/lending/LoanDelete.cpp b/src/libxrpl/tx/transactors/lending/LoanDelete.cpp
index 784bef7d78..875af3a03b 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::towards_zero) == beast::zero,
+                    Number::rounding_mode::towards_zero) == beast::zero,
                 "xrpl::LoanDelete::doApply",
                 "last loan, remaining debt rounds to zero");
             debtTotalProxy = 0;
diff --git a/src/libxrpl/tx/transactors/lending/LoanManage.cpp b/src/libxrpl/tx/transactors/lending/LoanManage.cpp
index 87afc2d908..de3de6ca25 100644
--- a/src/libxrpl/tx/transactors/lending/LoanManage.cpp
+++ b/src/libxrpl/tx/transactors/lending/LoanManage.cpp
@@ -167,7 +167,7 @@ LoanManage::defaultLoan(
     TenthBips32 const coverRateLiquidation{brokerSle->at(sfCoverRateLiquidation)};
     auto const defaultCovered = [&]() {
         // Always round the minimum required up.
-        NumberRoundModeGuard const mg(Number::upward);
+        NumberRoundModeGuard const mg(Number::rounding_mode::upward);
         auto const minimumCover = tenthBipsOfValue(brokerDebtTotalProxy.value(), coverRateMinimum);
         // Round the liquidation amount up, too
         auto const covered = roundToAsset(
@@ -206,8 +206,8 @@ LoanManage::defaultLoan(
             // LCOV_EXCL_STOP
         }
 
-        auto const vaultDefaultRounded =
-            roundToAsset(vaultAsset, vaultDefaultAmount, vaultScale, Number::downward);
+        auto const vaultDefaultRounded = roundToAsset(
+            vaultAsset, vaultDefaultAmount, vaultScale, Number::rounding_mode::downward);
         vaultTotalProxy -= vaultDefaultRounded;
         // Increase the Asset Available of the Vault by liquidated First-Loss
         // Capital and any unclaimed funds amount:
diff --git a/src/libxrpl/tx/transactors/lending/LoanPay.cpp b/src/libxrpl/tx/transactors/lending/LoanPay.cpp
index c08518a93e..f24fdc19b3 100644
--- a/src/libxrpl/tx/transactors/lending/LoanPay.cpp
+++ b/src/libxrpl/tx/transactors/lending/LoanPay.cpp
@@ -138,12 +138,14 @@ LoanPay::calculateBaseFee(ReadView const& view, STTx const& tx)
 
     // If making an overpayment, count it as a full payment because it will do
     // about the same amount of work, if not more.
-    NumberRoundModeGuard const mg(tx.isFlag(tfLoanOverpayment) ? Number::upward : Number::downward);
+    NumberRoundModeGuard const mg(
+        tx.isFlag(tfLoanOverpayment) ? Number::rounding_mode::upward
+                                     : Number::rounding_mode::downward);
     // Estimate how many payments will be made
     Number const numPaymentEstimate = static_cast<std::int64_t>(amount / regularPayment);
 
     // Charge one base fee per paymentsPerFeeIncrement payments, rounding up.
-    Number::setround(Number::upward);
+    Number::setround(Number::rounding_mode::upward);
     auto const feeIncrements = std::max(
         std::int64_t(1),
         static_cast<std::int64_t>(numPaymentEstimate / loanPaymentsPerFeeIncrement));
@@ -240,8 +242,8 @@ LoanPay::preclaim(PreclaimContext const& ctx)
             ctx.view,
             account,
             asset,
-            fhZERO_IF_FROZEN,
-            ahZERO_IF_UNAUTHORIZED,
+            FreezeHandling::fhZERO_IF_FROZEN,
+            AuthHandling::ahZERO_IF_UNAUTHORIZED,
             ctx.j,
             SpendableHandling::shFULL_BALANCE);
         balance < amount)
@@ -298,7 +300,7 @@ LoanPay::doApply()
         // Round the minimum required cover up to be conservative. This ensures
         // CoverAvailable never drops below the theoretical minimum, protecting
         // the broker's solvency.
-        NumberRoundModeGuard const mg(Number::upward);
+        NumberRoundModeGuard const mg(Number::rounding_mode::upward);
         return coverAvailableProxy >=
             roundToAsset(
                    asset, tenthBipsOfValue(debtTotalProxy.value(), coverRateMinimum), loanScale) &&
@@ -404,7 +406,7 @@ LoanPay::doApply()
 
     auto const totalPaidToVaultRaw = paymentParts->principalPaid + paymentParts->interestPaid;
     auto const totalPaidToVaultRounded =
-        roundToAsset(asset, totalPaidToVaultRaw, vaultScale, Number::downward);
+        roundToAsset(asset, totalPaidToVaultRaw, vaultScale, Number::rounding_mode::downward);
     XRPL_ASSERT_PARTS(
         !asset.integral() || totalPaidToVaultRaw == totalPaidToVaultRounded,
         "xrpl::LoanPay::doApply",
@@ -511,8 +513,8 @@ LoanPay::doApply()
         view,
         account_,
         asset,
-        fhIGNORE_FREEZE,
-        ahIGNORE_AUTH,
+        FreezeHandling::fhIGNORE_FREEZE,
+        AuthHandling::ahIGNORE_AUTH,
         j_,
         SpendableHandling::shFULL_BALANCE);
     auto const vaultBalanceBefore = account_ == vaultPseudoAccount
@@ -521,8 +523,8 @@ LoanPay::doApply()
               view,
               vaultPseudoAccount,
               asset,
-              fhIGNORE_FREEZE,
-              ahIGNORE_AUTH,
+              FreezeHandling::fhIGNORE_FREEZE,
+              AuthHandling::ahIGNORE_AUTH,
               j_,
               SpendableHandling::shFULL_BALANCE);
     auto const brokerBalanceBefore = account_ == brokerPayee
@@ -531,8 +533,8 @@ LoanPay::doApply()
               view,
               brokerPayee,
               asset,
-              fhIGNORE_FREEZE,
-              ahIGNORE_AUTH,
+              FreezeHandling::fhIGNORE_FREEZE,
+              AuthHandling::ahIGNORE_AUTH,
               j_,
               SpendableHandling::shFULL_BALANCE);
 #endif
@@ -588,8 +590,8 @@ LoanPay::doApply()
         view,
         account_,
         asset,
-        fhIGNORE_FREEZE,
-        ahIGNORE_AUTH,
+        FreezeHandling::fhIGNORE_FREEZE,
+        AuthHandling::ahIGNORE_AUTH,
         j_,
         SpendableHandling::shFULL_BALANCE);
     auto const vaultBalanceAfter = account_ == vaultPseudoAccount
@@ -598,8 +600,8 @@ LoanPay::doApply()
               view,
               vaultPseudoAccount,
               asset,
-              fhIGNORE_FREEZE,
-              ahIGNORE_AUTH,
+              FreezeHandling::fhIGNORE_FREEZE,
+              AuthHandling::ahIGNORE_AUTH,
               j_,
               SpendableHandling::shFULL_BALANCE);
     auto const brokerBalanceAfter = account_ == brokerPayee
@@ -608,8 +610,8 @@ LoanPay::doApply()
               view,
               brokerPayee,
               asset,
-              fhIGNORE_FREEZE,
-              ahIGNORE_AUTH,
+              FreezeHandling::fhIGNORE_FREEZE,
+              AuthHandling::ahIGNORE_AUTH,
               j_,
               SpendableHandling::shFULL_BALANCE);
 
diff --git a/src/libxrpl/tx/transactors/lending/LoanSet.cpp b/src/libxrpl/tx/transactors/lending/LoanSet.cpp
index 48a6005c7b..757ec0ec66 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::upward);
+        NumberRoundModeGuard const mg(Number::rounding_mode::upward);
         if (brokerSle->at(sfCoverAvailable) < tenthBipsOfValue(newDebtTotal, coverRateMinimum))
         {
             JLOG(j_.warn()) << "Insufficient first-loss capital to cover the loan.";
diff --git a/src/libxrpl/tx/transactors/nft/NFTokenAcceptOffer.cpp b/src/libxrpl/tx/transactors/nft/NFTokenAcceptOffer.cpp
index 296020ff95..9de382733d 100644
--- a/src/libxrpl/tx/transactors/nft/NFTokenAcceptOffer.cpp
+++ b/src/libxrpl/tx/transactors/nft/NFTokenAcceptOffer.cpp
@@ -189,7 +189,8 @@ NFTokenAcceptOffer::preclaim(PreclaimContext const& ctx)
         // own currency
         auto const needed = bo->at(sfAmount);
 
-        if (accountFunds(ctx.view, (*bo)[sfOwner], needed, fhZERO_IF_FROZEN, ctx.j) < needed)
+        if (accountFunds(
+                ctx.view, (*bo)[sfOwner], needed, FreezeHandling::fhZERO_IF_FROZEN, ctx.j) < needed)
             return tecINSUFFICIENT_FUNDS;
 
         // Check that the account accepting the buy offer (he's selling the NFT)
@@ -257,7 +258,9 @@ NFTokenAcceptOffer::preclaim(PreclaimContext const& ctx)
             // mode, because then we are confirming that the broker can
             // cover what the buyer will pay, which doesn't make sense, causes
             // an unnecessary tec, and is also resolved with this amendment.
-            if (accountFunds(ctx.view, ctx.tx[sfAccount], needed, fhZERO_IF_FROZEN, ctx.j) < needed)
+            if (accountFunds(
+                    ctx.view, ctx.tx[sfAccount], needed, FreezeHandling::fhZERO_IF_FROZEN, ctx.j) <
+                needed)
                 return tecINSUFFICIENT_FUNDS;
         }
 
@@ -345,9 +348,9 @@ NFTokenAcceptOffer::pay(AccountID const& from, AccountID const& to, STAmount con
     // just confirm that the end state is OK.
     if (!isTesSuccess(result))
         return result;
-    if (accountFunds(view(), from, amount, fhZERO_IF_FROZEN, j_).signum() < 0)
+    if (accountFunds(view(), from, amount, FreezeHandling::fhZERO_IF_FROZEN, j_).signum() < 0)
         return tecINSUFFICIENT_FUNDS;
-    if (accountFunds(view(), to, amount, fhZERO_IF_FROZEN, j_).signum() < 0)
+    if (accountFunds(view(), to, amount, FreezeHandling::fhZERO_IF_FROZEN, j_).signum() < 0)
         return tecINSUFFICIENT_FUNDS;
     return tesSUCCESS;
 }
diff --git a/src/libxrpl/tx/transactors/system/LedgerStateFix.cpp b/src/libxrpl/tx/transactors/system/LedgerStateFix.cpp
index 27cbad2e88..07ec677288 100644
--- a/src/libxrpl/tx/transactors/system/LedgerStateFix.cpp
+++ b/src/libxrpl/tx/transactors/system/LedgerStateFix.cpp
@@ -19,7 +19,7 @@ namespace xrpl {
 NotTEC
 LedgerStateFix::preflight(PreflightContext const& ctx)
 {
-    switch (ctx.tx[sfLedgerFixType])
+    switch (static_cast<FixType>(ctx.tx[sfLedgerFixType]))
     {
         case FixType::nfTokenPageLink:
             if (!ctx.tx.isFieldPresent(sfOwner))
@@ -44,7 +44,7 @@ LedgerStateFix::calculateBaseFee(ReadView const& view, STTx const& tx)
 TER
 LedgerStateFix::preclaim(PreclaimContext const& ctx)
 {
-    if (ctx.tx[sfLedgerFixType] == FixType::nfTokenPageLink)
+    if (static_cast<FixType>(ctx.tx[sfLedgerFixType]) == FixType::nfTokenPageLink)
     {
         AccountID const owner{ctx.tx[sfOwner]};
         if (!ctx.view.read(keylet::account(owner)))
@@ -60,7 +60,7 @@ LedgerStateFix::preclaim(PreclaimContext const& ctx)
 TER
 LedgerStateFix::doApply()
 {
-    if (ctx_.tx[sfLedgerFixType] == FixType::nfTokenPageLink)
+    if (static_cast<FixType>(ctx_.tx[sfLedgerFixType]) == FixType::nfTokenPageLink)
     {
         if (!nft::repairNFTokenDirectoryLinks(view(), ctx_.tx[sfOwner]))
             return tecFAILED_PROCESSING;
diff --git a/src/libxrpl/tx/transactors/token/Clawback.cpp b/src/libxrpl/tx/transactors/token/Clawback.cpp
index c9e6d32f6c..ff20bd82c3 100644
--- a/src/libxrpl/tx/transactors/token/Clawback.cpp
+++ b/src/libxrpl/tx/transactors/token/Clawback.cpp
@@ -138,8 +138,12 @@ preclaimHelper<Issue>(
     // the available balance of a trustline is prone to new changes (eg.
     // XLS-34). So we must use `accountHolds`.
     if (accountHolds(
-            ctx.view, holder, clawAmount.get<Issue>().currency, issuer, fhIGNORE_FREEZE, ctx.j) <=
-        beast::zero)
+            ctx.view,
+            holder,
+            clawAmount.get<Issue>().currency,
+            issuer,
+            FreezeHandling::fhIGNORE_FREEZE,
+            ctx.j) <= beast::zero)
         return tecINSUFFICIENT_FUNDS;
 
     return tesSUCCESS;
@@ -169,8 +173,12 @@ preclaimHelper<MPTIssue>(
         return tecOBJECT_NOT_FOUND;
 
     if (accountHolds(
-            ctx.view, holder, clawAmount.get<MPTIssue>(), fhIGNORE_FREEZE, ahIGNORE_AUTH, ctx.j) <=
-        beast::zero)
+            ctx.view,
+            holder,
+            clawAmount.get<MPTIssue>(),
+            FreezeHandling::fhIGNORE_FREEZE,
+            AuthHandling::ahIGNORE_AUTH,
+            ctx.j) <= beast::zero)
         return tecINSUFFICIENT_FUNDS;
 
     return tesSUCCESS;
@@ -229,7 +237,7 @@ applyHelper<Issue>(ApplyContext& ctx)
         holder,
         clawAmount.get<Issue>().currency,
         clawAmount.getIssuer(),
-        fhIGNORE_FREEZE,
+        FreezeHandling::fhIGNORE_FREEZE,
         ctx.journal);
 
     return directSendNoFee(
@@ -249,8 +257,8 @@ applyHelper<MPTIssue>(ApplyContext& ctx)
         ctx.view(),
         holder,
         clawAmount.get<MPTIssue>(),
-        fhIGNORE_FREEZE,
-        ahIGNORE_AUTH,
+        FreezeHandling::fhIGNORE_FREEZE,
+        AuthHandling::ahIGNORE_AUTH,
         ctx.journal);
 
     return directSendNoFee(
diff --git a/src/test/app/AMMExtended_test.cpp b/src/test/app/AMMExtended_test.cpp
index c94f0f405f..9eb7eb1620 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::small};
+    NumberMantissaScaleGuard const sg_{xrpl::MantissaRange::mantissa_scale::small};
 
 private:
     void
diff --git a/src/test/app/AMM_test.cpp b/src/test/app/AMM_test.cpp
index d2d7fbf2c7..d79bd667dd 100644
--- a/src/test/app/AMM_test.cpp
+++ b/src/test/app/AMM_test.cpp
@@ -73,7 +73,7 @@ namespace xrpl::test {
 struct AMM_test : public jtx::AMMTest
 {
     // Use small Number mantissas for the life of this test.
-    NumberMantissaScaleGuard const sg_{xrpl::MantissaRange::small};
+    NumberMantissaScaleGuard const sg_{xrpl::MantissaRange::mantissa_scale::small};
 
 private:
     static FeatureBitset
@@ -5802,7 +5802,7 @@ private:
         Env const env(*this, features, std::make_unique<CaptureLogs>(&logs));
         auto rules = env.current()->rules();
         CurrentTransactionRulesGuard const rg(rules);
-        NumberMantissaScaleGuard const sg(MantissaRange::small);
+        NumberMantissaScaleGuard const sg(MantissaRange::mantissa_scale::small);
 
         for (auto const& t : tests)
         {
@@ -6792,8 +6792,9 @@ private:
     {
         auto const [amount, amount2, lptBalance] = amm.balances(GBP, EUR);
 
-        NumberMantissaScaleGuard const sg(MantissaRange::small);
-        NumberRoundModeGuard const g(env.enabled(fixAMMv1_3) ? Number::upward : Number::getround());
+        NumberMantissaScaleGuard const sg(MantissaRange::mantissa_scale::small);
+        NumberRoundModeGuard const g(
+            env.enabled(fixAMMv1_3) ? Number::rounding_mode::upward : Number::getround());
         auto const res = root2(amount * amount2);
 
         if (shouldFail)
diff --git a/src/test/app/Delegate_test.cpp b/src/test/app/Delegate_test.cpp
index 5ed8c79146..d5847c5a85 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, delegable, ...) \
-    if (delegable == xrpl::delegable)                 \
-    {                                                 \
-        delegableCount++;                             \
+#define TRANSACTION(tag, value, name, txDelegable, ...) \
+    if (txDelegable == 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 = 75;
+        std::size_t const expectedDelegableCount = 51;
 
         BEAST_EXPECTS(
             delegableCount == expectedDelegableCount,
diff --git a/src/test/app/Invariants_test.cpp b/src/test/app/Invariants_test.cpp
index 5153e9d71e..c7fe90daa7 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::large};
+        NumberMantissaScaleGuard const g{MantissaRange::mantissa_scale::large};
 
         auto makeDelta = [&vaultAsset](Number const& n) -> ValidVault::DeltaInfo {
             return {.delta = n, .scale = scale(n, vaultAsset.raw())};
diff --git a/src/test/app/LedgerHistory_test.cpp b/src/test/app/LedgerHistory_test.cpp
index e78bdc588f..73944b617c 100644
--- a/src/test/app/LedgerHistory_test.cpp
+++ b/src/test/app/LedgerHistory_test.cpp
@@ -65,8 +65,8 @@ public:
         res->updateSkipList();
 
         {
-            res->stateMap().flushDirty(hotACCOUNT_NODE);
-            res->txMap().flushDirty(hotTRANSACTION_NODE);
+            res->stateMap().flushDirty(NodeObjectType::hotACCOUNT_NODE);
+            res->txMap().flushDirty(NodeObjectType::hotTRANSACTION_NODE);
         }
         res->unshare();
 
diff --git a/src/test/app/LoanBroker_test.cpp b/src/test/app/LoanBroker_test.cpp
index 55818b131c..1ffc34bdcc 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 LoanBrokerTest { CoverClawback, CoverDeposit, CoverWithdraw, Delete, Set };
+    enum class 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 == CoverDeposit)
+        if (brokerTest == LoanBrokerTest::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 == CoverWithdraw)
+        if (brokerTest == LoanBrokerTest::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 == CoverClawback)
+        if (brokerTest == LoanBrokerTest::CoverClawback)
         {
             // preflight: temINVALID (empty/zero broker id)
             testZeroBrokerID([&]() {
@@ -1038,7 +1038,7 @@ class LoanBroker_test : public beast::unit_test::suite
             env.close();
         }
 
-        if (brokerTest == Delete)
+        if (brokerTest == LoanBrokerTest::Delete)
         {
             Account const borrower{"borrower"};
             env.fund(XRP(1'000), borrower);
@@ -1070,7 +1070,7 @@ class LoanBroker_test : public beast::unit_test::suite
             env(del(alice, brokerKeylet.key));
         }
 
-        if (brokerTest == Set)
+        if (brokerTest == LoanBrokerTest::Set)
         {
             // preflight: temINVALID (empty/zero broker id)
             testZeroBrokerID([&]() {
@@ -1138,7 +1138,7 @@ class LoanBroker_test : public beast::unit_test::suite
 
         // Issue:
         // AllowTrustLineClawback is not set or NoFreeze is set
-        testLoanBroker({}, CoverClawback);
+        testLoanBroker({}, LoanBrokerTest::CoverClawback);
 
         // MPTIssue:
         // MPTCanClawback is not set
@@ -1147,7 +1147,7 @@ class LoanBroker_test : public beast::unit_test::suite
                 MPTTester const mpt({.env = env, .issuer = issuer, .holders = {alice}});
                 return mpt;
             },
-            CoverClawback);
+            LoanBrokerTest::CoverClawback);
     }
 
     void
@@ -1158,7 +1158,7 @@ class LoanBroker_test : public beast::unit_test::suite
 
         // preclaim:
         // tecWRONG_ASSET, tecINSUFFICIENT_FUNDS, frozen asset
-        testLoanBroker({}, CoverDeposit);
+        testLoanBroker({}, LoanBrokerTest::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({}, CoverWithdraw);
+        testLoanBroker({}, LoanBrokerTest::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({}, Delete);
+        testLoanBroker({}, LoanBrokerTest::Delete);
     }
 
     void
@@ -1207,7 +1207,7 @@ class LoanBroker_test : public beast::unit_test::suite
             addEmptyHolding failure
             can any of these happen?
         */
-        testLoanBroker({}, Set);
+        testLoanBroker({}, LoanBrokerTest::Set);
     }
 
     void
@@ -1585,7 +1585,7 @@ class LoanBroker_test : public beast::unit_test::suite
         Account const dest("destination");
         auto const token = issuer["IOU"];
 
-        enum TrustState {
+        enum class TrustState {
             RequireAuth,
             ZeroLimit,
             ReachedLimit,
@@ -1601,10 +1601,10 @@ class LoanBroker_test : public beast::unit_test::suite
             auto setTrustLine = [&](Account const& acct, TrustState state) {
                 switch (state)
                 {
-                    case RequireAuth:
+                    case TrustState::RequireAuth:
                         env(trust(issuer, token(0), acct, tfSetfAuth));
                         break;
-                    case ZeroLimit: {
+                    case TrustState::ZeroLimit: {
                         auto jv = trust(acct, token(0));
                         // set QualityIn so that the trustline is not
                         // auto-deleted
@@ -1612,19 +1612,19 @@ class LoanBroker_test : public beast::unit_test::suite
                         env(jv);
                     }
                     break;
-                    case ReachedLimit: {
+                    case TrustState::ReachedLimit: {
                         env(trust(acct, token(1'000)));
                         env(pay(issuer, acct, token(1'000)));
                         env.close();
                     }
                     break;
-                    case NearLimit: {
+                    case TrustState::NearLimit: {
                         env(trust(acct, token(1'000)));
                         env(pay(issuer, acct, token(950)));
                         env.close();
                     }
                     break;
-                    case NoTrustLine:
+                    case TrustState::NoTrustLine:
                         // don't create a trustline
                         break;
                     default:
@@ -1636,12 +1636,12 @@ class LoanBroker_test : public beast::unit_test::suite
             env.fund(XRP(1'000), issuer, broker, dest);
             env.close();
 
-            if (trustState == RequireAuth)
+            if (trustState == TrustState::RequireAuth)
             {
                 env(fset(issuer, asfRequireAuth));
                 env.close();
 
-                setTrustLine(broker, RequireAuth);
+                setTrustLine(broker, TrustState::RequireAuth);
             }
 
             setTrustLine(dest, trustState);
@@ -1683,7 +1683,7 @@ class LoanBroker_test : public beast::unit_test::suite
             env.close();
 
             // Clearing RequireAuth shouldn't change the result
-            if (trustState == RequireAuth)
+            if (trustState == TrustState::RequireAuth)
             {
                 env(fclear(issuer, asfRequireAuth));
                 env.close();
@@ -1696,11 +1696,11 @@ class LoanBroker_test : public beast::unit_test::suite
             }
         };
 
-        test(RequireAuth);
-        test(ZeroLimit);
-        test(ReachedLimit);
-        test(NearLimit);
-        test(NoTrustLine);
+        test(TrustState::RequireAuth);
+        test(TrustState::ZeroLimit);
+        test(TrustState::ReachedLimit);
+        test(TrustState::NearLimit);
+        test(TrustState::NoTrustLine);
     }
 
     void
@@ -1711,24 +1711,24 @@ class LoanBroker_test : public beast::unit_test::suite
         Account const broker("issuer");
         Account const dest("destination");
 
-        enum MPTState {
+        enum class MPTState {
             RequireAuth,
             ReachedMAX,
             NoMPT,
         };
 
-        auto test = [&](MPTState MPTState) {
+        auto test = [&](MPTState mptState) {
             Env env(*this);
 
-            testcase << "RIPD-4274 MPT with state: " << static_cast<int>(MPTState);
+            testcase << "RIPD-4274 MPT with state: " << static_cast<int>(mptState);
 
             env.fund(XRP(1'000), issuer, broker, dest);
             env.close();
 
             auto const maybeToken = [&]() -> std::optional<MPT> {
-                switch (MPTState)
+                switch (mptState)
                 {
-                    case RequireAuth: {
+                    case MPTState::RequireAuth: {
                         auto tester = MPTTester(
                             {.env = env,
                              .issuer = issuer,
@@ -1742,7 +1742,7 @@ class LoanBroker_test : public beast::unit_test::suite
                             {.account = issuer, .holder = dest, .flags = tfMPTUnauthorize});
                         return tester;
                     }
-                    case ReachedMAX: {
+                    case MPTState::ReachedMAX: {
                         auto tester = MPTTester(
                             {.env = env,
                              .issuer = issuer,
@@ -1753,7 +1753,7 @@ class LoanBroker_test : public beast::unit_test::suite
                         BEAST_EXPECT(env.balance(issuer, tester) == tester(-4'000));
                         return tester;
                     }
-                    case NoMPT: {
+                    case MPTState::NoMPT: {
                         return MPTTester(
                             {.env = env,
                              .issuer = issuer,
@@ -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 == ReachedMAX ? TER(tesSUCCESS) : tecNO_AUTH;
+            TER const err = mptState == 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(RequireAuth);
-        test(ReachedMAX);
-        test(NoMPT);
+        test(MPTState::RequireAuth);
+        test(MPTState::ReachedMAX);
+        test(MPTState::NoMPT);
     }
 
     void
diff --git a/src/test/app/Loan_test.cpp b/src/test/app/Loan_test.cpp
index 3fe727e368..f50a7f71d3 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::downward);
+            NumberRoundModeGuard const mg(Number::rounding_mode::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::upward);
+            NumberRoundModeGuard const mg(Number::rounding_mode::upward);
             BEAST_EXPECT(
                 state.totalValue ==
                 roundToAsset(
@@ -913,8 +913,8 @@ protected:
         }
 
         // Include the service fee
-        STAmount const totalDue =
-            roundToScale(roundedPeriodicPayment + serviceFee, state.loanScale, Number::upward);
+        STAmount const totalDue = roundToScale(
+            roundedPeriodicPayment + serviceFee, state.loanScale, Number::rounding_mode::upward);
 
         auto currentRoundedState = constructLoanState(
             state.totalValue, state.principalOutstanding, state.managementFeeOutstanding);
@@ -2013,7 +2013,7 @@ protected:
                          ? 0
                          : std::max(
                                broker.vaultScale(env), state.principalOutstanding.exponent())));
-                NumberRoundModeGuard const mg(Number::upward);
+                NumberRoundModeGuard const mg(Number::rounding_mode::upward);
                 auto const defaultAmount = roundToAsset(
                     broker.asset,
                     std::min(
@@ -2317,7 +2317,7 @@ protected:
                     // service fee is 2
                     auto const startingPayments = state.paymentRemaining;
                     STAmount const payoffAmount = [&]() {
-                        NumberRoundModeGuard const mg(Number::upward);
+                        NumberRoundModeGuard const mg(Number::rounding_mode::upward);
                         auto const rawPayoff =
                             startingPayments * (state.periodicPayment + broker.asset(2).value());
                         STAmount payoffAmount{broker.asset, rawPayoff};
@@ -2519,21 +2519,25 @@ protected:
                 BEAST_EXPECT(
                     roundedPeriodicPayment ==
                     roundToScale(
-                        broker.asset(Number(8333457002039338267, -17), Number::upward),
+                        broker.asset(
+                            Number(8333457002039338267, -17), Number::rounding_mode::upward),
                         state.loanScale,
-                        Number::upward));
+                        Number::rounding_mode::upward));
                 // 83334570.01162141
                 // Include the service fee
                 STAmount const totalDue = roundToScale(
-                    roundedPeriodicPayment + serviceFee, state.loanScale, Number::upward);
+                    roundedPeriodicPayment + serviceFee,
+                    state.loanScale,
+                    Number::rounding_mode::upward);
                 // Only check the first payment since the rounding
                 // may drift as payments are made
                 BEAST_EXPECT(
                     totalDue ==
                     roundToScale(
-                        broker.asset(Number(8533457002039338267, -17), Number::upward),
+                        broker.asset(
+                            Number(8533457002039338267, -17), Number::rounding_mode::upward),
                         state.loanScale,
-                        Number::upward));
+                        Number::rounding_mode::upward));
 
                 {
                     auto const raw = computeTheoreticalLoanState(
@@ -2561,9 +2565,9 @@ protected:
                 BEAST_EXPECT(
                     transactionAmount ==
                     roundToScale(
-                        broker.asset(Number(9533457002039400, -14), Number::upward),
+                        broker.asset(Number(9533457002039400, -14), Number::rounding_mode::upward),
                         state.loanScale,
-                        Number::upward));
+                        Number::rounding_mode::upward));
 
                 auto const initialState = state;
                 xrpl::detail::PaymentComponents totalPaid{
@@ -2651,11 +2655,16 @@ protected:
                     BEAST_EXPECT(
                         state.paymentRemaining < 12 ||
                         roundToAsset(
-                            broker.asset, deltas.principal, state.loanScale, Number::upward) ==
+                            broker.asset,
+                            deltas.principal,
+                            state.loanScale,
+                            Number::rounding_mode::upward) ==
                             roundToScale(
-                                broker.asset(Number(8333228691531218890, -17), Number::upward),
+                                broker.asset(
+                                    Number(8333228691531218890, -17),
+                                    Number::rounding_mode::upward),
                                 state.loanScale,
-                                Number::upward));
+                                Number::rounding_mode::upward));
                     BEAST_EXPECT(
                         paymentComponents.trackedPrincipalDelta >= beast::zero &&
                         paymentComponents.trackedPrincipalDelta <= state.principalOutstanding);
@@ -5239,7 +5248,7 @@ protected:
 
             // pay all but the last payment
             {
-                NumberRoundModeGuard const mg{Number::upward};
+                NumberRoundModeGuard const mg{Number::rounding_mode::upward};
                 Number const payment = beforeState.periodicPayment * (total - 1);
                 XRPAmount const payFee{baseFee * ((total - 1) / loanPaymentsPerFeeIncrement + 1)};
                 STAmount const paymentAmount =
diff --git a/src/test/app/MPToken_test.cpp b/src/test/app/MPToken_test.cpp
index a1c57ccbc2..681d2f2577 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 LockType { Global, Individual, None };
+            enum class LockType { Global, Individual, None };
             struct TestArg
             {
                 Account src;
                 Account dst;
                 Account offerOwner;
-                LockType srcFlag = None;
-                LockType dstFlag = None;
-                LockType offerFlagBuy = None;
-                LockType offerFlagSell = None;
-                LockType globalFlagBuy = None;
-                LockType globalFlagSell = None;
+                LockType srcFlag = LockType::None;
+                LockType dstFlag = LockType::None;
+                LockType offerFlagBuy = LockType::None;
+                LockType offerFlagSell = LockType::None;
+                LockType globalFlagBuy = LockType::None;
+                LockType globalFlagSell = LockType::None;
                 TER err = tesSUCCESS;
                 std::optional<TER> errIOU = std::nullopt;
             };
@@ -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 == None)
+                if (lock == LockType::None)
                     return;
                 if constexpr (std::is_same_v<Token, IOU>)
                 {
-                    if (lock == Global)
+                    if (lock == LockType::Global)
                     {
                         env(fset(gw, asfGlobalFreeze));
                     }
@@ -4254,7 +4254,7 @@ class MPToken_test : public beast::unit_test::suite
                 }
                 else if constexpr (std::is_same_v<Token, MPTTester>)
                 {
-                    if (lock == Global)
+                    if (lock == LockType::Global)
                     {
                         token.set({.flags = tfMPTLock});
                     }
@@ -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 = Individual, .err = tecPATH_DRY},
+                    {.src = alice, .dst = carol, .offerOwner = bob, .srcFlag = LockType::Individual, .err = tecPATH_DRY},
                     // dst can receive IOU even if the account is frozen
-                    {.src = alice, .dst = carol, .offerOwner = bob, .dstFlag = Individual, .err = tecPATH_DRY, .errIOU = tesSUCCESS},
-                    {.src = alice, .dst = carol, .offerOwner = bob, .globalFlagBuy = Global, .err = tecPATH_DRY},
-                    {.src = alice, .dst = carol, .offerOwner = bob, .globalFlagSell = Global, .err = tecPATH_DRY},
+                    {.src = alice, .dst = carol, .offerOwner = bob, .dstFlag = LockType::Individual, .err = tecPATH_DRY, .errIOU = tesSUCCESS},
+                    {.src = alice, .dst = carol, .offerOwner = bob, .globalFlagBuy = LockType::Global, .err = tecPATH_DRY},
+                    {.src = alice, .dst = carol, .offerOwner = bob, .globalFlagSell = LockType::Global, .err = tecPATH_DRY},
                     // offer's owner can receive IOU even if the account is frozen
-                    {.src = alice, .dst = carol, .offerOwner = bob, .offerFlagBuy = Individual, .err =
+                    {.src = alice, .dst = carol, .offerOwner = bob, .offerFlagBuy = LockType::Individual, .err =
                     tecPATH_PARTIAL, .errIOU = tesSUCCESS},
-                    {.src = alice, .dst = carol, .offerOwner = bob, .offerFlagSell = Individual, .err = tecPATH_PARTIAL},
+                    {.src = alice, .dst = carol, .offerOwner = bob, .offerFlagSell = LockType::Individual, .err = tecPATH_PARTIAL},
                     // src, dst are a holder, offer's owner is an issuer
-                    {.src = alice, .dst = carol, .offerOwner = gw, .srcFlag = Individual, .err = tecPATH_DRY},
+                    {.src = alice, .dst = carol, .offerOwner = gw, .srcFlag = LockType::Individual, .err = tecPATH_DRY},
                     // dst can receive IOU even if the account is frozen
-                    {.src = alice, .dst = carol, .offerOwner = gw, .dstFlag = Individual, .err = tecPATH_DRY, .errIOU = tesSUCCESS},
-                    {.src = alice, .dst = carol, .offerOwner = gw, .globalFlagBuy = Global, .err = tecPATH_DRY},
-                    {.src = alice, .dst = carol, .offerOwner = gw, .globalFlagSell = Global, .err = tecPATH_DRY},
+                    {.src = alice, .dst = carol, .offerOwner = gw, .dstFlag = LockType::Individual, .err = tecPATH_DRY, .errIOU = tesSUCCESS},
+                    {.src = alice, .dst = carol, .offerOwner = gw, .globalFlagBuy = LockType::Global, .err = tecPATH_DRY},
+                    {.src = alice, .dst = carol, .offerOwner = gw, .globalFlagSell = LockType::Global, .err = tecPATH_DRY},
                     // src is issuer, dst and offer's owner are a holder
                     // dst can receive IOU even if the account is frozen
-                    {.src = gw, .dst = carol, .offerOwner = bob, .dstFlag = Individual, .err = tecPATH_DRY, .errIOU = tesSUCCESS},
+                    {.src = gw, .dst = carol, .offerOwner = bob, .dstFlag = LockType::Individual, .err = tecPATH_DRY, .errIOU = tesSUCCESS},
                     // offer's owner can receive IOU from an issuer even if takerBuys is frozen, MPT offer is unfunded in this case
-                    {.src = gw, .dst = carol, .offerOwner = bob, .offerFlagBuy = Individual, .err = tecPATH_PARTIAL, .errIOU = tesSUCCESS},
-                    {.src = gw, .dst = carol, .offerOwner = bob, .offerFlagSell = Individual, .err = tecPATH_PARTIAL},
+                    {.src = gw, .dst = carol, .offerOwner = bob, .offerFlagBuy = LockType::Individual, .err = tecPATH_PARTIAL, .errIOU = tesSUCCESS},
+                    {.src = gw, .dst = carol, .offerOwner = bob, .offerFlagSell = LockType::Individual, .err = tecPATH_PARTIAL},
                     // dst is issuer, src and offer's owner are a holder
-                    {.src = alice, .dst = gw, .offerOwner = bob, .srcFlag = Individual, .err = tecPATH_DRY},
+                    {.src = alice, .dst = gw, .offerOwner = bob, .srcFlag = LockType::Individual, .err = tecPATH_DRY},
                     // offer's owner can receive IOU even if the account is frozen
-                    {.src = alice, .dst = gw, .offerOwner = bob, .offerFlagBuy = Individual, .err = tecPATH_PARTIAL,
+                    {.src = alice, .dst = gw, .offerOwner = bob, .offerFlagBuy = LockType::Individual, .err = tecPATH_PARTIAL,
                      .errIOU = tesSUCCESS},
-                    {.src = alice, .dst = gw, .offerOwner = bob, .offerFlagSell = Individual, .err = tecPATH_PARTIAL},
+                    {.src = alice, .dst = gw, .offerOwner = bob, .offerFlagSell = LockType::Individual, .err = tecPATH_PARTIAL},
             };
             // clang-format on
 
diff --git a/src/test/app/NFTokenBurn_test.cpp b/src/test/app/NFTokenBurn_test.cpp
index 08d7b4305e..efb255ea2d 100644
--- a/src/test/app/NFTokenBurn_test.cpp
+++ b/src/test/app/NFTokenBurn_test.cpp
@@ -88,7 +88,7 @@ class NFTokenBurn_test : public beast::unit_test::suite
     //
     // It uses the ledger RPC command to show the NFT pages in the ledger.
     // This parameter controls how noisy the output is.
-    enum Volume : bool {
+    enum class Volume : bool {
         quiet = false,
         noisy = true,
     };
@@ -123,7 +123,7 @@ class NFTokenBurn_test : public beast::unit_test::suite
                     std::cout << tokenCount << " NFtokens in page "
                               << state[i][jss::index].asString() << std::endl;
 
-                    if (vol == noisy)
+                    if (vol == Volume::noisy)
                     {
                         std::cout << state[i].toStyledString() << std::endl;
                     }
diff --git a/src/test/app/NFTokenDir_test.cpp b/src/test/app/NFTokenDir_test.cpp
index 5764e87f76..a1527e8601 100644
--- a/src/test/app/NFTokenDir_test.cpp
+++ b/src/test/app/NFTokenDir_test.cpp
@@ -42,7 +42,7 @@ class NFTokenDir_test : public beast::unit_test::suite
     //
     // It uses the ledger RPC command to show the NFT pages in the ledger.
     // This parameter controls how noisy the output is.
-    enum Volume : bool {
+    enum class Volume : bool {
         quiet = false,
         noisy = true,
     };
@@ -77,7 +77,7 @@ class NFTokenDir_test : public beast::unit_test::suite
                     std::cout << tokenCount << " NFtokens in page "
                               << state[i][jss::index].asString() << std::endl;
 
-                    if (vol == noisy)
+                    if (vol == Volume::noisy)
                     {
                         std::cout << state[i].toStyledString() << std::endl;
                     }
@@ -190,7 +190,7 @@ class NFTokenDir_test : public beast::unit_test::suite
             for (std::string_view const seed : seeds)
             {
                 Account const& account =
-                    accounts.emplace_back(Account::base58Seed, std::string(seed));
+                    accounts.emplace_back(Account::AcctStringType::base58Seed, std::string(seed));
                 env.fund(XRP(10000), account);
 
                 // Do not close the ledger inside the loop.  If accounts are
@@ -394,7 +394,7 @@ class NFTokenDir_test : public beast::unit_test::suite
             for (std::string_view const seed : seeds)
             {
                 Account const& account =
-                    accounts.emplace_back(Account::base58Seed, std::string(seed));
+                    accounts.emplace_back(Account::AcctStringType::base58Seed, std::string(seed));
                 env.fund(XRP(10000), account);
 
                 // Do not close the ledger inside the loop.  If accounts are
@@ -624,7 +624,8 @@ class NFTokenDir_test : public beast::unit_test::suite
         accounts.reserve(seeds.size());
         for (std::string_view const seed : seeds)
         {
-            Account const& account = accounts.emplace_back(Account::base58Seed, std::string(seed));
+            Account const& account =
+                accounts.emplace_back(Account::AcctStringType::base58Seed, std::string(seed));
             env.fund(XRP(10000), account);
 
             // Do not close the ledger inside the loop.  If accounts are
@@ -787,7 +788,8 @@ class NFTokenDir_test : public beast::unit_test::suite
         accounts.reserve(seeds.size());
         for (std::string_view const seed : seeds)
         {
-            Account const& account = accounts.emplace_back(Account::base58Seed, std::string(seed));
+            Account const& account =
+                accounts.emplace_back(Account::AcctStringType::base58Seed, std::string(seed));
             env.fund(XRP(10000), account);
 
             // Do not close the ledger inside the loop.  If accounts are
diff --git a/src/test/app/OfferMPT_test.cpp b/src/test/app/OfferMPT_test.cpp
index b07fe043d2..f67c2ce9c2 100644
--- a/src/test/app/OfferMPT_test.cpp
+++ b/src/test/app/OfferMPT_test.cpp
@@ -2013,7 +2013,7 @@ public:
         auto const f = env.current()->fees().base;
 
         // To keep things simple all offers are 1 : 1 for XRP : USD.
-        enum preAuthType { noPreAuth, acctPreAuth };
+        enum class preAuthType { noPreAuth, acctPreAuth };
         struct TestData
         {
             std::string account;      // Account operated on
@@ -2032,37 +2032,37 @@ public:
         // clang-format off
         TestData const tests[]{
             // acct                     fundXrp        bookAmt   preTrust  offerAmt                   tec     spentXrp       balanceUSD offers  owners scale
-            {.account="ann",             .fundXrp=reserve(env, 0) + 0 * f,    .bookAmount=1,   .preAuth=noPreAuth, .offerAmount=1000,      .tec=tecUNFUNDED_OFFER,               .spentXrp=f, .balanceUsd=USD(      0),    .offers=0, .owners=0},  // Account is at the reserve, and will dip below once fees are subtracted.
-            {.account="bev",             .fundXrp=reserve(env, 0) + 1 * f,    .bookAmount=1,   .preAuth=noPreAuth, .offerAmount=1000,      .tec=tecUNFUNDED_OFFER,               .spentXrp=f, .balanceUsd=USD(      0),    .offers=0, .owners=0},  // Account has just enough for the reserve and the fee.
-            {.account="cam",             .fundXrp=reserve(env, 0) + 2 * f,    .bookAmount=0,   .preAuth=noPreAuth, .offerAmount=1000, .tec=tecINSUF_RESERVE_OFFER,               .spentXrp=f, .balanceUsd=USD(      0),    .offers=0, .owners=0},  // Account has enough for the reserve, the fee and the offer, and a bit more, but not enough for the reserve after the offer is placed.
-            {.account="deb",             .fundXrp=reserve(env, 0) + 2 * f,    .bookAmount=1,   .preAuth=noPreAuth, .offerAmount=1000,             .tec=tesSUCCESS,           .spentXrp=2 * f, .balanceUsd=USD(      1),    .offers=0, .owners=1, .scale=100000},  // Account has enough to buy a little USD then the offer runs dry.
-            {.account="eve",             .fundXrp=reserve(env, 1) + 0 * f,    .bookAmount=0,   .preAuth=noPreAuth, .offerAmount=1000,             .tec=tesSUCCESS,               .spentXrp=f, .balanceUsd=USD(      0),    .offers=1, .owners=1},  // No offer to cross
-            {.account="flo",             .fundXrp=reserve(env, 1) + 0 * f,    .bookAmount=1,   .preAuth=noPreAuth, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP(   1)   + f, .balanceUsd=USD(      1),    .offers=0, .owners=1},
-            {.account="gay",             .fundXrp=reserve(env, 1) + 1 * f, .bookAmount=1000,   .preAuth=noPreAuth, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP(  50)   + f, .balanceUsd=USD(     50),    .offers=0, .owners=1},
-            {.account="hye", .fundXrp=XRP(1000)                   + 1 * f, .bookAmount=1000,   .preAuth=noPreAuth, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP( 800)   + f, .balanceUsd=USD(    800),    .offers=0, .owners=1},
-            {.account="ivy", .fundXrp=XRP(   1) + reserve(env, 1) + 1 * f,    .bookAmount=1,   .preAuth=noPreAuth, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP(   1)   + f, .balanceUsd=USD(      1),    .offers=0, .owners=1},
-            {.account="joy", .fundXrp=XRP(   1) + reserve(env, 2) + 1 * f,    .bookAmount=1,   .preAuth=noPreAuth, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP(   1)   + f, .balanceUsd=USD(      1),    .offers=1, .owners=2},
-            {.account="kim", .fundXrp=XRP( 900) + reserve(env, 2) + 1 * f,  .bookAmount=999,   .preAuth=noPreAuth, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP( 999)   + f, .balanceUsd=USD(    999),    .offers=0, .owners=1},
-            {.account="liz", .fundXrp=XRP( 998) + reserve(env, 0) + 1 * f,  .bookAmount=999,   .preAuth=noPreAuth, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP( 998)   + f, .balanceUsd=USD(    998),    .offers=0, .owners=1},
-            {.account="meg", .fundXrp=XRP( 998) + reserve(env, 1) + 1 * f,  .bookAmount=999,   .preAuth=noPreAuth, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP( 999)   + f, .balanceUsd=USD(    999),    .offers=0, .owners=1},
-            {.account="nia", .fundXrp=XRP( 998) + reserve(env, 2) + 1 * f,  .bookAmount=999,   .preAuth=noPreAuth, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP( 999)   + f, .balanceUsd=USD(    999),    .offers=1, .owners=2},
-            {.account="ova", .fundXrp=XRP( 999) + reserve(env, 0) + 1 * f, .bookAmount=1000,   .preAuth=noPreAuth, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP( 999)   + f, .balanceUsd=USD(    999),    .offers=0, .owners=1},
-            {.account="pam", .fundXrp=XRP( 999) + reserve(env, 1) + 1 * f, .bookAmount=1000,   .preAuth=noPreAuth, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP(1000)   + f, .balanceUsd=USD(   1000),    .offers=0, .owners=1},
-            {.account="rae", .fundXrp=XRP( 999) + reserve(env, 2) + 1 * f, .bookAmount=1000,   .preAuth=noPreAuth, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP(1000)   + f, .balanceUsd=USD(   1000),    .offers=0, .owners=1},
-            {.account="sue", .fundXrp=XRP(1000) + reserve(env, 2) + 1 * f,    .bookAmount=0,   .preAuth=noPreAuth, .offerAmount=1000,             .tec=tesSUCCESS,               .spentXrp=f, .balanceUsd=USD(      0),    .offers=1, .owners=1},
+            {.account="ann",             .fundXrp=reserve(env, 0) + 0 * f,    .bookAmount=1,   .preAuth=preAuthType::noPreAuth, .offerAmount=1000,      .tec=tecUNFUNDED_OFFER,               .spentXrp=f, .balanceUsd=USD(      0),    .offers=0, .owners=0},  // Account is at the reserve, and will dip below once fees are subtracted.
+            {.account="bev",             .fundXrp=reserve(env, 0) + 1 * f,    .bookAmount=1,   .preAuth=preAuthType::noPreAuth, .offerAmount=1000,      .tec=tecUNFUNDED_OFFER,               .spentXrp=f, .balanceUsd=USD(      0),    .offers=0, .owners=0},  // Account has just enough for the reserve and the fee.
+            {.account="cam",             .fundXrp=reserve(env, 0) + 2 * f,    .bookAmount=0,   .preAuth=preAuthType::noPreAuth, .offerAmount=1000, .tec=tecINSUF_RESERVE_OFFER,               .spentXrp=f, .balanceUsd=USD(      0),    .offers=0, .owners=0},  // Account has enough for the reserve, the fee and the offer, and a bit more, but not enough for the reserve after the offer is placed.
+            {.account="deb",             .fundXrp=reserve(env, 0) + 2 * f,    .bookAmount=1,   .preAuth=preAuthType::noPreAuth, .offerAmount=1000,             .tec=tesSUCCESS,           .spentXrp=2 * f, .balanceUsd=USD(      1),    .offers=0, .owners=1, .scale=100000},  // Account has enough to buy a little USD then the offer runs dry.
+            {.account="eve",             .fundXrp=reserve(env, 1) + 0 * f,    .bookAmount=0,   .preAuth=preAuthType::noPreAuth, .offerAmount=1000,             .tec=tesSUCCESS,               .spentXrp=f, .balanceUsd=USD(      0),    .offers=1, .owners=1},  // No offer to cross
+            {.account="flo",             .fundXrp=reserve(env, 1) + 0 * f,    .bookAmount=1,   .preAuth=preAuthType::noPreAuth, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP(   1)   + f, .balanceUsd=USD(      1),    .offers=0, .owners=1},
+            {.account="gay",             .fundXrp=reserve(env, 1) + 1 * f, .bookAmount=1000,   .preAuth=preAuthType::noPreAuth, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP(  50)   + f, .balanceUsd=USD(     50),    .offers=0, .owners=1},
+            {.account="hye", .fundXrp=XRP(1000)                   + 1 * f, .bookAmount=1000,   .preAuth=preAuthType::noPreAuth, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP( 800)   + f, .balanceUsd=USD(    800),    .offers=0, .owners=1},
+            {.account="ivy", .fundXrp=XRP(   1) + reserve(env, 1) + 1 * f,    .bookAmount=1,   .preAuth=preAuthType::noPreAuth, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP(   1)   + f, .balanceUsd=USD(      1),    .offers=0, .owners=1},
+            {.account="joy", .fundXrp=XRP(   1) + reserve(env, 2) + 1 * f,    .bookAmount=1,   .preAuth=preAuthType::noPreAuth, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP(   1)   + f, .balanceUsd=USD(      1),    .offers=1, .owners=2},
+            {.account="kim", .fundXrp=XRP( 900) + reserve(env, 2) + 1 * f,  .bookAmount=999,   .preAuth=preAuthType::noPreAuth, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP( 999)   + f, .balanceUsd=USD(    999),    .offers=0, .owners=1},
+            {.account="liz", .fundXrp=XRP( 998) + reserve(env, 0) + 1 * f,  .bookAmount=999,   .preAuth=preAuthType::noPreAuth, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP( 998)   + f, .balanceUsd=USD(    998),    .offers=0, .owners=1},
+            {.account="meg", .fundXrp=XRP( 998) + reserve(env, 1) + 1 * f,  .bookAmount=999,   .preAuth=preAuthType::noPreAuth, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP( 999)   + f, .balanceUsd=USD(    999),    .offers=0, .owners=1},
+            {.account="nia", .fundXrp=XRP( 998) + reserve(env, 2) + 1 * f,  .bookAmount=999,   .preAuth=preAuthType::noPreAuth, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP( 999)   + f, .balanceUsd=USD(    999),    .offers=1, .owners=2},
+            {.account="ova", .fundXrp=XRP( 999) + reserve(env, 0) + 1 * f, .bookAmount=1000,   .preAuth=preAuthType::noPreAuth, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP( 999)   + f, .balanceUsd=USD(    999),    .offers=0, .owners=1},
+            {.account="pam", .fundXrp=XRP( 999) + reserve(env, 1) + 1 * f, .bookAmount=1000,   .preAuth=preAuthType::noPreAuth, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP(1000)   + f, .balanceUsd=USD(   1000),    .offers=0, .owners=1},
+            {.account="rae", .fundXrp=XRP( 999) + reserve(env, 2) + 1 * f, .bookAmount=1000,   .preAuth=preAuthType::noPreAuth, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP(1000)   + f, .balanceUsd=USD(   1000),    .offers=0, .owners=1},
+            {.account="sue", .fundXrp=XRP(1000) + reserve(env, 2) + 1 * f,    .bookAmount=0,   .preAuth=preAuthType::noPreAuth, .offerAmount=1000,             .tec=tesSUCCESS,               .spentXrp=f, .balanceUsd=USD(      0),    .offers=1, .owners=1},
             //---------------- Pre-created MPT ---------------------
             // Unlike from IOU, an issuer can't pre-create MPToken for an account (see similar tests in Offer_test.cpp)
-            {.account="ned",             .fundXrp=reserve(env, 1) + 0 * f,    .bookAmount=1, .preAuth=acctPreAuth, .offerAmount=1000,      .tec=tecUNFUNDED_OFFER,           .spentXrp=2 * f, .balanceUsd=USD(      0),    .offers=0, .owners=1},
-            {.account="ole",             .fundXrp=reserve(env, 1) + 1 * f,    .bookAmount=1, .preAuth=acctPreAuth, .offerAmount=1000,      .tec=tecUNFUNDED_OFFER,           .spentXrp=2 * f, .balanceUsd=USD(      0),    .offers=0, .owners=1},
-            {.account="pat",             .fundXrp=reserve(env, 1) + 2 * f,    .bookAmount=0, .preAuth=acctPreAuth, .offerAmount=1000,      .tec=tecUNFUNDED_OFFER,           .spentXrp=2 * f, .balanceUsd=USD(      0),    .offers=0, .owners=1},
-            {.account="quy",             .fundXrp=reserve(env, 1) + 2 * f,    .bookAmount=1, .preAuth=acctPreAuth, .offerAmount=1000,      .tec=tecUNFUNDED_OFFER,           .spentXrp=2 * f, .balanceUsd=USD(      0),    .offers=0, .owners=1},
-            {.account="ron",             .fundXrp=reserve(env, 1) + 3 * f,    .bookAmount=0, .preAuth=acctPreAuth, .offerAmount=1000, .tec=tecINSUF_RESERVE_OFFER,           .spentXrp=2 * f, .balanceUsd=USD(      0),    .offers=0, .owners=1},
-            {.account="syd",             .fundXrp=reserve(env, 1) + 3 * f,    .bookAmount=1, .preAuth=acctPreAuth, .offerAmount=1000,             .tec=tesSUCCESS,           .spentXrp=3 * f, .balanceUsd=USD(      1),    .offers=0, .owners=1, .scale=100000},
-            {.account="ted", .fundXrp=XRP(  20) + reserve(env, 1) + 2 * f, .bookAmount=1000, .preAuth=acctPreAuth, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP(20) + 2 * f, .balanceUsd=USD(     20),    .offers=0, .owners=1},
-            {.account="uli",             .fundXrp=reserve(env, 2) + 0 * f,    .bookAmount=0, .preAuth=acctPreAuth, .offerAmount=1000, .tec=tecINSUF_RESERVE_OFFER,           .spentXrp=2 * f, .balanceUsd=USD(      0),    .offers=0, .owners=1},
-            {.account="vic",             .fundXrp=reserve(env, 2) + 0 * f,    .bookAmount=1, .preAuth=acctPreAuth, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP( 1) + 2 * f, .balanceUsd=USD(      1),    .offers=0, .owners=1},
-            {.account="wes",             .fundXrp=reserve(env, 2) + 1 * f,    .bookAmount=0, .preAuth=acctPreAuth, .offerAmount=1000,             .tec=tesSUCCESS,           .spentXrp=2 * f, .balanceUsd=USD(      0),    .offers=1, .owners=2},
-            {.account="xan",             .fundXrp=reserve(env, 2) + 1 * f,    .bookAmount=1, .preAuth=acctPreAuth, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP( 1) + 2 * f, .balanceUsd=USD(      1),    .offers=1, .owners=2},
+            {.account="ned",             .fundXrp=reserve(env, 1) + 0 * f,    .bookAmount=1, .preAuth=preAuthType::acctPreAuth, .offerAmount=1000,      .tec=tecUNFUNDED_OFFER,           .spentXrp=2 * f, .balanceUsd=USD(      0),    .offers=0, .owners=1},
+            {.account="ole",             .fundXrp=reserve(env, 1) + 1 * f,    .bookAmount=1, .preAuth=preAuthType::acctPreAuth, .offerAmount=1000,      .tec=tecUNFUNDED_OFFER,           .spentXrp=2 * f, .balanceUsd=USD(      0),    .offers=0, .owners=1},
+            {.account="pat",             .fundXrp=reserve(env, 1) + 2 * f,    .bookAmount=0, .preAuth=preAuthType::acctPreAuth, .offerAmount=1000,      .tec=tecUNFUNDED_OFFER,           .spentXrp=2 * f, .balanceUsd=USD(      0),    .offers=0, .owners=1},
+            {.account="quy",             .fundXrp=reserve(env, 1) + 2 * f,    .bookAmount=1, .preAuth=preAuthType::acctPreAuth, .offerAmount=1000,      .tec=tecUNFUNDED_OFFER,           .spentXrp=2 * f, .balanceUsd=USD(      0),    .offers=0, .owners=1},
+            {.account="ron",             .fundXrp=reserve(env, 1) + 3 * f,    .bookAmount=0, .preAuth=preAuthType::acctPreAuth, .offerAmount=1000, .tec=tecINSUF_RESERVE_OFFER,           .spentXrp=2 * f, .balanceUsd=USD(      0),    .offers=0, .owners=1},
+            {.account="syd",             .fundXrp=reserve(env, 1) + 3 * f,    .bookAmount=1, .preAuth=preAuthType::acctPreAuth, .offerAmount=1000,             .tec=tesSUCCESS,           .spentXrp=3 * f, .balanceUsd=USD(      1),    .offers=0, .owners=1, .scale=100000},
+            {.account="ted", .fundXrp=XRP(  20) + reserve(env, 1) + 2 * f, .bookAmount=1000, .preAuth=preAuthType::acctPreAuth, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP(20) + 2 * f, .balanceUsd=USD(     20),    .offers=0, .owners=1},
+            {.account="uli",             .fundXrp=reserve(env, 2) + 0 * f,    .bookAmount=0, .preAuth=preAuthType::acctPreAuth, .offerAmount=1000, .tec=tecINSUF_RESERVE_OFFER,           .spentXrp=2 * f, .balanceUsd=USD(      0),    .offers=0, .owners=1},
+            {.account="vic",             .fundXrp=reserve(env, 2) + 0 * f,    .bookAmount=1, .preAuth=preAuthType::acctPreAuth, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP( 1) + 2 * f, .balanceUsd=USD(      1),    .offers=0, .owners=1},
+            {.account="wes",             .fundXrp=reserve(env, 2) + 1 * f,    .bookAmount=0, .preAuth=preAuthType::acctPreAuth, .offerAmount=1000,             .tec=tesSUCCESS,           .spentXrp=2 * f, .balanceUsd=USD(      0),    .offers=1, .owners=2},
+            {.account="xan",             .fundXrp=reserve(env, 2) + 1 * f,    .bookAmount=1, .preAuth=preAuthType::acctPreAuth, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP( 1) + 2 * f, .balanceUsd=USD(      1),    .offers=1, .owners=2},
         };
         // clang-format on
 
@@ -2085,7 +2085,7 @@ public:
             // Optionally pre-authorize MPT for acct.
             // Note this is not really part of the test, so we expect there
             // to be enough XRP reserve for acct to create the trust line.
-            if (t.preAuth == acctPreAuth)
+            if (t.preAuth == preAuthType::acctPreAuth)
                 MUSD.authorize({.account = acct});
             env.close();
 
@@ -2120,7 +2120,7 @@ public:
                 BEAST_EXPECT(acctOffer[sfTakerPays] == USD(leftover));
             }
 
-            if (t.preAuth == noPreAuth)
+            if (t.preAuth == preAuthType::noPreAuth)
             {
                 if (t.balanceUsd.value().signum() != 0)
                 {
diff --git a/src/test/app/Offer_test.cpp b/src/test/app/Offer_test.cpp
index 0c00c91f63..78bdd3fef2 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 preTrustType { noPreTrust, gwPreTrust, acctPreTrust };
+        enum class 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=noPreTrust, .offerAmount=1000,      .tec=tecUNFUNDED_OFFER,               .spentXrp=f, .balanceUsd=USD(      0),    .offers=0, .owners=0},  // Account is at the reserve, and will dip below once fees are subtracted.
-            {.account="bev",             .fundXrp=reserve(env, 0) + 1 * f,    .bookAmount=1,   .preTrust=noPreTrust, .offerAmount=1000,      .tec=tecUNFUNDED_OFFER,               .spentXrp=f, .balanceUsd=USD(      0),    .offers=0, .owners=0},  // Account has just enough for the reserve and the fee.
-            {.account="cam",             .fundXrp=reserve(env, 0) + 2 * f,    .bookAmount=0,   .preTrust=noPreTrust, .offerAmount=1000, .tec=tecINSUF_RESERVE_OFFER,               .spentXrp=f, .balanceUsd=USD(      0),    .offers=0, .owners=0},  // Account has enough for the reserve, the fee and the offer, and a bit more, but not enough for the reserve after the offer is placed.
-            {.account="deb", .fundXrp=drops(10) + reserve(env, 0) + 1 * f,    .bookAmount=1,   .preTrust=noPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=drops(10)   + f, .balanceUsd=USD(0.00001),    .offers=0, .owners=1},  // Account has enough to buy a little USD then the offer runs dry.
-            {.account="eve",             .fundXrp=reserve(env, 1) + 0 * f,    .bookAmount=0,   .preTrust=noPreTrust, .offerAmount=1000,             .tec=tesSUCCESS,               .spentXrp=f, .balanceUsd=USD(      0),    .offers=1, .owners=1},  // No offer to cross
-            {.account="flo",             .fundXrp=reserve(env, 1) + 0 * f,    .bookAmount=1,   .preTrust=noPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP(   1)   + f, .balanceUsd=USD(      1),    .offers=0, .owners=1},
-            {.account="gay",             .fundXrp=reserve(env, 1) + 1 * f, .bookAmount=1000,   .preTrust=noPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP(  50)   + f, .balanceUsd=USD(     50),    .offers=0, .owners=1},
-            {.account="hye", .fundXrp=XRP(1000)                   + 1 * f, .bookAmount=1000,   .preTrust=noPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP( 800)   + f, .balanceUsd=USD(    800),    .offers=0, .owners=1},
-            {.account="ivy", .fundXrp=XRP(   1) + reserve(env, 1) + 1 * f,    .bookAmount=1,   .preTrust=noPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP(   1)   + f, .balanceUsd=USD(      1),    .offers=0, .owners=1},
-            {.account="joy", .fundXrp=XRP(   1) + reserve(env, 2) + 1 * f,    .bookAmount=1,   .preTrust=noPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP(   1)   + f, .balanceUsd=USD(      1),    .offers=1, .owners=2},
-            {.account="kim", .fundXrp=XRP( 900) + reserve(env, 2) + 1 * f,  .bookAmount=999,   .preTrust=noPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP( 999)   + f, .balanceUsd=USD(    999),    .offers=0, .owners=1},
-            {.account="liz", .fundXrp=XRP( 998) + reserve(env, 0) + 1 * f,  .bookAmount=999,   .preTrust=noPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP( 998)   + f, .balanceUsd=USD(    998),    .offers=0, .owners=1},
-            {.account="meg", .fundXrp=XRP( 998) + reserve(env, 1) + 1 * f,  .bookAmount=999,   .preTrust=noPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP( 999)   + f, .balanceUsd=USD(    999),    .offers=0, .owners=1},
-            {.account="nia", .fundXrp=XRP( 998) + reserve(env, 2) + 1 * f,  .bookAmount=999,   .preTrust=noPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP( 999)   + f, .balanceUsd=USD(    999),    .offers=1, .owners=2},
-            {.account="ova", .fundXrp=XRP( 999) + reserve(env, 0) + 1 * f, .bookAmount=1000,   .preTrust=noPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP( 999)   + f, .balanceUsd=USD(    999),    .offers=0, .owners=1},
-            {.account="pam", .fundXrp=XRP( 999) + reserve(env, 1) + 1 * f, .bookAmount=1000,   .preTrust=noPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP(1000)   + f, .balanceUsd=USD(   1000),    .offers=0, .owners=1},
-            {.account="rae", .fundXrp=XRP( 999) + reserve(env, 2) + 1 * f, .bookAmount=1000,   .preTrust=noPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP(1000)   + f, .balanceUsd=USD(   1000),    .offers=0, .owners=1},
-            {.account="sue", .fundXrp=XRP(1000) + reserve(env, 2) + 1 * f,    .bookAmount=0,   .preTrust=noPreTrust, .offerAmount=1000,             .tec=tesSUCCESS,               .spentXrp=f, .balanceUsd=USD(      0),    .offers=1, .owners=1},
+            {.account="ann",             .fundXrp=reserve(env, 0) + 0 * f,    .bookAmount=1,   .preTrust=preTrustType::noPreTrust, .offerAmount=1000,      .tec=tecUNFUNDED_OFFER,               .spentXrp=f, .balanceUsd=USD(      0),    .offers=0, .owners=0},  // Account is at the reserve, and will dip below once fees are subtracted.
+            {.account="bev",             .fundXrp=reserve(env, 0) + 1 * f,    .bookAmount=1,   .preTrust=preTrustType::noPreTrust, .offerAmount=1000,      .tec=tecUNFUNDED_OFFER,               .spentXrp=f, .balanceUsd=USD(      0),    .offers=0, .owners=0},  // Account has just enough for the reserve and the fee.
+            {.account="cam",             .fundXrp=reserve(env, 0) + 2 * f,    .bookAmount=0,   .preTrust=preTrustType::noPreTrust, .offerAmount=1000, .tec=tecINSUF_RESERVE_OFFER,               .spentXrp=f, .balanceUsd=USD(      0),    .offers=0, .owners=0},  // Account has enough for the reserve, the fee and the offer, and a bit more, but not enough for the reserve after the offer is placed.
+            {.account="deb", .fundXrp=drops(10) + reserve(env, 0) + 1 * f,    .bookAmount=1,   .preTrust=preTrustType::noPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=drops(10)   + f, .balanceUsd=USD(0.00001),    .offers=0, .owners=1},  // Account has enough to buy a little USD then the offer runs dry.
+            {.account="eve",             .fundXrp=reserve(env, 1) + 0 * f,    .bookAmount=0,   .preTrust=preTrustType::noPreTrust, .offerAmount=1000,             .tec=tesSUCCESS,               .spentXrp=f, .balanceUsd=USD(      0),    .offers=1, .owners=1},  // No offer to cross
+            {.account="flo",             .fundXrp=reserve(env, 1) + 0 * f,    .bookAmount=1,   .preTrust=preTrustType::noPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP(   1)   + f, .balanceUsd=USD(      1),    .offers=0, .owners=1},
+            {.account="gay",             .fundXrp=reserve(env, 1) + 1 * f, .bookAmount=1000,   .preTrust=preTrustType::noPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP(  50)   + f, .balanceUsd=USD(     50),    .offers=0, .owners=1},
+            {.account="hye", .fundXrp=XRP(1000)                   + 1 * f, .bookAmount=1000,   .preTrust=preTrustType::noPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP( 800)   + f, .balanceUsd=USD(    800),    .offers=0, .owners=1},
+            {.account="ivy", .fundXrp=XRP(   1) + reserve(env, 1) + 1 * f,    .bookAmount=1,   .preTrust=preTrustType::noPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP(   1)   + f, .balanceUsd=USD(      1),    .offers=0, .owners=1},
+            {.account="joy", .fundXrp=XRP(   1) + reserve(env, 2) + 1 * f,    .bookAmount=1,   .preTrust=preTrustType::noPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP(   1)   + f, .balanceUsd=USD(      1),    .offers=1, .owners=2},
+            {.account="kim", .fundXrp=XRP( 900) + reserve(env, 2) + 1 * f,  .bookAmount=999,   .preTrust=preTrustType::noPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP( 999)   + f, .balanceUsd=USD(    999),    .offers=0, .owners=1},
+            {.account="liz", .fundXrp=XRP( 998) + reserve(env, 0) + 1 * f,  .bookAmount=999,   .preTrust=preTrustType::noPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP( 998)   + f, .balanceUsd=USD(    998),    .offers=0, .owners=1},
+            {.account="meg", .fundXrp=XRP( 998) + reserve(env, 1) + 1 * f,  .bookAmount=999,   .preTrust=preTrustType::noPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP( 999)   + f, .balanceUsd=USD(    999),    .offers=0, .owners=1},
+            {.account="nia", .fundXrp=XRP( 998) + reserve(env, 2) + 1 * f,  .bookAmount=999,   .preTrust=preTrustType::noPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP( 999)   + f, .balanceUsd=USD(    999),    .offers=1, .owners=2},
+            {.account="ova", .fundXrp=XRP( 999) + reserve(env, 0) + 1 * f, .bookAmount=1000,   .preTrust=preTrustType::noPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP( 999)   + f, .balanceUsd=USD(    999),    .offers=0, .owners=1},
+            {.account="pam", .fundXrp=XRP( 999) + reserve(env, 1) + 1 * f, .bookAmount=1000,   .preTrust=preTrustType::noPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP(1000)   + f, .balanceUsd=USD(   1000),    .offers=0, .owners=1},
+            {.account="rae", .fundXrp=XRP( 999) + reserve(env, 2) + 1 * f, .bookAmount=1000,   .preTrust=preTrustType::noPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP(1000)   + f, .balanceUsd=USD(   1000),    .offers=0, .owners=1},
+            {.account="sue", .fundXrp=XRP(1000) + reserve(env, 2) + 1 * f,    .bookAmount=0,   .preTrust=preTrustType::noPreTrust, .offerAmount=1000,             .tec=tesSUCCESS,               .spentXrp=f, .balanceUsd=USD(      0),    .offers=1, .owners=1},
             //---------------- Pre-established trust lines ---------------------
-            {.account="abe",             .fundXrp=reserve(env, 0) + 0 * f,    .bookAmount=1,   .preTrust=gwPreTrust, .offerAmount=1000,      .tec=tecUNFUNDED_OFFER,               .spentXrp=f, .balanceUsd=USD(      0),    .offers=0, .owners=0},
-            {.account="bud",             .fundXrp=reserve(env, 0) + 1 * f,    .bookAmount=1,   .preTrust=gwPreTrust, .offerAmount=1000,      .tec=tecUNFUNDED_OFFER,               .spentXrp=f, .balanceUsd=USD(      0),    .offers=0, .owners=0},
-            {.account="che",             .fundXrp=reserve(env, 0) + 2 * f,    .bookAmount=0,   .preTrust=gwPreTrust, .offerAmount=1000, .tec=tecINSUF_RESERVE_OFFER,               .spentXrp=f, .balanceUsd=USD(      0),    .offers=0, .owners=0},
-            {.account="dan", .fundXrp=drops(10) + reserve(env, 0) + 1 * f,    .bookAmount=1,   .preTrust=gwPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=drops(10)   + f, .balanceUsd=USD(0.00001),    .offers=0, .owners=0},
-            {.account="eli", .fundXrp=XRP(  20) + reserve(env, 0) + 1 * f, .bookAmount=1000,   .preTrust=gwPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP(20) + 1 * f, .balanceUsd=USD(     20),    .offers=0, .owners=0},
-            {.account="fyn",             .fundXrp=reserve(env, 1) + 0 * f,    .bookAmount=0,   .preTrust=gwPreTrust, .offerAmount=1000,             .tec=tesSUCCESS,               .spentXrp=f, .balanceUsd=USD(      0),    .offers=1, .owners=1},
-            {.account="gar",             .fundXrp=reserve(env, 1) + 0 * f,    .bookAmount=1,   .preTrust=gwPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP( 1) +     f, .balanceUsd=USD(      1),    .offers=1, .owners=1},
-            {.account="hal",             .fundXrp=reserve(env, 1) + 1 * f,    .bookAmount=1,   .preTrust=gwPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP( 1) +     f, .balanceUsd=USD(      1),    .offers=1, .owners=1},
+            {.account="abe",             .fundXrp=reserve(env, 0) + 0 * f,    .bookAmount=1,   .preTrust=preTrustType::gwPreTrust, .offerAmount=1000,      .tec=tecUNFUNDED_OFFER,               .spentXrp=f, .balanceUsd=USD(      0),    .offers=0, .owners=0},
+            {.account="bud",             .fundXrp=reserve(env, 0) + 1 * f,    .bookAmount=1,   .preTrust=preTrustType::gwPreTrust, .offerAmount=1000,      .tec=tecUNFUNDED_OFFER,               .spentXrp=f, .balanceUsd=USD(      0),    .offers=0, .owners=0},
+            {.account="che",             .fundXrp=reserve(env, 0) + 2 * f,    .bookAmount=0,   .preTrust=preTrustType::gwPreTrust, .offerAmount=1000, .tec=tecINSUF_RESERVE_OFFER,               .spentXrp=f, .balanceUsd=USD(      0),    .offers=0, .owners=0},
+            {.account="dan", .fundXrp=drops(10) + reserve(env, 0) + 1 * f,    .bookAmount=1,   .preTrust=preTrustType::gwPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=drops(10)   + f, .balanceUsd=USD(0.00001),    .offers=0, .owners=0},
+            {.account="eli", .fundXrp=XRP(  20) + reserve(env, 0) + 1 * f, .bookAmount=1000,   .preTrust=preTrustType::gwPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP(20) + 1 * f, .balanceUsd=USD(     20),    .offers=0, .owners=0},
+            {.account="fyn",             .fundXrp=reserve(env, 1) + 0 * f,    .bookAmount=0,   .preTrust=preTrustType::gwPreTrust, .offerAmount=1000,             .tec=tesSUCCESS,               .spentXrp=f, .balanceUsd=USD(      0),    .offers=1, .owners=1},
+            {.account="gar",             .fundXrp=reserve(env, 1) + 0 * f,    .bookAmount=1,   .preTrust=preTrustType::gwPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP( 1) +     f, .balanceUsd=USD(      1),    .offers=1, .owners=1},
+            {.account="hal",             .fundXrp=reserve(env, 1) + 1 * f,    .bookAmount=1,   .preTrust=preTrustType::gwPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP( 1) +     f, .balanceUsd=USD(      1),    .offers=1, .owners=1},
 
-            {.account="ned",             .fundXrp=reserve(env, 1) + 0 * f,    .bookAmount=1, .preTrust=acctPreTrust, .offerAmount=1000,      .tec=tecUNFUNDED_OFFER,           .spentXrp=2 * f, .balanceUsd=USD(      0),    .offers=0, .owners=1},
-            {.account="ole",             .fundXrp=reserve(env, 1) + 1 * f,    .bookAmount=1, .preTrust=acctPreTrust, .offerAmount=1000,      .tec=tecUNFUNDED_OFFER,           .spentXrp=2 * f, .balanceUsd=USD(      0),    .offers=0, .owners=1},
-            {.account="pat",             .fundXrp=reserve(env, 1) + 2 * f,    .bookAmount=0, .preTrust=acctPreTrust, .offerAmount=1000,      .tec=tecUNFUNDED_OFFER,           .spentXrp=2 * f, .balanceUsd=USD(      0),    .offers=0, .owners=1},
-            {.account="quy",             .fundXrp=reserve(env, 1) + 2 * f,    .bookAmount=1, .preTrust=acctPreTrust, .offerAmount=1000,      .tec=tecUNFUNDED_OFFER,           .spentXrp=2 * f, .balanceUsd=USD(      0),    .offers=0, .owners=1},
-            {.account="ron",             .fundXrp=reserve(env, 1) + 3 * f,    .bookAmount=0, .preTrust=acctPreTrust, .offerAmount=1000, .tec=tecINSUF_RESERVE_OFFER,           .spentXrp=2 * f, .balanceUsd=USD(      0),    .offers=0, .owners=1},
-            {.account="syd", .fundXrp=drops(10) + reserve(env, 1) + 2 * f,    .bookAmount=1, .preTrust=acctPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=drops(10) + 2 * f, .balanceUsd=USD(0.00001),    .offers=0, .owners=1},
-            {.account="ted", .fundXrp=XRP(  20) + reserve(env, 1) + 2 * f, .bookAmount=1000, .preTrust=acctPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP(20) + 2 * f, .balanceUsd=USD(     20),    .offers=0, .owners=1},
-            {.account="uli",             .fundXrp=reserve(env, 2) + 0 * f,    .bookAmount=0, .preTrust=acctPreTrust, .offerAmount=1000, .tec=tecINSUF_RESERVE_OFFER,           .spentXrp=2 * f, .balanceUsd=USD(      0),    .offers=0, .owners=1},
-            {.account="vic",             .fundXrp=reserve(env, 2) + 0 * f,    .bookAmount=1, .preTrust=acctPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP( 1) + 2 * f, .balanceUsd=USD(      1),    .offers=0, .owners=1},
-            {.account="wes",             .fundXrp=reserve(env, 2) + 1 * f,    .bookAmount=0, .preTrust=acctPreTrust, .offerAmount=1000,             .tec=tesSUCCESS,           .spentXrp=2 * f, .balanceUsd=USD(      0),    .offers=1, .owners=2},
-            {.account="xan",             .fundXrp=reserve(env, 2) + 1 * f,    .bookAmount=1, .preTrust=acctPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP( 1) + 2 * f, .balanceUsd=USD(      1),    .offers=1, .owners=2},
+            {.account="ned",             .fundXrp=reserve(env, 1) + 0 * f,    .bookAmount=1, .preTrust=preTrustType::acctPreTrust, .offerAmount=1000,      .tec=tecUNFUNDED_OFFER,           .spentXrp=2 * f, .balanceUsd=USD(      0),    .offers=0, .owners=1},
+            {.account="ole",             .fundXrp=reserve(env, 1) + 1 * f,    .bookAmount=1, .preTrust=preTrustType::acctPreTrust, .offerAmount=1000,      .tec=tecUNFUNDED_OFFER,           .spentXrp=2 * f, .balanceUsd=USD(      0),    .offers=0, .owners=1},
+            {.account="pat",             .fundXrp=reserve(env, 1) + 2 * f,    .bookAmount=0, .preTrust=preTrustType::acctPreTrust, .offerAmount=1000,      .tec=tecUNFUNDED_OFFER,           .spentXrp=2 * f, .balanceUsd=USD(      0),    .offers=0, .owners=1},
+            {.account="quy",             .fundXrp=reserve(env, 1) + 2 * f,    .bookAmount=1, .preTrust=preTrustType::acctPreTrust, .offerAmount=1000,      .tec=tecUNFUNDED_OFFER,           .spentXrp=2 * f, .balanceUsd=USD(      0),    .offers=0, .owners=1},
+            {.account="ron",             .fundXrp=reserve(env, 1) + 3 * f,    .bookAmount=0, .preTrust=preTrustType::acctPreTrust, .offerAmount=1000, .tec=tecINSUF_RESERVE_OFFER,           .spentXrp=2 * f, .balanceUsd=USD(      0),    .offers=0, .owners=1},
+            {.account="syd", .fundXrp=drops(10) + reserve(env, 1) + 2 * f,    .bookAmount=1, .preTrust=preTrustType::acctPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=drops(10) + 2 * f, .balanceUsd=USD(0.00001),    .offers=0, .owners=1},
+            {.account="ted", .fundXrp=XRP(  20) + reserve(env, 1) + 2 * f, .bookAmount=1000, .preTrust=preTrustType::acctPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP(20) + 2 * f, .balanceUsd=USD(     20),    .offers=0, .owners=1},
+            {.account="uli",             .fundXrp=reserve(env, 2) + 0 * f,    .bookAmount=0, .preTrust=preTrustType::acctPreTrust, .offerAmount=1000, .tec=tecINSUF_RESERVE_OFFER,           .spentXrp=2 * f, .balanceUsd=USD(      0),    .offers=0, .owners=1},
+            {.account="vic",             .fundXrp=reserve(env, 2) + 0 * f,    .bookAmount=1, .preTrust=preTrustType::acctPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP( 1) + 2 * f, .balanceUsd=USD(      1),    .offers=0, .owners=1},
+            {.account="wes",             .fundXrp=reserve(env, 2) + 1 * f,    .bookAmount=0, .preTrust=preTrustType::acctPreTrust, .offerAmount=1000,             .tec=tesSUCCESS,           .spentXrp=2 * f, .balanceUsd=USD(      0),    .offers=1, .owners=2},
+            {.account="xan",             .fundXrp=reserve(env, 2) + 1 * f,    .bookAmount=1, .preTrust=preTrustType::acctPreTrust, .offerAmount=1000,             .tec=tesSUCCESS, .spentXrp=XRP( 1) + 2 * f, .balanceUsd=USD(      1),    .offers=1, .owners=2},
         };
         // clang-format on
 
@@ -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 == gwPreTrust)
+            if (t.preTrust == preTrustType::gwPreTrust)
                 env(trust(gw, acct["USD"](1)));
             env.close();
 
             // Optionally pre-establish a trustline between acct and gw.
             // Note this is not really part of the test, so we expect there
             // to be enough XRP reserve for acct to create the trust line.
-            if (t.preTrust == acctPreTrust)
+            if (t.preTrust == preTrustType::acctPreTrust)
                 env(trust(acct, USD(1)));
             env.close();
 
@@ -2340,7 +2340,7 @@ public:
                 BEAST_EXPECT(acctOffer[sfTakerPays] == USD(leftover));
             }
 
-            if (t.preTrust == noPreTrust)
+            if (t.preTrust == preTrustType::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 preTrustType { noPreTrust, gwPreTrust, acctPreTrust };
+        enum class preTrustType { noPreTrust, gwPreTrust, acctPreTrust };
         struct TestData
         {
             std::string account;  // Account operated on
diff --git a/src/test/app/Path_test.cpp b/src/test/app/Path_test.cpp
index 505d052faa..e6d27de415 100644
--- a/src/test/app/Path_test.cpp
+++ b/src/test/app/Path_test.cpp
@@ -132,7 +132,7 @@ public:
         void
         signal()
         {
-            std::lock_guard const lk(mutex_);
+            std::scoped_lock const lk(mutex_);
             signaled_ = true;
             cv_.notify_all();
         }
diff --git a/src/test/app/XChain_test.cpp b/src/test/app/XChain_test.cpp
index 3f49ab42bb..c790895921 100644
--- a/src/test/app/XChain_test.cpp
+++ b/src/test/app/XChain_test.cpp
@@ -4025,7 +4025,7 @@ private:
         ChainStateTrack b_;
     };
 
-    enum SmState {
+    enum class SmState {
         st_initial,
         st_claim_id_created,
         st_attesting,
@@ -4034,8 +4034,6 @@ private:
         st_closed,
     };
 
-    enum Act_Flags { af_a2b = 1 << 0 };
-
     // --------------------------------------------------
     template <class T>
     class SmBase
@@ -4169,7 +4167,7 @@ private:
                 st.spend(dstDoor(), reward, num_attestors);
                 st.transfer(dstDoor(), cr.to, cr.amt);
                 st.env.env_.memoize(cr.to);
-                sm_state = st_completed;
+                sm_state = SmState::st_completed;
             };
 
             counters.create_callbacks[cr.claim_id - 1] = std::move(complete_cb);
@@ -4180,12 +4178,12 @@ private:
         {
             switch (sm_state)
             {
-                case st_initial:
+                case SmState::st_initial:
                     cr.claim_id = issue_account_create();
-                    sm_state = st_attesting;
+                    sm_state = SmState::st_attesting;
                     break;
 
-                case st_attesting:
+                case SmState::st_attesting:
                     attest(time, rnd);
                     break;
 
@@ -4193,14 +4191,14 @@ private:
                     assert(0);
                     break;
 
-                case st_completed:
+                case SmState::st_completed:
                     break;  // will get this once
             }
             return sm_state;
         }
 
     private:
-        SmState sm_state{st_initial};
+        SmState sm_state{SmState::st_initial};
         AccountCreate cr;
     };
 
@@ -4329,35 +4327,36 @@ private:
         {
             switch (sm_state)
             {
-                case st_initial:
+                case SmState::st_initial:
                     xfer.claim_id = create_claim_id();
-                    sm_state = st_claim_id_created;
+                    sm_state = SmState::st_claim_id_created;
                     break;
 
-                case st_claim_id_created:
+                case SmState::st_claim_id_created:
                     commit();
-                    sm_state = st_attesting;
+                    sm_state = SmState::st_attesting;
                     break;
 
-                case st_attesting:
+                case SmState::st_attesting:
                     if (attest(time, rnd))
                     {
-                        sm_state = xfer.with_claim == WithClaim::yes ? st_attested : st_completed;
+                        sm_state = xfer.with_claim == WithClaim::yes ? SmState::st_attested
+                                                                     : SmState::st_completed;
                     }
                     else
                     {
-                        sm_state = st_attesting;
+                        sm_state = SmState::st_attesting;
                     }
                     break;
 
-                case st_attested:
+                case SmState::st_attested:
                     assert(xfer.with_claim == WithClaim::yes);
                     claim();
-                    sm_state = st_completed;
+                    sm_state = SmState::st_completed;
                     break;
 
                 default:
-                case st_completed:
+                case SmState::st_completed:
                     assert(0);  // should have been removed
                     break;
             }
@@ -4366,7 +4365,7 @@ private:
 
     private:
         Transfer xfer;
-        SmState sm_state{st_initial};
+        SmState sm_state{SmState::st_initial};
     };
 
     // --------------------------------------------------
@@ -4413,7 +4412,7 @@ public:
                     return sm.advance(time, rnd);
                 };
                 auto& [t, sm] = *it;
-                if (t <= time && std::visit(vis, sm) == st_completed)
+                if (t <= time && std::visit(vis, sm) == SmState::st_completed)
                 {
                     it = sm_.erase(it);
                 }
diff --git a/src/test/basics/IOUAmount_test.cpp b/src/test/basics/IOUAmount_test.cpp
index 95362c7545..5c01445e31 100644
--- a/src/test/basics/IOUAmount_test.cpp
+++ b/src/test/basics/IOUAmount_test.cpp
@@ -156,7 +156,8 @@ public:
             BEAST_EXPECTS(result == expected, ss.str());
         };
 
-        for (auto const mantissaSize : {MantissaRange::small, MantissaRange::large})
+        for (auto const mantissaSize :
+             {MantissaRange::mantissa_scale::small, MantissaRange::mantissa_scale::large})
         {
             NumberMantissaScaleGuard const mg(mantissaSize);
 
diff --git a/src/test/basics/Number_test.cpp b/src/test/basics/Number_test.cpp
index cc7ccaa8c2..607ae004b1 100644
--- a/src/test/basics/Number_test.cpp
+++ b/src/test/basics/Number_test.cpp
@@ -75,20 +75,21 @@ public:
 
         test(
             Number{std::numeric_limits<std::int64_t>::min()},
-            scale == MantissaRange::small
+            scale == MantissaRange::mantissa_scale::small
                 ? Number{-9'223'372'036'854'776, 3}
                 : Number{true, 9'223'372'036'854'775'808ULL, 0, Number::normalized{}},
             __LINE__);
         test(
             Number{std::numeric_limits<std::int64_t>::min() + 1},
-            scale == MantissaRange::small ? Number{-9'223'372'036'854'776, 3}
-                                          : Number{-9'223'372'036'854'775'807},
+            scale == MantissaRange::mantissa_scale::small ? Number{-9'223'372'036'854'776, 3}
+                                                          : Number{-9'223'372'036'854'775'807},
             __LINE__);
         test(
             Number{std::numeric_limits<std::int64_t>::max()},
             Number{
-                scale == MantissaRange::small ? 9'223'372'036'854'776
-                                              : std::numeric_limits<std::int64_t>::max(),
+                scale == MantissaRange::mantissa_scale::small
+                    ? 9'223'372'036'854'776
+                    : std::numeric_limits<std::int64_t>::max(),
                 18 - Number::mantissaLog()},
             __LINE__);
         caught = false;
@@ -207,7 +208,7 @@ public:
                 BEAST_EXPECTS(result == z, ss.str());
             }
         };
-        if (scale == MantissaRange::small)
+        if (scale == MantissaRange::mantissa_scale::small)
         {
             test(cSmall);
         }
@@ -303,7 +304,7 @@ public:
                 BEAST_EXPECTS(result == z, ss.str());
             }
         };
-        if (scale == MantissaRange::small)
+        if (scale == MantissaRange::mantissa_scale::small)
         {
             test(cSmall);
         }
@@ -330,7 +331,7 @@ public:
             }
         };
         auto tests = [&](auto const& cSmall, auto const& cLarge) {
-            if (scale == MantissaRange::small)
+            if (scale == MantissaRange::mantissa_scale::small)
             {
                 test(cSmall);
             }
@@ -341,7 +342,7 @@ public:
         };
         auto const maxMantissa = Number::maxMantissa();
 
-        saveNumberRoundMode const save{Number::setround(Number::to_nearest)};
+        saveNumberRoundMode const save{Number::setround(Number::rounding_mode::to_nearest)};
         {
             auto const cSmall = std::to_array<Case>({
                 {Number{7}, Number{8}, Number{56}},
@@ -407,7 +408,7 @@ public:
             });
             tests(cSmall, cLarge);
         }
-        Number::setround(Number::towards_zero);
+        Number::setround(Number::rounding_mode::towards_zero);
         testcase << "test_mul " << to_string(Number::getMantissaScale()) << " towards_zero";
         {
             auto const cSmall = std::to_array<Case>(
@@ -474,7 +475,7 @@ public:
                 });
             tests(cSmall, cLarge);
         }
-        Number::setround(Number::downward);
+        Number::setround(Number::rounding_mode::downward);
         testcase << "test_mul " << to_string(Number::getMantissaScale()) << " downward";
         {
             auto const cSmall = std::to_array<Case>(
@@ -541,7 +542,7 @@ public:
                 });
             tests(cSmall, cLarge);
         }
-        Number::setround(Number::upward);
+        Number::setround(Number::rounding_mode::upward);
         testcase << "test_mul " << to_string(Number::getMantissaScale()) << " upward";
         {
             auto const cSmall = std::to_array<Case>(
@@ -642,7 +643,7 @@ public:
         };
         auto const maxMantissa = Number::maxMantissa();
         auto tests = [&](auto const& cSmall, auto const& cLarge) {
-            if (scale == MantissaRange::small)
+            if (scale == MantissaRange::mantissa_scale::small)
             {
                 test(cSmall);
             }
@@ -651,7 +652,7 @@ public:
                 test(cLarge);
             }
         };
-        saveNumberRoundMode const save{Number::setround(Number::to_nearest)};
+        saveNumberRoundMode const save{Number::setround(Number::rounding_mode::to_nearest)};
         {
             auto const cSmall = std::to_array<Case>(
                 {{Number{1}, Number{2}, Number{5, -1}},
@@ -689,7 +690,7 @@ public:
             tests(cSmall, cLarge);
         }
         testcase << "test_div " << to_string(Number::getMantissaScale()) << " towards_zero";
-        Number::setround(Number::towards_zero);
+        Number::setround(Number::rounding_mode::towards_zero);
         {
             auto const cSmall = std::to_array<Case>(
                 {{Number{1}, Number{2}, Number{5, -1}},
@@ -727,7 +728,7 @@ public:
             tests(cSmall, cLarge);
         }
         testcase << "test_div " << to_string(Number::getMantissaScale()) << " downward";
-        Number::setround(Number::downward);
+        Number::setround(Number::rounding_mode::downward);
         {
             auto const cSmall = std::to_array<Case>(
                 {{Number{1}, Number{2}, Number{5, -1}},
@@ -765,7 +766,7 @@ public:
             tests(cSmall, cLarge);
         }
         testcase << "test_div " << to_string(Number::getMantissaScale()) << " upward";
-        Number::setround(Number::upward);
+        Number::setround(Number::rounding_mode::upward);
         {
             auto const cSmall = std::to_array<Case>(
                 {{Number{1}, Number{2}, Number{5, -1}},
@@ -834,7 +835,7 @@ public:
         /*
         auto tests = [&](auto const& cSmall, auto const& cLarge) {
             test(cSmall);
-            if (scale != MantissaRange::small)
+            if (scale != MantissaRange::mantissa_scale::small)
                 test(cLarge);
         };
         */
@@ -864,9 +865,9 @@ public:
              Number{false, 55'108'98747006743627, -14, Number::normalized{}}},
         });
         test(cSmall);
-        if (Number::getMantissaScale() != MantissaRange::small)
+        if (Number::getMantissaScale() != MantissaRange::mantissa_scale::small)
         {
-            NumberRoundModeGuard const mg(Number::towards_zero);
+            NumberRoundModeGuard const mg(Number::rounding_mode::towards_zero);
             test(cLarge);
         }
         bool caught = false;
@@ -1027,7 +1028,7 @@ public:
     {
         testcase << "test_to_integer " << to_string(Number::getMantissaScale());
         using Case = std::tuple<Number, std::int64_t>;
-        saveNumberRoundMode const save{Number::setround(Number::to_nearest)};
+        saveNumberRoundMode const save{Number::setround(Number::rounding_mode::to_nearest)};
         {
             Case const c[]{
                 {Number{0}, 0},
@@ -1064,8 +1065,8 @@ public:
                 BEAST_EXPECT(j == y);
             }
         }
-        auto prev_mode = Number::setround(Number::towards_zero);
-        BEAST_EXPECT(prev_mode == Number::to_nearest);
+        auto prev_mode = Number::setround(Number::rounding_mode::towards_zero);
+        BEAST_EXPECT(prev_mode == Number::rounding_mode::to_nearest);
         {
             Case const c[]{
                 {Number{0}, 0},
@@ -1102,8 +1103,8 @@ public:
                 BEAST_EXPECT(j == y);
             }
         }
-        prev_mode = Number::setround(Number::downward);
-        BEAST_EXPECT(prev_mode == Number::towards_zero);
+        prev_mode = Number::setround(Number::rounding_mode::downward);
+        BEAST_EXPECT(prev_mode == Number::rounding_mode::towards_zero);
         {
             Case const c[]{
                 {Number{0}, 0},
@@ -1140,8 +1141,8 @@ public:
                 BEAST_EXPECT(j == y);
             }
         }
-        prev_mode = Number::setround(Number::upward);
-        BEAST_EXPECT(prev_mode == Number::downward);
+        prev_mode = Number::setround(Number::rounding_mode::upward);
+        BEAST_EXPECT(prev_mode == Number::rounding_mode::downward);
         {
             Case const c[]{
                 {Number{0}, 0},
@@ -1236,13 +1237,13 @@ public:
 
         switch (scale)
         {
-            case MantissaRange::small:
+            case MantissaRange::mantissa_scale::small:
 
                 test(Number::min(), "1e-32753");
                 test(Number::max(), "9999999999999999e32768");
                 test(Number::lowest(), "-9999999999999999e32768");
                 {
-                    NumberRoundModeGuard const mg(Number::towards_zero);
+                    NumberRoundModeGuard const mg(Number::rounding_mode::towards_zero);
 
                     auto const maxMantissa = Number::maxMantissa();
                     BEAST_EXPECT(maxMantissa == 9'999'999'999'999'999);
@@ -1265,14 +1266,14 @@ public:
                         "9223372036854775e3");
                 }
                 break;
-            case MantissaRange::large:
+            case MantissaRange::mantissa_scale::large:
                 // Test the edges
                 // ((exponent < -(28)) || (exponent > -(8)))))
                 test(Number::min(), "1e-32750");
                 test(Number::max(), "9223372036854775807e32768");
                 test(Number::lowest(), "-9223372036854775807e32768");
                 {
-                    NumberRoundModeGuard const mg(Number::towards_zero);
+                    NumberRoundModeGuard const mg(Number::rounding_mode::towards_zero);
 
                     auto const maxMantissa = Number::maxMantissa();
                     BEAST_EXPECT(maxMantissa == 9'999'999'999'999'999'999ULL);
@@ -1348,19 +1349,19 @@ public:
         NumberSO const stNumberSO{true};
         Issue const issue;
         Number const n{7'518'783'80596, -5};
-        saveNumberRoundMode const save{Number::setround(Number::to_nearest)};
+        saveNumberRoundMode const save{Number::setround(Number::rounding_mode::to_nearest)};
         auto res2 = STAmount{issue, n};
         BEAST_EXPECT(res2 == STAmount{7518784});
 
-        Number::setround(Number::towards_zero);
+        Number::setround(Number::rounding_mode::towards_zero);
         res2 = STAmount{issue, n};
         BEAST_EXPECT(res2 == STAmount{7518783});
 
-        Number::setround(Number::downward);
+        Number::setround(Number::rounding_mode::downward);
         res2 = STAmount{issue, n};
         BEAST_EXPECT(res2 == STAmount{7518783});
 
-        Number::setround(Number::upward);
+        Number::setround(Number::rounding_mode::upward);
         res2 = STAmount{issue, n};
         BEAST_EXPECT(res2 == STAmount{7518784});
     }
@@ -1400,87 +1401,87 @@ public:
         std::map<Number, NumberRoundings> const expected{
             // Positive numbers
             {Number{13, -1},
-             {{Number::to_nearest, 1},
-              {Number::towards_zero, 1},
-              {Number::downward, 1},
-              {Number::upward, 2}}},
+             {{Number::rounding_mode::to_nearest, 1},
+              {Number::rounding_mode::towards_zero, 1},
+              {Number::rounding_mode::downward, 1},
+              {Number::rounding_mode::upward, 2}}},
             {Number{23, -1},
-             {{Number::to_nearest, 2},
-              {Number::towards_zero, 2},
-              {Number::downward, 2},
-              {Number::upward, 3}}},
+             {{Number::rounding_mode::to_nearest, 2},
+              {Number::rounding_mode::towards_zero, 2},
+              {Number::rounding_mode::downward, 2},
+              {Number::rounding_mode::upward, 3}}},
             {Number{15, -1},
-             {{Number::to_nearest, 2},
-              {Number::towards_zero, 1},
-              {Number::downward, 1},
-              {Number::upward, 2}}},
+             {{Number::rounding_mode::to_nearest, 2},
+              {Number::rounding_mode::towards_zero, 1},
+              {Number::rounding_mode::downward, 1},
+              {Number::rounding_mode::upward, 2}}},
             {Number{25, -1},
-             {{Number::to_nearest, 2},
-              {Number::towards_zero, 2},
-              {Number::downward, 2},
-              {Number::upward, 3}}},
+             {{Number::rounding_mode::to_nearest, 2},
+              {Number::rounding_mode::towards_zero, 2},
+              {Number::rounding_mode::downward, 2},
+              {Number::rounding_mode::upward, 3}}},
             {Number{152, -2},
-             {{Number::to_nearest, 2},
-              {Number::towards_zero, 1},
-              {Number::downward, 1},
-              {Number::upward, 2}}},
+             {{Number::rounding_mode::to_nearest, 2},
+              {Number::rounding_mode::towards_zero, 1},
+              {Number::rounding_mode::downward, 1},
+              {Number::rounding_mode::upward, 2}}},
             {Number{252, -2},
-             {{Number::to_nearest, 3},
-              {Number::towards_zero, 2},
-              {Number::downward, 2},
-              {Number::upward, 3}}},
+             {{Number::rounding_mode::to_nearest, 3},
+              {Number::rounding_mode::towards_zero, 2},
+              {Number::rounding_mode::downward, 2},
+              {Number::rounding_mode::upward, 3}}},
             {Number{17, -1},
-             {{Number::to_nearest, 2},
-              {Number::towards_zero, 1},
-              {Number::downward, 1},
-              {Number::upward, 2}}},
+             {{Number::rounding_mode::to_nearest, 2},
+              {Number::rounding_mode::towards_zero, 1},
+              {Number::rounding_mode::downward, 1},
+              {Number::rounding_mode::upward, 2}}},
             {Number{27, -1},
-             {{Number::to_nearest, 3},
-              {Number::towards_zero, 2},
-              {Number::downward, 2},
-              {Number::upward, 3}}},
+             {{Number::rounding_mode::to_nearest, 3},
+              {Number::rounding_mode::towards_zero, 2},
+              {Number::rounding_mode::downward, 2},
+              {Number::rounding_mode::upward, 3}}},
 
             // Negative numbers
             {Number{-13, -1},
-             {{Number::to_nearest, -1},
-              {Number::towards_zero, -1},
-              {Number::downward, -2},
-              {Number::upward, -1}}},
+             {{Number::rounding_mode::to_nearest, -1},
+              {Number::rounding_mode::towards_zero, -1},
+              {Number::rounding_mode::downward, -2},
+              {Number::rounding_mode::upward, -1}}},
             {Number{-23, -1},
-             {{Number::to_nearest, -2},
-              {Number::towards_zero, -2},
-              {Number::downward, -3},
-              {Number::upward, -2}}},
+             {{Number::rounding_mode::to_nearest, -2},
+              {Number::rounding_mode::towards_zero, -2},
+              {Number::rounding_mode::downward, -3},
+              {Number::rounding_mode::upward, -2}}},
             {Number{-15, -1},
-             {{Number::to_nearest, -2},
-              {Number::towards_zero, -1},
-              {Number::downward, -2},
-              {Number::upward, -1}}},
+             {{Number::rounding_mode::to_nearest, -2},
+              {Number::rounding_mode::towards_zero, -1},
+              {Number::rounding_mode::downward, -2},
+              {Number::rounding_mode::upward, -1}}},
             {Number{-25, -1},
-             {{Number::to_nearest, -2},
-              {Number::towards_zero, -2},
-              {Number::downward, -3},
-              {Number::upward, -2}}},
+             {{Number::rounding_mode::to_nearest, -2},
+              {Number::rounding_mode::towards_zero, -2},
+              {Number::rounding_mode::downward, -3},
+              {Number::rounding_mode::upward, -2}}},
             {Number{-152, -2},
-             {{Number::to_nearest, -2},
-              {Number::towards_zero, -1},
-              {Number::downward, -2},
-              {Number::upward, -1}}},
+             {{Number::rounding_mode::to_nearest, -2},
+              {Number::rounding_mode::towards_zero, -1},
+              {Number::rounding_mode::downward, -2},
+              {Number::rounding_mode::upward, -1}}},
             {Number{-252, -2},
-             {{Number::to_nearest, -3},
-              {Number::towards_zero, -2},
-              {Number::downward, -3},
-              {Number::upward, -2}}},
+             {{Number::rounding_mode::to_nearest, -3},
+              {Number::rounding_mode::towards_zero, -2},
+              {Number::rounding_mode::downward, -3},
+              {Number::rounding_mode::upward, -2}}},
             {Number{-17, -1},
-             {{Number::to_nearest, -2},
-              {Number::towards_zero, -1},
-              {Number::downward, -2},
-              {Number::upward, -1}}},
+             {{Number::rounding_mode::to_nearest, -2},
+              {Number::rounding_mode::towards_zero, -1},
+              {Number::rounding_mode::downward, -2},
+              {Number::rounding_mode::upward, -1}}},
             {Number{-27, -1},
-             {{Number::to_nearest, -3},
-              {Number::towards_zero, -2},
-              {Number::downward, -3},
-              {Number::upward, -2}}},
+             {{Number::rounding_mode::to_nearest, -3},
+              {Number::rounding_mode::towards_zero, -2},
+              {Number::rounding_mode::downward, -3},
+              {Number::rounding_mode::upward, -2}}},
         };
 
         for (auto const& [num, roundings] : expected)
@@ -1491,8 +1492,8 @@ public:
                 auto const res = static_cast<std::int64_t>(num);
                 BEAST_EXPECTS(
                     res == val,
-                    to_string(num) + " with mode " + std::to_string(mode) + " expected " +
-                        std::to_string(val) + " got " + std::to_string(res));
+                    to_string(num) + " with mode " + std::to_string(static_cast<int>(mode)) +
+                        " expected " + std::to_string(val) + " got " + std::to_string(res));
             }
         }
     }
@@ -1508,7 +1509,7 @@ public:
         Number const ten{10};
         BEAST_EXPECT(ten.exponent() <= 0);
 
-        if (scale == MantissaRange::small)
+        if (scale == MantissaRange::mantissa_scale::small)
         {
             BEAST_EXPECT(std::numeric_limits<std::int64_t>::max() > INITIAL_XRP.drops());
             BEAST_EXPECT(Number::maxMantissa() < INITIAL_XRP.drops());
@@ -1537,7 +1538,7 @@ public:
             // 85'070'591'730'234'615'847'396'907'784'232'501'249 - 38 digits
             BEAST_EXPECT((power(maxInt64, 2) == Number{85'070'591'730'234'615'85, 19}));
 
-            NumberRoundModeGuard const mg(Number::towards_zero);
+            NumberRoundModeGuard const mg(Number::rounding_mode::towards_zero);
 
             auto const maxMantissa = Number::maxMantissa();
             Number const max = Number{false, maxMantissa, 0, Number::normalized{}};
@@ -1553,7 +1554,8 @@ public:
     void
     run() override
     {
-        for (auto const scale : {MantissaRange::small, MantissaRange::large})
+        for (auto const scale :
+             {MantissaRange::mantissa_scale::small, MantissaRange::mantissa_scale::large})
         {
             NumberMantissaScaleGuard const sg(scale);
             testZero();
diff --git a/src/test/beast/beast_io_latency_probe_test.cpp b/src/test/beast/beast_io_latency_probe_test.cpp
index dfd20eced0..206fdfc8b1 100644
--- a/src/test/beast/beast_io_latency_probe_test.cpp
+++ b/src/test/beast/beast_io_latency_probe_test.cpp
@@ -66,7 +66,7 @@ class io_latency_probe_test : public beast::unit_test::suite, public beast::test
                         wait_err = ec;
                     auto const end{MeasureClock::now()};
                     elapsed_times_.emplace_back(end - start);
-                    std::lock_guard const lk{mtx};
+                    std::scoped_lock const lk{mtx};
                     done = true;
                     cv.notify_one();
                 });
diff --git a/src/test/consensus/NegativeUNL_test.cpp b/src/test/consensus/NegativeUNL_test.cpp
index a3987e8136..bb1bcb0c0f 100644
--- a/src/test/consensus/NegativeUNL_test.cpp
+++ b/src/test/consensus/NegativeUNL_test.cpp
@@ -738,9 +738,9 @@ class NegativeUNLVoteInternal_test : public beast::unit_test::suite
         PublicKey const toReEnableKey(derivePublicKey(KeyType::ed25519, randomSecretKey()));
         LedgerIndex const seq(1234);
         BEAST_EXPECT(countTx(txSet) == 0);
-        vote.addTx(seq, toDisableKey, NegativeUNLVote::ToDisable, txSet);
+        vote.addTx(seq, toDisableKey, NegativeUNLVote::NegativeUNLModify::ToDisable, txSet);
         BEAST_EXPECT(countTx(txSet) == 1);
-        vote.addTx(seq, toReEnableKey, NegativeUNLVote::ToReEnable, txSet);
+        vote.addTx(seq, toReEnableKey, NegativeUNLVote::NegativeUNLModify::ToReEnable, txSet);
         BEAST_EXPECT(countTx(txSet) == 2);
         // content of a tx is implicitly tested after applied to a ledger
         // in later test cases
diff --git a/src/test/core/Coroutine_test.cpp b/src/test/core/Coroutine_test.cpp
index 38bafe08fd..9696451f6a 100644
--- a/src/test/core/Coroutine_test.cpp
+++ b/src/test/core/Coroutine_test.cpp
@@ -43,7 +43,7 @@ public:
         void
         signal()
         {
-            std::lock_guard const lk(mutex_);
+            std::scoped_lock const lk(mutex_);
             signaled_ = true;
             cv_.notify_all();
         }
diff --git a/src/test/core/Workers_test.cpp b/src/test/core/Workers_test.cpp
index a5b579e810..e8a9f21816 100644
--- a/src/test/core/Workers_test.cpp
+++ b/src/test/core/Workers_test.cpp
@@ -89,7 +89,7 @@ public:
         void
         processTask(int instance) override
         {
-            std::lock_guard const lk{mut};
+            std::scoped_lock const lk{mut};
             if (--count == 0)
                 cv.notify_all();
         }
diff --git a/src/test/jtx/AMMTest.h b/src/test/jtx/AMMTest.h
index 8f46ef6f59..ffb186e0d6 100644
--- a/src/test/jtx/AMMTest.h
+++ b/src/test/jtx/AMMTest.h
@@ -140,7 +140,7 @@ protected:
         void
         signal()
         {
-            std::lock_guard const lk(mutex_);
+            std::scoped_lock const lk(mutex_);
             signaled_ = true;
             cv_.notify_all();
         }
diff --git a/src/test/jtx/Account.h b/src/test/jtx/Account.h
index c702bcffec..a30b974522 100644
--- a/src/test/jtx/Account.h
+++ b/src/test/jtx/Account.h
@@ -52,7 +52,7 @@ public:
      * secret key is unavailable, such as for pseudo-accounts. */
     explicit Account(std::string name, AccountID const& id);
 
-    enum AcctStringType { base58Seed, other };
+    enum class AcctStringType { base58Seed, other };
     /** Create an account from a base58 seed string.  Throws on invalid seed. */
     Account(AcctStringType stringType, std::string base58SeedStr);
 
diff --git a/src/test/jtx/CaptureLogs.h b/src/test/jtx/CaptureLogs.h
index 0e9598decd..491a341540 100644
--- a/src/test/jtx/CaptureLogs.h
+++ b/src/test/jtx/CaptureLogs.h
@@ -36,14 +36,14 @@ class CaptureLogs : public Logs
         void
         write(beast::severities::Severity level, std::string const& text) override
         {
-            std::lock_guard const lock(strmMutex_);
+            std::scoped_lock const lock(strmMutex_);
             strm_ << text;
         }
 
         void
         writeAlways(beast::severities::Severity level, std::string const& text) override
         {
-            std::lock_guard const lock(strmMutex_);
+            std::scoped_lock const lock(strmMutex_);
             strm_ << text;
         }
     };
diff --git a/src/test/jtx/TestHelpers.h b/src/test/jtx/TestHelpers.h
index e3119f4c71..ae52c50b89 100644
--- a/src/test/jtx/TestHelpers.h
+++ b/src/test/jtx/TestHelpers.h
@@ -464,7 +464,7 @@ public:
     void
     signal()
     {
-        std::lock_guard const lk(mutex_);
+        std::scoped_lock const lk(mutex_);
         signaled_ = true;
         cv_.notify_all();
     }
diff --git a/src/test/jtx/directory.h b/src/test/jtx/directory.h
index 0940c23623..08d8fef73e 100644
--- a/src/test/jtx/directory.h
+++ b/src/test/jtx/directory.h
@@ -12,7 +12,7 @@
 /** Directory operations. */
 namespace xrpl::test::jtx::directory {
 
-enum Error {
+enum class Error {
     DirectoryRootNotFound,
     DirectoryTooSmall,
     DirectoryPageDuplicate,
diff --git a/src/test/jtx/impl/AMMTest.cpp b/src/test/jtx/impl/AMMTest.cpp
index 24d831be7d..dbd8b690f7 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::small};
+        NumberMantissaScaleGuard const sg{xrpl::MantissaRange::mantissa_scale::small};
 
         // For now, just disable SAV entirely, which locks in the small Number
         // mantissas
diff --git a/src/test/jtx/impl/Account.cpp b/src/test/jtx/impl/Account.cpp
index 4e09940487..e93e6c6068 100644
--- a/src/test/jtx/impl/Account.cpp
+++ b/src/test/jtx/impl/Account.cpp
@@ -50,7 +50,7 @@ Account::fromCache(AcctStringType stringType, std::string name, KeyType type)
 
     auto const keys = [stringType, &name, type]() {
         // Special handling for base58Seeds.
-        if (stringType == base58Seed)
+        if (stringType == AcctStringType::base58Seed)
         {
             std::optional<Seed> const seed = parseBase58<Seed>(name);
             if (!seed.has_value())
@@ -68,12 +68,15 @@ Account::fromCache(AcctStringType stringType, std::string name, KeyType type)
 }
 
 Account::Account(std::string name, KeyType type)
-    : Account(fromCache(Account::other, std::move(name), type))
+    : Account(fromCache(Account::AcctStringType::other, std::move(name), type))
 {
 }
 
 Account::Account(AcctStringType stringType, std::string base58SeedStr)
-    : Account(fromCache(Account::base58Seed, std::move(base58SeedStr), KeyType::secp256k1))
+    : Account(fromCache(
+          Account::AcctStringType::base58Seed,
+          std::move(base58SeedStr),
+          KeyType::secp256k1))
 {
 }
 
diff --git a/src/test/jtx/impl/WSClient.cpp b/src/test/jtx/impl/WSClient.cpp
index a7db5e4302..72f9e25b7c 100644
--- a/src/test/jtx/impl/WSClient.cpp
+++ b/src/test/jtx/impl/WSClient.cpp
@@ -304,7 +304,7 @@ private:
         rb_.consume(rb_.size());
         auto m = std::make_shared<msg>(std::move(jv));
         {
-            std::lock_guard const lock(m_);
+            std::scoped_lock const lock(m_);
             msgs_.push_front(m);
             cv_.notify_all();
         }
@@ -318,7 +318,7 @@ private:
     void
     on_read_done()
     {
-        std::lock_guard const lock(m0_);
+        std::scoped_lock const lock(m0_);
         b0_ = true;
         cv0_.notify_all();
     }
diff --git a/src/test/jtx/impl/directory.cpp b/src/test/jtx/impl/directory.cpp
index ac4d81bdfb..0d545bd6f4 100644
--- a/src/test/jtx/impl/directory.cpp
+++ b/src/test/jtx/impl/directory.cpp
@@ -36,7 +36,7 @@ bumpLastPage(
         auto sleRoot = sb.peek(directory);
         if (!sleRoot)
         {
-            res = Unexpected<Error>(DirectoryRootNotFound);
+            res = Unexpected<Error>(Error::DirectoryRootNotFound);
             return false;
         }
 
@@ -44,26 +44,26 @@ bumpLastPage(
         auto const lastIndex = sleRoot->getFieldU64(sfIndexPrevious);
         if (lastIndex == 0)
         {
-            res = Unexpected<Error>(DirectoryTooSmall);
+            res = Unexpected<Error>(Error::DirectoryTooSmall);
             return false;
         }
 
         if (sb.exists(keylet::page(directory, newLastPage)))
         {
-            res = Unexpected<Error>(DirectoryPageDuplicate);
+            res = Unexpected<Error>(Error::DirectoryPageDuplicate);
             return false;
         }
 
         if (lastIndex >= newLastPage)
         {
-            res = Unexpected<Error>(InvalidLastPage);
+            res = Unexpected<Error>(Error::InvalidLastPage);
             return false;
         }
 
         auto slePage = sb.peek(keylet::page(directory, lastIndex));
         if (!slePage)
         {
-            res = Unexpected<Error>(DirectoryPageNotFound);
+            res = Unexpected<Error>(Error::DirectoryPageNotFound);
             return false;
         }
 
@@ -94,7 +94,7 @@ bumpLastPage(
             auto slePrev = sb.peek(keylet::page(directory, *prevIndex));
             if (!slePrev)
             {
-                res = Unexpected<Error>(DirectoryPageNotFound);
+                res = Unexpected<Error>(Error::DirectoryPageNotFound);
                 return false;
             }
             slePrev->setFieldU64(sfIndexNext, newLastPage);
@@ -109,7 +109,7 @@ bumpLastPage(
             {
                 if (!adjust(sb, key, newLastPage))
                 {
-                    res = Unexpected<Error>(AdjustmentError);
+                    res = Unexpected<Error>(Error::AdjustmentError);
                     return false;
                 }
             }
diff --git a/src/test/jtx/impl/ledgerStateFixes.cpp b/src/test/jtx/impl/ledgerStateFixes.cpp
index 99cd03cbb6..bc19915957 100644
--- a/src/test/jtx/impl/ledgerStateFixes.cpp
+++ b/src/test/jtx/impl/ledgerStateFixes.cpp
@@ -6,6 +6,8 @@
 #include <xrpl/protocol/jss.h>
 #include <xrpl/tx/transactors/system/LedgerStateFix.h>
 
+#include <cstdint>
+
 namespace xrpl::test::jtx::ledgerStateFix {
 
 // Fix NFTokenPage links on owner's account.  acct pays fee.
@@ -14,7 +16,8 @@ nftPageLinks(jtx::Account const& acct, jtx::Account const& owner)
 {
     Json::Value jv;
     jv[sfAccount.jsonName] = acct.human();
-    jv[sfLedgerFixType.jsonName] = LedgerStateFix::nfTokenPageLink;
+    jv[sfLedgerFixType.jsonName] =
+        static_cast<std::uint16_t>(LedgerStateFix::FixType::nfTokenPageLink);
     jv[sfOwner.jsonName] = owner.human();
     jv[sfTransactionType.jsonName] = jss::LedgerStateFix;
     return jv;
diff --git a/src/test/ledger/PaymentSandbox_test.cpp b/src/test/ledger/PaymentSandbox_test.cpp
index 0dc2cb6e74..a756eb312f 100644
--- a/src/test/ledger/PaymentSandbox_test.cpp
+++ b/src/test/ledger/PaymentSandbox_test.cpp
@@ -126,21 +126,23 @@ class PaymentSandbox_test : public beast::unit_test::suite
             ApplyViewImpl av(&*env.current(), tapNONE);
 
             auto const iss = USD_gw1;
-            auto const startingAmount =
-                accountHolds(av, alice, iss.currency, iss.account, fhIGNORE_FREEZE, j);
+            auto const startingAmount = accountHolds(
+                av, alice, iss.currency, iss.account, FreezeHandling::fhIGNORE_FREEZE, j);
             {
                 auto r = accountSend(av, gw1, alice, toCredit, j);
                 BEAST_EXPECT(isTesSuccess(r));
             }
             BEAST_EXPECT(
-                accountHolds(av, alice, iss.currency, iss.account, fhIGNORE_FREEZE, j) ==
+                accountHolds(
+                    av, alice, iss.currency, iss.account, FreezeHandling::fhIGNORE_FREEZE, j) ==
                 startingAmount + toCredit);
             {
                 auto r = accountSend(av, alice, gw1, toDebit, j);
                 BEAST_EXPECT(isTesSuccess(r));
             }
             BEAST_EXPECT(
-                accountHolds(av, alice, iss.currency, iss.account, fhIGNORE_FREEZE, j) ==
+                accountHolds(
+                    av, alice, iss.currency, iss.account, FreezeHandling::fhIGNORE_FREEZE, j) ==
                 startingAmount + toCredit - toDebit);
         }
 
@@ -149,17 +151,19 @@ class PaymentSandbox_test : public beast::unit_test::suite
             ApplyViewImpl av(&*env.current(), tapNONE);
 
             auto const iss = USD_gw1;
-            auto const startingAmount =
-                accountHolds(av, alice, iss.currency, iss.account, fhIGNORE_FREEZE, j);
+            auto const startingAmount = accountHolds(
+                av, alice, iss.currency, iss.account, FreezeHandling::fhIGNORE_FREEZE, j);
 
             directSendNoFee(av, gw1, alice, toCredit, true, j);
             BEAST_EXPECT(
-                accountHolds(av, alice, iss.currency, iss.account, fhIGNORE_FREEZE, j) ==
+                accountHolds(
+                    av, alice, iss.currency, iss.account, FreezeHandling::fhIGNORE_FREEZE, j) ==
                 startingAmount + toCredit);
 
             directSendNoFee(av, alice, gw1, toDebit, true, j);
             BEAST_EXPECT(
-                accountHolds(av, alice, iss.currency, iss.account, fhIGNORE_FREEZE, j) ==
+                accountHolds(
+                    av, alice, iss.currency, iss.account, FreezeHandling::fhIGNORE_FREEZE, j) ==
                 startingAmount + toCredit - toDebit);
         }
 
@@ -169,15 +173,16 @@ class PaymentSandbox_test : public beast::unit_test::suite
             PaymentSandbox pv(&av);
 
             auto const iss = USD_gw1;
-            auto const startingAmount =
-                accountHolds(pv, alice, iss.currency, iss.account, fhIGNORE_FREEZE, j);
+            auto const startingAmount = accountHolds(
+                pv, alice, iss.currency, iss.account, FreezeHandling::fhIGNORE_FREEZE, j);
 
             {
                 auto r = accountSend(pv, gw1, alice, toCredit, j);
                 BEAST_EXPECT(isTesSuccess(r));
             }
             BEAST_EXPECT(
-                accountHolds(pv, alice, iss.currency, iss.account, fhIGNORE_FREEZE, j) ==
+                accountHolds(
+                    pv, alice, iss.currency, iss.account, FreezeHandling::fhIGNORE_FREEZE, j) ==
                 startingAmount);
 
             {
@@ -185,7 +190,8 @@ class PaymentSandbox_test : public beast::unit_test::suite
                 BEAST_EXPECT(isTesSuccess(r));
             }
             BEAST_EXPECT(
-                accountHolds(pv, alice, iss.currency, iss.account, fhIGNORE_FREEZE, j) ==
+                accountHolds(
+                    pv, alice, iss.currency, iss.account, FreezeHandling::fhIGNORE_FREEZE, j) ==
                 startingAmount - toDebit);
         }
 
@@ -195,12 +201,13 @@ class PaymentSandbox_test : public beast::unit_test::suite
             PaymentSandbox pv(&av);
 
             auto const iss = USD_gw1;
-            auto const startingAmount =
-                accountHolds(pv, alice, iss.currency, iss.account, fhIGNORE_FREEZE, j);
+            auto const startingAmount = accountHolds(
+                pv, alice, iss.currency, iss.account, FreezeHandling::fhIGNORE_FREEZE, j);
 
             directSendNoFee(pv, gw1, alice, toCredit, true, j);
             BEAST_EXPECT(
-                accountHolds(pv, alice, iss.currency, iss.account, fhIGNORE_FREEZE, j) ==
+                accountHolds(
+                    pv, alice, iss.currency, iss.account, FreezeHandling::fhIGNORE_FREEZE, j) ==
                 startingAmount);
         }
 
@@ -210,12 +217,13 @@ class PaymentSandbox_test : public beast::unit_test::suite
             PaymentSandbox pv(&av);
 
             auto const iss = USD_gw1;
-            auto const startingAmount =
-                accountHolds(pv, alice, iss.currency, iss.account, fhIGNORE_FREEZE, j);
+            auto const startingAmount = accountHolds(
+                pv, alice, iss.currency, iss.account, FreezeHandling::fhIGNORE_FREEZE, j);
 
             BEAST_EXPECT(redeemIOU(pv, alice, toDebit, iss, j) == tesSUCCESS);
             BEAST_EXPECT(
-                accountHolds(pv, alice, iss.currency, iss.account, fhIGNORE_FREEZE, j) ==
+                accountHolds(
+                    pv, alice, iss.currency, iss.account, FreezeHandling::fhIGNORE_FREEZE, j) ==
                 startingAmount - toDebit);
         }
 
@@ -225,12 +233,13 @@ class PaymentSandbox_test : public beast::unit_test::suite
             PaymentSandbox pv(&av);
 
             auto const iss = USD_gw1;
-            auto const startingAmount =
-                accountHolds(pv, alice, iss.currency, iss.account, fhIGNORE_FREEZE, j);
+            auto const startingAmount = accountHolds(
+                pv, alice, iss.currency, iss.account, FreezeHandling::fhIGNORE_FREEZE, j);
 
             BEAST_EXPECT(issueIOU(pv, alice, toCredit, iss, j) == tesSUCCESS);
             BEAST_EXPECT(
-                accountHolds(pv, alice, iss.currency, iss.account, fhIGNORE_FREEZE, j) ==
+                accountHolds(
+                    pv, alice, iss.currency, iss.account, FreezeHandling::fhIGNORE_FREEZE, j) ==
                 startingAmount);
         }
 
@@ -240,29 +249,40 @@ class PaymentSandbox_test : public beast::unit_test::suite
             PaymentSandbox pv(&av);
 
             auto const iss = USD_gw1;
-            auto const startingAmount =
-                accountHolds(pv, alice, iss.currency, iss.account, fhIGNORE_FREEZE, j);
+            auto const startingAmount = accountHolds(
+                pv, alice, iss.currency, iss.account, FreezeHandling::fhIGNORE_FREEZE, j);
 
             {
                 auto r = accountSend(pv, gw1, alice, toCredit, j);
                 BEAST_EXPECT(isTesSuccess(r));
             }
             BEAST_EXPECT(
-                accountHolds(pv, alice, iss.currency, iss.account, fhIGNORE_FREEZE, j) ==
+                accountHolds(
+                    pv, alice, iss.currency, iss.account, FreezeHandling::fhIGNORE_FREEZE, j) ==
                 startingAmount);
 
             {
                 PaymentSandbox pv2(&pv);
                 BEAST_EXPECT(
-                    accountHolds(pv2, alice, iss.currency, iss.account, fhIGNORE_FREEZE, j) ==
-                    startingAmount);
+                    accountHolds(
+                        pv2,
+                        alice,
+                        iss.currency,
+                        iss.account,
+                        FreezeHandling::fhIGNORE_FREEZE,
+                        j) == startingAmount);
                 {
                     auto r = accountSend(pv2, gw1, alice, toCredit, j);
                     BEAST_EXPECT(isTesSuccess(r));
                 }
                 BEAST_EXPECT(
-                    accountHolds(pv2, alice, iss.currency, iss.account, fhIGNORE_FREEZE, j) ==
-                    startingAmount);
+                    accountHolds(
+                        pv2,
+                        alice,
+                        iss.currency,
+                        iss.account,
+                        FreezeHandling::fhIGNORE_FREEZE,
+                        j) == startingAmount);
             }
 
             {
@@ -270,7 +290,8 @@ class PaymentSandbox_test : public beast::unit_test::suite
                 BEAST_EXPECT(isTesSuccess(r));
             }
             BEAST_EXPECT(
-                accountHolds(pv, alice, iss.currency, iss.account, fhIGNORE_FREEZE, j) ==
+                accountHolds(
+                    pv, alice, iss.currency, iss.account, FreezeHandling::fhIGNORE_FREEZE, j) ==
                 startingAmount - toDebit);
         }
     }
@@ -312,8 +333,8 @@ class PaymentSandbox_test : public beast::unit_test::suite
 
         auto accountFundsXRP =
             [](ReadView const& view, AccountID const& id, beast::Journal j) -> XRPAmount {
-            return toAmount<XRPAmount>(
-                accountHolds(view, id, xrpCurrency(), xrpAccount(), fhZERO_IF_FROZEN, j));
+            return toAmount<XRPAmount>(accountHolds(
+                view, id, xrpCurrency(), xrpAccount(), FreezeHandling::fhZERO_IF_FROZEN, j));
         };
 
         auto reserve = [](jtx::Env& env, std::uint32_t count) -> XRPAmount {
diff --git a/src/test/ledger/View_test.cpp b/src/test/ledger/View_test.cpp
index cf2e478889..e0d757c0d3 100644
--- a/src/test/ledger/View_test.cpp
+++ b/src/test/ledger/View_test.cpp
@@ -787,7 +787,12 @@ class View_test : public beast::unit_test::suite
             BEAST_EXPECT(
                 USD(0) ==
                 accountHolds(
-                    *env.closed(), alice, USD.currency, gw, fhZERO_IF_FROZEN, env.journal));
+                    *env.closed(),
+                    alice,
+                    USD.currency,
+                    gw,
+                    FreezeHandling::fhZERO_IF_FROZEN,
+                    env.journal));
 
             // Thaw gw and try again.
             env(fclear(gw, asfGlobalFreeze));
@@ -806,14 +811,26 @@ class View_test : public beast::unit_test::suite
             // Bob's balance should be zero if frozen.
             BEAST_EXPECT(
                 USD(0) ==
-                accountHolds(*env.closed(), bob, USD.currency, gw, fhZERO_IF_FROZEN, env.journal));
+                accountHolds(
+                    *env.closed(),
+                    bob,
+                    USD.currency,
+                    gw,
+                    FreezeHandling::fhZERO_IF_FROZEN,
+                    env.journal));
 
             // gw thaws bob's trust line.  bob gets his money back.
             env(trust(gw, USD(100), bob, tfClearFreeze));
             env.close();
             BEAST_EXPECT(
                 USD(50) ==
-                accountHolds(*env.closed(), bob, USD.currency, gw, fhZERO_IF_FROZEN, env.journal));
+                accountHolds(
+                    *env.closed(),
+                    bob,
+                    USD.currency,
+                    gw,
+                    FreezeHandling::fhZERO_IF_FROZEN,
+                    env.journal));
         }
         {
             // accountHolds().
@@ -824,17 +841,32 @@ class View_test : public beast::unit_test::suite
             BEAST_EXPECT(
                 EUR(0) ==
                 accountHolds(
-                    *env.closed(), carol, EUR.currency, gw, fhZERO_IF_FROZEN, env.journal));
+                    *env.closed(),
+                    carol,
+                    EUR.currency,
+                    gw,
+                    FreezeHandling::fhZERO_IF_FROZEN,
+                    env.journal));
 
             // But carol does have USD.
             BEAST_EXPECT(
                 USD(50) ==
                 accountHolds(
-                    *env.closed(), carol, USD.currency, gw, fhZERO_IF_FROZEN, env.journal));
+                    *env.closed(),
+                    carol,
+                    USD.currency,
+                    gw,
+                    FreezeHandling::fhZERO_IF_FROZEN,
+                    env.journal));
 
             // carol's XRP balance should be her holdings minus her reserve.
             auto const carolsXRP = accountHolds(
-                *env.closed(), carol, xrpCurrency(), xrpAccount(), fhZERO_IF_FROZEN, env.journal);
+                *env.closed(),
+                carol,
+                xrpCurrency(),
+                xrpAccount(),
+                FreezeHandling::fhZERO_IF_FROZEN,
+                env.journal);
             // carol's XRP balance:              10000
             // base reserve:                      -200
             // 1 trust line times its reserve: 1 * -50
@@ -851,28 +883,35 @@ class View_test : public beast::unit_test::suite
             BEAST_EXPECT(
                 XRP(0) ==
                 accountHolds(
-                    *env.closed(), carol, xrpCurrency(), gw, fhZERO_IF_FROZEN, env.journal));
+                    *env.closed(),
+                    carol,
+                    xrpCurrency(),
+                    gw,
+                    FreezeHandling::fhZERO_IF_FROZEN,
+                    env.journal));
         }
         {
             // accountFunds().
             // Gateways have whatever funds they claim to have.
-            auto const gwUSD =
-                accountFunds(*env.closed(), gw, USD(314159), fhZERO_IF_FROZEN, env.journal);
+            auto const gwUSD = accountFunds(
+                *env.closed(), gw, USD(314159), FreezeHandling::fhZERO_IF_FROZEN, env.journal);
             BEAST_EXPECT(gwUSD == USD(314159));
 
             // carol has funds from the gateway.
-            auto carolsUSD =
-                accountFunds(*env.closed(), carol, USD(0), fhZERO_IF_FROZEN, env.journal);
+            auto carolsUSD = accountFunds(
+                *env.closed(), carol, USD(0), FreezeHandling::fhZERO_IF_FROZEN, env.journal);
             BEAST_EXPECT(carolsUSD == USD(50));
 
             // If carol's funds are frozen she has no funds...
             env(fset(gw, asfGlobalFreeze));
             env.close();
-            carolsUSD = accountFunds(*env.closed(), carol, USD(0), fhZERO_IF_FROZEN, env.journal);
+            carolsUSD = accountFunds(
+                *env.closed(), carol, USD(0), FreezeHandling::fhZERO_IF_FROZEN, env.journal);
             BEAST_EXPECT(carolsUSD == USD(0));
 
             // ... unless the query ignores the FROZEN state.
-            carolsUSD = accountFunds(*env.closed(), carol, USD(0), fhIGNORE_FREEZE, env.journal);
+            carolsUSD = accountFunds(
+                *env.closed(), carol, USD(0), FreezeHandling::fhIGNORE_FREEZE, env.journal);
             BEAST_EXPECT(carolsUSD == USD(50));
 
             // Just to be tidy, thaw gw.
diff --git a/src/test/nodestore/TestBase.h b/src/test/nodestore/TestBase.h
index e527942629..8ea32517d5 100644
--- a/src/test/nodestore/TestBase.h
+++ b/src/test/nodestore/TestBase.h
@@ -67,16 +67,16 @@ public:
                 switch (rand_int(rng, 3))
                 {
                     case 0:
-                        return hotLEDGER;
+                        return NodeObjectType::hotLEDGER;
                     case 1:
-                        return hotACCOUNT_NODE;
+                        return NodeObjectType::hotACCOUNT_NODE;
                     case 2:
-                        return hotTRANSACTION_NODE;
+                        return NodeObjectType::hotTRANSACTION_NODE;
                     case 3:
-                        return hotUNKNOWN;
+                        return NodeObjectType::hotUNKNOWN;
                     default:
                         // will never happen, but make static analysis tool happy.
-                        return hotUNKNOWN;
+                        return NodeObjectType::hotUNKNOWN;
                 }
             }();
 
@@ -140,9 +140,9 @@ public:
 
             Status const status = backend.fetch(batch[i]->getHash(), &object);
 
-            BEAST_EXPECT(status == ok);
+            BEAST_EXPECT(status == Status::ok);
 
-            if (status == ok)
+            if (status == Status::ok)
             {
                 BEAST_EXPECT(object != nullptr);
 
@@ -160,7 +160,7 @@ public:
 
             Status const status = backend.fetch(batch[i]->getHash(), &object);
 
-            BEAST_EXPECT(status == notFound);
+            BEAST_EXPECT(status == Status::notFound);
         }
     }
 
diff --git a/src/test/nodestore/Timing_test.cpp b/src/test/nodestore/Timing_test.cpp
index cc9881dbac..1145bc80f4 100644
--- a/src/test/nodestore/Timing_test.cpp
+++ b/src/test/nodestore/Timing_test.cpp
@@ -77,6 +77,8 @@ rngcpy(void* buffer, std::size_t bytes, Generator& g)
 class Sequence
 {
 private:
+    // Need to be named before converting
+    // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
     enum { minLedger = 1, maxLedger = 1000000, minSize = 250, maxSize = 1250 };
 
     beast::xor_shift_engine gen_;
@@ -135,6 +137,8 @@ public:
 class Timing_test : public beast::unit_test::suite
 {
 public:
+    // Need to be named before converting
+    // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
     enum {
         // percent of fetches for missing nodes
         missingNodePercent = 20
@@ -678,7 +682,7 @@ public:
     void
     run() override
     {
-        testcase("Timing", beast::unit_test::abort_on_fail);
+        testcase("Timing", beast::unit_test::abort_t::abort_on_fail);
 
         /*  Parameters:
 
diff --git a/src/test/nodestore/import_test.cpp b/src/test/nodestore/import_test.cpp
index 1341b98894..359f27ef7d 100644
--- a/src/test/nodestore/import_test.cpp
+++ b/src/test/nodestore/import_test.cpp
@@ -288,7 +288,7 @@ public:
     void
     run() override
     {
-        testcase(beast::unit_test::abort_on_fail) << arg();
+        testcase(beast::unit_test::abort_t::abort_on_fail) << arg();
 
         using namespace nudb;
         using namespace nudb::detail;
diff --git a/src/test/overlay/TMGetObjectByHash_test.cpp b/src/test/overlay/TMGetObjectByHash_test.cpp
index c1db5262d0..e42d4ffe75 100644
--- a/src/test/overlay/TMGetObjectByHash_test.cpp
+++ b/src/test/overlay/TMGetObjectByHash_test.cpp
@@ -158,7 +158,8 @@ class TMGetObjectByHash_test : public beast::unit_test::suite
             hashes.push_back(hash);
 
             Blob data(100, static_cast<unsigned char>(i % 256));
-            nodeStore.store(hotLEDGER, std::move(data), hash, nodeStore.earliestLedgerSeq());
+            nodeStore.store(
+                NodeObjectType::hotLEDGER, std::move(data), hash, nodeStore.earliestLedgerSeq());
         }
 
         // Create a request with more objects than hardMaxReplyNodes
diff --git a/src/test/overlay/reduce_relay_test.cpp b/src/test/overlay/reduce_relay_test.cpp
index 21f3482ab5..1a650655f2 100644
--- a/src/test/overlay/reduce_relay_test.cpp
+++ b/src/test/overlay/reduce_relay_test.cpp
@@ -913,8 +913,8 @@ protected:
         return sp->id();
     }
 
-    enum State { On, Off, WaitReset };
-    enum EventType { LinkDown = 0, PeerDisconnected = 1 };
+    enum class State { On, Off, WaitReset };
+    enum class EventType { LinkDown = 0, PeerDisconnected = 1 };
     // Link down or Peer disconnect event
     // TBD - add new peer event
     // TBD - add overlapping type of events at any
@@ -938,7 +938,8 @@ protected:
     void
     random(bool log)
     {
-        std::unordered_map<EventType, Event> events{{LinkDown, {}}, {PeerDisconnected, {}}};
+        std::unordered_map<EventType, Event> events{
+            {EventType::LinkDown, {}}, {EventType::PeerDisconnected, {}}};
         time_point<ManualClock> lastCheck = ManualClock::now();
 
         network_.reset();
diff --git a/src/test/overlay/short_read_test.cpp b/src/test/overlay/short_read_test.cpp
index 02c9312732..42959000a1 100644
--- a/src/test/overlay/short_read_test.cpp
+++ b/src/test/overlay/short_read_test.cpp
@@ -118,14 +118,14 @@ private:
         void
         add(std::shared_ptr<Child> const& child)
         {
-            std::lock_guard const lock(mutex_);
+            std::scoped_lock const lock(mutex_);
             list_.emplace(child.get(), child);
         }
 
         void
         remove(Child* child)
         {
-            std::lock_guard const lock(mutex_);
+            std::scoped_lock const lock(mutex_);
             list_.erase(child);
             if (list_.empty())
                 cond_.notify_one();
@@ -136,7 +136,7 @@ private:
         {
             std::vector<std::shared_ptr<Child>> v;
             {
-                std::lock_guard const lock(mutex_);
+                std::scoped_lock const lock(mutex_);
                 v.reserve(list_.size());
                 if (closed_)
                     return;
diff --git a/src/test/protocol/MultiApiJson_test.cpp b/src/test/protocol/MultiApiJson_test.cpp
index f0cbf805f3..f9f1ff1373 100644
--- a/src/test/protocol/MultiApiJson_test.cpp
+++ b/src/test/protocol/MultiApiJson_test.cpp
@@ -308,15 +308,15 @@ struct MultiApiJson_test : beast::unit_test::suite
             testcase("isMember");
 
             // Well defined behaviour even if we have different types of members
-            BEAST_EXPECT(subject.isMember("foo") == decltype(subject)::none);
+            BEAST_EXPECT(subject.isMember("foo") == decltype(subject)::IsMemberResult::none);
 
             {
                 // All variants have element "One", none have element "Two"
                 MultiApiJson<1, 2> s1{};
                 s1.val[0] = makeJson("One", 12);
                 s1.val[1] = makeJson("One", 42);
-                BEAST_EXPECT(s1.isMember("One") == decltype(s1)::all);
-                BEAST_EXPECT(s1.isMember("Two") == decltype(s1)::none);
+                BEAST_EXPECT(s1.isMember("One") == decltype(s1)::IsMemberResult::all);
+                BEAST_EXPECT(s1.isMember("Two") == decltype(s1)::IsMemberResult::none);
             }
 
             {
@@ -324,8 +324,8 @@ struct MultiApiJson_test : beast::unit_test::suite
                 MultiApiJson<1, 2> s2{};
                 s2.val[0] = makeJson("One", 12);
                 s2.val[1] = makeJson("Two", 42);
-                BEAST_EXPECT(s2.isMember("One") == decltype(s2)::some);
-                BEAST_EXPECT(s2.isMember("Two") == decltype(s2)::some);
+                BEAST_EXPECT(s2.isMember("One") == decltype(s2)::IsMemberResult::some);
+                BEAST_EXPECT(s2.isMember("Two") == decltype(s2)::IsMemberResult::some);
             }
 
             {
@@ -333,8 +333,8 @@ struct MultiApiJson_test : beast::unit_test::suite
                 MultiApiJson<1, 3> s3{};
                 s3.val[0] = makeJson("One", 12);
                 s3.val[1] = makeJson("One", 42);
-                BEAST_EXPECT(s3.isMember("One") == decltype(s3)::some);
-                BEAST_EXPECT(s3.isMember("Two") == decltype(s3)::none);
+                BEAST_EXPECT(s3.isMember("One") == decltype(s3)::IsMemberResult::some);
+                BEAST_EXPECT(s3.isMember("Two") == decltype(s3)::IsMemberResult::none);
             }
         }
 
diff --git a/src/test/protocol/STNumber_test.cpp b/src/test/protocol/STNumber_test.cpp
index 156f5b42aa..e2c1a91e64 100644
--- a/src/test/protocol/STNumber_test.cpp
+++ b/src/test/protocol/STNumber_test.cpp
@@ -101,12 +101,12 @@ struct STNumber_test : public beast::unit_test::suite
             BEAST_EXPECT(numberFromJson(sfNumber, "-0.000e6") == STNumber(sfNumber, 0));
 
             {
-                NumberRoundModeGuard const mg(Number::towards_zero);
+                NumberRoundModeGuard const mg(Number::rounding_mode::towards_zero);
                 // maxint64 9,223,372,036,854,775,807
                 auto const maxInt = std::to_string(std::numeric_limits<std::int64_t>::max());
                 // minint64 -9,223,372,036,854,775,808
                 auto const minInt = std::to_string(std::numeric_limits<std::int64_t>::min());
-                if (Number::getMantissaScale() == MantissaRange::small)
+                if (Number::getMantissaScale() == MantissaRange::mantissa_scale::small)
                 {
                     BEAST_EXPECT(
                         numberFromJson(sfNumber, maxInt) ==
@@ -280,7 +280,8 @@ struct STNumber_test : public beast::unit_test::suite
     {
         static_assert(!std::is_convertible_v<STNumber*, Number*>);
 
-        for (auto const scale : {MantissaRange::small, MantissaRange::large})
+        for (auto const scale :
+             {MantissaRange::mantissa_scale::small, MantissaRange::mantissa_scale::large})
         {
             NumberMantissaScaleGuard const sg(scale);
             testcase << to_string(Number::getMantissaScale());
diff --git a/src/test/protocol/SeqProxy_test.cpp b/src/test/protocol/SeqProxy_test.cpp
index d0764d7399..71b483425b 100644
--- a/src/test/protocol/SeqProxy_test.cpp
+++ b/src/test/protocol/SeqProxy_test.cpp
@@ -14,7 +14,7 @@ struct SeqProxy_test : public beast::unit_test::suite
     static constexpr bool
     expectValues(SeqProxy seqProx, std::uint32_t value, SeqProxy::Type type)
     {
-        bool const expectSeq{type == SeqProxy::seq};
+        bool const expectSeq{type == SeqProxy::Type::seq};
         return (seqProx.value() == value) && (seqProx.isSeq() == expectSeq) &&
             (seqProx.isTicket() == !expectSeq);
     }
@@ -65,8 +65,8 @@ struct SeqProxy_test : public beast::unit_test::suite
         // expected in the wild.  Nevertheless they are tested here.
         // But so are values of 1, which are expected to occur in the wild.
         static constexpr std::uint32_t uintMax{std::numeric_limits<std::uint32_t>::max()};
-        static constexpr SeqProxy::Type seq{SeqProxy::seq};
-        static constexpr SeqProxy::Type ticket{SeqProxy::ticket};
+        static constexpr SeqProxy::Type seq{SeqProxy::Type::seq};
+        static constexpr SeqProxy::Type ticket{SeqProxy::Type::ticket};
 
         static constexpr SeqProxy seqZero{seq, 0};
         static constexpr SeqProxy seqSmall{seq, 1};
diff --git a/src/test/resource/Logic_test.cpp b/src/test/resource/Logic_test.cpp
index f6da313b22..53fb81e436 100644
--- a/src/test/resource/Logic_test.cpp
+++ b/src/test/resource/Logic_test.cpp
@@ -114,7 +114,7 @@ public:
                     return;
                 }
 
-                if (c.charge(fee) == warn)
+                if (c.charge(fee) == Disposition::warn)
                 {
                     if (limited)
                     {
@@ -145,7 +145,7 @@ public:
                     return;
                 }
 
-                if (c.charge(fee) == drop)
+                if (c.charge(fee) == Disposition::drop)
                 {
                     // Disconnect abusive Consumer
                     BEAST_EXPECT(c.disconnect(j) == limited);
@@ -159,7 +159,7 @@ public:
         {
             Consumer const c(logic.newInboundEndpoint(addr));
             logic.periodicActivity();
-            if (c.disposition() != drop)
+            if (c.disposition() != Disposition::drop)
             {
                 if (limited)
                 {
@@ -185,7 +185,7 @@ public:
                 ++logic.clock();
                 logic.periodicActivity();
                 Consumer const c(logic.newInboundEndpoint(addr));
-                if (c.disposition() != drop)
+                if (c.disposition() != Disposition::drop)
                 {
                     readmitted = true;
                     break;
diff --git a/src/test/rpc/AMMInfo_test.cpp b/src/test/rpc/AMMInfo_test.cpp
index 876c9b66f1..726d23db1d 100644
--- a/src/test/rpc/AMMInfo_test.cpp
+++ b/src/test/rpc/AMMInfo_test.cpp
@@ -37,13 +37,13 @@ public:
         using namespace jtx;
 
         Account const bogie("bogie");
-        enum TestAccount { None, Alice, Bogie };
+        enum class TestAccount { None, Alice, Bogie };
         auto accountId = [&](AMM const& ammAlice, TestAccount v) -> std::optional<AccountID> {
-            if (v == Alice)
+            if (v == TestAccount::Alice)
             {
                 return ammAlice.ammAccount();
             }
-            if (v == Bogie)
+            if (v == TestAccount::Bogie)
             {
                 return bogie;
             }
@@ -67,12 +67,12 @@ public:
 
         std::vector<std::tuple<std::optional<Issue>, std::optional<Issue>, TestAccount, bool>> const
             invalidParams = {
-                {xrpIssue(), std::nullopt, None, false},
-                {std::nullopt, USD, None, false},
-                {xrpIssue(), std::nullopt, Alice, false},
-                {std::nullopt, USD, Alice, false},
-                {xrpIssue(), USD, Alice, false},
-                {std::nullopt, std::nullopt, None, true}};
+                {xrpIssue(), std::nullopt, TestAccount::None, false},
+                {std::nullopt, USD, TestAccount::None, false},
+                {xrpIssue(), std::nullopt, TestAccount::Alice, false},
+                {std::nullopt, USD, TestAccount::Alice, false},
+                {xrpIssue(), USD, TestAccount::Alice, false},
+                {std::nullopt, std::nullopt, TestAccount::None, true}};
 
         // Invalid parameters
         testAMM([&](AMM& ammAlice, Env&) {
@@ -129,12 +129,12 @@ public:
 
         std::vector<std::tuple<std::optional<Issue>, std::optional<Issue>, TestAccount, bool>> const
             invalidParamsBadAccount = {
-                {xrpIssue(), std::nullopt, None, false},
-                {std::nullopt, USD, None, false},
-                {xrpIssue(), std::nullopt, Bogie, false},
-                {std::nullopt, USD, Bogie, false},
-                {xrpIssue(), USD, Bogie, false},
-                {std::nullopt, std::nullopt, None, true}};
+                {xrpIssue(), std::nullopt, TestAccount::None, false},
+                {std::nullopt, USD, TestAccount::None, false},
+                {xrpIssue(), std::nullopt, TestAccount::Bogie, false},
+                {std::nullopt, USD, TestAccount::Bogie, false},
+                {xrpIssue(), USD, TestAccount::Bogie, false},
+                {std::nullopt, std::nullopt, TestAccount::None, true}};
 
         // Invalid parameters *and* invalid AMM account, default API version
         testAMM([&](AMM& ammAlice, Env&) {
@@ -165,8 +165,8 @@ public:
                     3);
                 BEAST_EXPECT(
                     jv[jss::error_message] ==
-                    (acct == Bogie ? std::string("Account malformed.")
-                                   : std::string("Invalid parameters.")));
+                    (acct == TestAccount::Bogie ? std::string("Account malformed.")
+                                                : std::string("Invalid parameters.")));
             }
         });
     }
diff --git a/src/test/rpc/GetAggregatePrice_test.cpp b/src/test/rpc/GetAggregatePrice_test.cpp
index f4473c0aa3..ea8c498619 100644
--- a/src/test/rpc/GetAggregatePrice_test.cpp
+++ b/src/test/rpc/GetAggregatePrice_test.cpp
@@ -177,7 +177,8 @@ public:
             auto const all = testable_amendments();
             for (auto const& feats : {all - featureSingleAssetVault - featureLendingProtocol, all})
             {
-                for (auto const mantissaSize : {MantissaRange::small, MantissaRange::large})
+                for (auto const mantissaSize :
+                     {MantissaRange::mantissa_scale::small, MantissaRange::mantissa_scale::large})
                 {
                     // Regardless of the features enabled, RPC is controlled by
                     // the global mantissa size. And since it's a thread-local,
diff --git a/src/test/rpc/RPCCall_test.cpp b/src/test/rpc/RPCCall_test.cpp
index 3ece97344c..409ba660d8 100644
--- a/src/test/rpc/RPCCall_test.cpp
+++ b/src/test/rpc/RPCCall_test.cpp
@@ -31,7 +31,7 @@ struct RPCCallTestData
     std::vector<char const*> const args;
 
     // If it throws, what does it throw?
-    enum Exception { no_exception = 0, bad_cast };
+    enum class Exception { no_exception = 0, bad_cast };
     Exception const throwsWhat;
 
     // Expected JSON response.
@@ -72,7 +72,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"account_channels: minimal.",
      __LINE__,
      {"account_channels", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_channels",
     "params" : [
@@ -87,7 +87,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {"account_channels",
       "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
       "rD5MbavGfiSC5m7mkxy1FANuT7s3HxqpoF"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_channels",
     "params" : [
@@ -103,7 +103,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {"account_channels",
       "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
       "r9emE59aTWb85t64dAebKrxYMBTpzK5yR7"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_channels",
     "params" : [
@@ -119,7 +119,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {"account_channels",
       "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
       "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_channels",
     "params" : [
@@ -136,7 +136,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
       "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
       "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_channels",
     "params" : [
@@ -154,7 +154,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
       "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
       "90210"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_channels",
     "params" : [
@@ -171,7 +171,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "account_channels",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_channels",
     "params" : [
@@ -189,7 +189,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
       "current",
       "extra"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_channels",
     "params" : [
@@ -206,7 +206,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "account_channels",
          "",  // Note: very few values are detected as bad!
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_channels",
     "params" : [
@@ -223,7 +223,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"account_currencies: minimal 1.",
      __LINE__,
      {"account_currencies", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_currencies",
     "params" : [
@@ -236,7 +236,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"account_currencies: minimal 2.",
      __LINE__,
      {"account_currencies", "racb4o3DrdYxuCfyVa6vsLb7vgju9RFbBr"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_currencies",
     "params" : [
@@ -249,7 +249,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"account_currencies: ledger index.",
      __LINE__,
      {"account_currencies", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "42"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_currencies",
     "params" : [
@@ -263,7 +263,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"account_currencies: validated ledger.",
      __LINE__,
      {"account_currencies", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "validated"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_currencies",
     "params" : [
@@ -277,7 +277,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"account_currencies: current ledger.",
      __LINE__,
      {"account_currencies", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "current"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_currencies",
     "params" : [
@@ -293,7 +293,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "account_currencies",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_currencies",
     "params" : [
@@ -307,7 +307,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"account_currencies: too many arguments.",
      __LINE__,
      {"account_currencies", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "current", "spare1", "spare2"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_currencies",
     "params" : [
@@ -321,7 +321,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"account_currencies: invalid second argument.",
      __LINE__,
      {"account_currencies", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "yup"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_currencies",
     "params" : [
@@ -339,7 +339,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
             "account_currencies",
             "",  // Note: very few values are detected as bad!
         },
-        RPCCallTestData::no_exception,
+        RPCCallTestData::Exception::no_exception,
         R"({
     "method" : "account_currencies",
     "params" : [
@@ -357,7 +357,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"account_info: minimal.",
      __LINE__,
      {"account_info", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_info",
     "params" : [
@@ -370,7 +370,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"account_info: with numeric ledger index.",
      __LINE__,
      {"account_info", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "77777"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_info",
     "params" : [
@@ -384,7 +384,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"account_info: with text ledger index.",
      __LINE__,
      {"account_info", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "closed"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_info",
     "params" : [
@@ -400,7 +400,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {"account_info",
       "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
       "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_info",
     "params" : [
@@ -414,7 +414,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"account_info: with ledger index.",
      __LINE__,
      {"account_info", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "validated"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_info",
     "params" : [
@@ -430,7 +430,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "account_info",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_info",
     "params" : [
@@ -444,7 +444,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"account_info: too many arguments.",
      __LINE__,
      {"account_info", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "current", "extra1", "extra2"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_info",
     "params" : [
@@ -462,7 +462,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
             "account_info",
             "",  // Note: very few values are detected as bad!
         },
-        RPCCallTestData::no_exception,
+        RPCCallTestData::Exception::no_exception,
         R"({
     "method" : "account_info",
     "params" : [
@@ -480,7 +480,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"account_lines: minimal.",
      __LINE__,
      {"account_lines", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_lines",
     "params" : [
@@ -493,7 +493,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"account_lines: peer.",
      __LINE__,
      {"account_lines", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_lines",
     "params" : [
@@ -510,7 +510,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
       "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
       "888888888"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_lines",
     "params" : [
@@ -528,7 +528,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
       "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
       "closed"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_lines",
     "params" : [
@@ -546,7 +546,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
       "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
       "FFFFEEEEDDDDCCCCBBBBAAAA9999888877776666555544443333222211110000"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_lines",
     "params" : [
@@ -563,7 +563,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "account_lines",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_lines",
     "params" : [
@@ -582,7 +582,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
       "12345678",
       "current"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_lines",
     "params" : [
@@ -603,7 +603,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "12345678",
       "current",
       "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_lines",
     "params" : [
@@ -624,7 +624,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "current",
       "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
       "validated"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_lines",
     "params" : [
@@ -642,7 +642,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
             "account_lines",
             "",  // Note: very few values are detected as bad!
         },
-        RPCCallTestData::no_exception,
+        RPCCallTestData::Exception::no_exception,
         R"({
     "method" : "account_lines",
     "params" : [
@@ -662,7 +662,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
             "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
             ""  // Note: very few values are detected as bad!
         },
-        RPCCallTestData::no_exception,
+        RPCCallTestData::Exception::no_exception,
         R"({
     "method" : "account_lines",
     "params" : [
@@ -680,7 +680,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
          "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
          "not_a_ledger"},
-        RPCCallTestData::no_exception,
+        RPCCallTestData::Exception::no_exception,
         R"({
     "method" : "account_lines",
     "params" : [
@@ -699,7 +699,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"account_objects: minimal.",
      __LINE__,
      {"account_objects", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_objects",
     "params" : [
@@ -712,7 +712,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"account_objects: with numeric ledger index.",
      __LINE__,
      {"account_objects", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "77777"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_objects",
     "params" : [
@@ -726,7 +726,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"account_objects: with text ledger index.",
      __LINE__,
      {"account_objects", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "closed"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_objects",
     "params" : [
@@ -742,7 +742,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {"account_objects",
       "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
       "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_objects",
     "params" : [
@@ -756,7 +756,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"account_objects: with ledger index.",
      __LINE__,
      {"account_objects", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "validated"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_objects",
     "params" : [
@@ -772,7 +772,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "account_objects",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_objects",
     "params" : [
@@ -793,7 +793,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "extra1",
          "extra2",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_objects",
     "params" : [
@@ -814,7 +814,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "extra2",
          "extra3",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_objects",
     "params" : [
@@ -835,7 +835,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "extra3",
          "extra4",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_objects",
     "params" : [
@@ -853,7 +853,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
             "account_objects",
             "",  // Note: very few values are detected as bad!
         },
-        RPCCallTestData::no_exception,
+        RPCCallTestData::Exception::no_exception,
         R"({
     "method" : "account_objects",
     "params" : [
@@ -871,7 +871,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
         "account_objects: invalid ledger selection 1.",
         __LINE__,
         {"account_objects", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "no_ledger"},
-        RPCCallTestData::no_exception,
+        RPCCallTestData::Exception::no_exception,
         R"({
     "method" : "account_objects",
     "params" : [
@@ -889,7 +889,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
         "account_objects: invalid ledger selection 2.",
         __LINE__,
         {"account_objects", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "no_ledger"},
-        RPCCallTestData::no_exception,
+        RPCCallTestData::Exception::no_exception,
         R"({
     "method" : "account_objects",
     "params" : [
@@ -907,7 +907,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"account_offers: minimal.",
      __LINE__,
      {"account_offers", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_offers",
     "params" : [
@@ -920,7 +920,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"account_offers: with numeric ledger index.",
      __LINE__,
      {"account_offers", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "987654321"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_offers",
     "params" : [
@@ -934,7 +934,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"account_offers: with text ledger index.",
      __LINE__,
      {"account_offers", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "validated"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_offers",
     "params" : [
@@ -950,7 +950,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {"account_offers",
       "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
       "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_offers",
     "params" : [
@@ -964,7 +964,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"account_offers: with ledger index.",
      __LINE__,
      {"account_offers", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "validated"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_offers",
     "params" : [
@@ -980,7 +980,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "account_offers",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_offers",
     "params" : [
@@ -995,7 +995,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      "account_offers: four arguments.",
      __LINE__,
      {"account_offers", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "current", "extra"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_offers",
     "params" : [
@@ -1015,7 +1015,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "extra2",
          "extra3",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_offers",
     "params" : [
@@ -1033,7 +1033,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
             "account_offers",
             "",  // Note: very few values are detected as bad!
         },
-        RPCCallTestData::no_exception,
+        RPCCallTestData::Exception::no_exception,
         R"({
     "method" : "account_offers",
     "params" : [
@@ -1051,7 +1051,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
         "account_offers: invalid ledger selection 1.",
         __LINE__,
         {"account_offers", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "no_ledger"},
-        RPCCallTestData::no_exception,
+        RPCCallTestData::Exception::no_exception,
         R"({
     "method" : "account_offers",
     "params" : [
@@ -1069,7 +1069,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
         "account_offers: invalid ledger selection 2.",
         __LINE__,
         {"account_offers", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "no_ledger"},
-        RPCCallTestData::no_exception,
+        RPCCallTestData::Exception::no_exception,
         R"({
     "method" : "account_offers",
     "params" : [
@@ -1087,7 +1087,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"account_tx: minimal.",
      __LINE__,
      {"account_tx", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_tx",
     "params" : [
@@ -1100,7 +1100,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"account_tx: ledger_index .",
      __LINE__,
      {"account_tx", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "444"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_tx",
     "params" : [
@@ -1114,7 +1114,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"account_tx: ledger_index plus trailing params.",
      __LINE__,
      {"account_tx", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "707", "descending", "binary", "count"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_tx",
     "params" : [
@@ -1131,7 +1131,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"account_tx: ledger_index_min and _max.",
      __LINE__,
      {"account_tx", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "-1", "-1"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_tx",
     "params" : [
@@ -1152,7 +1152,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "binary",
       "count",
       "descending"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_tx",
     "params" : [
@@ -1170,7 +1170,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"account_tx: ledger_index_min and _max plus limit.",
      __LINE__,
      {"account_tx", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "247", "-1", "300"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_tx",
     "params" : [
@@ -1193,7 +1193,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "count",
       "descending",
       "binary"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_tx",
     "params" : [
@@ -1212,7 +1212,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"account_tx: ledger_index_min and _max plus limit and offset.",
      __LINE__,
      {"account_tx", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "589", "590", "67", "45"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_tx",
     "params" : [
@@ -1236,7 +1236,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "45",
       "descending",
       "count"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_tx",
     "params" : [
@@ -1257,7 +1257,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "account_tx",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_tx",
     "params" : [
@@ -1280,7 +1280,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "descending",
       "count",
       "binary"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "account_tx",
     "params" : [
@@ -1295,7 +1295,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
         "account_tx: invalid accountID.",
         __LINE__,
         {"account_tx", "rHb9CJAWyB4rj9!VRWn96DkukG4bwdtyTh"},
-        RPCCallTestData::no_exception,
+        RPCCallTestData::Exception::no_exception,
         R"({
     "method" : "account_tx",
     "params" : [
@@ -1312,7 +1312,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
         "account_tx: invalid ledger.",
         __LINE__,
         {"account_tx", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "-478.7"},
-        RPCCallTestData::no_exception,
+        RPCCallTestData::Exception::no_exception,
         R"({
     "method" : "account_tx",
     "params" : [
@@ -1328,7 +1328,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
         "account_tx: max less than min.",
         __LINE__,
         {"account_tx", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "580", "579"},
-        RPCCallTestData::no_exception,
+        RPCCallTestData::Exception::no_exception,
         {
             R"({
     "method" : "account_tx",
@@ -1356,7 +1356,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
         "account_tx: non-integer min.",
         __LINE__,
         {"account_tx", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "Binary", "-1"},
-        RPCCallTestData::bad_cast,
+        RPCCallTestData::Exception::bad_cast,
         R"()",
     },
     {
@@ -1364,7 +1364,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
         "account_tx: non-integer max.",
         __LINE__,
         {"account_tx", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "-1", "counts"},
-        RPCCallTestData::bad_cast,
+        RPCCallTestData::Exception::bad_cast,
         R"()",
     },
     {
@@ -1372,7 +1372,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
         "account_tx: non-integer offset.",
         __LINE__,
         {"account_tx", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "-1", "-1", "decending"},
-        RPCCallTestData::bad_cast,
+        RPCCallTestData::Exception::bad_cast,
         R"()",
     },
     {
@@ -1380,7 +1380,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
         "account_tx: non-integer limit.",
         __LINE__,
         {"account_tx", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "-1", "-1", "300", "false"},
-        RPCCallTestData::bad_cast,
+        RPCCallTestData::Exception::bad_cast,
         R"()",
     },
     {// Note: this really shouldn't throw, but does at the moment.
@@ -1394,7 +1394,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "false",
       "false",
       "false"},
-     RPCCallTestData::bad_cast,
+     RPCCallTestData::Exception::bad_cast,
      R"()"},
 
     // book_offers
@@ -1406,7 +1406,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "USD",
          "EUR",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "book_offers",
     "params" : [
@@ -1428,7 +1428,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "USD/rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
          "EUR/rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "book_offers",
     "params" : [
@@ -1450,7 +1450,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      "book_offers: add issuer.",
      __LINE__,
      {"book_offers", "USD", "EUR", "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "book_offers",
     "params" : [
@@ -1473,7 +1473,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "EUR",
       "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
       "666"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "book_offers",
     "params" : [
@@ -1498,7 +1498,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "EUR/rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
       "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
       "current"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "book_offers",
     "params" : [
@@ -1523,7 +1523,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "EUR/rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
       "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
       "ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "book_offers",
     "params" : [
@@ -1552,7 +1552,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789",
          "200",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "book_offers",
     "params" : [
@@ -1583,7 +1583,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "200",
       "0",
       "MyMarker"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "book_offers",
     "params" : [
@@ -1609,7 +1609,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "book_offers",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "book_offers",
     "params" : [
@@ -1631,7 +1631,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "0",
       "MyMarker",
       "extra"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "book_offers",
     "params" : [
@@ -1650,7 +1650,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "/rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
          "EUR/rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "book_offers",
     "params" : [
@@ -1668,7 +1668,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "USD/rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
          "/rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "book_offers",
     "params" : [
@@ -1682,7 +1682,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"book_offers: invalid issuer.",
      __LINE__,
      {"book_offers", "USD", "EUR", "not_a_valid_issuer"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "book_offers",
     "params" : [
@@ -1705,7 +1705,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "EUR/rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
       "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
       "not_a_ledger"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "book_offers",
     "params" : [
@@ -1734,7 +1734,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789",
          "not_a_number",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "book_offers",
     "params" : [
@@ -1753,7 +1753,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "can_delete",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "can_delete",
     "params" : [
@@ -1768,7 +1768,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "can_delete",
          "4294967295",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "can_delete",
     "params" : [
@@ -1784,7 +1784,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "can_delete",
          "FEDCBA9876543210FEDCBA9876543210FEDCBA9876543210FEDCBA9876543210",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "can_delete",
     "params" : [
@@ -1800,7 +1800,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "can_delete",
          "always",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "can_delete",
     "params" : [
@@ -1816,7 +1816,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "can_delete",
          "never",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "can_delete",
     "params" : [
@@ -1832,7 +1832,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "can_delete",
          "now",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "can_delete",
     "params" : [
@@ -1845,7 +1845,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"can_delete: too many arguments.",
      __LINE__,
      {"can_delete", "always", "never"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "can_delete",
     "params" : [
@@ -1859,7 +1859,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"can_delete: invalid argument.",
      __LINE__,
      {"can_delete", "invalid"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "can_delete",
     "params" : [
@@ -1876,7 +1876,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "can_delete",
          "4294967296",
      },
-     RPCCallTestData::bad_cast,
+     RPCCallTestData::Exception::bad_cast,
      R"()"},
     {// Note: this really shouldn't throw since it's a legitimate ledger hash.
      "can_delete: ledger hash with no alphas.",
@@ -1885,7 +1885,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "can_delete",
          "0123456701234567012345670123456701234567012345670123456701234567",
      },
-     RPCCallTestData::bad_cast,
+     RPCCallTestData::Exception::bad_cast,
      R"()"},
 
     // channel_authorize
@@ -1896,7 +1896,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "secret_can_be_anything",
       "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
       "18446744073709551615"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "channel_authorize",
     "params" : [
@@ -1915,7 +1915,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "secret_can_be_anything",
          "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "channel_authorize",
     "params" : [
@@ -1934,7 +1934,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "2000",
       "whatever",
       "whenever"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "channel_authorize",
     "params" : [
@@ -1952,7 +1952,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
       "2000",
       "whatever"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "channel_authorize",
     "params" : [
@@ -1969,7 +1969,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "secret_can_be_anything",
       "123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
       "2000"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "channel_authorize",
     "params" : [
@@ -1986,7 +1986,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "secret_can_be_anything",
       "10123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
       "2000"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "channel_authorize",
     "params" : [
@@ -2003,7 +2003,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "secret_can_be_anything",
       "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEZ",
       "2000"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "channel_authorize",
     "params" : [
@@ -2020,7 +2020,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "secret_can_be_anything",
       "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
       "-1"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "channel_authorize",
     "params" : [
@@ -2037,7 +2037,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "secret_can_be_anything",
       "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
       "18446744073709551616"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "channel_authorize",
     "params" : [
@@ -2058,7 +2058,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
       "0",
       "DEADBEEF"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "channel_verify",
     "params" : [
@@ -2078,7 +2078,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
       "18446744073709551615",
       "DEADBEEF"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "channel_verify",
     "params" : [
@@ -2096,7 +2096,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {"channel_verify",
       "aB4BXXLuPu8DpVuyq1DBiu3SrPdtK9AYZisKhu8mvkoiUD8J9Gov",
       "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "channel_verify",
     "params" : [
@@ -2115,7 +2115,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "2000",
       "DEADBEEF",
       "Whatever"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "channel_verify",
     "params" : [
@@ -2133,7 +2133,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
       "2000",
       "DEADBEEF"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "channel_verify",
     "params" : [
@@ -2151,7 +2151,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
       "2000",
       "DEADBEEF"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "channel_verify",
     "params" : [
@@ -2169,7 +2169,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "10123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
       "2000",
       "DEADBEEF"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "channel_verify",
     "params" : [
@@ -2187,7 +2187,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
       "2000",
       "DEADBEEF"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "channel_verify",
     "params" : [
@@ -2205,7 +2205,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
       "-1",
       "DEADBEEF"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "channel_verify",
     "params" : [
@@ -2223,7 +2223,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
       "18446744073709551616",
       "DEADBEEF"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "channel_verify",
     "params" : [
@@ -2241,7 +2241,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
       "40000000",
       "ThisIsNotHexadecimal"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "channel_verify",
     "params" : [
@@ -2263,7 +2263,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "connect",
          "ThereIsNoCheckingOnTheIPFormat",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "connect",
     "params" : [
@@ -2276,7 +2276,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"connect: ip and port.",
      __LINE__,
      {"connect", "ThereIsNoCheckingOnTheIPFormat", "6561"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "connect",
     "params" : [
@@ -2292,7 +2292,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "connect",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "connect",
     "params" : [
@@ -2306,7 +2306,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"connect: too many arguments.",
      __LINE__,
      {"connect", "ThereIsNoCheckingOnTheIPFormat", "6561", "extra"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "connect",
     "params" : [
@@ -2325,7 +2325,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "ThereIsNoCheckingOnTheIPFormat",
          "-1",
      },
-     RPCCallTestData::bad_cast,
+     RPCCallTestData::Exception::bad_cast,
      R"()"},
     {// Note: this should return an error but not throw.
      "connect: port too large.",
@@ -2335,7 +2335,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "ThereIsNoCheckingOnTheIPFormat",
          "4294967296",
      },
-     RPCCallTestData::bad_cast,
+     RPCCallTestData::Exception::bad_cast,
      R"()"},
 
     // consensus_info
@@ -2345,7 +2345,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "consensus_info",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "consensus_info",
     "params" : [
@@ -2357,7 +2357,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"consensus_info: too many arguments.",
      __LINE__,
      {"consensus_info", "whatever"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "consensus_info",
     "params" : [
@@ -2378,7 +2378,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "source_account_NotValidated",
          "destination_account_NotValidated",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "deposit_authorized",
     "params" : [
@@ -2395,7 +2395,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "source_account_NotValidated",
       "destination_account_NotValidated",
       "validated"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "deposit_authorized",
     "params" : [
@@ -2421,7 +2421,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "cred6",
       "cred7",
       "cred8"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "deposit_authorized",
     "params" : [
@@ -2440,7 +2440,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "source_account_NotValidated",
       "destination_account_NotValidated",
       "ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "deposit_authorized",
     "params" : [
@@ -2458,7 +2458,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "deposit_authorized",
          "source_account_NotValidated",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "deposit_authorized",
     "params" : [
@@ -2484,7 +2484,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "cred7",
       "cred8",
       "too_much"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "deposit_authorized",
     "params" : [
@@ -2503,7 +2503,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "destination_account_NotValidated",
          "NotALedger",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "deposit_authorized",
     "params" : [
@@ -2523,7 +2523,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "feature",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "feature",
     "params" : [
@@ -2535,7 +2535,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"feature: with name.",
      __LINE__,
      {"feature", "featureNameOrHexIsNotValidated"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "feature",
     "params" : [
@@ -2551,7 +2551,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "FEDCBA9876543210FEDCBA9876543210FEDCBA9876543210FEDCBA9876543210FEDCBA98"
       "76543210",
       "accept"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "feature",
     "params" : [
@@ -2565,7 +2565,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"feature: reject.",
      __LINE__,
      {"feature", "0", "reject"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "feature",
     "params" : [
@@ -2579,7 +2579,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"feature: too many arguments.",
      __LINE__,
      {"feature", "featureNameOrHexIsNotValidated", "accept", "anotherArg"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "feature",
     "params" : [
@@ -2597,7 +2597,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "featureNameOrHexIsNotValidated",
          "veto",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "feature",
     "params" : [
@@ -2616,7 +2616,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "fetch_info",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "fetch_info",
     "params" : [
@@ -2628,7 +2628,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"fetch_info: clear.",
      __LINE__,
      {"fetch_info", "clear"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "fetch_info",
     "params" : [
@@ -2641,7 +2641,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"fetch_info: too many arguments.",
      __LINE__,
      {"fetch_info", "clear", "other"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "fetch_info",
     "params" : [
@@ -2655,7 +2655,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"fetch_info: other trailing argument.",
      __LINE__,
      {"fetch_info", "too"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "fetch_info",
     "params" : [
@@ -2671,7 +2671,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"gateway_balances: minimal.",
      __LINE__,
      {"gateway_balances", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "gateway_balances",
     "params" : [
@@ -2684,7 +2684,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"gateway_balances: with ledger index.",
      __LINE__,
      {"gateway_balances", "890765", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "gateway_balances",
     "params" : [
@@ -2698,7 +2698,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"gateway_balances: with text ledger index.",
      __LINE__,
      {"gateway_balances", "current", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "gateway_balances",
     "params" : [
@@ -2714,7 +2714,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {"gateway_balances",
       "0123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUV",
       "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "gateway_balances",
     "params" : [
@@ -2728,7 +2728,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"gateway_balances: 1 hotwallet.",
      __LINE__,
      {"gateway_balances", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "hotwallet_is_not_validated"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "gateway_balances",
     "params" : [
@@ -2749,7 +2749,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "hotwallet_is_not_validated_2",
          "hotwallet_is_not_validated_3",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "gateway_balances",
     "params" : [
@@ -2770,7 +2770,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "gateway_balances",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "gateway_balances",
     "params" : [
@@ -2784,7 +2784,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"gateway_balances: empty first argument.",
      __LINE__,
      {"gateway_balances", ""},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "gateway_balances",
     "params" : [
@@ -2801,7 +2801,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "gateway_balances",
          "890765",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "gateway_balances",
     "params" : [
@@ -2818,7 +2818,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "gateway_balances",
          "current",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "gateway_balances",
     "params" : [
@@ -2835,7 +2835,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "gateway_balances",
          "0123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUV",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "gateway_balances",
     "params" : [
@@ -2854,7 +2854,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "get_counts",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "get_counts",
     "params" : [
@@ -2866,7 +2866,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"get_counts: with maximum count.",
      __LINE__,
      {"get_counts", "100"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "get_counts",
     "params" : [
@@ -2879,7 +2879,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"get_counts: too many arguments.",
      __LINE__,
      {"get_counts", "100", "whatever"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "get_counts",
     "params" : [
@@ -2896,12 +2896,12 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "get_counts",
          "-1",
      },
-     RPCCallTestData::bad_cast,
+     RPCCallTestData::Exception::bad_cast,
      R"()"},
     {"get_counts: count too large.",
      __LINE__,
      {"get_counts", "4294967296"},
-     RPCCallTestData::bad_cast,
+     RPCCallTestData::Exception::bad_cast,
      R"()"},
 
     // json
@@ -2913,7 +2913,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "command",
          R"({"json_argument":true})",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "command",
     "params" : [
@@ -2931,7 +2931,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "command",
          R"({})",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "command",
     "params" : [
@@ -2944,7 +2944,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"json: too few arguments.",
      __LINE__,
      {"json", "command"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "json",
     "params" : [
@@ -2958,7 +2958,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"json: too many arguments.",
      __LINE__,
      {"json", "command", R"({"json_argument":true})", "extra"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "json",
     "params" : [
@@ -2976,7 +2976,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "command",
          R"(["arg1","arg2"])",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "json",
     "params" : [
@@ -2994,7 +2994,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "command",
          R"({"json_argument":true,})",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "json",
     "params" : [
@@ -3014,7 +3014,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "json2",
          R"({"jsonrpc":"2.0","ripplerpc":"2.0","id":"A1","method":"call_1"})",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "id" : "A1",
     "jsonrpc" : "2.0",
@@ -3042,7 +3042,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
         "params" : [{"inner_arg" : "yup"}]
         })",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "id" : "A1",
     "jsonrpc" : "2.0",
@@ -3067,7 +3067,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "json2",
          R"([{"jsonrpc":"2.0","ripplerpc":"2.0","id":"A1","method":"call_1"}])",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "json2",
     "params" : [
@@ -3094,7 +3094,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
         "params" : [{"inner_arg" : "yup"}]}
         ])",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "json2",
    "params" : [
@@ -3116,7 +3116,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "json2",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "json2",
     "params" : [
@@ -3130,7 +3130,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"json2: too many arguments.",
      __LINE__,
      {"json2", R"({"jsonrpc":"2.0","ripplerpc":"2.0","id":"A1","method":"call_this"})", "extra"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "json2",
     "params" : [
@@ -3147,7 +3147,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "json2",
          R"({"jsonrpc":"2.0","ripplerpc":"2.0","id":"A1","method":"call_1",})",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "id" : "A1",
     "jsonrpc" : "2.0",
@@ -3170,7 +3170,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "json2",
          R"({"ripplerpc":"2.0","id":"A1","method":"call_1"})",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "id" : "A1",
     "method" : "json2",
@@ -3191,7 +3191,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "json2",
          R"({"jsonrpc":"2.1","ripplerpc":"2.0","id":"A1","method":"call_1"})",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "id" : "A1",
     "jsonrpc" : "2.1",
@@ -3214,7 +3214,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "json2",
          R"({"jsonrpc":"2.0","id":"A1","method":"call_1"})",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "id" : "A1",
     "jsonrpc" : "2.0",
@@ -3235,7 +3235,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "json2",
          R"({"jsonrpc":"2.0","ripplerpc":"2.00","id":"A1","method":"call_1"})",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "id" : "A1",
     "jsonrpc" : "2.0",
@@ -3258,7 +3258,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "json2",
          R"({"jsonrpc":"2.0","ripplerpc":"2.0","method":"call_1"})",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "jsonrpc" : "2.0",
     "method" : "json2",
@@ -3279,7 +3279,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "json2",
          R"({"jsonrpc":"2.0","ripplerpc":"2.0","id":"A1"})",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "id" : "A1",
     "jsonrpc" : "2.0",
@@ -3302,7 +3302,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "json2",
          R"([])",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "json2",
     "params" : [
@@ -3319,7 +3319,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "json2",
          R"([{"jsonrpc":"2.0","ripplerpc":"2.0","id":"A1","method":"call_1",[]}])",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "json2",
     "params" : [
@@ -3342,7 +3342,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
             }
         ])",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "json2",
     "params" : [
@@ -3365,7 +3365,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
         "params" : true
         })",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
    "id" : "A1",
    "jsonrpc" : "2.0",
@@ -3388,7 +3388,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ledger: minimal.",
      __LINE__,
      {"ledger"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ledger",
     "params" : [
@@ -3400,7 +3400,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ledger: ledger index.",
      __LINE__,
      {"ledger", "4294967295"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ledger",
     "params" : [
@@ -3413,7 +3413,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ledger: text ledger index.",
      __LINE__,
      {"ledger", "validated"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ledger",
     "params" : [
@@ -3426,7 +3426,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ledger: ledger hash.",
      __LINE__,
      {"ledger", "ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ledger",
     "params" : [
@@ -3439,7 +3439,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ledger: full.",
      __LINE__,
      {"ledger", "current", "full"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ledger",
     "params" : [
@@ -3453,7 +3453,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ledger: tx.",
      __LINE__,
      {"ledger", "closed", "tx"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ledger",
     "params" : [
@@ -3468,7 +3468,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ledger: too many arguments.",
      __LINE__,
      {"ledger", "4294967295", "spare"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ledger",
     "params" : [
@@ -3481,7 +3481,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ledger: ledger index too small.",
      __LINE__,
      {"ledger", "-1"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ledger",
     "params" : [
@@ -3494,7 +3494,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ledger: ledger index too big.",
      __LINE__,
      {"ledger", "4294967296"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ledger",
     "params" : [
@@ -3507,7 +3507,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ledger: invalid ledger text.",
      __LINE__,
      {"ledger", "latest"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ledger",
     "params" : [
@@ -3520,7 +3520,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ledger: unsupported final argument.",
      __LINE__,
      {"ledger", "current", "expand"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ledger",
     "params" : [
@@ -3536,7 +3536,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ledger_closed: minimal.",
      __LINE__,
      {"ledger_closed"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ledger_closed",
     "params" : [
@@ -3548,7 +3548,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ledger_closed: too many arguments.",
      __LINE__,
      {"ledger_closed", "today"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ledger_closed",
     "params" : [
@@ -3565,7 +3565,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ledger_current: minimal.",
      __LINE__,
      {"ledger_current"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ledger_current",
     "params" : [
@@ -3577,7 +3577,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ledger_current: too many arguments.",
      __LINE__,
      {"ledger_current", "today"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ledger_current",
     "params" : [
@@ -3594,7 +3594,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ledger_header: ledger index.",
      __LINE__,
      {"ledger_header", "4294967295"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ledger_header",
     "params" : [
@@ -3607,7 +3607,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ledger_header: ledger hash.",
      __LINE__,
      {"ledger_header", "ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ledger_header",
     "params" : [
@@ -3622,7 +3622,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "ledger_header",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ledger_header",
     "params" : [
@@ -3636,7 +3636,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ledger_header: too many arguments.",
      __LINE__,
      {"ledger_header", "4294967295", "spare"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ledger_header",
     "params" : [
@@ -3650,7 +3650,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ledger_header: text ledger index.",
      __LINE__,
      {"ledger_header", "current"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ledger_header",
     "params" : [
@@ -3663,7 +3663,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ledger_header: ledger index too small.",
      __LINE__,
      {"ledger_header", "-1"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ledger_header",
     "params" : [
@@ -3676,7 +3676,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ledger_header: ledger index too big.",
      __LINE__,
      {"ledger_header", "4294967296"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ledger_header",
     "params" : [
@@ -3692,7 +3692,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ledger_request: ledger index.",
      __LINE__,
      {"ledger_request", "4294967295"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ledger_request",
     "params" : [
@@ -3705,7 +3705,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ledger_request: ledger hash.",
      __LINE__,
      {"ledger_request", "ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ledger_request",
     "params" : [
@@ -3720,7 +3720,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "ledger_request",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ledger_request",
     "params" : [
@@ -3734,7 +3734,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ledger_request: too many arguments.",
      __LINE__,
      {"ledger_request", "4294967295", "spare"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ledger_request",
     "params" : [
@@ -3748,7 +3748,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ledger_request: text ledger index.",
      __LINE__,
      {"ledger_request", "current"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ledger_request",
     "params" : [
@@ -3761,7 +3761,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ledger_request: ledger index too small.",
      __LINE__,
      {"ledger_request", "-1"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ledger_request",
     "params" : [
@@ -3774,7 +3774,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ledger_request: ledger index too big.",
      __LINE__,
      {"ledger_request", "4294967296"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ledger_request",
     "params" : [
@@ -3792,7 +3792,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "log_level",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "log_level",
     "params" : [
@@ -3804,7 +3804,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"log_level: fatal.",
      __LINE__,
      {"log_level", "fatal"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "log_level",
     "params" : [
@@ -3817,7 +3817,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"log_level: error.",
      __LINE__,
      {"log_level", "error"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "log_level",
     "params" : [
@@ -3830,7 +3830,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"log_level: warn.",
      __LINE__,
      {"log_level", "warn"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "log_level",
     "params" : [
@@ -3843,7 +3843,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"log_level: debug.",
      __LINE__,
      {"log_level", "debug"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "log_level",
     "params" : [
@@ -3856,7 +3856,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"log_level: trace.",
      __LINE__,
      {"log_level", "trace"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "log_level",
     "params" : [
@@ -3869,7 +3869,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"log_level: base partition.",
      __LINE__,
      {"log_level", "base", "trace"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "log_level",
     "params" : [
@@ -3883,7 +3883,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"log_level: partition_name.",
      __LINE__,
      {"log_level", "partition_name", "fatal"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "log_level",
     "params" : [
@@ -3897,7 +3897,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"log_level: too many arguments.",
      __LINE__,
      {"log_level", "partition_name", "fatal", "extra"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "log_level",
     "params" : [
@@ -3911,7 +3911,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"log_level: invalid severity.",
      __LINE__,
      {"log_level", "err"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "log_level",
     "params" : [
@@ -3928,7 +3928,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "fatal",
          "partition_name",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "log_level",
     "params" : [
@@ -3947,7 +3947,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "logrotate",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "logrotate",
     "params" : [
@@ -3959,7 +3959,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"logrotate: too many arguments.",
      __LINE__,
      {"logrotate", "extra"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "logrotate",
     "params" : [
@@ -3976,7 +3976,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"owner_info: minimal.",
      __LINE__,
      {"owner_info", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "owner_info",
     "params" : [
@@ -3989,7 +3989,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"owner_info: with numeric ledger index.",
      __LINE__,
      {"owner_info", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "987654321"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "owner_info",
     "params" : [
@@ -4003,7 +4003,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"owner_info: with text ledger index.",
      __LINE__,
      {"owner_info", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "validated"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "owner_info",
     "params" : [
@@ -4019,7 +4019,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {"owner_info",
       "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
       "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "owner_info",
     "params" : [
@@ -4033,7 +4033,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"owner_info: with ledger index.",
      __LINE__,
      {"owner_info", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "validated"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "owner_info",
     "params" : [
@@ -4049,7 +4049,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "owner_info",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "owner_info",
     "params" : [
@@ -4069,7 +4069,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "extra1",
          "extra2",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "owner_info",
     "params" : [
@@ -4087,7 +4087,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
             "owner_info",
             "",  // Note: very few values are detected as bad!
         },
-        RPCCallTestData::no_exception,
+        RPCCallTestData::Exception::no_exception,
         R"({
     "method" : "owner_info",
     "params" : [
@@ -4105,7 +4105,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
         "owner_info: invalid ledger selection.",
         __LINE__,
         {"owner_info", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "no_ledger"},
-        RPCCallTestData::no_exception,
+        RPCCallTestData::Exception::no_exception,
         R"({
     "method" : "owner_info",
     "params" : [
@@ -4123,7 +4123,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
         "owner_info: invalid ledger selection.",
         __LINE__,
         {"owner_info", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "no_ledger"},
-        RPCCallTestData::no_exception,
+        RPCCallTestData::Exception::no_exception,
         R"({
     "method" : "owner_info",
     "params" : [
@@ -4143,7 +4143,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "peers",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "peers",
     "params" : [
@@ -4155,7 +4155,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"peers: too many arguments.",
      __LINE__,
      {"peers", "extra"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "peers",
     "params" : [
@@ -4172,7 +4172,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"peer_reservations_add: minimal.",
      __LINE__,
      {"peer_reservations_add", "public_key_string"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "peer_reservations_add",
     "params" : [
@@ -4185,7 +4185,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"peer_reservations_add: with description.",
      __LINE__,
      {"peer_reservations_add", "public_key_string", "public_key_description"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "peer_reservations_add",
     "params" : [
@@ -4199,7 +4199,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"peer_reservations_add: too few arguments.",
      __LINE__,
      {"peer_reservations_add"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "peer_reservations_add",
     "params" : [
@@ -4213,7 +4213,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"peer_reservations_add: too many arguments.",
      __LINE__,
      {"peer_reservations_add", "public_key_string", "public_key_description", "spare"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "peer_reservations_add",
     "params" : [
@@ -4230,7 +4230,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"peer_reservations_del: minimal.",
      __LINE__,
      {"peer_reservations_del", "public_key_string"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "peer_reservations_del",
     "params" : [
@@ -4243,7 +4243,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"peer_reservations_del: too few arguments.",
      __LINE__,
      {"peer_reservations_del"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "peer_reservations_del",
     "params" : [
@@ -4257,7 +4257,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"peer_reservations_del: too many arguments.",
      __LINE__,
      {"peer_reservations_del", "public_key_string", "public_key_description", "spare"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "peer_reservations_del",
     "params" : [
@@ -4276,7 +4276,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "ping",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ping",
     "params" : [
@@ -4288,7 +4288,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ping: too many arguments.",
      __LINE__,
      {"ping", "extra"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ping",
     "params" : [
@@ -4307,7 +4307,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "print",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "print",
     "params" : [
@@ -4320,7 +4320,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      "print: extra argument.",
      __LINE__,
      {"print", "extra"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "print",
     "params" : [
@@ -4333,7 +4333,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"print: too many arguments.",
      __LINE__,
      {"print", "extra1", "extra2"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "print",
     "params" : [
@@ -4352,7 +4352,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "random",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "random",
     "params" : [
@@ -4364,7 +4364,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"random: too many arguments.",
      __LINE__,
      {"random", "extra"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "random",
     "params" : [
@@ -4384,7 +4384,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "ripple_path_find",
          R"({"json_argument":true})",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ripple_path_find",
     "params" : [
@@ -4397,7 +4397,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ripple_path_find: ledger index.",
      __LINE__,
      {"ripple_path_find", R"({"json_argument":true})", "4294967295"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ripple_path_find",
     "params" : [
@@ -4411,7 +4411,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ripple_path_find: text ledger index.",
      __LINE__,
      {"ripple_path_find", R"({"json_argument":true})", "closed"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ripple_path_find",
     "params" : [
@@ -4427,7 +4427,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {"ripple_path_find",
       R"({"json_argument":true})",
       "0123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUV"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ripple_path_find",
     "params" : [
@@ -4444,7 +4444,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "ripple_path_find",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ripple_path_find",
     "params" : [
@@ -4458,7 +4458,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ripple_path_find: too many arguments.",
      __LINE__,
      {"ripple_path_find", R"({"json_argument":true})", "current", "extra"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ripple_path_find",
     "params" : [
@@ -4475,7 +4475,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "ripple_path_find",
          R"({"json_argument":true,})",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ripple_path_find",
     "params" : [
@@ -4489,7 +4489,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ripple_path_find: ledger index too small.",
      __LINE__,
      {"ripple_path_find", R"({"json_argument":true})", "-1"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ripple_path_find",
     "params" : [
@@ -4503,7 +4503,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ripple_path_find: ledger index too big.",
      __LINE__,
      {"ripple_path_find", R"({"json_argument":true})", "4294967296"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ripple_path_find",
     "params" : [
@@ -4517,7 +4517,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"ripple_path_find: invalid text ledger index.",
      __LINE__,
      {"ripple_path_find", R"({"json_argument":true})", "cur"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "ripple_path_find",
     "params" : [
@@ -4538,7 +4538,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "my_secret",
          R"({"json_argument":true})",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "sign",
     "params" : [
@@ -4554,7 +4554,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"sign: offline.",
      __LINE__,
      {"sign", "my_secret", R"({"json_argument":true})", "offline"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "sign",
     "params" : [
@@ -4571,7 +4571,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"sign: too few arguments.",
      __LINE__,
      {"sign", "contents_of_blob"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "sign",
     "params" : [
@@ -4585,7 +4585,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"sign: offline flag with signature_target.",
      __LINE__,
      {"sign", "my_secret", R"({"json_argument":true})", "offline", "extra"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
         "method" : "sign",
         "params" : [
@@ -4609,7 +4609,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "offline",
       "CounterpartySignature",
       "extra"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "sign",
     "params" : [
@@ -4627,7 +4627,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "my_secret",
          R"({"json_argument":true,})",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "sign",
     "params" : [
@@ -4641,7 +4641,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"sign: misspelled offline flag interpreted as signature_target.",
      __LINE__,
      {"sign", "my_secret", R"({"json_argument":true})", "offlin"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
         "method" : "sign",
         "params" : [
@@ -4667,7 +4667,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "my_secret",
          R"({"json_argument":true})",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "sign_for",
     "params" : [
@@ -4688,7 +4688,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "my_secret",
       R"({"json_argument":true})",
       "offline"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "sign_for",
     "params" : [
@@ -4710,7 +4710,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
          "my_secret",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "sign_for",
     "params" : [
@@ -4729,7 +4729,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       R"({"json_argument":true})",
       "offline",
       "extra"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "sign_for",
     "params" : [
@@ -4748,7 +4748,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "my_secret",
          R"({"json_argument":true,})",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "sign_for",
     "params" : [
@@ -4766,7 +4766,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "my_secret",
       R"({"json_argument":true})",
       "ofline"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "sign_for",
     "params" : [
@@ -4783,7 +4783,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"submit: blob.",
      __LINE__,
      {"submit", "the blob is unvalidated and may be any length..."},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "submit",
     "params" : [
@@ -4800,7 +4800,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "my_secret",
          R"({"json_argument":true})",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "submit",
     "params" : [
@@ -4818,7 +4818,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "submit",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "submit",
     "params" : [
@@ -4833,7 +4833,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      "submit: four arguments.",
      __LINE__,
      {"submit", "my_secret", R"({"json_argument":true})", "offline"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "submit",
     "params" : [
@@ -4850,7 +4850,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"submit: offline flag with signature_target.",
      __LINE__,
      {"submit", "my_secret", R"({"json_argument":true})", "offline", "extra"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
         "method" : "submit",
         "params" : [
@@ -4874,7 +4874,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "offline",
       "CounterpartySignature",
       "extra"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "submit",
     "params" : [
@@ -4892,7 +4892,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "my_secret",
          R"({"json_argument":true,})",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "submit",
     "params" : [
@@ -4906,7 +4906,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"submit: misspelled offline flag interpreted as signature_target.",
      __LINE__,
      {"submit", "my_secret", R"({"json_argument":true})", "offlne"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
         "method" : "submit",
         "params" : [
@@ -4930,7 +4930,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "submit_multisigned",
          R"({"json_argument":true})",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "submit_multisigned",
     "params" : [
@@ -4947,7 +4947,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "submit_multisigned",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "submit_multisigned",
     "params" : [
@@ -4961,7 +4961,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"submit_multisigned: too many arguments.",
      __LINE__,
      {"submit_multisigned", R"({"json_argument":true})", "extra"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "submit_multisigned",
     "params" : [
@@ -4978,7 +4978,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "submit_multisigned",
          R"({"json_argument":true,})",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "submit_multisigned",
     "params" : [
@@ -4998,7 +4998,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "server_info",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "server_info",
     "params" : [
@@ -5010,7 +5010,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"server_info: counters.",
      __LINE__,
      {"server_info", "counters"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "server_info",
     "params" : [
@@ -5023,7 +5023,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"server_info: too many arguments.",
      __LINE__,
      {"server_info", "counters", "extra"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "server_info",
     "params" : [
@@ -5037,7 +5037,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"server_info: non-counters argument.",
      __LINE__,
      {"server_info", "counter"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "server_info",
     "params" : [
@@ -5054,7 +5054,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "server_state",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "server_state",
     "params" : [
@@ -5066,7 +5066,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"server_state: counters.",
      __LINE__,
      {"server_state", "counters"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "server_state",
     "params" : [
@@ -5079,7 +5079,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"server_state: too many arguments.",
      __LINE__,
      {"server_state", "counters", "extra"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "server_state",
     "params" : [
@@ -5093,7 +5093,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"server_state: non-counters argument.",
      __LINE__,
      {"server_state", "counter"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "server_state",
     "params" : [
@@ -5110,7 +5110,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "stop",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "stop",
     "params" : [
@@ -5122,7 +5122,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"stop: too many arguments.",
      __LINE__,
      {"stop", "extra"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "stop",
     "params" : [
@@ -5141,7 +5141,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {"transaction_entry",
       "0123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUV",
       "4294967295"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "transaction_entry",
     "params" : [
@@ -5157,7 +5157,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {"transaction_entry",
       "0123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUV",
       "current"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "transaction_entry",
     "params" : [
@@ -5173,7 +5173,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {"transaction_entry",
       "0123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUV",
       "VUTSRQPONMLKJIHGFEDCBA9876543210VUTSRQPONMLKJIHGFEDCBA9876543210"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "transaction_entry",
     "params" : [
@@ -5190,7 +5190,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "transaction_entry",
          "0123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUV",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "transaction_entry",
     "params" : [
@@ -5207,7 +5207,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
       "0123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUV",
       "validated",
       "extra"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "transaction_entry",
     "params" : [
@@ -5225,7 +5225,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUV",
          "validated",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "transaction_entry",
     "params" : [
@@ -5243,7 +5243,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "0123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUVW",
          "validated",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "transaction_entry",
     "params" : [
@@ -5261,7 +5261,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "0123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUV",
          "0",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "transaction_entry",
     "params" : [
@@ -5279,7 +5279,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "0123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUV",
          "4294967296",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "transaction_entry",
     "params" : [
@@ -5297,7 +5297,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "0123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUV",
          "VUTSRQPONMLKJIHGFEDCBA9876543210VUTSRQPONMLKJIHGFEDCBA987654321",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "transaction_entry",
     "params" : [
@@ -5315,7 +5315,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
          "0123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUV",
          "VUTSRQPONMLKJIHGFEDCBA9876543210VUTSRQPONMLKJIHGFEDCBA9876543210Z",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "transaction_entry",
     "params" : [
@@ -5332,7 +5332,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"tx: ctid. minimal",
      __LINE__,
      {"tx", "FFFFFFFFFFFFFFFF", "1", "2"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "tx",
     "params" : [
@@ -5347,7 +5347,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"tx: ctid. binary",
      __LINE__,
      {"tx", "FFFFFFFFFFFFFFFF", "binary", "1", "2"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "tx",
     "params" : [
@@ -5363,7 +5363,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"tx: minimal.",
      __LINE__,
      {"tx", "transaction_hash_is_not_validated"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "tx",
     "params" : [
@@ -5376,7 +5376,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"tx: binary.",
      __LINE__,
      {"tx", "transaction_hash_is_not_validated", "binary"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "tx",
     "params" : [
@@ -5392,7 +5392,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "tx",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "tx",
     "params" : [
@@ -5406,7 +5406,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"tx: too many arguments.",
      __LINE__,
      {"tx", "transaction_hash_is_not_validated", "binary", "1", "2", "extra"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "tx",
     "params" : [
@@ -5420,7 +5420,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"tx: invalid final argument is apparently ignored.",
      __LINE__,
      {"tx", "transaction_hash_is_not_validated", "bin"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "tx",
     "params" : [
@@ -5436,7 +5436,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"tx_history: minimal.",
      __LINE__,
      {"tx_history", "0"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "tx_history",
     "params" : [
@@ -5451,7 +5451,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "tx_history",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "tx_history",
     "params" : [
@@ -5465,7 +5465,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"tx_history: too many arguments.",
      __LINE__,
      {"tx_history", "0", "1"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "tx_history",
     "params" : [
@@ -5481,7 +5481,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
         "tx_history: start too small.",
         __LINE__,
         {"tx_history", "-1"},
-        RPCCallTestData::bad_cast,
+        RPCCallTestData::Exception::bad_cast,
         R"()",
     },
     {
@@ -5489,7 +5489,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
         "tx_history: start too big.",
         __LINE__,
         {"tx_history", "4294967296"},
-        RPCCallTestData::bad_cast,
+        RPCCallTestData::Exception::bad_cast,
         R"()",
     },
     {
@@ -5497,7 +5497,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
         "tx_history: start not integer.",
         __LINE__,
         {"tx_history", "beginning"},
-        RPCCallTestData::bad_cast,
+        RPCCallTestData::Exception::bad_cast,
         R"()",
     },
 
@@ -5508,7 +5508,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "unl_list",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "unl_list",
     "params" : [
@@ -5520,7 +5520,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"unl_list: too many arguments.",
      __LINE__,
      {"unl_list", "extra"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "unl_list",
     "params" : [
@@ -5539,7 +5539,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "validation_create",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "validation_create",
     "params" : [
@@ -5551,7 +5551,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"validation_create: with secret.",
      __LINE__,
      {"validation_create", "the form of the secret is not validated"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "validation_create",
     "params" : [
@@ -5564,7 +5564,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"validation_create: too many arguments.",
      __LINE__,
      {"validation_create", "the form of the secret is not validated", "extra"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "validation_create",
     "params" : [
@@ -5583,7 +5583,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "version",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "version",
     "params" : [
@@ -5595,7 +5595,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"version: too many arguments.",
      __LINE__,
      {"version", "extra"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "version",
     "params" : [
@@ -5614,7 +5614,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "wallet_propose",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "wallet_propose",
     "params" : [
@@ -5626,7 +5626,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"wallet_propose: with passphrase.",
      __LINE__,
      {"wallet_propose", "the form of the passphrase is not validated"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "wallet_propose",
     "params" : [
@@ -5639,7 +5639,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"wallet_propose: too many arguments.",
      __LINE__,
      {"wallet_propose", "the form of the passphrase is not validated", "extra"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "wallet_propose",
     "params" : [
@@ -5656,7 +5656,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"internal: minimal.",
      __LINE__,
      {"internal", "command_name"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "internal",
     "params" : [
@@ -5670,7 +5670,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"internal: with parameters.",
      __LINE__,
      {"internal", "command_name", "string_arg", "1", "-1", "4294967296", "3.14159"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "internal",
     "params" : [
@@ -5686,7 +5686,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "internal",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "internal",
     "params" : [
@@ -5705,7 +5705,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "path_find",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "path_find",
     "params" : [
@@ -5719,7 +5719,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"path_find: with arguments.",
      __LINE__,
      {"path_find", "string_arg", "1", "-1", "4294967296", "3.14159"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "path_find",
     "params" : [
@@ -5738,7 +5738,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "subscribe",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "subscribe",
     "params" : [
@@ -5752,7 +5752,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"subscribe: with arguments.",
      __LINE__,
      {"subscribe", "string_arg", "1", "-1", "4294967296", "3.14159"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "subscribe",
     "params" : [
@@ -5771,7 +5771,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "unsubscribe",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "unsubscribe",
     "params" : [
@@ -5785,7 +5785,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"unsubscribe: with arguments.",
      __LINE__,
      {"unsubscribe", "string_arg", "1", "-1", "4294967296", "3.14159"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "unsubscribe",
     "params" : [
@@ -5804,7 +5804,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
      {
          "unknown_command",
      },
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "unknown_command",
     "params" : [
@@ -5816,7 +5816,7 @@ static RPCCallTestData const rpcCallTestArray[] = {
     {"unknown_command: with arguments.",
      __LINE__,
      {"unknown_command", "string_arg", "1", "-1", "4294967296", "3.14159"},
-     RPCCallTestData::no_exception,
+     RPCCallTestData::Exception::no_exception,
      R"({
     "method" : "unknown_command",
     "params" : [
@@ -5884,7 +5884,7 @@ public:
             }
             catch (std::bad_cast const&)
             {
-                if ((rpcCallTest.throwsWhat == RPCCallTestData::bad_cast) &&
+                if ((rpcCallTest.throwsWhat == RPCCallTestData::Exception::bad_cast) &&
                     (std::strlen(expVersioned) == 0))
                 {
                     pass();
@@ -5913,7 +5913,8 @@ public:
             rmErrorCode(exp);
 
             // Pass if we didn't expect a throw and we got what we expected.
-            if ((rpcCallTest.throwsWhat == RPCCallTestData::no_exception) && (got == exp))
+            if ((rpcCallTest.throwsWhat == RPCCallTestData::Exception::no_exception) &&
+                (got == exp))
             {
                 pass();
             }
diff --git a/src/test/shamap/FetchPack_test.cpp b/src/test/shamap/FetchPack_test.cpp
index cd3bc99fa8..a68b0442d0 100644
--- a/src/test/shamap/FetchPack_test.cpp
+++ b/src/test/shamap/FetchPack_test.cpp
@@ -33,6 +33,8 @@ namespace xrpl::tests {
 class FetchPack_test : public beast::unit_test::suite
 {
 public:
+    // Need to be named before converting
+    // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
     enum { tableItems = 100, tableItemsExtra = 20 };
 
     using Map = hash_map<SHAMapHash, Blob>;
diff --git a/src/test/shamap/common.h b/src/test/shamap/common.h
index 08910b5c5d..3f05bc2c57 100644
--- a/src/test/shamap/common.h
+++ b/src/test/shamap/common.h
@@ -91,8 +91,8 @@ public:
     void
     reset() override
     {
-        fbCache_->reset();
-        tnCache_->reset();
+        (*fbCache_).reset();
+        (*tnCache_).reset();
     }
 
     beast::manual_clock<std::chrono::steady_clock>
diff --git a/src/test/unit_test/SuiteJournal.h b/src/test/unit_test/SuiteJournal.h
index f4cbb5baa0..b0b3807dd3 100644
--- a/src/test/unit_test/SuiteJournal.h
+++ b/src/test/unit_test/SuiteJournal.h
@@ -69,7 +69,7 @@ SuiteJournalSink::writeAlways(beast::severities::Severity level, std::string con
     }();
 
     static std::mutex log_mutex;
-    std::lock_guard const lock(log_mutex);
+    std::scoped_lock const lock(log_mutex);
     suite_.log << s << partition_ << text << std::endl;
 }
 
diff --git a/src/test/unit_test/multi_runner.cpp b/src/test/unit_test/multi_runner.cpp
index a09110ca43..1dffece1da 100644
--- a/src/test/unit_test/multi_runner.cpp
+++ b/src/test/unit_test/multi_runner.cpp
@@ -167,7 +167,7 @@ template <bool IsParent>
 std::size_t
 multi_runner_base<IsParent>::inner::tests() const
 {
-    std::lock_guard const l{m_};
+    std::scoped_lock const l{m_};
     return results_.total;
 }
 
@@ -175,7 +175,7 @@ template <bool IsParent>
 std::size_t
 multi_runner_base<IsParent>::inner::suites() const
 {
-    std::lock_guard const l{m_};
+    std::scoped_lock const l{m_};
     return results_.suites;
 }
 
@@ -197,7 +197,7 @@ template <bool IsParent>
 void
 multi_runner_base<IsParent>::inner::add(results const& r)
 {
-    std::lock_guard const l{m_};
+    std::scoped_lock const l{m_};
     results_.merge(r);
 }
 
@@ -206,7 +206,7 @@ template <class S>
 void
 multi_runner_base<IsParent>::inner::print_results(S& s)
 {
-    std::lock_guard const l{m_};
+    std::scoped_lock const l{m_};
     results_.print(s);
 }
 
@@ -339,7 +339,7 @@ void
 multi_runner_base<IsParent>::message_queue_send(MessageType mt, std::string const& s)
 {
     // must use a mutex since the two "sends" must happen in order
-    std::lock_guard const l{inner_->m_};
+    std::scoped_lock const l{inner_->m_};
     message_queue_->send(&mt, sizeof(mt), /*priority*/ 0);
     message_queue_->send(s.c_str(), s.size(), /*priority*/ 0);
 }
diff --git a/src/test/unit_test/multi_runner.h b/src/test/unit_test/multi_runner.h
index 0f675955de..4ccedf9498 100644
--- a/src/test/unit_test/multi_runner.h
+++ b/src/test/unit_test/multi_runner.h
@@ -59,6 +59,8 @@ struct results
     // pointers from different memory spaces do not co-mingle
     using run_time = std::pair<static_string, typename clock_type::duration>;
 
+    // Need to be named before converting
+    // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
     enum { max_top = 10 };
 
     std::size_t suites = 0;
diff --git a/src/tests/libxrpl/basics/Mutex.cpp b/src/tests/libxrpl/basics/Mutex.cpp
index e91781c463..260bd49da1 100644
--- a/src/tests/libxrpl/basics/Mutex.cpp
+++ b/src/tests/libxrpl/basics/Mutex.cpp
@@ -197,7 +197,7 @@ struct MutexDifferentLockTypesTest : ::testing::Test
 {
 };
 
-TEST_F(MutexDifferentLockTypesTest, lock_guard)
+TEST_F(MutexDifferentLockTypesTest, scoped_lock)
 {
     Mutex<int> m(0);
     {
diff --git a/src/tests/libxrpl/json/Writer.cpp b/src/tests/libxrpl/json/Writer.cpp
index a21f27199f..71fead1b69 100644
--- a/src/tests/libxrpl/json/Writer.cpp
+++ b/src/tests/libxrpl/json/Writer.cpp
@@ -83,11 +83,11 @@ TEST_F(WriterFixture, primitives)
 
 TEST_F(WriterFixture, empty)
 {
-    writer->startRoot(Writer::array);
+    writer->startRoot(Writer::CollectionType::array);
     writer->finish();
     checkOutputAndReset("[]");
 
-    writer->startRoot(Writer::object);
+    writer->startRoot(Writer::CollectionType::object);
     writer->finish();
     checkOutputAndReset("{}");
 }
@@ -112,7 +112,7 @@ TEST_F(WriterFixture, escaping)
 
 TEST_F(WriterFixture, array)
 {
-    writer->startRoot(Writer::array);
+    writer->startRoot(Writer::CollectionType::array);
     writer->append(12);
     writer->finish();
     checkOutputAndReset("[12]");
@@ -120,7 +120,7 @@ TEST_F(WriterFixture, array)
 
 TEST_F(WriterFixture, long_array)
 {
-    writer->startRoot(Writer::array);
+    writer->startRoot(Writer::CollectionType::array);
     writer->append(12);
     writer->append(true);
     writer->append("hello");
@@ -130,8 +130,8 @@ TEST_F(WriterFixture, long_array)
 
 TEST_F(WriterFixture, embedded_array_simple)
 {
-    writer->startRoot(Writer::array);
-    writer->startAppend(Writer::array);
+    writer->startRoot(Writer::CollectionType::array);
+    writer->startAppend(Writer::CollectionType::array);
     writer->finish();
     writer->finish();
     checkOutputAndReset("[[]]");
@@ -139,7 +139,7 @@ TEST_F(WriterFixture, embedded_array_simple)
 
 TEST_F(WriterFixture, object)
 {
-    writer->startRoot(Writer::object);
+    writer->startRoot(Writer::CollectionType::object);
     writer->set("hello", "world");
     writer->finish();
     checkOutputAndReset(R"({"hello":"world"})");
@@ -147,15 +147,15 @@ TEST_F(WriterFixture, object)
 
 TEST_F(WriterFixture, complex_object)
 {
-    writer->startRoot(Writer::object);
+    writer->startRoot(Writer::CollectionType::object);
     writer->set("hello", "world");
-    writer->startSet(Writer::array, "array");
+    writer->startSet(Writer::CollectionType::array, "array");
     writer->append(true);
     writer->append(12);
-    writer->startAppend(Writer::array);
-    writer->startAppend(Writer::object);
+    writer->startAppend(Writer::CollectionType::array);
+    writer->startAppend(Writer::CollectionType::object);
     writer->set("goodbye", "cruel world.");
-    writer->startSet(Writer::array, "subarray");
+    writer->startSet(Writer::CollectionType::array, "subarray");
     writer->append(23.5);
     writer->finishAll();
     checkOutputAndReset(
@@ -166,7 +166,7 @@ TEST_F(WriterFixture, json_value)
 {
     Json::Value value(Json::objectValue);
     value["foo"] = 23;
-    writer->startRoot(Writer::object);
+    writer->startRoot(Writer::CollectionType::object);
     writer->set("hello", value);
     writer->finish();
     checkOutputAndReset(R"({"hello":{"foo":23}})");
diff --git a/src/xrpld/app/consensus/RCLConsensus.cpp b/src/xrpld/app/consensus/RCLConsensus.cpp
index 6d99c2ee15..262f217680 100644
--- a/src/xrpld/app/consensus/RCLConsensus.cpp
+++ b/src/xrpld/app/consensus/RCLConsensus.cpp
@@ -907,7 +907,7 @@ RCLConsensus::getJson(bool full) const
 {
     Json::Value ret;
     {
-        std::lock_guard const _{mutex_};
+        std::scoped_lock const _{mutex_};
         ret = consensus_.getJson(full);
     }
     ret["validating"] = adaptor_.validating();
@@ -921,7 +921,7 @@ RCLConsensus::timerEntry(
 {
     try
     {
-        std::lock_guard const _{mutex_};
+        std::scoped_lock const _{mutex_};
         consensus_.timerEntry(now, clog);
     }
     catch (SHAMapMissingNode const& mn)
@@ -940,7 +940,7 @@ RCLConsensus::gotTxSet(NetClock::time_point const& now, RCLTxSet const& txSet)
 {
     try
     {
-        std::lock_guard const _{mutex_};
+        std::scoped_lock const _{mutex_};
         consensus_.gotTxSet(now, txSet);
     }
     catch (SHAMapMissingNode const& mn)
@@ -958,14 +958,14 @@ RCLConsensus::simulate(
     NetClock::time_point const& now,
     std::optional<std::chrono::milliseconds> consensusDelay)
 {
-    std::lock_guard const _{mutex_};
+    std::scoped_lock const _{mutex_};
     consensus_.simulate(now, consensusDelay);
 }
 
 bool
 RCLConsensus::peerProposal(NetClock::time_point const& now, RCLCxPeerPos const& newProposal)
 {
-    std::lock_guard const _{mutex_};
+    std::scoped_lock const _{mutex_};
     return consensus_.peerProposal(now, newProposal);
 }
 
@@ -1064,7 +1064,7 @@ RCLConsensus::startRound(
     hash_set<NodeID> const& nowTrusted,
     std::unique_ptr<std::stringstream> const& clog)
 {
-    std::lock_guard const _{mutex_};
+    std::scoped_lock const _{mutex_};
     consensus_.startRound(
         now, prevLgrId, prevLgr, nowUntrusted, adaptor_.preStartRound(prevLgr, nowTrusted), clog);
 }
diff --git a/src/xrpld/app/consensus/RCLConsensus.h b/src/xrpld/app/consensus/RCLConsensus.h
index c965ed3d87..b8695fd46e 100644
--- a/src/xrpld/app/consensus/RCLConsensus.h
+++ b/src/xrpld/app/consensus/RCLConsensus.h
@@ -472,7 +472,7 @@ public:
     RCLCxLedger::ID
     prevLedgerID() const
     {
-        std::lock_guard const _{mutex_};
+        std::scoped_lock const _{mutex_};
         return consensus_.prevLedgerID();
     }
 
diff --git a/src/xrpld/app/ledger/AccountStateSF.cpp b/src/xrpld/app/ledger/AccountStateSF.cpp
index d5fa5d83ff..bca527d3d0 100644
--- a/src/xrpld/app/ledger/AccountStateSF.cpp
+++ b/src/xrpld/app/ledger/AccountStateSF.cpp
@@ -19,7 +19,8 @@ AccountStateSF::gotNode(
     Blob&& nodeData,
     SHAMapNodeType) const
 {
-    db_.store(hotACCOUNT_NODE, std::move(nodeData), nodeHash.as_uint256(), ledgerSeq);
+    db_.store(
+        NodeObjectType::hotACCOUNT_NODE, std::move(nodeData), nodeHash.as_uint256(), ledgerSeq);
 }
 
 std::optional<Blob>
diff --git a/src/xrpld/app/ledger/LedgerHolder.h b/src/xrpld/app/ledger/LedgerHolder.h
index bf9d478c40..322ad85e23 100644
--- a/src/xrpld/app/ledger/LedgerHolder.h
+++ b/src/xrpld/app/ledger/LedgerHolder.h
@@ -28,7 +28,7 @@ public:
             LogicError("LedgerHolder::set with nullptr");
         if (!ledger->isImmutable())
             LogicError("LedgerHolder::set with mutable Ledger");
-        std::lock_guard const sl(m_lock);
+        std::scoped_lock const sl(m_lock);
         m_heldLedger = std::move(ledger);
     }
 
@@ -36,14 +36,14 @@ public:
     std::shared_ptr<Ledger const>
     get()
     {
-        std::lock_guard const sl(m_lock);
+        std::scoped_lock const sl(m_lock);
         return m_heldLedger;
     }
 
     bool
     empty()
     {
-        std::lock_guard const sl(m_lock);
+        std::scoped_lock const sl(m_lock);
         return m_heldLedger == nullptr;
     }
 
diff --git a/src/xrpld/app/ledger/LedgerMaster.h b/src/xrpld/app/ledger/LedgerMaster.h
index 1bd4530d6d..62970eab15 100644
--- a/src/xrpld/app/ledger/LedgerMaster.h
+++ b/src/xrpld/app/ledger/LedgerMaster.h
@@ -387,7 +387,7 @@ private:
     void
     collect_metrics()
     {
-        std::lock_guard const lock(m_mutex);
+        std::scoped_lock const lock(m_mutex);
         m_stats.validatedLedgerAge.set(getValidatedLedgerAge().count());
         m_stats.publishedLedgerAge.set(getPublishedLedgerAge().count());
     }
diff --git a/src/xrpld/app/ledger/LedgerReplayer.h b/src/xrpld/app/ledger/LedgerReplayer.h
index ce2acb0699..9ea544c79b 100644
--- a/src/xrpld/app/ledger/LedgerReplayer.h
+++ b/src/xrpld/app/ledger/LedgerReplayer.h
@@ -103,21 +103,21 @@ public:
     std::size_t
     tasksSize() const
     {
-        std::lock_guard<std::mutex> const lock(mtx_);
+        std::scoped_lock const lock(mtx_);
         return tasks_.size();
     }
 
     std::size_t
     deltasSize() const
     {
-        std::lock_guard<std::mutex> const lock(mtx_);
+        std::scoped_lock const lock(mtx_);
         return deltas_.size();
     }
 
     std::size_t
     skipListsSize() const
     {
-        std::lock_guard<std::mutex> const lock(mtx_);
+        std::scoped_lock const lock(mtx_);
         return skipLists_.size();
     }
 
diff --git a/src/xrpld/app/ledger/LedgerToJson.h b/src/xrpld/app/ledger/LedgerToJson.h
index 53985f343b..91878c3c1b 100644
--- a/src/xrpld/app/ledger/LedgerToJson.h
+++ b/src/xrpld/app/ledger/LedgerToJson.h
@@ -23,6 +23,8 @@ struct LedgerFill
             closeTime = context->ledgerMaster.getCloseTimeBySeq(ledger.seq());
     }
 
+    // Bitwise bitmask
+    // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
     enum Options {
         dumpTxrp = 1,
         dumpState = 2,
diff --git a/src/xrpld/app/ledger/OpenLedger.h b/src/xrpld/app/ledger/OpenLedger.h
index 5b1d611b44..d55c9c97e3 100644
--- a/src/xrpld/app/ledger/OpenLedger.h
+++ b/src/xrpld/app/ledger/OpenLedger.h
@@ -169,7 +169,7 @@ private:
         ApplyFlags flags,
         beast::Journal j);
 
-    enum Result { success, failure, retry };
+    enum class Result { success, failure, retry };
 
     std::shared_ptr<OpenView>
     create(Rules const& rules, std::shared_ptr<Ledger const> const& ledger);
diff --git a/src/xrpld/app/ledger/OrderBookDBImpl.cpp b/src/xrpld/app/ledger/OrderBookDBImpl.cpp
index 1c64c5e6fa..4bfa982082 100644
--- a/src/xrpld/app/ledger/OrderBookDBImpl.cpp
+++ b/src/xrpld/app/ledger/OrderBookDBImpl.cpp
@@ -210,7 +210,7 @@ OrderBookDBImpl::update(std::shared_ptr<ReadView const> const& ledger)
     JLOG(j_.debug()) << "Update completed (" << ledger->seq() << "): " << cnt << " books found";
 
     {
-        std::lock_guard const sl(mLock);
+        std::scoped_lock const sl(mLock);
         allBooks_.swap(allBooks);
         xrpBooks_.swap(xrpBooks);
         domainBooks_.swap(domainBooks);
@@ -225,7 +225,7 @@ OrderBookDBImpl::addOrderBook(Book const& book)
 {
     bool const toXRP = isXRP(book.out);
 
-    std::lock_guard const sl(mLock);
+    std::scoped_lock const sl(mLock);
 
     if (book.domain)
     {
@@ -253,7 +253,7 @@ OrderBookDBImpl::getBooksByTakerPays(Asset const& asset, std::optional<uint256>
     std::vector<Book> ret;
 
     {
-        std::lock_guard const sl(mLock);
+        std::scoped_lock const sl(mLock);
 
         auto getBooks = [&](auto const& container, auto const& key) {
             if (auto it = container.find(key); it != container.end())
@@ -282,7 +282,7 @@ OrderBookDBImpl::getBooksByTakerPays(Asset const& asset, std::optional<uint256>
 int
 OrderBookDBImpl::getBookSize(Asset const& asset, std::optional<uint256> const& domain)
 {
-    std::lock_guard const sl(mLock);
+    std::scoped_lock const sl(mLock);
 
     if (!domain)
     {
@@ -301,7 +301,7 @@ OrderBookDBImpl::getBookSize(Asset const& asset, std::optional<uint256> const& d
 bool
 OrderBookDBImpl::isBookToXRP(Asset const& asset, std::optional<Domain> const& domain)
 {
-    std::lock_guard const sl(mLock);
+    std::scoped_lock const sl(mLock);
     if (domain)
         return xrpDomainBooks_.contains({asset, *domain});
     return xrpBooks_.contains(asset);
@@ -310,7 +310,7 @@ OrderBookDBImpl::isBookToXRP(Asset const& asset, std::optional<Domain> const& do
 BookListeners::pointer
 OrderBookDBImpl::makeBookListeners(Book const& book)
 {
-    std::lock_guard const sl(mLock);
+    std::scoped_lock const sl(mLock);
     auto ret = getBookListeners(book);
 
     if (!ret)
@@ -331,7 +331,7 @@ BookListeners::pointer
 OrderBookDBImpl::getBookListeners(Book const& book)
 {
     BookListeners::pointer ret;
-    std::lock_guard const sl(mLock);
+    std::scoped_lock const sl(mLock);
 
     auto it0 = mListeners.find(book);
     if (it0 != mListeners.end())
@@ -348,7 +348,7 @@ OrderBookDBImpl::processTxn(
     AcceptedLedgerTx const& alTx,
     MultiApiJson const& jvObj)
 {
-    std::lock_guard const sl(mLock);
+    std::scoped_lock const sl(mLock);
 
     // For this particular transaction, maintain the set of unique
     // subscriptions that have already published it.  This prevents sending
diff --git a/src/xrpld/app/ledger/TransactionStateSF.cpp b/src/xrpld/app/ledger/TransactionStateSF.cpp
index e2ec3ca7b6..201a2204a5 100644
--- a/src/xrpld/app/ledger/TransactionStateSF.cpp
+++ b/src/xrpld/app/ledger/TransactionStateSF.cpp
@@ -24,7 +24,8 @@ TransactionStateSF::gotNode(
     XRPL_ASSERT(
         type != SHAMapNodeType::tnTRANSACTION_NM,
         "xrpl::TransactionStateSF::gotNode : valid input");
-    db_.store(hotTRANSACTION_NODE, std::move(nodeData), nodeHash.as_uint256(), ledgerSeq);
+    db_.store(
+        NodeObjectType::hotTRANSACTION_NODE, std::move(nodeData), nodeHash.as_uint256(), ledgerSeq);
 }
 
 std::optional<Blob>
diff --git a/src/xrpld/app/ledger/detail/BuildLedger.cpp b/src/xrpld/app/ledger/detail/BuildLedger.cpp
index 8f5184336a..c75b1e0a12 100644
--- a/src/xrpld/app/ledger/detail/BuildLedger.cpp
+++ b/src/xrpld/app/ledger/detail/BuildLedger.cpp
@@ -63,8 +63,8 @@ buildLedgerImpl(
         // Write the final version of all modified SHAMap
         // nodes to the node store to preserve the new LCL
 
-        int const asf = built->stateMap().flushDirty(hotACCOUNT_NODE);
-        int const tmf = built->txMap().flushDirty(hotTRANSACTION_NODE);
+        int const asf = built->stateMap().flushDirty(NodeObjectType::hotACCOUNT_NODE);
+        int const tmf = built->txMap().flushDirty(NodeObjectType::hotTRANSACTION_NODE);
         JLOG(j.debug()) << "Flushed " << asf << " accounts and " << tmf << " transaction nodes";
     }
     built->unshare();
diff --git a/src/xrpld/app/ledger/detail/InboundLedger.cpp b/src/xrpld/app/ledger/detail/InboundLedger.cpp
index a65fae2ff3..52636d08c6 100644
--- a/src/xrpld/app/ledger/detail/InboundLedger.cpp
+++ b/src/xrpld/app/ledger/detail/InboundLedger.cpp
@@ -53,6 +53,8 @@ namespace xrpl {
 
 using namespace std::chrono_literals;
 
+// Need to be named before converting
+// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
 enum {
     // Number of peers to start with
     peerCountStart = 5
@@ -276,7 +278,8 @@ InboundLedger::tryDB(NodeStore::Database& srcDB)
             if (std::addressof(dstDB) != std::addressof(srcDB))
             {
                 Blob blob{nodeObject->getData()};
-                dstDB.store(hotLEDGER, std::move(blob), hash_, mLedger->header().seq);
+                dstDB.store(
+                    NodeObjectType::hotLEDGER, std::move(blob), hash_, mLedger->header().seq);
             }
         }
         else
@@ -294,7 +297,7 @@ InboundLedger::tryDB(NodeStore::Database& srcDB)
 
             // Store the ledger header in the ledger's database
             mLedger->stateMap().family().db().store(
-                hotLEDGER, std::move(*data), hash_, mLedger->header().seq);
+                NodeObjectType::hotLEDGER, std::move(*data), hash_, mLedger->header().seq);
         }
 
         if (mSeq == 0)
@@ -820,7 +823,7 @@ InboundLedger::takeHeader(std::string const& data)
     Serializer s(data.size() + 4);
     s.add32(HashPrefix::ledgerMaster);
     s.addRaw(data.data(), data.size());
-    f->db().store(hotLEDGER, std::move(s.modData()), hash_, mSeq);
+    f->db().store(NodeObjectType::hotLEDGER, std::move(s.modData()), hash_, mSeq);
 
     if (mLedger->header().txHash.isZero())
         mHaveTransactions = true;
@@ -1021,7 +1024,7 @@ InboundLedger::gotData(
     std::weak_ptr<Peer> peer,
     std::shared_ptr<protocol::TMLedgerData> const& data)
 {
-    std::lock_guard const sl(mReceivedDataLock);
+    std::scoped_lock const sl(mReceivedDataLock);
 
     if (isDone())
         return false;
@@ -1233,7 +1236,7 @@ InboundLedger::runData()
         data.clear();
 
         {
-            std::lock_guard const sl(mReceivedDataLock);
+            std::scoped_lock const sl(mReceivedDataLock);
 
             if (mReceivedData.empty())
             {
diff --git a/src/xrpld/app/ledger/detail/InboundLedgers.cpp b/src/xrpld/app/ledger/detail/InboundLedgers.cpp
index 2207308737..a882f5be73 100644
--- a/src/xrpld/app/ledger/detail/InboundLedgers.cpp
+++ b/src/xrpld/app/ledger/detail/InboundLedgers.cpp
@@ -284,7 +284,7 @@ public:
     std::size_t
     fetchRate() override
     {
-        std::lock_guard const lock(fetchRateMutex_);
+        std::scoped_lock const lock(fetchRateMutex_);
         return 60 * fetchRate_.value(m_clock.now());
     }
 
@@ -293,7 +293,7 @@ public:
     void
     onLedgerFetched() override
     {
-        std::lock_guard const lock(fetchRateMutex_);
+        std::scoped_lock const lock(fetchRateMutex_);
         fetchRate_.add(1, m_clock.now());
     }
 
diff --git a/src/xrpld/app/ledger/detail/InboundTransactions.cpp b/src/xrpld/app/ledger/detail/InboundTransactions.cpp
index 56c9c633f4..cbf0ac04d5 100644
--- a/src/xrpld/app/ledger/detail/InboundTransactions.cpp
+++ b/src/xrpld/app/ledger/detail/InboundTransactions.cpp
@@ -27,6 +27,8 @@
 
 namespace xrpl {
 
+// Need to be named before converting
+// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
 enum {
     // Ideal number of peers to start with
     startPeers = 2,
@@ -77,7 +79,7 @@ public:
     getAcquire(uint256 const& hash)
     {
         {
-            std::lock_guard const sl(mLock);
+            std::scoped_lock const sl(mLock);
 
             auto it = m_map.find(hash);
 
@@ -93,7 +95,7 @@ public:
         TransactionAcquire::pointer ta;
 
         {
-            std::lock_guard const sl(mLock);
+            std::scoped_lock const sl(mLock);
 
             if (auto it = m_map.find(hash); it != m_map.end())
             {
@@ -176,7 +178,7 @@ public:
         bool isNew = true;
 
         {
-            std::lock_guard const sl(mLock);
+            std::scoped_lock const sl(mLock);
 
             auto& inboundSet = m_map[hash];
 
@@ -201,7 +203,7 @@ public:
     void
     newRound(std::uint32_t seq) override
     {
-        std::lock_guard const lock(mLock);
+        std::scoped_lock const lock(mLock);
 
         // Protect zero set from expiration
         m_zeroSet.mSeq = seq;
@@ -232,7 +234,7 @@ public:
     void
     stop() override
     {
-        std::lock_guard const lock(mLock);
+        std::scoped_lock const lock(mLock);
         stopping_ = true;
         m_map.clear();
     }
diff --git a/src/xrpld/app/ledger/detail/LedgerCleaner.cpp b/src/xrpld/app/ledger/detail/LedgerCleaner.cpp
index 850b60f4ed..d500c8ee7b 100644
--- a/src/xrpld/app/ledger/detail/LedgerCleaner.cpp
+++ b/src/xrpld/app/ledger/detail/LedgerCleaner.cpp
@@ -98,7 +98,7 @@ public:
     {
         JLOG(j_.info()) << "Stopping";
         {
-            std::lock_guard const lock(mutex_);
+            std::scoped_lock const lock(mutex_);
             shouldExit_ = true;
             wakeup_.notify_one();
         }
@@ -114,7 +114,7 @@ public:
     void
     onWrite(beast::PropertyStream::Map& map) override
     {
-        std::lock_guard const lock(mutex_);
+        std::scoped_lock const lock(mutex_);
 
         if (maxRange_ == 0)
         {
@@ -146,7 +146,7 @@ public:
         app_.getLedgerMaster().getFullValidatedRange(minRange, maxRange);
 
         {
-            std::lock_guard const lock(mutex_);
+            std::scoped_lock const lock(mutex_);
 
             maxRange_ = maxRange;
             minRange_ = minRange;
@@ -376,7 +376,7 @@ private:
     doLedgerCleaner()
     {
         auto shouldExit = [this] {
-            std::lock_guard const lock(mutex_);
+            std::scoped_lock const lock(mutex_);
             return shouldExit_;
         };
 
@@ -397,7 +397,7 @@ private:
             }
 
             {
-                std::lock_guard const lock(mutex_);
+                std::scoped_lock const lock(mutex_);
                 if ((minRange_ > maxRange_) || (maxRange_ == 0) || (minRange_ == 0))
                 {
                     minRange_ = maxRange_ = 0;
@@ -425,7 +425,7 @@ private:
             if (fail)
             {
                 {
-                    std::lock_guard const lock(mutex_);
+                    std::scoped_lock const lock(mutex_);
                     ++failures_;
                 }
                 // Wait for acquiring to catch up to us
@@ -434,7 +434,7 @@ private:
             else
             {
                 {
-                    std::lock_guard const lock(mutex_);
+                    std::scoped_lock const lock(mutex_);
                     if (ledgerIndex == minRange_)
                         ++minRange_;
                     if (ledgerIndex == maxRange_)
diff --git a/src/xrpld/app/ledger/detail/LedgerMaster.cpp b/src/xrpld/app/ledger/detail/LedgerMaster.cpp
index c53249fa07..1c0e627cd0 100644
--- a/src/xrpld/app/ledger/detail/LedgerMaster.cpp
+++ b/src/xrpld/app/ledger/detail/LedgerMaster.cpp
@@ -163,7 +163,7 @@ LedgerMaster::isCompatible(ReadView const& view, beast::Journal::Stream s, char
     }
 
     {
-        std::lock_guard const sl(m_mutex);
+        std::scoped_lock const sl(m_mutex);
 
         if ((mLastValidLedger.second != 0) &&
             !areCompatible(mLastValidLedger.first, mLastValidLedger.second, view, s, reason))
@@ -342,7 +342,7 @@ LedgerMaster::setPubLedger(std::shared_ptr<Ledger const> const& l)
 void
 LedgerMaster::addHeldTransaction(std::shared_ptr<Transaction> const& transaction)
 {
-    std::lock_guard const ml(m_mutex);
+    std::scoped_lock const ml(m_mutex);
     mHeldTransactions.insert(transaction->getSTransaction());
 }
 
@@ -425,7 +425,7 @@ LedgerMaster::switchLCL(std::shared_ptr<Ledger const> const& lastClosed)
         LogicError("The new last closed ledger is open!");
 
     {
-        std::lock_guard const ml(m_mutex);
+        std::scoped_lock const ml(m_mutex);
         mClosedLedger.set(lastClosed);
     }
 
@@ -463,7 +463,7 @@ void
 LedgerMaster::applyHeldTransactions()
 {
     CanonicalTXSet const set = [this]() {
-        std::lock_guard const sl(m_mutex);
+        std::scoped_lock const sl(m_mutex);
         // VFALCO NOTE The hash for an open ledger is undefined so we use
         // something that is a reasonable substitute.
         CanonicalTXSet set(app_.getOpenLedger().current()->header().parentHash);
@@ -478,7 +478,7 @@ LedgerMaster::applyHeldTransactions()
 std::shared_ptr<STTx const>
 LedgerMaster::popAcctTransaction(std::shared_ptr<STTx const> const& tx)
 {
-    std::lock_guard const sl(m_mutex);
+    std::scoped_lock const sl(m_mutex);
 
     return mHeldTransactions.popAcctTransaction(tx);
 }
@@ -492,14 +492,14 @@ LedgerMaster::setBuildingLedger(LedgerIndex i)
 bool
 LedgerMaster::haveLedger(std::uint32_t seq)
 {
-    std::lock_guard const sl(mCompleteLock);
+    std::scoped_lock const sl(mCompleteLock);
     return boost::icl::contains(mCompleteLedgers, seq);
 }
 
 void
 LedgerMaster::clearLedger(std::uint32_t seq)
 {
-    std::lock_guard const sl(mCompleteLock);
+    std::scoped_lock const sl(mCompleteLock);
     mCompleteLedgers.erase(seq);
 }
 
@@ -560,7 +560,7 @@ LedgerMaster::getFullValidatedRange(std::uint32_t& minVal, std::uint32_t& maxVal
 
     std::optional<std::uint32_t> maybeMin;
     {
-        std::lock_guard const sl(mCompleteLock);
+        std::scoped_lock const sl(mCompleteLock);
         maybeMin = prevMissing(mCompleteLedgers, maxVal);
     }
 
@@ -655,7 +655,7 @@ LedgerMaster::tryFill(std::shared_ptr<Ledger const> ledger)
     while (!app_.getJobQueue().isStopping() && seq > 0)
     {
         {
-            std::lock_guard const ml(m_mutex);
+            std::scoped_lock const ml(m_mutex);
             minHas = seq;
             --seq;
 
@@ -671,7 +671,7 @@ LedgerMaster::tryFill(std::shared_ptr<Ledger const> ledger)
                 return;
 
             {
-                std::lock_guard const ml(mCompleteLock);
+                std::scoped_lock const ml(mCompleteLock);
                 mCompleteLedgers.insert(range(minHas, maxHas));
             }
             maxHas = minHas;
@@ -699,11 +699,11 @@ LedgerMaster::tryFill(std::shared_ptr<Ledger const> ledger)
     }
 
     {
-        std::lock_guard const ml(mCompleteLock);
+        std::scoped_lock const ml(mCompleteLock);
         mCompleteLedgers.insert(range(minHas, maxHas));
     }
     {
-        std::lock_guard const ml(m_mutex);
+        std::scoped_lock const ml(m_mutex);
         mFillInProgress = 0;
         tryAdvance();
     }
@@ -841,12 +841,12 @@ LedgerMaster::setFullLedger(
     pendSaveValidated(app_, ledger, isSynchronous, isCurrent);
 
     {
-        std::lock_guard const ml(mCompleteLock);
+        std::scoped_lock const ml(mCompleteLock);
         mCompleteLedgers.insert(ledger->header().seq);
     }
 
     {
-        std::lock_guard const ml(m_mutex);
+        std::scoped_lock const ml(m_mutex);
 
         if (ledger->header().seq > mValidLedgerSeq)
             setValidLedger(ledger);
@@ -896,7 +896,7 @@ LedgerMaster::checkAccept(uint256 const& hash, std::uint32_t seq)
         valCount = validations.size();
         if (valCount >= app_.getValidators().quorum())
         {
-            std::lock_guard const ml(m_mutex);
+            std::scoped_lock const ml(m_mutex);
             if (seq > mLastValidLedger.second)
                 mLastValidLedger = std::make_pair(hash, seq);
         }
@@ -950,7 +950,7 @@ LedgerMaster::checkAccept(std::shared_ptr<Ledger const> const& ledger)
 
     // Can we advance the last fully-validated ledger? If so, can we
     // publish?
-    std::lock_guard const ml(m_mutex);
+    std::scoped_lock const ml(m_mutex);
 
     if (ledger->header().seq <= mValidLedgerSeq)
         return;
@@ -1344,7 +1344,7 @@ LedgerMaster::findNewLedgersToPublish(std::unique_lock<std::recursive_mutex>& sl
 void
 LedgerMaster::tryAdvance()
 {
-    std::lock_guard const ml(m_mutex);
+    std::scoped_lock const ml(m_mutex);
 
     // Can't advance without at least one fully-valid ledger
     mAdvanceWork = true;
@@ -1379,7 +1379,7 @@ void
 LedgerMaster::updatePaths()
 {
     {
-        std::lock_guard const ml(m_mutex);
+        std::scoped_lock const ml(m_mutex);
         if (app_.getOPs().isNeedNetworkLedger())
         {
             --mPathFindThread;
@@ -1394,7 +1394,7 @@ LedgerMaster::updatePaths()
         JLOG(m_journal.debug()) << "updatePaths running";
         std::shared_ptr<ReadView const> lastLedger;
         {
-            std::lock_guard const ml(m_mutex);
+            std::scoped_lock const ml(m_mutex);
 
             if (!mValidLedger.empty() &&
                 (!mPathLedger || (mPathLedger->header().seq != mValidLedgerSeq)))
@@ -1423,7 +1423,7 @@ LedgerMaster::updatePaths()
             if (age > 1min)
             {
                 JLOG(m_journal.debug()) << "Published ledger too old for updating paths";
-                std::lock_guard const ml(m_mutex);
+                std::scoped_lock const ml(m_mutex);
                 --mPathFindThread;
                 mPathLedger.reset();
                 return;
@@ -1434,7 +1434,7 @@ LedgerMaster::updatePaths()
         {
             auto& pathRequests = app_.getPathRequestManager();
             {
-                std::lock_guard const ml(m_mutex);
+                std::scoped_lock const ml(m_mutex);
                 if (!pathRequests.requestsPending())
                 {
                     --mPathFindThread;
@@ -1448,7 +1448,7 @@ LedgerMaster::updatePaths()
             JLOG(m_journal.debug()) << "Updating paths";
             pathRequests.updateAll(lastLedger);
 
-            std::lock_guard const ml(m_mutex);
+            std::scoped_lock const ml(m_mutex);
             if (!pathRequests.requestsPending())
             {
                 JLOG(m_journal.debug()) << "No path requests left. No need for further updating "
@@ -1492,7 +1492,7 @@ LedgerMaster::newPathRequest()
 bool
 LedgerMaster::isNewPathRequest()
 {
-    std::lock_guard const ml(m_mutex);
+    std::scoped_lock const ml(m_mutex);
     bool const ret = mPathFindNewRequest;
     mPathFindNewRequest = false;
     return ret;
@@ -1565,14 +1565,14 @@ LedgerMaster::getValidatedRules()
 std::shared_ptr<ReadView const>
 LedgerMaster::getPublishedLedger()
 {
-    std::lock_guard const lock(m_mutex);
+    std::scoped_lock const lock(m_mutex);
     return mPubLedger;
 }
 
 std::string
 LedgerMaster::getCompleteLedgers()
 {
-    std::lock_guard const sl(mCompleteLock);
+    std::scoped_lock const sl(mCompleteLock);
     return to_string(mCompleteLedgers);
 }
 
@@ -1731,7 +1731,7 @@ LedgerMaster::getLedgerByHash(uint256 const& hash)
 void
 LedgerMaster::setLedgerRangePresent(std::uint32_t minV, std::uint32_t maxV)
 {
-    std::lock_guard const sl(mCompleteLock);
+    std::scoped_lock const sl(mCompleteLock);
     mCompleteLedgers.insert(range(minV, maxV));
 }
 
@@ -1751,7 +1751,7 @@ LedgerMaster::getCacheHitRate()
 void
 LedgerMaster::clearPriorLedgers(LedgerIndex seq)
 {
-    std::lock_guard const sl(mCompleteLock);
+    std::scoped_lock const sl(mCompleteLock);
     if (seq > 0)
         mCompleteLedgers.erase(range(0u, seq - 1));
 }
@@ -1812,7 +1812,7 @@ LedgerMaster::fetchForHistory(
             setFullLedger(ledger, false, false);
             int fillInProgress = 0;
             {
-                std::lock_guard const lock(m_mutex);
+                std::scoped_lock const lock(m_mutex);
                 mHistLedger = ledger;
                 fillInProgress = mFillInProgress;
             }
@@ -1821,7 +1821,7 @@ LedgerMaster::fetchForHistory(
             {
                 {
                     // Previous ledger is in DB
-                    std::lock_guard const lock(m_mutex);
+                    std::scoped_lock const lock(m_mutex);
                     mFillInProgress = seq;
                 }
                 app_.getJobQueue().addJob(
@@ -1893,7 +1893,7 @@ LedgerMaster::doAdvance(std::unique_lock<std::recursive_mutex>& sl)
                 InboundLedger::Reason const reason = InboundLedger::Reason::HISTORY;
                 std::optional<std::uint32_t> missing;
                 {
-                    std::lock_guard const sll(mCompleteLock);
+                    std::scoped_lock const sll(mCompleteLock);
                     missing = prevMissing(
                         mCompleteLedgers,
                         mPubLedger->header().seq,
diff --git a/src/xrpld/app/ledger/detail/LedgerReplayer.cpp b/src/xrpld/app/ledger/detail/LedgerReplayer.cpp
index 7779132b39..8f5d38132c 100644
--- a/src/xrpld/app/ledger/detail/LedgerReplayer.cpp
+++ b/src/xrpld/app/ledger/detail/LedgerReplayer.cpp
@@ -39,7 +39,7 @@ LedgerReplayer::LedgerReplayer(
 
 LedgerReplayer::~LedgerReplayer()
 {
-    std::lock_guard<std::mutex> const lock(mtx_);
+    std::scoped_lock const lock(mtx_);
     tasks_.clear();
 }
 
@@ -61,7 +61,7 @@ LedgerReplayer::replay(
     std::shared_ptr<SkipListAcquire> skipList;
     bool newSkipList = false;
     {
-        std::lock_guard<std::mutex> const lock(mtx_);
+        std::scoped_lock const lock(mtx_);
         if (app_.isStopping())
             return;
         if (tasks_.size() >= LedgerReplayParameters::MAX_TASKS)
@@ -139,7 +139,7 @@ LedgerReplayer::createDeltas(std::shared_ptr<LedgerReplayTask> task)
             std::shared_ptr<LedgerDeltaAcquire> delta;
             bool newDelta = false;
             {
-                std::lock_guard<std::mutex> const lock(mtx_);
+                std::scoped_lock const lock(mtx_);
                 if (app_.isStopping())
                     return;
                 auto i = deltas_.find(*skipListItem);
@@ -169,7 +169,7 @@ LedgerReplayer::gotSkipList(
 {
     std::shared_ptr<SkipListAcquire> skipList = {};
     {
-        std::lock_guard<std::mutex> const lock(mtx_);
+        std::scoped_lock const lock(mtx_);
         auto i = skipLists_.find(info.hash);
         if (i == skipLists_.end())
             return;
@@ -192,7 +192,7 @@ LedgerReplayer::gotReplayDelta(
 {
     std::shared_ptr<LedgerDeltaAcquire> delta = {};
     {
-        std::lock_guard<std::mutex> const lock(mtx_);
+        std::scoped_lock const lock(mtx_);
         auto i = deltas_.find(info.hash);
         if (i == deltas_.end())
             return;
@@ -213,7 +213,7 @@ LedgerReplayer::sweep()
 {
     auto const start = std::chrono::steady_clock::now();
     {
-        std::lock_guard<std::mutex> const lock(mtx_);
+        std::scoped_lock const lock(mtx_);
         JLOG(j_.debug()) << "Sweeping, LedgerReplayer has " << tasks_.size() << " tasks, "
                          << skipLists_.size() << " skipLists, and " << deltas_.size() << " deltas.";
 
@@ -260,7 +260,7 @@ LedgerReplayer::stop()
 {
     JLOG(j_.info()) << "Stopping...";
     {
-        std::lock_guard<std::mutex> const lock(mtx_);
+        std::scoped_lock const lock(mtx_);
         std::ranges::for_each(tasks_, [](auto& i) { i->cancel(); });
         tasks_.clear();
         auto lockAndCancel = [](auto& i) {
diff --git a/src/xrpld/app/ledger/detail/LedgerToJson.cpp b/src/xrpld/app/ledger/detail/LedgerToJson.cpp
index 8ba45fb515..2d244942e7 100644
--- a/src/xrpld/app/ledger/detail/LedgerToJson.cpp
+++ b/src/xrpld/app/ledger/detail/LedgerToJson.cpp
@@ -206,7 +206,7 @@ fillJsonTx(
                 fill.ledger,
                 account,
                 amount,
-                fhIGNORE_FREEZE,
+                FreezeHandling::fhIGNORE_FREEZE,
                 beast::Journal{beast::Journal::getNullSink()});
             txJson[jss::owner_funds] = ownerFunds.getText();
         }
diff --git a/src/xrpld/app/ledger/detail/LocalTxs.cpp b/src/xrpld/app/ledger/detail/LocalTxs.cpp
index 83d9c61c3c..6cc83261d1 100644
--- a/src/xrpld/app/ledger/detail/LocalTxs.cpp
+++ b/src/xrpld/app/ledger/detail/LocalTxs.cpp
@@ -106,7 +106,7 @@ public:
     void
     push_back(LedgerIndex index, std::shared_ptr<STTx const> const& txn) override
     {
-        std::lock_guard const lock(m_lock);
+        std::scoped_lock const lock(m_lock);
 
         m_txns.emplace_back(index, txn);
     }
@@ -119,7 +119,7 @@ public:
         // Get the set of local transactions as a canonical
         // set (so they apply in a valid order)
         {
-            std::lock_guard const lock(m_lock);
+            std::scoped_lock const lock(m_lock);
 
             for (auto const& it : m_txns)
                 tset.insert(it.getTX());
@@ -133,7 +133,7 @@ public:
     void
     sweep(ReadView const& view) override
     {
-        std::lock_guard const lock(m_lock);
+        std::scoped_lock const lock(m_lock);
 
         m_txns.remove_if([&view](auto const& txn) {
             if (txn.isExpired(view.header().seq))
@@ -170,7 +170,7 @@ public:
     std::size_t
     size() override
     {
-        std::lock_guard const lock(m_lock);
+        std::scoped_lock const lock(m_lock);
 
         return m_txns.size();
     }
diff --git a/src/xrpld/app/ledger/detail/OpenLedger.cpp b/src/xrpld/app/ledger/detail/OpenLedger.cpp
index 5db4e23e1e..20ddf27237 100644
--- a/src/xrpld/app/ledger/detail/OpenLedger.cpp
+++ b/src/xrpld/app/ledger/detail/OpenLedger.cpp
@@ -47,26 +47,26 @@ OpenLedger::OpenLedger(
 bool
 OpenLedger::empty() const
 {
-    std::lock_guard const lock(modify_mutex_);
+    std::scoped_lock const lock(modify_mutex_);
     return current_->txCount() == 0;
 }
 
 std::shared_ptr<OpenView const>
 OpenLedger::current() const
 {
-    std::lock_guard const lock(current_mutex_);
+    std::scoped_lock const lock(current_mutex_);
     return current_;
 }
 
 bool
 OpenLedger::modify(modify_type const& f)
 {
-    std::lock_guard const lock1(modify_mutex_);
+    std::scoped_lock const lock1(modify_mutex_);
     auto next = std::make_shared<OpenView>(*current_);
     auto const changed = f(*next, j_);
     if (changed)
     {
-        std::lock_guard const lock2(current_mutex_);
+        std::scoped_lock const lock2(current_mutex_);
         current_ = std::move(next);
     }
     return changed;
@@ -95,7 +95,7 @@ OpenLedger::accept(
     // Block calls to modify, otherwise
     // new tx going into the open ledger
     // would get lost.
-    std::lock_guard const lock1(modify_mutex_);
+    std::scoped_lock const lock1(modify_mutex_);
     // Apply tx from the current open view
     if (!current_->txs.empty())
     {
@@ -153,7 +153,7 @@ OpenLedger::accept(
     }
 
     // Switch to the new open view
-    std::lock_guard const lock2(current_mutex_);
+    std::scoped_lock const lock2(current_mutex_);
     current_ = std::move(next);
 }
 
diff --git a/src/xrpld/app/ledger/detail/TransactionAcquire.cpp b/src/xrpld/app/ledger/detail/TransactionAcquire.cpp
index b38c413344..686d33ce63 100644
--- a/src/xrpld/app/ledger/detail/TransactionAcquire.cpp
+++ b/src/xrpld/app/ledger/detail/TransactionAcquire.cpp
@@ -31,6 +31,8 @@ using namespace std::chrono_literals;
 // Timeout interval in milliseconds
 auto constexpr TX_ACQUIRE_TIMEOUT = 250ms;
 
+// Need to be named before converting
+// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
 enum {
     NORM_TIMEOUTS = 4,
     MAX_TIMEOUTS = 20,
diff --git a/src/xrpld/app/ledger/detail/TransactionMaster.cpp b/src/xrpld/app/ledger/detail/TransactionMaster.cpp
index 798c29dc05..bc0b7ca4ab 100644
--- a/src/xrpld/app/ledger/detail/TransactionMaster.cpp
+++ b/src/xrpld/app/ledger/detail/TransactionMaster.cpp
@@ -50,7 +50,7 @@ TransactionMaster::inLedger(
     if (!txn)
         return false;
 
-    txn->setStatus(COMMITTED, ledger, tseq, netID);
+    txn->setStatus(TransStatus::COMMITTED, ledger, tseq, netID);
     return true;
 }
 
@@ -130,7 +130,7 @@ TransactionMaster::fetch(
     else
     {
         if (uCommitLedger != 0u)
-            iTx->setStatus(COMMITTED, uCommitLedger);
+            iTx->setStatus(TransStatus::COMMITTED, uCommitLedger);
 
         txn = iTx->getSTransaction();
     }
diff --git a/src/xrpld/app/main/Application.cpp b/src/xrpld/app/main/Application.cpp
index 005586eaba..d43f842eed 100644
--- a/src/xrpld/app/main/Application.cpp
+++ b/src/xrpld/app/main/Application.cpp
@@ -1885,7 +1885,7 @@ ApplicationImp::loadLedgerFromFile(std::string const& name)
             }
         }
 
-        loadLedger->stateMap().flushDirty(hotACCOUNT_NODE);
+        loadLedger->stateMap().flushDirty(NodeObjectType::hotACCOUNT_NODE);
 
         XRPL_ASSERT(
             loadLedger->header().seq < XRP_LEDGER_EARLIEST_FEES || loadLedger->read(keylet::fees()),
diff --git a/src/xrpld/app/main/LoadManager.cpp b/src/xrpld/app/main/LoadManager.cpp
index 84c57ad360..4f9023dbc5 100644
--- a/src/xrpld/app/main/LoadManager.cpp
+++ b/src/xrpld/app/main/LoadManager.cpp
@@ -42,7 +42,7 @@ LoadManager::~LoadManager()
 void
 LoadManager::activateStallDetector()
 {
-    std::lock_guard const sl(mutex_);
+    std::scoped_lock const sl(mutex_);
     armed_ = true;
     lastHeartbeat_ = std::chrono::steady_clock::now();
 }
@@ -51,7 +51,7 @@ void
 LoadManager::heartbeat()
 {
     auto const heartbeat = std::chrono::steady_clock::now();
-    std::lock_guard const sl(mutex_);
+    std::scoped_lock const sl(mutex_);
     lastHeartbeat_ = heartbeat;
 }
 
@@ -70,7 +70,7 @@ void
 LoadManager::stop()
 {
     {
-        std::lock_guard const lock(mutex_);
+        std::scoped_lock const lock(mutex_);
         stop_ = true;
         // There is at most one thread waiting on this condition.
         cv_.notify_all();
diff --git a/src/xrpld/app/main/Main.cpp b/src/xrpld/app/main/Main.cpp
index 3da6e3a2ad..c774c77253 100644
--- a/src/xrpld/app/main/Main.cpp
+++ b/src/xrpld/app/main/Main.cpp
@@ -213,7 +213,7 @@ public:
         std::ranges::for_each(v, [this](std::string s) {
             boost::trim(s);
             if (selectors_.empty() || !s.empty())
-                selectors_.emplace_back(beast::unit_test::selector::automatch, s);
+                selectors_.emplace_back(beast::unit_test::selector::mode_t::automatch, s);
         });
     }
 
diff --git a/src/xrpld/app/misc/NegativeUNLVote.cpp b/src/xrpld/app/misc/NegativeUNLVote.cpp
index 8db726ff48..c733de3bd3 100644
--- a/src/xrpld/app/misc/NegativeUNLVote.cpp
+++ b/src/xrpld/app/misc/NegativeUNLVote.cpp
@@ -93,7 +93,7 @@ NegativeUNLVote::doVoting(
             auto n = choose(prevLedger->header().hash, candidates.toDisableCandidates);
             XRPL_ASSERT(
                 nidToKeyMap.contains(n), "xrpl::NegativeUNLVote::doVoting : found node to disable");
-            addTx(seq, nidToKeyMap.at(n), ToDisable, initialSet);
+            addTx(seq, nidToKeyMap.at(n), NegativeUNLModify::ToDisable, initialSet);
         }
 
         if (!candidates.toReEnableCandidates.empty())
@@ -101,7 +101,7 @@ NegativeUNLVote::doVoting(
             auto n = choose(prevLedger->header().hash, candidates.toReEnableCandidates);
             XRPL_ASSERT(
                 nidToKeyMap.contains(n), "xrpl::NegativeUNLVote::doVoting : found node to enable");
-            addTx(seq, nidToKeyMap.at(n), ToReEnable, initialSet);
+            addTx(seq, nidToKeyMap.at(n), NegativeUNLModify::ToReEnable, initialSet);
         }
     }
 }
@@ -114,7 +114,7 @@ NegativeUNLVote::addTx(
     std::shared_ptr<SHAMap> const& initialSet)
 {
     STTx const negUnlTx(ttUNL_MODIFY, [&](auto& obj) {
-        obj.setFieldU8(sfUNLModifyDisabling, modify == ToDisable ? 1 : 0);
+        obj.setFieldU8(sfUNLModifyDisabling, modify == NegativeUNLModify::ToDisable ? 1 : 0);
         obj.setFieldU32(sfLedgerSequence, seq);
         obj.setFieldVL(sfUNLModifyValidator, vp.slice());
     });
@@ -132,7 +132,8 @@ NegativeUNLVote::addTx(
         JLOG(j_.debug()) << "N-UNL: ledger seq=" << seq
                          << ", add a ttUNL_MODIFY Tx with txID: " << negUnlTx.getTransactionID()
                          << ", the validator to "
-                         << (modify == ToDisable ? "disable: " : "re-enable: ") << vp;
+                         << (modify == NegativeUNLModify::ToDisable ? "disable: " : "re-enable: ")
+                         << vp;
     }
 }
 
@@ -308,7 +309,7 @@ NegativeUNLVote::findAllCandidates(
 void
 NegativeUNLVote::newValidators(LedgerIndex seq, hash_set<NodeID> const& nowTrusted)
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     for (auto const& n : nowTrusted)
     {
         if (!newValidators_.contains(n))
@@ -322,7 +323,7 @@ NegativeUNLVote::newValidators(LedgerIndex seq, hash_set<NodeID> const& nowTrust
 void
 NegativeUNLVote::purgeNewValidators(LedgerIndex seq)
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     auto i = newValidators_.begin();
     while (i != newValidators_.end())
     {
diff --git a/src/xrpld/app/misc/NegativeUNLVote.h b/src/xrpld/app/misc/NegativeUNLVote.h
index 2cc63cf8c5..02e84ccca1 100644
--- a/src/xrpld/app/misc/NegativeUNLVote.h
+++ b/src/xrpld/app/misc/NegativeUNLVote.h
@@ -57,7 +57,7 @@ public:
      * A flag indicating whether a UNLModify Tx is to disable or to re-enable
      * a validator.
      */
-    enum NegativeUNLModify {
+    enum class NegativeUNLModify {
         ToDisable,  // UNLModify Tx is to disable a validator
         ToReEnable  // UNLModify Tx is to re-enable a validator
     };
diff --git a/src/xrpld/app/misc/NetworkOPs.cpp b/src/xrpld/app/misc/NetworkOPs.cpp
index 8de65d8b39..964a51e15e 100644
--- a/src/xrpld/app/misc/NetworkOPs.cpp
+++ b/src/xrpld/app/misc/NetworkOPs.cpp
@@ -257,7 +257,7 @@ class NetworkOPsImp final : public NetworkOPs
         CounterData
         getCounterData() const
         {
-            std::lock_guard const lock(mutex_);
+            std::scoped_lock const lock(mutex_);
             return {
                 .counters = counters_,
                 .mode = mode_,
@@ -809,6 +809,8 @@ private:
 
     SubAccountHistoryMapType mSubAccountHistory;
 
+    // Used as array indices; converting to enum class would require casts at ~40 call sites.
+    // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
     enum SubTypes {
         sLedger,          // Accepted ledgers.
         sManifests,       // Received validator manifests.
@@ -1261,7 +1263,7 @@ NetworkOPsImp::preProcessTransaction(std::shared_ptr<Transaction>& transaction)
     {
         // cached bad
         JLOG(m_journal.warn()) << transaction->getID() << ": cached bad!\n";
-        transaction->setStatus(INVALID);
+        transaction->setStatus(TransStatus::INVALID);
         transaction->setResult(temBAD_SIGNATURE);
         return false;
     }
@@ -1274,7 +1276,7 @@ NetworkOPsImp::preProcessTransaction(std::shared_ptr<Transaction>& transaction)
     auto const sttx = *transaction->getSTransaction();
     if (sttx.isFlag(tfInnerBatchTxn) && view->rules().enabled(featureBatch))
     {
-        transaction->setStatus(INVALID);
+        transaction->setStatus(TransStatus::INVALID);
         transaction->setResult(temINVALID_FLAG);
         registry_.get().getHashRouter().setFlags(transaction->getID(), HashRouterFlags::BAD);
         return false;
@@ -1292,7 +1294,7 @@ NetworkOPsImp::preProcessTransaction(std::shared_ptr<Transaction>& transaction)
     if (validity == Validity::SigBad)
     {
         JLOG(m_journal.info()) << "Transaction has bad signature: " << reason;
-        transaction->setStatus(INVALID);
+        transaction->setStatus(TransStatus::INVALID);
         transaction->setResult(temBAD_SIGNATURE);
         registry_.get().getHashRouter().setFlags(transaction->getID(), HashRouterFlags::BAD);
         return false;
@@ -1333,7 +1335,7 @@ NetworkOPsImp::doTransactionAsync(
     bool bUnlimited,
     FailHard failType)
 {
-    std::lock_guard const lock(mMutex);
+    std::scoped_lock const lock(mMutex);
 
     if (transaction->getApplying())
         return;
@@ -1408,7 +1410,7 @@ NetworkOPsImp::processTransactionSet(CanonicalTXSet const& set)
         std::string reason;
         auto transaction = std::make_shared<Transaction>(tx, reason, registry_.get().getApp());
 
-        if (transaction->getStatus() == INVALID)
+        if (transaction->getStatus() == TransStatus::INVALID)
         {
             if (!reason.empty())
             {
@@ -1559,7 +1561,7 @@ NetworkOPsImp::apply(std::unique_lock<std::mutex>& batchLock)
             if (isTesSuccess(e.result))
             {
                 JLOG(m_journal.debug()) << "Transaction is now included in open ledger";
-                e.transaction->setStatus(INCLUDED);
+                e.transaction->setStatus(TransStatus::INCLUDED);
 
                 // Pop as many "reasonable" transactions for this account as
                 // possible. "Reasonable" means they have sequential sequence
@@ -1588,14 +1590,14 @@ NetworkOPsImp::apply(std::unique_lock<std::mutex>& batchLock)
             {
                 // duplicate or conflict
                 JLOG(m_journal.info()) << "Transaction is obsolete";
-                e.transaction->setStatus(OBSOLETE);
+                e.transaction->setStatus(TransStatus::OBSOLETE);
             }
             else if (e.result == terQUEUED)
             {
                 JLOG(m_journal.debug()) << "Transaction is likely to claim a"
                                         << " fee, but is queued until fee drops";
 
-                e.transaction->setStatus(HELD);
+                e.transaction->setStatus(TransStatus::HELD);
                 // Add to held transactions, because it could get
                 // kicked out of the queue, and this will try to
                 // put it back.
@@ -1634,7 +1636,7 @@ NetworkOPsImp::apply(std::unique_lock<std::mutex>& batchLock)
                     {
                         // transaction should be held
                         JLOG(m_journal.debug()) << "Transaction should be held: " << e.result;
-                        e.transaction->setStatus(HELD);
+                        e.transaction->setStatus(TransStatus::HELD);
                         m_ledgerMaster.addHeldTransaction(e.transaction);
                         e.transaction->setKept();
                     }
@@ -1649,7 +1651,7 @@ NetworkOPsImp::apply(std::unique_lock<std::mutex>& batchLock)
             else
             {
                 JLOG(m_journal.debug()) << "Status other than success " << e.result;
-                e.transaction->setStatus(INVALID);
+                e.transaction->setStatus(TransStatus::INVALID);
             }
 
             auto const enforceFailHard = e.failType == FailHard::yes && !isTesSuccess(e.result);
@@ -2190,7 +2192,7 @@ void
 NetworkOPsImp::pubManifest(Manifest const& mo)
 {
     // VFALCO consider std::shared_mutex
-    std::lock_guard const sl(mSubLock);
+    std::scoped_lock const sl(mSubLock);
 
     if (!mStreamMaps[sManifests].empty())
     {
@@ -2268,7 +2270,7 @@ NetworkOPsImp::pubServer()
     //             list into a local array while holding the lock then release
     //             the lock and call send on everyone.
     //
-    std::lock_guard const sl(mSubLock);
+    std::scoped_lock const sl(mSubLock);
 
     if (!mStreamMaps[sServer].empty())
     {
@@ -2327,7 +2329,7 @@ NetworkOPsImp::pubServer()
 void
 NetworkOPsImp::pubConsensus(ConsensusPhase phase)
 {
-    std::lock_guard const sl(mSubLock);
+    std::scoped_lock const sl(mSubLock);
 
     auto& streamMap = mStreamMaps[sConsensusPhase];
     if (!streamMap.empty())
@@ -2355,7 +2357,7 @@ void
 NetworkOPsImp::pubValidation(std::shared_ptr<STValidation> const& val)
 {
     // VFALCO consider std::shared_mutex
-    std::lock_guard const sl(mSubLock);
+    std::scoped_lock const sl(mSubLock);
 
     if (!mStreamMaps[sValidations].empty())
     {
@@ -2460,7 +2462,7 @@ NetworkOPsImp::pubValidation(std::shared_ptr<STValidation> const& val)
 void
 NetworkOPsImp::pubPeerStatus(std::function<Json::Value(void)> const& func)
 {
-    std::lock_guard const sl(mSubLock);
+    std::scoped_lock const sl(mSubLock);
 
     if (!mStreamMaps[sPeerStatus].empty())
     {
@@ -3017,7 +3019,7 @@ NetworkOPsImp::pubProposedTransaction(
     MultiApiJson jvObj = transJson(transaction, result, false, ledger, std::nullopt);
 
     {
-        std::lock_guard const sl(mSubLock);
+        std::scoped_lock const sl(mSubLock);
 
         auto it = mStreamMaps[sRTTransactions].begin();
         while (it != mStreamMaps[sRTTransactions].end())
@@ -3064,7 +3066,7 @@ NetworkOPsImp::pubLedger(std::shared_ptr<ReadView const> const& lpAccepted)
         JLOG(m_journal.debug()) << "Publishing ledger " << lpAccepted->header().seq << " "
                                 << lpAccepted->header().hash;
 
-        std::lock_guard const sl(mSubLock);
+        std::scoped_lock const sl(mSubLock);
 
         if (!mStreamMaps[sLedger].empty())
         {
@@ -3267,8 +3269,8 @@ NetworkOPsImp::transJson(
                 *ledger,
                 account,
                 amount,
-                fhIGNORE_FREEZE,
-                ahIGNORE_AUTH,
+                FreezeHandling::fhIGNORE_FREEZE,
+                AuthHandling::ahIGNORE_AUTH,
                 registry_.get().getJournal("View"));
             jvObj[jss::transaction][jss::owner_funds] = ownerFunds.getText();
         }
@@ -3309,7 +3311,7 @@ NetworkOPsImp::pubValidatedTransaction(
     MultiApiJson jvObj = transJson(stTxn, trResult, true, ledger, metaRef);
 
     {
-        std::lock_guard const sl(mSubLock);
+        std::scoped_lock const sl(mSubLock);
 
         auto it = mStreamMaps[sTransactions].begin();
         while (it != mStreamMaps[sTransactions].end())
@@ -3368,7 +3370,7 @@ NetworkOPsImp::pubAccountTransaction(
     std::vector<SubAccountHistoryInfo> accountHistoryNotify;
     auto const currLedgerSeq = ledger->seq();
     {
-        std::lock_guard const sl(mSubLock);
+        std::scoped_lock const sl(mSubLock);
 
         if (!mSubAccount.empty() || !mSubRTAccount.empty() || !mSubAccountHistory.empty())
         {
@@ -3471,7 +3473,7 @@ NetworkOPsImp::pubAccountTransaction(
             jvObj.set(jss::account_history_boundary, true);
 
         XRPL_ASSERT(
-            jvObj.isMember(jss::account_history_tx_stream) == MultiApiJson::none,
+            jvObj.isMember(jss::account_history_tx_stream) == MultiApiJson::IsMemberResult::none,
             "xrpl::NetworkOPsImp::pubAccountTransaction : "
             "account_history_tx_stream not set");
         for (auto& info : accountHistoryNotify)
@@ -3501,7 +3503,7 @@ NetworkOPsImp::pubProposedAccountTransaction(
     std::vector<SubAccountHistoryInfo> accountHistoryNotify;
 
     {
-        std::lock_guard const sl(mSubLock);
+        std::scoped_lock const sl(mSubLock);
 
         if (mSubRTAccount.empty())
             return;
@@ -3550,7 +3552,7 @@ NetworkOPsImp::pubProposedAccountTransaction(
         }
 
         XRPL_ASSERT(
-            jvObj.isMember(jss::account_history_tx_stream) == MultiApiJson::none,
+            jvObj.isMember(jss::account_history_tx_stream) == MultiApiJson::IsMemberResult::none,
             "xrpl::NetworkOPs::pubProposedAccountTransaction : "
             "account_history_tx_stream not set");
         for (auto& info : accountHistoryNotify)
@@ -3585,7 +3587,7 @@ NetworkOPsImp::subAccount(
         isrListener->insertSubAccountInfo(naAccountID, rt);
     }
 
-    std::lock_guard const sl(mSubLock);
+    std::scoped_lock const sl(mSubLock);
 
     for (auto const& naAccountID : vnaAccountIDs)
     {
@@ -3628,7 +3630,7 @@ NetworkOPsImp::unsubAccountInternal(
     hash_set<AccountID> const& vnaAccountIDs,
     bool rt)
 {
-    std::lock_guard const sl(mSubLock);
+    std::scoped_lock const sl(mSubLock);
 
     SubInfoMapType& subMap = rt ? mSubRTAccount : mSubAccount;
 
@@ -3934,7 +3936,7 @@ NetworkOPsImp::subAccountHistory(InfoSub::ref isrListener, AccountID const& acco
         return rpcINVALID_PARAMS;
     }
 
-    std::lock_guard const sl(mSubLock);
+    std::scoped_lock const sl(mSubLock);
     SubAccountHistoryInfoWeak ahi{
         .sinkWptr_ = isrListener, .index_ = std::make_shared<SubAccountHistoryIndex>(accountId)};
     auto simIterator = mSubAccountHistory.find(accountId);
@@ -3982,7 +3984,7 @@ NetworkOPsImp::unsubAccountHistoryInternal(
     AccountID const& account,
     bool historyOnly)
 {
-    std::lock_guard const sl(mSubLock);
+    std::scoped_lock const sl(mSubLock);
     auto simIterator = mSubAccountHistory.find(account);
     if (simIterator != mSubAccountHistory.end())
     {
@@ -4071,7 +4073,7 @@ NetworkOPsImp::subLedger(InfoSub::ref isrListener, Json::Value& jvResult)
         jvResult[jss::validated_ledgers] = registry_.get().getLedgerMaster().getCompleteLedgers();
     }
 
-    std::lock_guard const sl(mSubLock);
+    std::scoped_lock const sl(mSubLock);
     return mStreamMaps[sLedger].emplace(isrListener->getSeq(), isrListener).second;
 }
 
@@ -4079,7 +4081,7 @@ NetworkOPsImp::subLedger(InfoSub::ref isrListener, Json::Value& jvResult)
 bool
 NetworkOPsImp::subBookChanges(InfoSub::ref isrListener)
 {
-    std::lock_guard const sl(mSubLock);
+    std::scoped_lock const sl(mSubLock);
     return mStreamMaps[sBookChanges].emplace(isrListener->getSeq(), isrListener).second;
 }
 
@@ -4087,7 +4089,7 @@ NetworkOPsImp::subBookChanges(InfoSub::ref isrListener)
 bool
 NetworkOPsImp::unsubLedger(std::uint64_t uSeq)
 {
-    std::lock_guard const sl(mSubLock);
+    std::scoped_lock const sl(mSubLock);
     return mStreamMaps[sLedger].erase(uSeq) != 0u;
 }
 
@@ -4095,7 +4097,7 @@ NetworkOPsImp::unsubLedger(std::uint64_t uSeq)
 bool
 NetworkOPsImp::unsubBookChanges(std::uint64_t uSeq)
 {
-    std::lock_guard const sl(mSubLock);
+    std::scoped_lock const sl(mSubLock);
     return mStreamMaps[sBookChanges].erase(uSeq) != 0u;
 }
 
@@ -4103,7 +4105,7 @@ NetworkOPsImp::unsubBookChanges(std::uint64_t uSeq)
 bool
 NetworkOPsImp::subManifests(InfoSub::ref isrListener)
 {
-    std::lock_guard const sl(mSubLock);
+    std::scoped_lock const sl(mSubLock);
     return mStreamMaps[sManifests].emplace(isrListener->getSeq(), isrListener).second;
 }
 
@@ -4111,7 +4113,7 @@ NetworkOPsImp::subManifests(InfoSub::ref isrListener)
 bool
 NetworkOPsImp::unsubManifests(std::uint64_t uSeq)
 {
-    std::lock_guard const sl(mSubLock);
+    std::scoped_lock const sl(mSubLock);
     return mStreamMaps[sManifests].erase(uSeq) != 0u;
 }
 
@@ -4136,7 +4138,7 @@ NetworkOPsImp::subServer(InfoSub::ref isrListener, Json::Value& jvResult, bool a
     jvResult[jss::pubkey_node] =
         toBase58(TokenType::NodePublic, registry_.get().getApp().nodeIdentity().first);
 
-    std::lock_guard const sl(mSubLock);
+    std::scoped_lock const sl(mSubLock);
     return mStreamMaps[sServer].emplace(isrListener->getSeq(), isrListener).second;
 }
 
@@ -4144,7 +4146,7 @@ NetworkOPsImp::subServer(InfoSub::ref isrListener, Json::Value& jvResult, bool a
 bool
 NetworkOPsImp::unsubServer(std::uint64_t uSeq)
 {
-    std::lock_guard const sl(mSubLock);
+    std::scoped_lock const sl(mSubLock);
     return mStreamMaps[sServer].erase(uSeq) != 0u;
 }
 
@@ -4152,7 +4154,7 @@ NetworkOPsImp::unsubServer(std::uint64_t uSeq)
 bool
 NetworkOPsImp::subTransactions(InfoSub::ref isrListener)
 {
-    std::lock_guard const sl(mSubLock);
+    std::scoped_lock const sl(mSubLock);
     return mStreamMaps[sTransactions].emplace(isrListener->getSeq(), isrListener).second;
 }
 
@@ -4160,7 +4162,7 @@ NetworkOPsImp::subTransactions(InfoSub::ref isrListener)
 bool
 NetworkOPsImp::unsubTransactions(std::uint64_t uSeq)
 {
-    std::lock_guard const sl(mSubLock);
+    std::scoped_lock const sl(mSubLock);
     return mStreamMaps[sTransactions].erase(uSeq) != 0u;
 }
 
@@ -4168,7 +4170,7 @@ NetworkOPsImp::unsubTransactions(std::uint64_t uSeq)
 bool
 NetworkOPsImp::subRTTransactions(InfoSub::ref isrListener)
 {
-    std::lock_guard const sl(mSubLock);
+    std::scoped_lock const sl(mSubLock);
     return mStreamMaps[sRTTransactions].emplace(isrListener->getSeq(), isrListener).second;
 }
 
@@ -4176,7 +4178,7 @@ NetworkOPsImp::subRTTransactions(InfoSub::ref isrListener)
 bool
 NetworkOPsImp::unsubRTTransactions(std::uint64_t uSeq)
 {
-    std::lock_guard const sl(mSubLock);
+    std::scoped_lock const sl(mSubLock);
     return mStreamMaps[sRTTransactions].erase(uSeq) != 0u;
 }
 
@@ -4184,7 +4186,7 @@ NetworkOPsImp::unsubRTTransactions(std::uint64_t uSeq)
 bool
 NetworkOPsImp::subValidations(InfoSub::ref isrListener)
 {
-    std::lock_guard const sl(mSubLock);
+    std::scoped_lock const sl(mSubLock);
     return mStreamMaps[sValidations].emplace(isrListener->getSeq(), isrListener).second;
 }
 
@@ -4198,7 +4200,7 @@ NetworkOPsImp::stateAccounting(Json::Value& obj)
 bool
 NetworkOPsImp::unsubValidations(std::uint64_t uSeq)
 {
-    std::lock_guard const sl(mSubLock);
+    std::scoped_lock const sl(mSubLock);
     return mStreamMaps[sValidations].erase(uSeq) != 0u;
 }
 
@@ -4206,7 +4208,7 @@ NetworkOPsImp::unsubValidations(std::uint64_t uSeq)
 bool
 NetworkOPsImp::subPeerStatus(InfoSub::ref isrListener)
 {
-    std::lock_guard const sl(mSubLock);
+    std::scoped_lock const sl(mSubLock);
     return mStreamMaps[sPeerStatus].emplace(isrListener->getSeq(), isrListener).second;
 }
 
@@ -4214,7 +4216,7 @@ NetworkOPsImp::subPeerStatus(InfoSub::ref isrListener)
 bool
 NetworkOPsImp::unsubPeerStatus(std::uint64_t uSeq)
 {
-    std::lock_guard const sl(mSubLock);
+    std::scoped_lock const sl(mSubLock);
     return mStreamMaps[sPeerStatus].erase(uSeq) != 0u;
 }
 
@@ -4222,7 +4224,7 @@ NetworkOPsImp::unsubPeerStatus(std::uint64_t uSeq)
 bool
 NetworkOPsImp::subConsensus(InfoSub::ref isrListener)
 {
-    std::lock_guard const sl(mSubLock);
+    std::scoped_lock const sl(mSubLock);
     return mStreamMaps[sConsensusPhase].emplace(isrListener->getSeq(), isrListener).second;
 }
 
@@ -4230,14 +4232,14 @@ NetworkOPsImp::subConsensus(InfoSub::ref isrListener)
 bool
 NetworkOPsImp::unsubConsensus(std::uint64_t uSeq)
 {
-    std::lock_guard const sl(mSubLock);
+    std::scoped_lock const sl(mSubLock);
     return mStreamMaps[sConsensusPhase].erase(uSeq) != 0u;
 }
 
 InfoSub::pointer
 NetworkOPsImp::findRpcSub(std::string const& strUrl)
 {
-    std::lock_guard const sl(mSubLock);
+    std::scoped_lock const sl(mSubLock);
 
     subRpcMapType::iterator const it = mRpcSubMap.find(strUrl);
 
@@ -4250,7 +4252,7 @@ NetworkOPsImp::findRpcSub(std::string const& strUrl)
 InfoSub::pointer
 NetworkOPsImp::addRpcSub(std::string const& strUrl, InfoSub::ref rspEntry)
 {
-    std::lock_guard const sl(mSubLock);
+    std::scoped_lock const sl(mSubLock);
 
     mRpcSubMap.emplace(strUrl, rspEntry);
 
@@ -4260,7 +4262,7 @@ NetworkOPsImp::addRpcSub(std::string const& strUrl, InfoSub::ref rspEntry)
 bool
 NetworkOPsImp::tryRemoveRpcSub(std::string const& strUrl)
 {
-    std::lock_guard const sl(mSubLock);
+    std::scoped_lock const sl(mSubLock);
     auto pInfo = findRpcSub(strUrl);
 
     if (!pInfo)
@@ -4400,8 +4402,8 @@ NetworkOPsImp::getBookPage(
                             view,
                             uOfferOwnerID,
                             book.out,
-                            fhZERO_IF_FROZEN,
-                            ahZERO_IF_UNAUTHORIZED,
+                            FreezeHandling::fhZERO_IF_FROZEN,
+                            AuthHandling::ahZERO_IF_UNAUTHORIZED,
                             viewJ);
 
                         if (saOwnerFunds < beast::zero)
@@ -4545,7 +4547,10 @@ NetworkOPsImp::getBookPage(
                     // Did not find balance in table.
 
                     saOwnerFunds = lesActive.accountHolds(
-                        uOfferOwnerID, book.out.currency, book.out.account, fhZERO_IF_FROZEN);
+                        uOfferOwnerID,
+                        book.out.currency,
+                        book.out.account,
+                        FreezeHandling::fhZERO_IF_FROZEN);
 
                     if (saOwnerFunds.isNegative())
                     {
@@ -4621,7 +4626,7 @@ NetworkOPsImp::collect_metrics()
         std::chrono::steady_clock::now() - start);
     counters[static_cast<std::size_t>(mode)].dur += current;
 
-    std::lock_guard const lock(m_statsMutex);
+    std::scoped_lock const lock(m_statsMutex);
     m_stats.disconnected_duration.set(
         counters[static_cast<std::size_t>(OperatingMode::DISCONNECTED)].dur.count());
     m_stats.connected_duration.set(
@@ -4649,7 +4654,7 @@ NetworkOPsImp::StateAccounting::mode(OperatingMode om)
 {
     auto now = std::chrono::steady_clock::now();
 
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     ++counters_[static_cast<std::size_t>(om)].transitions;
     if (om == OperatingMode::FULL && counters_[static_cast<std::size_t>(om)].transitions == 1)
     {
diff --git a/src/xrpld/app/misc/SHAMapStoreImp.cpp b/src/xrpld/app/misc/SHAMapStoreImp.cpp
index 518d9f6b14..3a6cb1742d 100644
--- a/src/xrpld/app/misc/SHAMapStoreImp.cpp
+++ b/src/xrpld/app/misc/SHAMapStoreImp.cpp
@@ -45,14 +45,14 @@ namespace xrpl {
 void
 SHAMapStoreImp::SavedStateDB::init(BasicConfig const& config, std::string const& dbName)
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     initStateDB(sqlDb_, config, dbName);
 }
 
 LedgerIndex
 SHAMapStoreImp::SavedStateDB::getCanDelete()
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
 
     return xrpl::getCanDelete(sqlDb_);
 }
@@ -60,7 +60,7 @@ SHAMapStoreImp::SavedStateDB::getCanDelete()
 LedgerIndex
 SHAMapStoreImp::SavedStateDB::setCanDelete(LedgerIndex canDelete)
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
 
     return xrpl::setCanDelete(sqlDb_, canDelete);
 }
@@ -68,7 +68,7 @@ SHAMapStoreImp::SavedStateDB::setCanDelete(LedgerIndex canDelete)
 SavedState
 SHAMapStoreImp::SavedStateDB::getState()
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
 
     return xrpl::getSavedState(sqlDb_);
 }
@@ -76,14 +76,14 @@ SHAMapStoreImp::SavedStateDB::getState()
 void
 SHAMapStoreImp::SavedStateDB::setState(SavedState const& state)
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     xrpl::setSavedState(sqlDb_, state);
 }
 
 void
 SHAMapStoreImp::SavedStateDB::setLastRotated(LedgerIndex seq)
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     xrpl::setLastRotated(sqlDb_, seq);
 }
 
@@ -209,7 +209,7 @@ void
 SHAMapStoreImp::onLedgerClosed(std::shared_ptr<Ledger const> const& ledger)
 {
     {
-        std::lock_guard const lock(mutex_);
+        std::scoped_lock const lock(mutex_);
         newLedger_ = ledger;
         working_ = true;
     }
@@ -240,7 +240,7 @@ SHAMapStoreImp::copyNode(std::uint64_t& nodeCount, SHAMapTreeNode const& node)
         node.getHash().as_uint256(), 0, NodeStore::FetchType::synchronous, true);
     if ((++nodeCount % checkHealthInterval_) == 0u)
     {
-        if (healthWait() == stopping)
+        if (healthWait() == HealthResult::stopping)
             return false;
     }
 
@@ -290,7 +290,7 @@ SHAMapStoreImp::run()
         }
 
         bool const readyToRotate = validatedSeq >= lastRotated + deleteInterval_ &&
-            canDelete_ >= lastRotated - 1 && healthWait() == keepGoing;
+            canDelete_ >= lastRotated - 1 && healthWait() == HealthResult::keepGoing;
 
         // will delete up to (not including) lastRotated
         if (readyToRotate)
@@ -302,7 +302,7 @@ SHAMapStoreImp::run()
                                   << ledgerMaster_->getValidatedLedgerAge().count() << 's';
 
             clearPrior(lastRotated);
-            if (healthWait() == stopping)
+            if (healthWait() == HealthResult::stopping)
                 return;
 
             JLOG(journal_.debug()) << "copying ledger " << validatedSeq;
@@ -324,7 +324,7 @@ SHAMapStoreImp::run()
                 continue;
             }
 
-            if (healthWait() == stopping)
+            if (healthWait() == HealthResult::stopping)
                 return;
             // Only log if we completed without a "health" abort
             JLOG(journal_.debug())
@@ -332,7 +332,7 @@ SHAMapStoreImp::run()
 
             JLOG(journal_.debug()) << "freshening caches";
             freshenCaches();
-            if (healthWait() == stopping)
+            if (healthWait() == HealthResult::stopping)
                 return;
             // Only log if we completed without a "health" abort
             JLOG(journal_.debug()) << validatedSeq << " freshened caches";
@@ -342,7 +342,7 @@ SHAMapStoreImp::run()
             JLOG(journal_.debug()) << validatedSeq << " new backend " << newBackend->getName();
 
             clearCaches(validatedSeq);
-            if (healthWait() == stopping)
+            if (healthWait() == HealthResult::stopping)
                 return;
 
             lastRotated = validatedSeq;
@@ -506,7 +506,7 @@ SHAMapStoreImp::clearSql(
         min = *m;
     }
 
-    if (min > lastRotated || healthWait() == stopping)
+    if (min > lastRotated || healthWait() == HealthResult::stopping)
         return;
     if (min == lastRotated)
     {
@@ -525,11 +525,11 @@ SHAMapStoreImp::clearSql(
         deleteBeforeSeq(min);
         JLOG(journal_.trace()) << "End: Delete up to " << deleteBatch_ << " rows with LedgerSeq < "
                                << min << " from: " << TableName;
-        if (healthWait() == stopping)
+        if (healthWait() == HealthResult::stopping)
             return;
         if (min < lastRotated)
             std::this_thread::sleep_for(backOff_);
-        if (healthWait() == stopping)
+        if (healthWait() == HealthResult::stopping)
             return;
     }
     JLOG(journal_.debug()) << "finished deleting from: " << TableName;
@@ -563,7 +563,7 @@ SHAMapStoreImp::clearPrior(LedgerIndex lastRotated)
     JLOG(journal_.trace()) << "Begin: Clear internal ledgers up to " << lastRotated;
     ledgerMaster_->clearPriorLedgers(lastRotated);
     JLOG(journal_.trace()) << "End: Clear internal ledgers up to " << lastRotated;
-    if (healthWait() == stopping)
+    if (healthWait() == HealthResult::stopping)
         return;
 
     auto& db = app_.getRelationalDatabase();
@@ -573,7 +573,7 @@ SHAMapStoreImp::clearPrior(LedgerIndex lastRotated)
         "Ledgers",
         [&db]() -> std::optional<LedgerIndex> { return db.getMinLedgerSeq(); },
         [&db](LedgerIndex min) -> void { db.deleteBeforeLedgerSeq(min); });
-    if (healthWait() == stopping)
+    if (healthWait() == HealthResult::stopping)
         return;
 
     if (!app_.config().useTxTables())
@@ -584,7 +584,7 @@ SHAMapStoreImp::clearPrior(LedgerIndex lastRotated)
         "Transactions",
         [&db]() -> std::optional<LedgerIndex> { return db.getTransactionsMinLedgerSeq(); },
         [&db](LedgerIndex min) -> void { db.deleteTransactionsBeforeLedgerSeq(min); });
-    if (healthWait() == stopping)
+    if (healthWait() == HealthResult::stopping)
         return;
 
     clearSql(
@@ -592,7 +592,7 @@ SHAMapStoreImp::clearPrior(LedgerIndex lastRotated)
         "AccountTransactions",
         [&db]() -> std::optional<LedgerIndex> { return db.getAccountTransactionsMinLedgerSeq(); },
         [&db](LedgerIndex min) -> void { db.deleteAccountTransactionsBeforeLedgerSeq(min); });
-    if (healthWait() == stopping)
+    if (healthWait() == HealthResult::stopping)
         return;
 }
 
@@ -615,7 +615,7 @@ SHAMapStoreImp::healthWait()
         lock.lock();
     }
 
-    return stop_ ? stopping : keepGoing;
+    return stop_ ? HealthResult::stopping : HealthResult::keepGoing;
 }
 
 void
@@ -624,7 +624,7 @@ SHAMapStoreImp::stop()
     if (thread_.joinable())
     {
         {
-            std::lock_guard const lock(mutex_);
+            std::scoped_lock const lock(mutex_);
             stop_ = true;
             cond_.notify_one();
         }
diff --git a/src/xrpld/app/misc/SHAMapStoreImp.h b/src/xrpld/app/misc/SHAMapStoreImp.h
index 08e3dd70eb..22cb06c0e4 100644
--- a/src/xrpld/app/misc/SHAMapStoreImp.h
+++ b/src/xrpld/app/misc/SHAMapStoreImp.h
@@ -170,7 +170,7 @@ private:
         for (auto const& key : cache.getKeys())
         {
             dbRotating_->fetchNodeObject(key, 0, NodeStore::FetchType::synchronous, true);
-            if (!(++check % checkHealthInterval_) && healthWait() == stopping)
+            if (!(++check % checkHealthInterval_) && healthWait() == HealthResult::stopping)
                 return true;
         }
 
@@ -201,7 +201,7 @@ private:
      *
      * @return Whether the server is stopping.
      */
-    enum HealthResult { stopping, keepGoing };
+    enum class HealthResult { stopping, keepGoing };
     [[nodiscard]] HealthResult
     healthWait();
 
diff --git a/src/xrpld/app/misc/Transaction.h b/src/xrpld/app/misc/Transaction.h
index 40e0a3d10d..43ef2094fe 100644
--- a/src/xrpld/app/misc/Transaction.h
+++ b/src/xrpld/app/misc/Transaction.h
@@ -23,7 +23,7 @@ namespace xrpl {
 class Application;
 class Rules;
 
-enum TransStatus {
+enum class TransStatus {
     NEW = 0,         // just received / generated
     INVALID = 1,     // no valid signature, insufficient funds
     INCLUDED = 2,    // added to the current ledger
@@ -369,7 +369,7 @@ private:
     LedgerIndex mLedgerIndex = 0;
     std::optional<uint32_t> mTxnSeq;
     std::optional<uint32_t> mNetworkID;
-    TransStatus mStatus = INVALID;
+    TransStatus mStatus = TransStatus::INVALID;
     TER mResult = temUNCERTAIN;
     /* Note that all access to mApplying are made by NetworkOPsImp,
         and must be done under that class's lock. This avoids the overhead of
diff --git a/src/xrpld/app/misc/TxQ.h b/src/xrpld/app/misc/TxQ.h
index ce32755db1..c3dddd12ba 100644
--- a/src/xrpld/app/misc/TxQ.h
+++ b/src/xrpld/app/misc/TxQ.h
@@ -344,7 +344,7 @@ private:
     SeqProxy
     nextQueuableSeqImpl(
         std::shared_ptr<SLE const> const& sleAccount,
-        std::lock_guard<std::mutex> const&) const;
+        std::scoped_lock<std::mutex> const&) const;
 
     /**
         Track and use the fee escalation metrics of the
@@ -701,7 +701,7 @@ private:
         OpenView& view,
         ApplyFlags flags,
         FeeMetrics::Snapshot const& metricsSnapshot,
-        std::lock_guard<std::mutex> const& lock);
+        std::scoped_lock<std::mutex> const& lock);
 
     // Helper function for TxQ::apply.  If a transaction's fee is high enough,
     // attempt to directly apply that transaction to the ledger.
@@ -785,7 +785,7 @@ private:
         std::shared_ptr<SLE const> const& sleAccount,
         AccountMap::iterator const&,
         std::optional<TxQAccount::TxMap::iterator> const&,
-        std::lock_guard<std::mutex> const& lock);
+        std::scoped_lock<std::mutex> const& lock);
 
     /// Erase and return the next entry in byFee_ (lower fee level)
     FeeMultiSet::iterator_type erase(FeeMultiSet::const_iterator_type);
diff --git a/src/xrpld/app/misc/ValidatorList.h b/src/xrpld/app/misc/ValidatorList.h
index 2c7900465c..ee6f14ed4c 100644
--- a/src/xrpld/app/misc/ValidatorList.h
+++ b/src/xrpld/app/misc/ValidatorList.h
@@ -207,7 +207,7 @@ class ValidatorList
     boost::filesystem::path const dataPath_;
     beast::Journal const j_;
     std::shared_mutex mutable mutex_;
-    using lock_guard = std::lock_guard<decltype(mutex_)>;
+    using scoped_lock = std::scoped_lock<decltype(mutex_)>;
     using shared_lock = std::shared_lock<decltype(mutex_)>;
 
     std::atomic<std::size_t> quorum_;
@@ -759,7 +759,7 @@ private:
         std::uint32_t version,
         std::string siteUri,
         std::optional<uint256> const& hash,
-        lock_guard const&);
+        scoped_lock const&);
 
     // This function updates the keyListings_ counts for all the trusted
     // master keys
@@ -768,7 +768,7 @@ private:
         PublicKey const& pubKey,
         PublisherList const& current,
         std::vector<PublicKey> const& oldList,
-        lock_guard const&);
+        scoped_lock const&);
 
     static void
     buildBlobInfos(
@@ -804,7 +804,7 @@ private:
     /** Get the filename used for caching UNLs
      */
     boost::filesystem::path
-    getCacheFileName(lock_guard const&, PublicKey const& pubKey) const;
+    getCacheFileName(scoped_lock const&, PublicKey const& pubKey) const;
 
     /** Build a Json representation of the collection, suitable for
         writing to a cache file, or serving to a /vl/ query
@@ -836,7 +836,7 @@ private:
     /** Write a JSON UNL to a cache file
      */
     void
-    cacheValidatorFile(lock_guard const& lock, PublicKey const& pubKey) const;
+    cacheValidatorFile(scoped_lock const& lock, PublicKey const& pubKey) const;
 
     /** Check response for trusted valid published list
 
@@ -848,7 +848,7 @@ private:
     */
     std::pair<ListDisposition, std::optional<PublicKey>>
     verify(
-        lock_guard const&,
+        scoped_lock const&,
         Json::Value& list,
         Manifest manifest,
         std::string const& blob,
@@ -865,7 +865,7 @@ private:
         Calling public member function is expected to lock mutex
     */
     bool
-    removePublisherList(lock_guard const&, PublicKey const& publisherKey, PublisherStatus reason);
+    removePublisherList(scoped_lock const&, PublicKey const& publisherKey, PublisherStatus reason);
 
     /** Return quorum for trusted validator set
 
diff --git a/src/xrpld/app/misc/ValidatorSite.h b/src/xrpld/app/misc/ValidatorSite.h
index ab82ae168d..308b8f72bc 100644
--- a/src/xrpld/app/misc/ValidatorSite.h
+++ b/src/xrpld/app/misc/ValidatorSite.h
@@ -177,12 +177,12 @@ public:
 private:
     /// Load configured site URIs.
     bool
-    load(std::vector<std::string> const& siteURIs, std::lock_guard<std::mutex> const&);
+    load(std::vector<std::string> const& siteURIs, std::scoped_lock<std::mutex> const&);
 
     /// Queue next site to be fetched
     /// lock over site_mutex_ and state_mutex_ required
     void
-    setTimer(std::lock_guard<std::mutex> const&, std::lock_guard<std::mutex> const&);
+    setTimer(std::scoped_lock<std::mutex> const&, std::scoped_lock<std::mutex> const&);
 
     /// request took too long
     void
@@ -210,7 +210,7 @@ private:
     makeRequest(
         std::shared_ptr<Site::Resource> resource,
         std::size_t siteIdx,
-        std::lock_guard<std::mutex> const&);
+        std::scoped_lock<std::mutex> const&);
 
     /// Parse json response from validator list site.
     /// lock over sites_mutex_ required
@@ -218,7 +218,7 @@ private:
     parseJsonResponse(
         std::string const& res,
         std::size_t siteIdx,
-        std::lock_guard<std::mutex> const&);
+        std::scoped_lock<std::mutex> const&);
 
     /// Interpret a redirect response.
     /// lock over sites_mutex_ required
@@ -226,12 +226,12 @@ private:
     processRedirect(
         detail::response_type const& res,
         std::size_t siteIdx,
-        std::lock_guard<std::mutex> const&);
+        std::scoped_lock<std::mutex> const&);
 
     /// If no sites are provided, or a site fails to load,
     /// get a list of local cache files from the ValidatorList.
     bool
-    missingSite(std::lock_guard<std::mutex> const&);
+    missingSite(std::scoped_lock<std::mutex> const&);
 };
 
 }  // namespace xrpl
diff --git a/src/xrpld/app/misc/detail/AmendmentTable.cpp b/src/xrpld/app/misc/detail/AmendmentTable.cpp
index 65342dac2f..1eee034a16 100644
--- a/src/xrpld/app/misc/detail/AmendmentTable.cpp
+++ b/src/xrpld/app/misc/detail/AmendmentTable.cpp
@@ -126,7 +126,7 @@ public:
     //
     // Call with AmendmentTable::mutex_ locked.
     void
-    trustChanged(hash_set<PublicKey> const& allTrusted, std::lock_guard<std::mutex> const& lock)
+    trustChanged(hash_set<PublicKey> const& allTrusted, std::scoped_lock<std::mutex> const& lock)
     {
         decltype(recordedVotes_) newRecordedVotes;
         newRecordedVotes.reserve(allTrusted.size());
@@ -162,7 +162,7 @@ public:
         std::vector<std::shared_ptr<STValidation>> const& valSet,
         NetClock::time_point const closeTime,
         beast::Journal j,
-        std::lock_guard<std::mutex> const& lock)
+        std::scoped_lock<std::mutex> const& lock)
     {
         // When we get an STValidation we save the upVotes it contains, but
         // we also set an expiration for those upVotes.  The following constant
@@ -259,7 +259,7 @@ public:
     //
     // Call with AmendmentTable::mutex_ locked.
     [[nodiscard]] std::pair<int, hash_map<uint256, int>>
-    getVotes(Rules const& rules, std::lock_guard<std::mutex> const& lock) const
+    getVotes(Rules const& rules, std::scoped_lock<std::mutex> const& lock) const
     {
         hash_map<uint256, int> ret;
         int available = 0;
@@ -319,7 +319,7 @@ public:
     AmendmentSet(
         Rules const& rules,
         TrustedVotes const& trustedVotes,
-        std::lock_guard<std::mutex> const& lock)
+        std::scoped_lock<std::mutex> const& lock)
     {
         // process validations for ledger before flag ledger.
         auto [trustedCount, newVotes] = trustedVotes.getVotes(rules, lock);
@@ -415,14 +415,14 @@ private:
 
     // Finds or creates state.  Must be called with mutex_ locked.
     AmendmentState&
-    add(uint256 const& amendment, std::lock_guard<std::mutex> const& lock);
+    add(uint256 const& amendment, std::scoped_lock<std::mutex> const& lock);
 
     // Finds existing state.  Must be called with mutex_ locked.
     AmendmentState*
-    get(uint256 const& amendment, std::lock_guard<std::mutex> const& lock);
+    get(uint256 const& amendment, std::scoped_lock<std::mutex> const& lock);
 
     AmendmentState const*
-    get(uint256 const& amendment, std::lock_guard<std::mutex> const& lock) const;
+    get(uint256 const& amendment, std::scoped_lock<std::mutex> const& lock) const;
 
     // Injects amendment json into v.  Must be called with mutex_ locked.
     void
@@ -431,7 +431,7 @@ private:
         uint256 const& amendment,
         AmendmentState const& state,
         bool isAdmin,
-        std::lock_guard<std::mutex> const& lock) const;
+        std::scoped_lock<std::mutex> const& lock) const;
 
     void
     persistVote(uint256 const& amendment, std::string const& name, AmendmentVote vote) const;
@@ -510,7 +510,7 @@ AmendmentTableImpl::AmendmentTableImpl(
     beast::Journal journal)
     : majorityTime_(majorityTime), j_(journal), db_(registry.getWalletDB())
 {
-    std::lock_guard lock(mutex_);
+    std::scoped_lock lock(mutex_);
 
     // Find out if the FeatureVotes table exists in WalletDB
     bool const featureVotesExist = [this]() {
@@ -633,21 +633,21 @@ AmendmentTableImpl::AmendmentTableImpl(
 }
 
 AmendmentState&
-AmendmentTableImpl::add(uint256 const& amendmentHash, std::lock_guard<std::mutex> const&)
+AmendmentTableImpl::add(uint256 const& amendmentHash, std::scoped_lock<std::mutex> const&)
 {
     // call with the mutex held
     return amendmentMap_[amendmentHash];
 }
 
 AmendmentState*
-AmendmentTableImpl::get(uint256 const& amendmentHash, std::lock_guard<std::mutex> const& lock)
+AmendmentTableImpl::get(uint256 const& amendmentHash, std::scoped_lock<std::mutex> const& lock)
 {
     // Forward to the const version of get.
     return const_cast<AmendmentState*>(std::as_const(*this).get(amendmentHash, lock));
 }
 
 AmendmentState const*
-AmendmentTableImpl::get(uint256 const& amendmentHash, std::lock_guard<std::mutex> const&) const
+AmendmentTableImpl::get(uint256 const& amendmentHash, std::scoped_lock<std::mutex> const&) const
 {
     // call with the mutex held
     auto ret = amendmentMap_.find(amendmentHash);
@@ -661,7 +661,7 @@ AmendmentTableImpl::get(uint256 const& amendmentHash, std::lock_guard<std::mutex
 uint256
 AmendmentTableImpl::find(std::string const& name) const
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
 
     for (auto const& e : amendmentMap_)
     {
@@ -688,7 +688,7 @@ AmendmentTableImpl::persistVote(
 bool
 AmendmentTableImpl::veto(uint256 const& amendment)
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     AmendmentState& s = add(amendment, lock);
 
     if (s.vote != AmendmentVote::up)
@@ -701,7 +701,7 @@ AmendmentTableImpl::veto(uint256 const& amendment)
 bool
 AmendmentTableImpl::unVeto(uint256 const& amendment)
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     AmendmentState* const s = get(amendment, lock);
 
     if ((s == nullptr) || s->vote != AmendmentVote::down)
@@ -714,7 +714,7 @@ AmendmentTableImpl::unVeto(uint256 const& amendment)
 bool
 AmendmentTableImpl::enable(uint256 const& amendment)
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     AmendmentState& s = add(amendment, lock);
 
     if (s.enabled)
@@ -734,7 +734,7 @@ AmendmentTableImpl::enable(uint256 const& amendment)
 bool
 AmendmentTableImpl::isEnabled(uint256 const& amendment) const
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     AmendmentState const* s = get(amendment, lock);
     return (s != nullptr) && s->enabled;
 }
@@ -742,7 +742,7 @@ AmendmentTableImpl::isEnabled(uint256 const& amendment) const
 bool
 AmendmentTableImpl::isSupported(uint256 const& amendment) const
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     AmendmentState const* s = get(amendment, lock);
     return (s != nullptr) && s->supported;
 }
@@ -750,14 +750,14 @@ AmendmentTableImpl::isSupported(uint256 const& amendment) const
 bool
 AmendmentTableImpl::hasUnsupportedEnabled() const
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     return unsupportedEnabled_;
 }
 
 std::optional<NetClock::time_point>
 AmendmentTableImpl::firstUnsupportedExpected() const
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     return firstUnsupportedExpected_;
 }
 
@@ -769,7 +769,7 @@ AmendmentTableImpl::doValidation(std::set<uint256> const& enabled) const
     std::vector<uint256> amendments;
 
     {
-        std::lock_guard const lock(mutex_);
+        std::scoped_lock const lock(mutex_);
         amendments.reserve(amendmentMap_.size());
         for (auto const& e : amendmentMap_)
         {
@@ -807,7 +807,7 @@ AmendmentTableImpl::doVoting(
                      << enabledAmendments.size() << ", " << majorityAmendments.size() << ", "
                      << valSet.size();
 
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
 
     // Keep a record of the votes we received.
     previousTrustedVotes_.recordVotes(rules, valSet, closeTime, j_, lock);
@@ -889,7 +889,7 @@ AmendmentTableImpl::doVoting(
 bool
 AmendmentTableImpl::needValidatedLedger(LedgerIndex ledgerSeq) const
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
 
     // Is there a ledger in which an amendment could have been enabled
     // between these two ledger sequences?
@@ -906,7 +906,7 @@ AmendmentTableImpl::doValidatedLedger(
     for (auto& e : enabled)
         enable(e);
 
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
 
     // Remember the ledger sequence of this update.
     lastUpdateSeq_ = ledgerSeq;
@@ -937,7 +937,7 @@ AmendmentTableImpl::doValidatedLedger(
 void
 AmendmentTableImpl::trustChanged(hash_set<PublicKey> const& allTrusted)
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     previousTrustedVotes_.trustChanged(allTrusted, lock);
 }
 
@@ -947,7 +947,7 @@ AmendmentTableImpl::injectJson(
     uint256 const& id,
     AmendmentState const& fs,
     bool isAdmin,
-    std::lock_guard<std::mutex> const&) const
+    std::scoped_lock<std::mutex> const&) const
 {
     if (!fs.name.empty())
         v[jss::name] = fs.name;
@@ -985,7 +985,7 @@ AmendmentTableImpl::getJson(bool isAdmin) const
 {
     Json::Value ret(Json::objectValue);
     {
-        std::lock_guard const lock(mutex_);
+        std::scoped_lock const lock(mutex_);
         for (auto const& e : amendmentMap_)
         {
             injectJson(
@@ -1001,7 +1001,7 @@ AmendmentTableImpl::getJson(uint256 const& amendmentID, bool isAdmin) const
     Json::Value ret = Json::objectValue;
 
     {
-        std::lock_guard const lock(mutex_);
+        std::scoped_lock const lock(mutex_);
         AmendmentState const* a = get(amendmentID, lock);
         if (a != nullptr)
         {
diff --git a/src/xrpld/app/misc/detail/Transaction.cpp b/src/xrpld/app/misc/detail/Transaction.cpp
index 758f560835..34a9613171 100644
--- a/src/xrpld/app/misc/detail/Transaction.cpp
+++ b/src/xrpld/app/misc/detail/Transaction.cpp
@@ -48,7 +48,7 @@ Transaction::Transaction(
         return;
     }
 
-    mStatus = NEW;
+    mStatus = TransStatus::NEW;
 }
 
 //
@@ -78,22 +78,22 @@ Transaction::sqlTransactionStatus(boost::optional<std::string> const& status)
     switch (static_cast<TxnSql>(c))
     {
         case TxnSql::txnSqlNew:
-            return NEW;
+            return TransStatus::NEW;
         case TxnSql::txnSqlConflict:
-            return CONFLICTED;
+            return TransStatus::CONFLICTED;
         case TxnSql::txnSqlHeld:
-            return HELD;
+            return TransStatus::HELD;
         case TxnSql::txnSqlValidated:
-            return COMMITTED;
+            return TransStatus::COMMITTED;
         case TxnSql::txnSqlIncluded:
-            return INCLUDED;
+            return TransStatus::INCLUDED;
         default:
             XRPL_ASSERT(
                 c == TxnSql::txnSqlUnknown,
                 "xrpl::Transaction::sqlTransactionStatus : unknown transaction status");
     }
 
-    return INVALID;
+    return TransStatus::INVALID;
 }
 
 Transaction::pointer
diff --git a/src/xrpld/app/misc/detail/TxQ.cpp b/src/xrpld/app/misc/detail/TxQ.cpp
index dde0988b4a..3e4a420e48 100644
--- a/src/xrpld/app/misc/detail/TxQ.cpp
+++ b/src/xrpld/app/misc/detail/TxQ.cpp
@@ -390,7 +390,7 @@ TxQ::canBeHeld(
     std::shared_ptr<SLE const> const& sleAccount,
     AccountMap::iterator const& accountIter,
     std::optional<TxQAccount::TxMap::iterator> const& replacementIter,
-    std::lock_guard<std::mutex> const& lock)
+    std::scoped_lock<std::mutex> const& lock)
 {
     // PreviousTxnID is deprecated and should never be used.
     // AccountTxnID is not supported by the transaction
@@ -775,7 +775,7 @@ TxQ::apply(
         return {terPRE_TICKET, false};
     }
 
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
 
     // accountIter is not const because it may be updated further down.
     AccountMap::iterator accountIter = byAccount_.find(account);
@@ -1332,7 +1332,7 @@ TxQ::apply(
 void
 TxQ::processClosedLedger(Application& app, ReadView const& view, bool timeLeap)
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
 
     feeMetrics_.update(app, view, timeLeap, setup_);
     auto const& snapshot = feeMetrics_.getSnapshot();
@@ -1411,7 +1411,7 @@ TxQ::accept(Application& app, OpenView& view)
 
     auto ledgerChanged = false;
 
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
 
     auto const metricsSnapshot = feeMetrics_.getSnapshot();
 
@@ -1575,7 +1575,7 @@ TxQ::accept(Application& app, OpenView& view)
 SeqProxy
 TxQ::nextQueuableSeq(std::shared_ptr<SLE const> const& sleAccount) const
 {
-    std::lock_guard<std::mutex> const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     return nextQueuableSeqImpl(sleAccount, lock);
 }
 
@@ -1588,7 +1588,7 @@ TxQ::nextQueuableSeq(std::shared_ptr<SLE const> const& sleAccount) const
 SeqProxy
 TxQ::nextQueuableSeqImpl(
     std::shared_ptr<SLE const> const& sleAccount,
-    std::lock_guard<std::mutex> const&) const
+    std::scoped_lock<std::mutex> const&) const
 {
     // If the account is not in the ledger or a non-account was passed
     // then return zero.  We have no idea.
@@ -1637,7 +1637,7 @@ TxQ::getRequiredFeeLevel(
     OpenView& view,
     ApplyFlags flags,
     FeeMetrics::Snapshot const& metricsSnapshot,
-    std::lock_guard<std::mutex> const& lock)
+    std::scoped_lock<std::mutex> const& lock)
 {
     return FeeMetrics::scaleFeeLevel(metricsSnapshot, view);
 }
@@ -1666,7 +1666,7 @@ TxQ::tryDirectApply(
         return {};
 
     FeeLevel64 const requiredFeeLevel = [this, &view, flags]() {
-        std::lock_guard const lock(mutex_);
+        std::scoped_lock const lock(mutex_);
         return getRequiredFeeLevel(view, flags, feeMetrics_.getSnapshot(), lock);
     }();
 
@@ -1690,7 +1690,7 @@ TxQ::tryDirectApply(
         {
             // If the applied transaction replaced a transaction in the
             // queue then remove the replaced transaction.
-            std::lock_guard const lock(mutex_);
+            std::scoped_lock const lock(mutex_);
 
             AccountMap::iterator const accountIter = byAccount_.find(account);
             if (accountIter != byAccount_.end())
@@ -1739,7 +1739,7 @@ TxQ::getMetrics(OpenView const& view) const
 {
     Metrics result;
 
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
 
     auto const snapshot = feeMetrics_.getSnapshot();
 
@@ -1760,7 +1760,7 @@ TxQ::getTxRequiredFeeAndSeq(OpenView const& view, std::shared_ptr<STTx const> co
 {
     auto const account = (*tx)[sfAccount];
 
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
 
     auto const snapshot = feeMetrics_.getSnapshot();
     auto const baseFee = calculateBaseFee(view, *tx);
@@ -1782,7 +1782,7 @@ TxQ::getAccountTxs(AccountID const& account) const
 {
     std::vector<TxDetails> result;
 
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
 
     AccountMap::const_iterator const accountIter{byAccount_.find(account)};
 
@@ -1802,7 +1802,7 @@ TxQ::getTxs() const
 {
     std::vector<TxDetails> result;
 
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
 
     result.reserve(byFee_.size());
 
diff --git a/src/xrpld/app/misc/detail/ValidatorList.cpp b/src/xrpld/app/misc/detail/ValidatorList.cpp
index 8a62a71972..b9a32f1463 100644
--- a/src/xrpld/app/misc/detail/ValidatorList.cpp
+++ b/src/xrpld/app/misc/detail/ValidatorList.cpp
@@ -169,7 +169,7 @@ ValidatorList::load(
         ")?"                 // end optional comment block
     );
 
-    std::lock_guard const lock{mutex_};
+    std::scoped_lock const lock{mutex_};
 
     JLOG(j_.debug()) << "Loading configured trusted validator list publisher keys";
 
@@ -289,7 +289,7 @@ ValidatorList::load(
 }
 
 boost::filesystem::path
-ValidatorList::getCacheFileName(ValidatorList::lock_guard const&, PublicKey const& pubKey) const
+ValidatorList::getCacheFileName(ValidatorList::scoped_lock const&, PublicKey const& pubKey) const
 {
     return dataPath_ / (filePrefix_ + strHex(pubKey));
 }
@@ -366,7 +366,7 @@ ValidatorList::buildFileData(
 }
 
 void
-ValidatorList::cacheValidatorFile(ValidatorList::lock_guard const& lock, PublicKey const& pubKey)
+ValidatorList::cacheValidatorFile(ValidatorList::scoped_lock const& lock, PublicKey const& pubKey)
     const
 {
     if (dataPath_.empty())
@@ -982,7 +982,7 @@ ValidatorList::applyLists(
         1)
         return PublisherListStats{ListDisposition::unsupported_version};
 
-    std::lock_guard const lock{mutex_};
+    std::scoped_lock const lock{mutex_};
 
     PublisherListStats result;
     for (auto const& blobInfo : blobs)
@@ -1052,7 +1052,7 @@ ValidatorList::updatePublisherList(
     PublicKey const& pubKey,
     PublisherList const& current,
     std::vector<PublicKey> const& oldList,
-    ValidatorList::lock_guard const&)
+    ValidatorList::scoped_lock const&)
 {
     // Update keyListings_ for added and removed keys
     std::vector<PublicKey> const& publisherList = current.list;
@@ -1121,7 +1121,7 @@ ValidatorList::applyList(
     std::uint32_t version,
     std::string siteUri,
     std::optional<uint256> const& hash,
-    ValidatorList::lock_guard const& lock)
+    ValidatorList::scoped_lock const& lock)
 {
     using namespace std::string_literals;
 
@@ -1286,7 +1286,7 @@ ValidatorList::loadLists()
     using namespace boost::filesystem;
     using namespace boost::system::errc;
 
-    std::lock_guard const lock{mutex_};
+    std::scoped_lock const lock{mutex_};
 
     std::vector<std::string> sites;
     sites.reserve(publisherLists_.size());
@@ -1336,7 +1336,7 @@ ValidatorList::loadLists()
 // contain the default-constructed public keys
 std::pair<ListDisposition, std::optional<PublicKey>>
 ValidatorList::verify(
-    ValidatorList::lock_guard const& lock,
+    ValidatorList::scoped_lock const& lock,
     Json::Value& list,
     Manifest manifest,
     std::string const& blob,
@@ -1494,7 +1494,7 @@ ValidatorList::localPublicKey() const
 
 bool
 ValidatorList::removePublisherList(
-    ValidatorList::lock_guard const&,
+    ValidatorList::scoped_lock const&,
     PublicKey const& publisherKey,
     PublisherStatus reason)
 {
@@ -1901,7 +1901,7 @@ ValidatorList::updateTrusted(
     if (timeKeeper_.now() > closeTime + 30s)
         closeTime = timeKeeper_.now();
 
-    std::lock_guard const lock{mutex_};
+    std::scoped_lock const lock{mutex_};
 
     // Rotate pending and remove expired published lists
     bool good = true;
@@ -2095,7 +2095,7 @@ ValidatorList::getNegativeUNL() const
 void
 ValidatorList::setNegativeUNL(hash_set<PublicKey> const& negUnl)
 {
-    std::lock_guard const lock{mutex_};
+    std::scoped_lock const lock{mutex_};
     negativeUNL_ = negUnl;
 }
 
diff --git a/src/xrpld/app/misc/detail/ValidatorSite.cpp b/src/xrpld/app/misc/detail/ValidatorSite.cpp
index 557a4e4f25..4c05ce5f09 100644
--- a/src/xrpld/app/misc/detail/ValidatorSite.cpp
+++ b/src/xrpld/app/misc/detail/ValidatorSite.cpp
@@ -130,7 +130,7 @@ ValidatorSite::~ValidatorSite()
 }
 
 bool
-ValidatorSite::missingSite(std::lock_guard<std::mutex> const& lock_sites)
+ValidatorSite::missingSite(std::scoped_lock<std::mutex> const& lock_sites)
 {
     auto const sites = app_.getValidators().loadLists();
     return sites.empty() || load(sites, lock_sites);
@@ -141,7 +141,7 @@ ValidatorSite::load(std::vector<std::string> const& siteURIs)
 {
     JLOG(j_.debug()) << "Loading configured validator list sites";
 
-    std::lock_guard const lock{sites_mutex_};
+    std::scoped_lock const lock{sites_mutex_};
 
     return load(siteURIs, lock);
 }
@@ -149,7 +149,7 @@ ValidatorSite::load(std::vector<std::string> const& siteURIs)
 bool
 ValidatorSite::load(
     std::vector<std::string> const& siteURIs,
-    std::lock_guard<std::mutex> const& lock_sites)
+    std::scoped_lock<std::mutex> const& lock_sites)
 {
     // If no sites are provided, act as if a site failed to load.
     if (siteURIs.empty())
@@ -178,8 +178,8 @@ ValidatorSite::load(
 void
 ValidatorSite::start()
 {
-    std::lock_guard const l0{sites_mutex_};
-    std::lock_guard const l1{state_mutex_};
+    std::scoped_lock const l0{sites_mutex_};
+    std::scoped_lock const l1{state_mutex_};
     if (timer_.expiry() == clock_type::time_point{})
         setTimer(l0, l1);
 }
@@ -219,8 +219,8 @@ ValidatorSite::stop()
 
 void
 ValidatorSite::setTimer(
-    std::lock_guard<std::mutex> const& site_lock,
-    std::lock_guard<std::mutex> const& state_lock)
+    std::scoped_lock<std::mutex> const& site_lock,
+    std::scoped_lock<std::mutex> const& state_lock)
 {
     auto next = std::ranges::min_element(
         sites_, [](Site const& a, Site const& b) { return a.nextRefresh < b.nextRefresh; });
@@ -240,13 +240,13 @@ void
 ValidatorSite::makeRequest(
     std::shared_ptr<Site::Resource> resource,
     std::size_t siteIdx,
-    std::lock_guard<std::mutex> const& sites_lock)
+    std::scoped_lock<std::mutex> const& sites_lock)
 {
     fetching_ = true;
     sites_[siteIdx].activeResource = resource;
     std::shared_ptr<detail::Work> sp;
     auto timeoutCancel = [this]() {
-        std::lock_guard const lock_state{state_mutex_};
+        std::scoped_lock const lock_state{state_mutex_};
         // docs indicate cancel_one() can throw, but this
         // should be reconsidered if it changes to noexcept
         try
@@ -312,7 +312,7 @@ ValidatorSite::makeRequest(
     sp->run();
     // start a timer for the request, which shouldn't take more
     // than requestTimeout_ to complete
-    std::lock_guard const lock_state{state_mutex_};
+    std::scoped_lock const lock_state{state_mutex_};
     timer_.expires_after(requestTimeout_);
     timer_.async_wait([this, siteIdx](boost::system::error_code const& ec) {
         this->onRequestTimeout(siteIdx, ec);
@@ -326,7 +326,7 @@ ValidatorSite::onRequestTimeout(std::size_t siteIdx, error_code const& ec)
         return;
 
     {
-        std::lock_guard const lock_site{sites_mutex_};
+        std::scoped_lock const lock_site{sites_mutex_};
         // In some circumstances, both this function and the response
         // handler (onSiteFetch or onTextFetch) can get queued and
         // processed. In all observed cases, the response handler
@@ -343,7 +343,7 @@ ValidatorSite::onRequestTimeout(std::size_t siteIdx, error_code const& ec)
                                 "already been processed";
     }
 
-    std::lock_guard const lock_state{state_mutex_};
+    std::scoped_lock const lock_state{state_mutex_};
     if (auto sp = work_.lock())
         sp->cancel();
 }
@@ -362,7 +362,7 @@ ValidatorSite::onTimer(std::size_t siteIdx, error_code const& ec)
 
     try
     {
-        std::lock_guard const lock{sites_mutex_};
+        std::scoped_lock const lock{sites_mutex_};
         sites_[siteIdx].nextRefresh = clock_type::now() + sites_[siteIdx].refreshInterval;
         sites_[siteIdx].redirCount = 0;
         // the WorkSSL client ctor can throw if SSL init fails
@@ -383,7 +383,7 @@ void
 ValidatorSite::parseJsonResponse(
     std::string const& res,
     std::size_t siteIdx,
-    std::lock_guard<std::mutex> const& sites_lock)
+    std::scoped_lock<std::mutex> const& sites_lock)
 {
     Json::Value const body = [&res, siteIdx, this]() {
         Json::Reader r;
@@ -501,7 +501,7 @@ std::shared_ptr<ValidatorSite::Site::Resource>
 ValidatorSite::processRedirect(
     detail::response_type const& res,
     std::size_t siteIdx,
-    std::lock_guard<std::mutex> const& sites_lock)
+    std::scoped_lock<std::mutex> const& sites_lock)
 {
     using namespace boost::beast::http;
     std::shared_ptr<Site::Resource> newLocation;
@@ -545,7 +545,7 @@ ValidatorSite::onSiteFetch(
     detail::response_type const& res,
     std::size_t siteIdx)
 {
-    std::lock_guard lock_sites{sites_mutex_};
+    std::scoped_lock lock_sites{sites_mutex_};
     {
         if (endpoint != endpoint_type{})
             sites_[siteIdx].lastRequestEndpoint = endpoint;
@@ -617,7 +617,7 @@ ValidatorSite::onSiteFetch(
         sites_[siteIdx].activeResource.reset();
     }
 
-    std::lock_guard const lock_state{state_mutex_};
+    std::scoped_lock const lock_state{state_mutex_};
     fetching_ = false;
     if (!stopping_)
         setTimer(lock_sites, lock_state);
@@ -630,7 +630,7 @@ ValidatorSite::onTextFetch(
     std::string const& res,
     std::size_t siteIdx)
 {
-    std::lock_guard const lock_sites{sites_mutex_};
+    std::scoped_lock const lock_sites{sites_mutex_};
     {
         try
         {
@@ -657,7 +657,7 @@ ValidatorSite::onTextFetch(
         sites_[siteIdx].activeResource.reset();
     }
 
-    std::lock_guard const lock_state{state_mutex_};
+    std::scoped_lock const lock_state{state_mutex_};
     fetching_ = false;
     if (!stopping_)
         setTimer(lock_sites, lock_state);
@@ -673,7 +673,7 @@ ValidatorSite::getJson() const
     Json::Value jrr(Json::objectValue);
     Json::Value& jSites = (jrr[jss::validator_sites] = Json::arrayValue);
     {
-        std::lock_guard const lock{sites_mutex_};
+        std::scoped_lock const lock{sites_mutex_};
         for (Site const& site : sites_)
         {
             Json::Value& v = jSites.append(Json::objectValue);
diff --git a/src/xrpld/app/rdb/backend/detail/Node.cpp b/src/xrpld/app/rdb/backend/detail/Node.cpp
index f1b5f4edc3..c698c7ca76 100644
--- a/src/xrpld/app/rdb/backend/detail/Node.cpp
+++ b/src/xrpld/app/rdb/backend/detail/Node.cpp
@@ -249,7 +249,8 @@ saveValidatedLedger(
         Serializer s(128);
         s.add32(HashPrefix::ledgerMaster);
         addRaw(ledger->header(), s);
-        app.getNodeStore().store(hotLEDGER, std::move(s.modData()), ledger->header().hash, seq);
+        app.getNodeStore().store(
+            NodeObjectType::hotLEDGER, std::move(s.modData()), ledger->header().hash, seq);
     }
 
     std::shared_ptr<AcceptedLedger> aLedger;
diff --git a/src/xrpld/consensus/Consensus.h b/src/xrpld/consensus/Consensus.h
index 9edbebd429..32460516bd 100644
--- a/src/xrpld/consensus/Consensus.h
+++ b/src/xrpld/consensus/Consensus.h
@@ -551,7 +551,7 @@ private:
 
     NetClock::duration closeResolution_ = ledgerDefaultTimeResolution;
 
-    ConsensusParms::AvalancheState closeTimeAvalancheState_ = ConsensusParms::init;
+    ConsensusParms::AvalancheState closeTimeAvalancheState_ = ConsensusParms::AvalancheState::init;
 
     // Time it took for the last consensus round to converge
     std::chrono::milliseconds prevRoundTime_{};
@@ -677,7 +677,7 @@ Consensus<Adaptor>::startRoundInternal(
     previousLedger_ = prevLedger;
     result_.reset();
     convergePercent_ = 0;
-    closeTimeAvalancheState_ = ConsensusParms::init;
+    closeTimeAvalancheState_ = ConsensusParms::AvalancheState::init;
     haveCloseTimeConsensus_ = false;
     openTime_.reset(clock_.now());
     currPeerPositions_.clear();
diff --git a/src/xrpld/consensus/ConsensusParms.h b/src/xrpld/consensus/ConsensusParms.h
index c8b79c4de9..7b9ec5dcff 100644
--- a/src/xrpld/consensus/ConsensusParms.h
+++ b/src/xrpld/consensus/ConsensusParms.h
@@ -106,7 +106,7 @@ struct ConsensusParms
     // As a function of the percent this round's duration is of the prior round,
     // we increase the threshold for yes votes to add a transaction to our
     // position.
-    enum AvalancheState { init, mid, late, stuck };
+    enum class AvalancheState { init, mid, late, stuck };
     struct AvalancheCutoff
     {
         int const consensusTime;
@@ -121,14 +121,18 @@ struct ConsensusParms
     std::map<AvalancheState, AvalancheCutoff> const avalancheCutoffs{
         // {state, {time, percent, nextState}},
         // Initial state: 50% of nodes must vote yes
-        {init, {.consensusTime = 0, .consensusPct = 50, .next = mid}},
+        {AvalancheState::init,
+         {.consensusTime = 0, .consensusPct = 50, .next = AvalancheState::mid}},
         // mid-consensus starts after 50% of the previous round time, and
         // requires 65% yes
-        {mid, {.consensusTime = 50, .consensusPct = 65, .next = late}},
+        {AvalancheState::mid,
+         {.consensusTime = 50, .consensusPct = 65, .next = AvalancheState::late}},
         // late consensus starts after 85% time, and requires 70% yes
-        {late, {.consensusTime = 85, .consensusPct = 70, .next = stuck}},
+        {AvalancheState::late,
+         {.consensusTime = 85, .consensusPct = 70, .next = AvalancheState::stuck}},
         // we're stuck after 2x time, requires 95% yes votes
-        {stuck, {.consensusTime = 200, .consensusPct = 95, .next = stuck}},
+        {AvalancheState::stuck,
+         {.consensusTime = 200, .consensusPct = 95, .next = AvalancheState::stuck}},
     };
 
     //! Percentage of nodes required to reach agreement on ledger close time
diff --git a/src/xrpld/consensus/DisputedTx.h b/src/xrpld/consensus/DisputedTx.h
index aff4ccae68..4320505d0f 100644
--- a/src/xrpld/consensus/DisputedTx.h
+++ b/src/xrpld/consensus/DisputedTx.h
@@ -185,7 +185,7 @@ private:
     //! The number of rounds we've gone without changing our vote
     std::size_t currentVoteCounter_ = 0;
     //! Which minimum acceptance percentage phase we are currently in
-    ConsensusParms::AvalancheState avalancheState_ = ConsensusParms::init;
+    ConsensusParms::AvalancheState avalancheState_ = ConsensusParms::AvalancheState::init;
     //! How long we have been in the current acceptance phase
     std::size_t avalancheCounter_ = 0;
     beast::Journal const j_;
diff --git a/src/xrpld/consensus/Validations.h b/src/xrpld/consensus/Validations.h
index 46b0ef0b32..5edb1db77f 100644
--- a/src/xrpld/consensus/Validations.h
+++ b/src/xrpld/consensus/Validations.h
@@ -334,7 +334,7 @@ class Validations
 private:
     // Remove support of a validated ledger
     void
-    removeTrie(std::lock_guard<Mutex> const&, NodeID const& nodeID, Validation const& val)
+    removeTrie(std::scoped_lock<Mutex> const&, NodeID const& nodeID, Validation const& val)
     {
         {
             auto it = acquiring_.find(std::make_pair(val.seq(), val.ledgerID()));
@@ -357,7 +357,7 @@ private:
 
     // Check if any pending acquire ledger requests are complete
     void
-    checkAcquired(std::lock_guard<Mutex> const& lock)
+    checkAcquired(std::scoped_lock<Mutex> const& lock)
     {
         for (auto it = acquiring_.begin(); it != acquiring_.end();)
         {
@@ -377,7 +377,7 @@ private:
 
     // Update the trie to reflect a new validated ledger
     void
-    updateTrie(std::lock_guard<Mutex> const&, NodeID const& nodeID, Ledger ledger)
+    updateTrie(std::scoped_lock<Mutex> const&, NodeID const& nodeID, Ledger ledger)
     {
         auto const [it, inserted] = lastLedger_.emplace(nodeID, ledger);
         if (!inserted)
@@ -403,7 +403,7 @@ private:
     */
     void
     updateTrie(
-        std::lock_guard<Mutex> const& lock,
+        std::scoped_lock<Mutex> const& lock,
         NodeID const& nodeID,
         Validation const& val,
         std::optional<std::pair<Seq, ID>> prior)
@@ -457,7 +457,7 @@ private:
     */
     template <class F>
     auto
-    withTrie(std::lock_guard<Mutex> const& lock, F&& f)
+    withTrie(std::scoped_lock<Mutex> const& lock, F&& f)
     {
         // Call current to flush any stale validations
         current(lock, [](auto) {}, [](auto, auto) {});
@@ -483,7 +483,7 @@ private:
 
     template <class Pre, class F>
     void
-    current(std::lock_guard<Mutex> const& lock, Pre&& pre, F&& f)
+    current(std::scoped_lock<Mutex> const& lock, Pre&& pre, F&& f)
     {
         NetClock::time_point const t = adaptor_.now();
         pre(current_.size());
@@ -520,7 +520,7 @@ private:
     */
     template <class Pre, class F>
     void
-    byLedger(std::lock_guard<Mutex> const&, ID const& ledgerID, Pre&& pre, F&& f)
+    byLedger(std::scoped_lock<Mutex> const&, ID const& ledgerID, Pre&& pre, F&& f)
     {
         auto it = byLedger_.find(ledgerID);
         if (it != byLedger_.end())
@@ -575,7 +575,7 @@ public:
     bool
     canValidateSeq(Seq const s)
     {
-        std::lock_guard const lock{mutex_};
+        std::scoped_lock const lock{mutex_};
         return localSeqEnforcer_(byLedger_.clock().now(), s, parms_);
     }
 
@@ -594,7 +594,7 @@ public:
             return ValStatus::stale;
 
         {
-            std::lock_guard const lock{mutex_};
+            std::scoped_lock const lock{mutex_};
 
             // Check that validation sequence is greater than any non-expired
             // validations sequence from that validator; if it's not, perform
@@ -682,7 +682,7 @@ public:
     void
     setSeqToKeep(Seq const& low, Seq const& high)
     {
-        std::lock_guard const lock{mutex_};
+        std::scoped_lock const lock{mutex_};
         XRPL_ASSERT(low < high, "xrpl::Validations::setSeqToKeep : valid inputs");
         toKeep_ = {low, high};
     }
@@ -697,7 +697,7 @@ public:
     {
         auto const start = std::chrono::steady_clock::now();
         {
-            std::lock_guard const lock{mutex_};
+            std::scoped_lock const lock{mutex_};
             if (toKeep_)
             {
                 // We only need to refresh the keep range when it's just about
@@ -754,7 +754,7 @@ public:
     void
     trustChanged(hash_set<NodeID> const& added, hash_set<NodeID> const& removed)
     {
-        std::lock_guard const lock{mutex_};
+        std::scoped_lock const lock{mutex_};
 
         for (auto& [nodeId, validation] : current_)
         {
@@ -790,7 +790,7 @@ public:
     Json::Value
     getJsonTrie() const
     {
-        std::lock_guard const lock{mutex_};
+        std::scoped_lock const lock{mutex_};
         return trie_.getJson();
     }
 
@@ -809,7 +809,7 @@ public:
     std::optional<std::pair<Seq, ID>>
     getPreferred(Ledger const& curr)
     {
-        std::lock_guard const lock{mutex_};
+        std::scoped_lock const lock{mutex_};
         std::optional<SpanTip<Ledger>> preferred = withTrie(lock, [this](LedgerTrie<Ledger>& trie) {
             return trie.getPreferred(localSeqEnforcer_.largest());
         });
@@ -921,7 +921,7 @@ public:
     std::size_t
     getNodesAfter(Ledger const& ledger, ID const& ledgerID)
     {
-        std::lock_guard const lock{mutex_};
+        std::scoped_lock const lock{mutex_};
 
         // Use trie if ledger is the right one
         if (ledger.id() == ledgerID)
@@ -946,7 +946,7 @@ public:
     currentTrusted()
     {
         std::vector<WrappedValidationType> ret;
-        std::lock_guard const lock{mutex_};
+        std::scoped_lock const lock{mutex_};
         current(
             lock,
             [&](std::size_t numValidations) { ret.reserve(numValidations); },
@@ -965,7 +965,7 @@ public:
     getCurrentNodeIDs() -> hash_set<NodeID>
     {
         hash_set<NodeID> ret;
-        std::lock_guard const lock{mutex_};
+        std::scoped_lock const lock{mutex_};
         current(
             lock,
             [&](std::size_t numValidations) { ret.reserve(numValidations); },
@@ -983,7 +983,7 @@ public:
     numTrustedForLedger(ID const& ledgerID)
     {
         std::size_t count = 0;
-        std::lock_guard const lock{mutex_};
+        std::scoped_lock const lock{mutex_};
         byLedger(
             lock,
             ledgerID,
@@ -1005,7 +1005,7 @@ public:
     getTrustedForLedger(ID const& ledgerID, Seq const& seq)
     {
         std::vector<WrappedValidationType> res;
-        std::lock_guard const lock{mutex_};
+        std::scoped_lock const lock{mutex_};
         byLedger(
             lock,
             ledgerID,
@@ -1028,7 +1028,7 @@ public:
     fees(ID const& ledgerID, std::uint32_t baseFee)
     {
         std::vector<std::uint32_t> res;
-        std::lock_guard const lock{mutex_};
+        std::scoped_lock const lock{mutex_};
         byLedger(
             lock,
             ledgerID,
@@ -1055,7 +1055,7 @@ public:
     void
     flush()
     {
-        std::lock_guard const lock{mutex_};
+        std::scoped_lock const lock{mutex_};
         current_.clear();
     }
 
@@ -1080,7 +1080,7 @@ public:
         std::size_t laggards = 0;
 
         current(
-            std::lock_guard{mutex_},
+            std::scoped_lock{mutex_},
             [](std::size_t) {},
             [&](NodeID const&, Validation const& v) {
                 if (adaptor_.now() < v.seenTime() + parms_.validationFRESHNESS &&
@@ -1098,28 +1098,28 @@ public:
     std::size_t
     sizeOfCurrentCache() const
     {
-        std::lock_guard const lock{mutex_};
+        std::scoped_lock const lock{mutex_};
         return current_.size();
     }
 
     std::size_t
     sizeOfSeqEnforcersCache() const
     {
-        std::lock_guard const lock{mutex_};
+        std::scoped_lock const lock{mutex_};
         return seqEnforcers_.size();
     }
 
     std::size_t
     sizeOfByLedgerCache() const
     {
-        std::lock_guard const lock{mutex_};
+        std::scoped_lock const lock{mutex_};
         return byLedger_.size();
     }
 
     std::size_t
     sizeOfBySequenceCache() const
     {
-        std::lock_guard const lock{mutex_};
+        std::scoped_lock const lock{mutex_};
         return bySequence_.size();
     }
 };
diff --git a/src/xrpld/overlay/detail/Cluster.cpp b/src/xrpld/overlay/detail/Cluster.cpp
index c74a9aa5bd..b15ed1859c 100644
--- a/src/xrpld/overlay/detail/Cluster.cpp
+++ b/src/xrpld/overlay/detail/Cluster.cpp
@@ -29,7 +29,7 @@ Cluster::Cluster(beast::Journal j) : j_(j)
 std::optional<std::string>
 Cluster::member(PublicKey const& identity) const
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
 
     auto iter = nodes_.find(identity);
     if (iter == nodes_.end())
@@ -40,7 +40,7 @@ Cluster::member(PublicKey const& identity) const
 std::size_t
 Cluster::size() const
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
 
     return nodes_.size();
 }
@@ -52,7 +52,7 @@ Cluster::update(
     std::uint32_t loadFee,
     NetClock::time_point reportTime)
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
 
     auto iter = nodes_.find(identity);
 
@@ -74,7 +74,7 @@ Cluster::update(
 void
 Cluster::for_each(std::function<void(ClusterNode const&)> func) const
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     for (auto const& ni : nodes_)
         func(ni);
 }
diff --git a/src/xrpld/overlay/detail/Message.cpp b/src/xrpld/overlay/detail/Message.cpp
index f8d3fbc8ff..eb8add8666 100644
--- a/src/xrpld/overlay/detail/Message.cpp
+++ b/src/xrpld/overlay/detail/Message.cpp
@@ -22,7 +22,8 @@ Message::Message(
     ::google::protobuf::Message const& message,
     protocol::MessageType type,
     std::optional<PublicKey> const& validator)
-    : category_(TrafficCount::categorize(message, type, false)), validatorKey_(validator)
+    : category_(static_cast<std::size_t>(TrafficCount::categorize(message, type, false)))
+    , validatorKey_(validator)
 {
     using namespace xrpl::compression;
 
diff --git a/src/xrpld/overlay/detail/OverlayImpl.cpp b/src/xrpld/overlay/detail/OverlayImpl.cpp
index f29d97cb11..d17a556dd8 100644
--- a/src/xrpld/overlay/detail/OverlayImpl.cpp
+++ b/src/xrpld/overlay/detail/OverlayImpl.cpp
@@ -92,6 +92,8 @@
 namespace xrpl {
 
 namespace CrawlOptions {
+// Need to be named before converting
+// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
 enum {
     Disabled = 0,
     Overlay = (1 << 0),
@@ -332,7 +334,7 @@ OverlayImpl::onHandoff(
             // As we are not on the strand, run() must be called
             // while holding the lock, otherwise new I/O can be
             // queued after a call to stop().
-            std::lock_guard<decltype(mutex_)> const lock(mutex_);
+            std::scoped_lock const lock(mutex_);
             {
                 auto const result = m_peers.emplace(peer->slot(), peer);
                 XRPL_ASSERT(result.second, "xrpl::OverlayImpl::onHandoff : peer is inserted");
@@ -455,7 +457,7 @@ OverlayImpl::connect(beast::IP::Endpoint const& remote_endpoint)
         app_.getJournal("Peer"),
         *this);
 
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     list_.emplace(p.get(), p);
     p->run();
 }
@@ -469,7 +471,7 @@ OverlayImpl::add_active(std::shared_ptr<PeerImp> const& peer)
     beast::WrappedSink sink{journal_.sink(), peer->prefix()};
     beast::Journal const journal{sink};
 
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
 
     {
         auto const result = m_peers.emplace(peer->slot(), peer);
@@ -497,7 +499,7 @@ OverlayImpl::add_active(std::shared_ptr<PeerImp> const& peer)
 void
 OverlayImpl::remove(std::shared_ptr<PeerFinder::Slot> const& slot)
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     auto const iter = m_peers.find(slot);
     XRPL_ASSERT(iter != m_peers.end(), "xrpl::OverlayImpl::remove : valid input");
     m_peers.erase(iter);
@@ -584,7 +586,7 @@ OverlayImpl::start()
             });
     }
     auto const timer = std::make_shared<Timer>(*this);
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     list_.emplace(timer.get(), timer);
     timer_ = timer;
     timer->async_wait();
@@ -637,7 +639,7 @@ OverlayImpl::activate(std::shared_ptr<PeerImp> const& peer)
 
     // Now track this peer
     {
-        std::lock_guard const lock(mutex_);
+        std::scoped_lock const lock(mutex_);
         auto const result(ids_.emplace(
             std::piecewise_construct, std::make_tuple(peer->id()), std::make_tuple(peer)));
         XRPL_ASSERT(result.second, "xrpl::OverlayImpl::activate : peer ID is inserted");
@@ -653,7 +655,7 @@ OverlayImpl::activate(std::shared_ptr<PeerImp> const& peer)
 void
 OverlayImpl::onPeerDeactivate(Peer::id_t id)
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     ids_.erase(id);
 }
 
@@ -732,7 +734,7 @@ OverlayImpl::reportOutboundTraffic(TrafficCount::category cat, int size)
 std::size_t
 OverlayImpl::size() const
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     return ids_.size();
 }
 
@@ -1091,7 +1093,7 @@ OverlayImpl::getActivePeers(
     std::size_t& enabledInSkip) const
 {
     Overlay::PeerSequence ret;
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
 
     active = ids_.size();
     disabled = enabledInSkip = 0;
@@ -1131,7 +1133,7 @@ OverlayImpl::checkTracking(std::uint32_t index)
 std::shared_ptr<Peer>
 OverlayImpl::findPeerByShortID(Peer::id_t const& id) const
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     auto const iter = ids_.find(id);
     if (iter != ids_.end())
         return iter->second.lock();
@@ -1143,7 +1145,7 @@ OverlayImpl::findPeerByShortID(Peer::id_t const& id) const
 std::shared_ptr<Peer>
 OverlayImpl::findPeerByPublicKey(PublicKey const& pubKey)
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     // NOTE The purpose of peer is to delay the destruction of PeerImp
     std::shared_ptr<PeerImp> peer;
     for (auto const& e : ids_)
@@ -1204,7 +1206,7 @@ OverlayImpl::relay(protocol::TMValidation& m, uint256 const& uid, PublicKey cons
 std::shared_ptr<Message>
 OverlayImpl::getManifestsMessage()
 {
-    std::lock_guard const g(manifestLock_);
+    std::scoped_lock const g(manifestLock_);
 
     if (auto seq = app_.getValidatorManifests().sequence(); seq != manifestListSeq_)
     {
@@ -1323,7 +1325,7 @@ OverlayImpl::relay(
 void
 OverlayImpl::remove(Child& child)
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     list_.erase(&child);
     if (list_.empty())
         cond_.notify_all();
@@ -1342,7 +1344,7 @@ OverlayImpl::stopChildren()
     // won't be called until vector<> children leaves scope.
     std::vector<std::shared_ptr<Child>> children;
     {
-        std::lock_guard const lock(mutex_);
+        std::scoped_lock const lock(mutex_);
         if (!work_)
             return;
         work_ = std::nullopt;
@@ -1377,7 +1379,7 @@ OverlayImpl::sendEndpoints()
     {
         std::shared_ptr<PeerImp> peer;
         {
-            std::lock_guard const lock(mutex_);
+            std::scoped_lock const lock(mutex_);
             auto const iter = m_peers.find(e.first);
             if (iter != m_peers.end())
                 peer = iter->second.lock();
@@ -1452,7 +1454,7 @@ OverlayImpl::updateSlotAndSquelch(
     for (auto id : peers)
     {
         slots_.updateSlotAndSquelch(key, validator, id, type, [&]() {
-            reportInboundTraffic(TrafficCount::squelch_ignored, 0);
+            reportInboundTraffic(TrafficCount::category::squelch_ignored, 0);
         });
     }
 }
@@ -1481,7 +1483,7 @@ OverlayImpl::updateSlotAndSquelch(
     }
 
     slots_.updateSlotAndSquelch(key, validator, peer, type, [&]() {
-        reportInboundTraffic(TrafficCount::squelch_ignored, 0);
+        reportInboundTraffic(TrafficCount::category::squelch_ignored, 0);
     });
 }
 
diff --git a/src/xrpld/overlay/detail/OverlayImpl.h b/src/xrpld/overlay/detail/OverlayImpl.h
index 0c4990a6f4..caccd35562 100644
--- a/src/xrpld/overlay/detail/OverlayImpl.h
+++ b/src/xrpld/overlay/detail/OverlayImpl.h
@@ -254,7 +254,7 @@ public:
     {
         std::vector<std::weak_ptr<PeerImp>> wp;
         {
-            std::lock_guard const lock(mutex_);
+            std::scoped_lock const lock(mutex_);
 
             // Iterate over a copy of the peer list because peer
             // destruction can invalidate iterators.
@@ -572,7 +572,7 @@ private:
     collect_metrics()
     {
         auto counts = m_traffic.getCounts();
-        std::lock_guard const lock(m_statsMutex);
+        std::scoped_lock const lock(m_statsMutex);
         XRPL_ASSERT(
             counts.size() == m_stats.trafficGauges.size(),
             "xrpl::OverlayImpl::collect_metrics : counts size do match");
diff --git a/src/xrpld/overlay/detail/PeerImp.cpp b/src/xrpld/overlay/detail/PeerImp.cpp
index 46a640ec5c..01cad680ba 100644
--- a/src/xrpld/overlay/detail/PeerImp.cpp
+++ b/src/xrpld/overlay/detail/PeerImp.cpp
@@ -240,7 +240,7 @@ PeerImp::run()
         fail("Malformed handshake data (3)");
 
     {
-        std::lock_guard<std::mutex> const sl(recentLock_);
+        std::scoped_lock const sl(recentLock_);
         if (closed)
             closedLedgerHash_ = *closed;
         if (previous)
@@ -408,8 +408,8 @@ PeerImp::removeTxQueue(uint256 const& hash)
 void
 PeerImp::charge(Resource::Charge const& fee, std::string const& context)
 {
-    if ((usage_.charge(fee, context) == Resource::drop) && usage_.disconnect(p_journal_) &&
-        strand_.running_in_this_thread())
+    if ((usage_.charge(fee, context) == Resource::Disposition::drop) &&
+        usage_.disconnect(p_journal_) && strand_.running_in_this_thread())
     {
         // Sever the connection
         overlay_.incPeerDisconnectCharges();
@@ -478,7 +478,7 @@ PeerImp::json()
     ret[jss::protocol] = to_string(protocol_);
 
     {
-        std::lock_guard const sl(recentLock_);
+        std::scoped_lock const sl(recentLock_);
         if (latency_)
             ret[jss::latency] = static_cast<Json::UInt>(latency_->count());
     }
@@ -510,7 +510,7 @@ PeerImp::json()
     uint256 closedLedgerHash;
     protocol::TMStatusChange last_status;
     {
-        std::lock_guard const sl(recentLock_);
+        std::scoped_lock const sl(recentLock_);
         closedLedgerHash = closedLedgerHash_;
         last_status = last_status_;
     }
@@ -577,7 +577,7 @@ bool
 PeerImp::hasLedger(uint256 const& hash, std::uint32_t seq) const
 {
     {
-        std::lock_guard const sl(recentLock_);
+        std::scoped_lock const sl(recentLock_);
         if ((seq != 0) && (seq >= minLedger_) && (seq <= maxLedger_) &&
             (tracking_.load() == Tracking::converged))
             return true;
@@ -590,7 +590,7 @@ PeerImp::hasLedger(uint256 const& hash, std::uint32_t seq) const
 void
 PeerImp::ledgerRange(std::uint32_t& minSeq, std::uint32_t& maxSeq) const
 {
-    std::lock_guard const sl(recentLock_);
+    std::scoped_lock const sl(recentLock_);
 
     minSeq = minLedger_;
     maxSeq = maxLedger_;
@@ -599,7 +599,7 @@ PeerImp::ledgerRange(std::uint32_t& minSeq, std::uint32_t& maxSeq) const
 bool
 PeerImp::hasTxSet(uint256 const& hash) const
 {
-    std::lock_guard const sl(recentLock_);
+    std::scoped_lock const sl(recentLock_);
     return std::ranges::find(recentTxSets_, hash) != recentTxSets_.end();
 }
 
@@ -608,7 +608,7 @@ PeerImp::cycleStatus()
 {
     // Operations on closedLedgerHash_ and previousLedgerHash_ must be
     // guarded by recentLock_.
-    std::lock_guard const sl(recentLock_);
+    std::scoped_lock const sl(recentLock_);
     previousLedgerHash_ = closedLedgerHash_;
     closedLedgerHash_.zero();
 }
@@ -616,7 +616,7 @@ PeerImp::cycleStatus()
 bool
 PeerImp::hasRange(std::uint32_t uMin, std::uint32_t uMax)
 {
-    std::lock_guard const sl(recentLock_);
+    std::scoped_lock const sl(recentLock_);
     return (tracking_ != Tracking::diverged) && (uMin >= minLedger_) && (uMax <= maxLedger_);
 }
 
@@ -813,7 +813,7 @@ PeerImp::onTimer(error_code const& ec)
         clock_type::duration duration;
 
         {
-            std::lock_guard const sl(recentLock_);
+            std::scoped_lock const sl(recentLock_);
             duration = clock_type::now() - trackingTime_;
         }
 
@@ -1267,7 +1267,7 @@ PeerImp::onMessage(std::shared_ptr<protocol::TMPing> const& m)
             auto const rtt =
                 std::chrono::round<std::chrono::milliseconds>(clock_type::now() - lastPingTime_);
 
-            std::lock_guard const sl(recentLock_);
+            std::scoped_lock const sl(recentLock_);
 
             if (latency_)
             {
@@ -1964,7 +1964,7 @@ PeerImp::onMessage(std::shared_ptr<protocol::TMStatusChange> const& m)
         m->set_networktime(app_.getTimeKeeper().now().time_since_epoch().count());
 
     {
-        std::lock_guard const sl(recentLock_);
+        std::scoped_lock const sl(recentLock_);
         if (!last_status_.has_newstatus() || m->has_newstatus())
         {
             last_status_ = *m;
@@ -1984,7 +1984,7 @@ PeerImp::onMessage(std::shared_ptr<protocol::TMStatusChange> const& m)
         {
             // Operations on closedLedgerHash_ and previousLedgerHash_ must be
             // guarded by recentLock_.
-            std::lock_guard const sl(recentLock_);
+            std::scoped_lock const sl(recentLock_);
             if (!closedLedgerHash_.isZero())
             {
                 outOfSync = true;
@@ -2006,7 +2006,7 @@ PeerImp::onMessage(std::shared_ptr<protocol::TMStatusChange> const& m)
         {
             // Operations on closedLedgerHash_ and previousLedgerHash_ must be
             // guarded by recentLock_.
-            std::lock_guard const sl(recentLock_);
+            std::scoped_lock const sl(recentLock_);
             if (peerChangedLedgers)
             {
                 closedLedgerHash_ = m->ledgerhash();
@@ -2040,7 +2040,7 @@ PeerImp::onMessage(std::shared_ptr<protocol::TMStatusChange> const& m)
 
     if (m->has_firstseq() && m->has_lastseq())
     {
-        std::lock_guard const sl(recentLock_);
+        std::scoped_lock const sl(recentLock_);
 
         minLedger_ = m->firstseq();
         maxLedger_ = m->lastseq();
@@ -2107,7 +2107,7 @@ PeerImp::onMessage(std::shared_ptr<protocol::TMStatusChange> const& m)
         {
             uint256 closedLedgerHash{};
             {
-                std::lock_guard const sl(recentLock_);
+                std::scoped_lock const sl(recentLock_);
                 closedLedgerHash = closedLedgerHash_;
             }
             j[jss::ledger_hash] = to_string(closedLedgerHash);
@@ -2135,7 +2135,7 @@ PeerImp::checkTracking(std::uint32_t validationSeq)
     {
         // Extract the sequence number of the highest
         // ledger this peer has
-        std::lock_guard const sl(recentLock_);
+        std::scoped_lock const sl(recentLock_);
 
         serverSeq = maxLedger_;
     }
@@ -2161,7 +2161,7 @@ PeerImp::checkTracking(std::uint32_t seq1, std::uint32_t seq2)
     if ((diff > Tuning::divergedLedgerLimit) && (tracking_.load() != Tracking::diverged))
     {
         // The peer's ledger sequence is way off the validation's
-        std::lock_guard const sl(recentLock_);
+        std::scoped_lock const sl(recentLock_);
 
         tracking_ = Tracking::diverged;
         trackingTime_ = clock_type::now();
@@ -2181,7 +2181,7 @@ PeerImp::onMessage(std::shared_ptr<protocol::TMHaveTransactionSet> const& m)
 
     if (m->status() == protocol::tsHAVE)
     {
-        std::lock_guard const sl(recentLock_);
+        std::scoped_lock const sl(recentLock_);
 
         if (std::ranges::find(recentTxSets_, hash) != recentTxSets_.end())
         {
@@ -2248,7 +2248,7 @@ PeerImp::onValidatorListMessage(
         case ListDisposition::expired:
         // Future list
         case ListDisposition::pending: {
-            std::lock_guard<std::mutex> const sl(recentLock_);
+            std::scoped_lock const sl(recentLock_);
 
             XRPL_ASSERT(
                 applyResult.publisherKey,
@@ -2272,7 +2272,7 @@ PeerImp::onValidatorListMessage(
         case ListDisposition::known_sequence:
 #ifndef NDEBUG
         {
-            std::lock_guard<std::mutex> const sl(recentLock_);
+            std::scoped_lock<std::mutex> const sl(recentLock_);
             XRPL_ASSERT(
                 applyResult.sequence && applyResult.publisherKey,
                 "xrpl::PeerImp::onValidatorListMessage : nonzero sequence "
@@ -2838,7 +2838,7 @@ PeerImp::onMessage(std::shared_ptr<protocol::TMSquelch> const& m)
 //--------------------------------------------------------------------------
 
 void
-PeerImp::addLedger(uint256 const& hash, std::lock_guard<std::mutex> const& lockedRecentLock)
+PeerImp::addLedger(uint256 const& hash, std::scoped_lock<std::mutex> const& lockedRecentLock)
 {
     // lockedRecentLock is passed as a reminder that recentLock_ must be
     // locked by the caller.
@@ -2925,7 +2925,8 @@ PeerImp::doTransactions(std::shared_ptr<protocol::TMGetObjectByHash> const& pack
         auto sttx = txn->getSTransaction();
         sttx->add(s);
         tx->set_rawtransaction(s.data(), s.size());
-        tx->set_status(txn->getStatus() == INCLUDED ? protocol::tsCURRENT : protocol::tsNEW);
+        tx->set_status(
+            txn->getStatus() == TransStatus::INCLUDED ? protocol::tsCURRENT : protocol::tsNEW);
         tx->set_receivetimestamp(app_.getTimeKeeper().now().time_since_epoch().count());
         tx->set_deferred(txn->getSubmitResult().queued);
     }
@@ -2989,10 +2990,10 @@ PeerImp::checkTransaction(
             std::string reason;
             auto tx = std::make_shared<Transaction>(stx, reason, app_);
             XRPL_ASSERT(
-                tx->getStatus() == NEW,
+                tx->getStatus() == TransStatus::NEW,
                 "xrpl::PeerImp::checkTransaction Transaction created "
                 "correctly");
-            if (tx->getStatus() == NEW)
+            if (tx->getStatus() == TransStatus::NEW)
             {
                 JLOG(p_journal_.debug()) << "Processing " << (batch ? "batch" : "unsolicited")
                                          << " pseudo-transaction tx " << tx->getID();
@@ -3044,7 +3045,7 @@ PeerImp::checkTransaction(
         std::string reason;
         auto tx = std::make_shared<Transaction>(stx, reason, app_);
 
-        if (tx->getStatus() == INVALID)
+        if (tx->getStatus() == TransStatus::INVALID)
         {
             if (!reason.empty())
             {
@@ -3557,7 +3558,7 @@ PeerImp::getScore(bool haveItem) const
 
     std::optional<std::chrono::milliseconds> latency;
     {
-        std::lock_guard const sl(recentLock_);
+        std::scoped_lock const sl(recentLock_);
         latency = latency_;
     }
 
@@ -3576,7 +3577,7 @@ PeerImp::getScore(bool haveItem) const
 bool
 PeerImp::isHighLatency() const
 {
-    std::lock_guard const sl(recentLock_);
+    std::scoped_lock const sl(recentLock_);
     return latency_ >= peerHighLatency;
 }
 
diff --git a/src/xrpld/overlay/detail/PeerImp.h b/src/xrpld/overlay/detail/PeerImp.h
index f2cca1407a..d2cf46e838 100644
--- a/src/xrpld/overlay/detail/PeerImp.h
+++ b/src/xrpld/overlay/detail/PeerImp.h
@@ -428,7 +428,7 @@ public:
     std::optional<std::size_t>
     publisherListSequence(PublicKey const& pubKey) const override
     {
-        std::lock_guard<std::mutex> const sl(recentLock_);
+        std::scoped_lock const sl(recentLock_);
 
         auto iter = publisherListSequences_.find(pubKey);
         if (iter != publisherListSequences_.end())
@@ -439,7 +439,7 @@ public:
     void
     setPublisherListSequence(PublicKey const& pubKey, std::size_t const seq) override
     {
-        std::lock_guard<std::mutex> const sl(recentLock_);
+        std::scoped_lock const sl(recentLock_);
 
         publisherListSequences_[pubKey] = seq;
     }
@@ -744,7 +744,7 @@ private:
     // lockedRecentLock is passed as a reminder to callers that recentLock_
     // must be locked.
     void
-    addLedger(uint256 const& hash, std::lock_guard<std::mutex> const& lockedRecentLock);
+    addLedger(uint256 const& hash, std::scoped_lock<std::mutex> const& lockedRecentLock);
 
     void
     doFetchPack(std::shared_ptr<protocol::TMGetObjectByHash> const& packet);
diff --git a/src/xrpld/overlay/detail/PeerReservationTable.cpp b/src/xrpld/overlay/detail/PeerReservationTable.cpp
index f0e5f55a00..6f004a3b39 100644
--- a/src/xrpld/overlay/detail/PeerReservationTable.cpp
+++ b/src/xrpld/overlay/detail/PeerReservationTable.cpp
@@ -32,7 +32,7 @@ PeerReservationTable::list() const -> std::vector<PeerReservation>
 {
     std::vector<PeerReservation> list;
     {
-        std::lock_guard const lock(mutex_);
+        std::scoped_lock const lock(mutex_);
         list.reserve(table_.size());
         std::ranges::copy(table_, std::back_inserter(list));
     }
@@ -49,7 +49,7 @@ PeerReservationTable::list() const -> std::vector<PeerReservation>
 bool
 PeerReservationTable::load(DatabaseCon& connection)
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
 
     connection_ = &connection;
     auto db = connection.checkoutDb();
@@ -64,7 +64,7 @@ PeerReservationTable::insert_or_assign(PeerReservation const& reservation)
 {
     std::optional<PeerReservation> previous;
 
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
 
     auto hint = table_.find(reservation);
     if (hint != table_.end())
@@ -98,7 +98,7 @@ PeerReservationTable::erase(PublicKey const& nodeId)
 {
     std::optional<PeerReservation> previous;
 
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
 
     auto const it = table_.find({.nodeId = nodeId});
     if (it != table_.end())
diff --git a/src/xrpld/overlay/detail/TrafficCount.h b/src/xrpld/overlay/detail/TrafficCount.h
index 736c3b76e3..8597ca897c 100644
--- a/src/xrpld/overlay/detail/TrafficCount.h
+++ b/src/xrpld/overlay/detail/TrafficCount.h
@@ -29,7 +29,7 @@ namespace xrpl {
 class TrafficCount
 {
 public:
-    enum category : std::size_t;
+    enum class category : std::size_t;
 
     class TrafficStats
     {
@@ -63,7 +63,7 @@ public:
     // If you add entries to this enum, you need to update the initialization
     // of the arrays at the bottom of this file which map array numbers to
     // human-readable, monitoring-tool friendly names.
-    enum category : std::size_t {
+    enum class category : std::size_t {
         base,  // basic peer overhead, must be first
 
         cluster,    // cluster overhead
@@ -193,7 +193,8 @@ public:
     addCount(category cat, bool inbound, int bytes)
     {
         XRPL_ASSERT(
-            cat <= category::unknown, "xrpl::TrafficCount::addCount : valid category input");
+            static_cast<std::size_t>(cat) <= static_cast<std::size_t>(category::unknown),
+            "xrpl::TrafficCount::addCount : valid category input");
 
         auto it = counts_.find(cat);
 
@@ -227,62 +228,62 @@ public:
     to_string(category cat)
     {
         static std::unordered_map<category, std::string> const category_map = {
-            {base, "overhead"},
-            {cluster, "overhead_cluster"},
-            {overlay, "overhead_overlay"},
-            {manifests, "overhead_manifest"},
-            {transaction, "transactions"},
-            {transaction_duplicate, "transactions_duplicate"},
-            {proposal, "proposals"},
-            {proposal_untrusted, "proposals_untrusted"},
-            {proposal_duplicate, "proposals_duplicate"},
-            {validation, "validations"},
-            {validation_untrusted, "validations_untrusted"},
-            {validation_duplicate, "validations_duplicate"},
-            {validatorlist, "validator_lists"},
-            {squelch, "squelch"},
-            {squelch_suppressed, "squelch_suppressed"},
-            {squelch_ignored, "squelch_ignored"},
-            {get_set, "set_get"},
-            {share_set, "set_share"},
-            {ld_tsc_get, "ledger_data_Transaction_Set_candidate_get"},
-            {ld_tsc_share, "ledger_data_Transaction_Set_candidate_share"},
-            {ld_txn_get, "ledger_data_Transaction_Node_get"},
-            {ld_txn_share, "ledger_data_Transaction_Node_share"},
-            {ld_asn_get, "ledger_data_Account_State_Node_get"},
-            {ld_asn_share, "ledger_data_Account_State_Node_share"},
-            {ld_get, "ledger_data_get"},
-            {ld_share, "ledger_data_share"},
-            {gl_tsc_share, "ledger_Transaction_Set_candidate_share"},
-            {gl_tsc_get, "ledger_Transaction_Set_candidate_get"},
-            {gl_txn_share, "ledger_Transaction_node_share"},
-            {gl_txn_get, "ledger_Transaction_node_get"},
-            {gl_asn_share, "ledger_Account_State_node_share"},
-            {gl_asn_get, "ledger_Account_State_node_get"},
-            {gl_share, "ledger_share"},
-            {gl_get, "ledger_get"},
-            {share_hash_ledger, "getobject_Ledger_share"},
-            {get_hash_ledger, "getobject_Ledger_get"},
-            {share_hash_tx, "getobject_Transaction_share"},
-            {get_hash_tx, "getobject_Transaction_get"},
-            {share_hash_txnode, "getobject_Transaction_node_share"},
-            {get_hash_txnode, "getobject_Transaction_node_get"},
-            {share_hash_asnode, "getobject_Account_State_node_share"},
-            {get_hash_asnode, "getobject_Account_State_node_get"},
-            {share_cas_object, "getobject_CAS_share"},
-            {get_cas_object, "getobject_CAS_get"},
-            {share_fetch_pack, "getobject_Fetch_Pack_share"},
-            {get_fetch_pack, "getobject_Fetch Pack_get"},
-            {get_transactions, "getobject_Transactions_get"},
-            {share_hash, "getobject_share"},
-            {get_hash, "getobject_get"},
-            {proof_path_request, "proof_path_request"},
-            {proof_path_response, "proof_path_response"},
-            {replay_delta_request, "replay_delta_request"},
-            {replay_delta_response, "replay_delta_response"},
-            {have_transactions, "have_transactions"},
-            {requested_transactions, "requested_transactions"},
-            {total, "total"}};
+            {category::base, "overhead"},
+            {category::cluster, "overhead_cluster"},
+            {category::overlay, "overhead_overlay"},
+            {category::manifests, "overhead_manifest"},
+            {category::transaction, "transactions"},
+            {category::transaction_duplicate, "transactions_duplicate"},
+            {category::proposal, "proposals"},
+            {category::proposal_untrusted, "proposals_untrusted"},
+            {category::proposal_duplicate, "proposals_duplicate"},
+            {category::validation, "validations"},
+            {category::validation_untrusted, "validations_untrusted"},
+            {category::validation_duplicate, "validations_duplicate"},
+            {category::validatorlist, "validator_lists"},
+            {category::squelch, "squelch"},
+            {category::squelch_suppressed, "squelch_suppressed"},
+            {category::squelch_ignored, "squelch_ignored"},
+            {category::get_set, "set_get"},
+            {category::share_set, "set_share"},
+            {category::ld_tsc_get, "ledger_data_Transaction_Set_candidate_get"},
+            {category::ld_tsc_share, "ledger_data_Transaction_Set_candidate_share"},
+            {category::ld_txn_get, "ledger_data_Transaction_Node_get"},
+            {category::ld_txn_share, "ledger_data_Transaction_Node_share"},
+            {category::ld_asn_get, "ledger_data_Account_State_Node_get"},
+            {category::ld_asn_share, "ledger_data_Account_State_Node_share"},
+            {category::ld_get, "ledger_data_get"},
+            {category::ld_share, "ledger_data_share"},
+            {category::gl_tsc_share, "ledger_Transaction_Set_candidate_share"},
+            {category::gl_tsc_get, "ledger_Transaction_Set_candidate_get"},
+            {category::gl_txn_share, "ledger_Transaction_node_share"},
+            {category::gl_txn_get, "ledger_Transaction_node_get"},
+            {category::gl_asn_share, "ledger_Account_State_node_share"},
+            {category::gl_asn_get, "ledger_Account_State_node_get"},
+            {category::gl_share, "ledger_share"},
+            {category::gl_get, "ledger_get"},
+            {category::share_hash_ledger, "getobject_Ledger_share"},
+            {category::get_hash_ledger, "getobject_Ledger_get"},
+            {category::share_hash_tx, "getobject_Transaction_share"},
+            {category::get_hash_tx, "getobject_Transaction_get"},
+            {category::share_hash_txnode, "getobject_Transaction_node_share"},
+            {category::get_hash_txnode, "getobject_Transaction_node_get"},
+            {category::share_hash_asnode, "getobject_Account_State_node_share"},
+            {category::get_hash_asnode, "getobject_Account_State_node_get"},
+            {category::share_cas_object, "getobject_CAS_share"},
+            {category::get_cas_object, "getobject_CAS_get"},
+            {category::share_fetch_pack, "getobject_Fetch_Pack_share"},
+            {category::get_fetch_pack, "getobject_Fetch Pack_get"},
+            {category::get_transactions, "getobject_Transactions_get"},
+            {category::share_hash, "getobject_share"},
+            {category::get_hash, "getobject_get"},
+            {category::proof_path_request, "proof_path_request"},
+            {category::proof_path_response, "proof_path_response"},
+            {category::replay_delta_request, "replay_delta_request"},
+            {category::replay_delta_response, "replay_delta_response"},
+            {category::have_transactions, "have_transactions"},
+            {category::requested_transactions, "requested_transactions"},
+            {category::total, "total"}};
 
         if (auto it = category_map.find(cat); it != category_map.end())
             return it->second;
@@ -292,63 +293,63 @@ public:
 
 protected:
     std::unordered_map<category, TrafficStats> counts_{
-        {base, {base}},
-        {cluster, {cluster}},
-        {overlay, {overlay}},
-        {manifests, {manifests}},
-        {transaction, {transaction}},
-        {transaction_duplicate, {transaction_duplicate}},
-        {proposal, {proposal}},
-        {proposal_untrusted, {proposal_untrusted}},
-        {proposal_duplicate, {proposal_duplicate}},
-        {validation, {validation}},
-        {validation_untrusted, {validation_untrusted}},
-        {validation_duplicate, {validation_duplicate}},
-        {validatorlist, {validatorlist}},
-        {squelch, {squelch}},
-        {squelch_suppressed, {squelch_suppressed}},
-        {squelch_ignored, {squelch_ignored}},
-        {get_set, {get_set}},
-        {share_set, {share_set}},
-        {ld_tsc_get, {ld_tsc_get}},
-        {ld_tsc_share, {ld_tsc_share}},
-        {ld_txn_get, {ld_txn_get}},
-        {ld_txn_share, {ld_txn_share}},
-        {ld_asn_get, {ld_asn_get}},
-        {ld_asn_share, {ld_asn_share}},
-        {ld_get, {ld_get}},
-        {ld_share, {ld_share}},
-        {gl_tsc_share, {gl_tsc_share}},
-        {gl_tsc_get, {gl_tsc_get}},
-        {gl_txn_share, {gl_txn_share}},
-        {gl_txn_get, {gl_txn_get}},
-        {gl_asn_share, {gl_asn_share}},
-        {gl_asn_get, {gl_asn_get}},
-        {gl_share, {gl_share}},
-        {gl_get, {gl_get}},
-        {share_hash_ledger, {share_hash_ledger}},
-        {get_hash_ledger, {get_hash_ledger}},
-        {share_hash_tx, {share_hash_tx}},
-        {get_hash_tx, {get_hash_tx}},
-        {share_hash_txnode, {share_hash_txnode}},
-        {get_hash_txnode, {get_hash_txnode}},
-        {share_hash_asnode, {share_hash_asnode}},
-        {get_hash_asnode, {get_hash_asnode}},
-        {share_cas_object, {share_cas_object}},
-        {get_cas_object, {get_cas_object}},
-        {share_fetch_pack, {share_fetch_pack}},
-        {get_fetch_pack, {get_fetch_pack}},
-        {get_transactions, {get_transactions}},
-        {share_hash, {share_hash}},
-        {get_hash, {get_hash}},
-        {proof_path_request, {proof_path_request}},
-        {proof_path_response, {proof_path_response}},
-        {replay_delta_request, {replay_delta_request}},
-        {replay_delta_response, {replay_delta_response}},
-        {have_transactions, {have_transactions}},
-        {requested_transactions, {requested_transactions}},
-        {total, {total}},
-        {unknown, {unknown}},
+        {category::base, {category::base}},
+        {category::cluster, {category::cluster}},
+        {category::overlay, {category::overlay}},
+        {category::manifests, {category::manifests}},
+        {category::transaction, {category::transaction}},
+        {category::transaction_duplicate, {category::transaction_duplicate}},
+        {category::proposal, {category::proposal}},
+        {category::proposal_untrusted, {category::proposal_untrusted}},
+        {category::proposal_duplicate, {category::proposal_duplicate}},
+        {category::validation, {category::validation}},
+        {category::validation_untrusted, {category::validation_untrusted}},
+        {category::validation_duplicate, {category::validation_duplicate}},
+        {category::validatorlist, {category::validatorlist}},
+        {category::squelch, {category::squelch}},
+        {category::squelch_suppressed, {category::squelch_suppressed}},
+        {category::squelch_ignored, {category::squelch_ignored}},
+        {category::get_set, {category::get_set}},
+        {category::share_set, {category::share_set}},
+        {category::ld_tsc_get, {category::ld_tsc_get}},
+        {category::ld_tsc_share, {category::ld_tsc_share}},
+        {category::ld_txn_get, {category::ld_txn_get}},
+        {category::ld_txn_share, {category::ld_txn_share}},
+        {category::ld_asn_get, {category::ld_asn_get}},
+        {category::ld_asn_share, {category::ld_asn_share}},
+        {category::ld_get, {category::ld_get}},
+        {category::ld_share, {category::ld_share}},
+        {category::gl_tsc_share, {category::gl_tsc_share}},
+        {category::gl_tsc_get, {category::gl_tsc_get}},
+        {category::gl_txn_share, {category::gl_txn_share}},
+        {category::gl_txn_get, {category::gl_txn_get}},
+        {category::gl_asn_share, {category::gl_asn_share}},
+        {category::gl_asn_get, {category::gl_asn_get}},
+        {category::gl_share, {category::gl_share}},
+        {category::gl_get, {category::gl_get}},
+        {category::share_hash_ledger, {category::share_hash_ledger}},
+        {category::get_hash_ledger, {category::get_hash_ledger}},
+        {category::share_hash_tx, {category::share_hash_tx}},
+        {category::get_hash_tx, {category::get_hash_tx}},
+        {category::share_hash_txnode, {category::share_hash_txnode}},
+        {category::get_hash_txnode, {category::get_hash_txnode}},
+        {category::share_hash_asnode, {category::share_hash_asnode}},
+        {category::get_hash_asnode, {category::get_hash_asnode}},
+        {category::share_cas_object, {category::share_cas_object}},
+        {category::get_cas_object, {category::get_cas_object}},
+        {category::share_fetch_pack, {category::share_fetch_pack}},
+        {category::get_fetch_pack, {category::get_fetch_pack}},
+        {category::get_transactions, {category::get_transactions}},
+        {category::share_hash, {category::share_hash}},
+        {category::get_hash, {category::get_hash}},
+        {category::proof_path_request, {category::proof_path_request}},
+        {category::proof_path_response, {category::proof_path_response}},
+        {category::replay_delta_request, {category::replay_delta_request}},
+        {category::replay_delta_response, {category::replay_delta_response}},
+        {category::have_transactions, {category::have_transactions}},
+        {category::requested_transactions, {category::requested_transactions}},
+        {category::total, {category::total}},
+        {category::unknown, {category::unknown}},
     };
 };
 
diff --git a/src/xrpld/overlay/detail/Tuning.h b/src/xrpld/overlay/detail/Tuning.h
index 0471587fec..07cf2d2238 100644
--- a/src/xrpld/overlay/detail/Tuning.h
+++ b/src/xrpld/overlay/detail/Tuning.h
@@ -4,6 +4,8 @@
 
 namespace xrpl::Tuning {
 
+// Need to be named before converting
+// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
 enum {
     /** How many ledgers off a server can be and we will
         still consider it converged */
diff --git a/src/xrpld/overlay/detail/TxMetrics.cpp b/src/xrpld/overlay/detail/TxMetrics.cpp
index 0a44c719f4..2bcf5f2f2f 100644
--- a/src/xrpld/overlay/detail/TxMetrics.cpp
+++ b/src/xrpld/overlay/detail/TxMetrics.cpp
@@ -17,7 +17,7 @@ void
 TxMetrics::addMetrics(protocol::MessageType type, std::uint32_t val)
 {
     auto add = [&](auto& m, std::uint32_t val) {
-        std::lock_guard const lock(mutex);
+        std::scoped_lock const lock(mutex);
         m.addMetrics(val);
     };
 
@@ -46,7 +46,7 @@ TxMetrics::addMetrics(protocol::MessageType type, std::uint32_t val)
 void
 TxMetrics::addMetrics(std::uint32_t selected, std::uint32_t suppressed, std::uint32_t notenabled)
 {
-    std::lock_guard const lock(mutex);
+    std::scoped_lock const lock(mutex);
     selectedPeers.addMetrics(selected);
     suppressedPeers.addMetrics(suppressed);
     notEnabled.addMetrics(notenabled);
@@ -55,7 +55,7 @@ TxMetrics::addMetrics(std::uint32_t selected, std::uint32_t suppressed, std::uin
 void
 TxMetrics::addMetrics(std::uint32_t missing)
 {
-    std::lock_guard const lock(mutex);
+    std::scoped_lock const lock(mutex);
     missingTx.addMetrics(missing);
 }
 
@@ -99,7 +99,7 @@ SingleMetrics::addMetrics(std::uint32_t val)
 Json::Value
 TxMetrics::json() const
 {
-    std::lock_guard const l(mutex);
+    std::scoped_lock const l(mutex);
 
     Json::Value ret(Json::objectValue);
 
diff --git a/src/xrpld/peerfinder/Slot.h b/src/xrpld/peerfinder/Slot.h
index 5c459b25ea..e67df7ee17 100644
--- a/src/xrpld/peerfinder/Slot.h
+++ b/src/xrpld/peerfinder/Slot.h
@@ -13,7 +13,7 @@ class Slot
 public:
     using ptr = std::shared_ptr<Slot>;
 
-    enum State { accept, connect, connected, active, closing };
+    enum class State { accept, connect, connected, active, closing };
 
     virtual ~Slot() = 0;
 
diff --git a/src/xrpld/peerfinder/detail/Checker.h b/src/xrpld/peerfinder/detail/Checker.h
index 3bd23f85db..820d030b23 100644
--- a/src/xrpld/peerfinder/detail/Checker.h
+++ b/src/xrpld/peerfinder/detail/Checker.h
@@ -149,7 +149,7 @@ template <class Protocol>
 void
 Checker<Protocol>::stop()
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     if (!stop_)
     {
         stop_ = true;
@@ -175,7 +175,7 @@ Checker<Protocol>::async_connect(beast::IP::Endpoint const& endpoint, Handler&&
     auto const op =
         std::make_shared<async_op<Handler>>(*this, io_context_, std::forward<Handler>(handler));
     {
-        std::lock_guard const lock(mutex_);
+        std::scoped_lock const lock(mutex_);
         list_.push_back(*op);
     }
     op->socket_.async_connect(
@@ -187,7 +187,7 @@ template <class Protocol>
 void
 Checker<Protocol>::remove(basic_async_op& op)
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     list_.erase(list_.iterator_to(op));
     if (list_.size() == 0)
         cond_.notify_all();
diff --git a/src/xrpld/peerfinder/detail/Counts.h b/src/xrpld/peerfinder/detail/Counts.h
index 6d1221d331..367caed54b 100644
--- a/src/xrpld/peerfinder/detail/Counts.h
+++ b/src/xrpld/peerfinder/detail/Counts.h
@@ -35,7 +35,7 @@ public:
     {
         // Must be handshaked and in the right state
         XRPL_ASSERT(
-            s.state() == Slot::connected || s.state() == Slot::accept,
+            s.state() == Slot::State::connected || s.state() == Slot::State::accept,
             "xrpl::PeerFinder::Counts::can_activate : valid input state");
 
         if (s.fixed() || s.reserved())
@@ -241,13 +241,13 @@ private:
 
         switch (s.state())
         {
-            case Slot::accept:
+            case Slot::State::accept:
                 XRPL_ASSERT(s.inbound(), "xrpl::PeerFinder::Counts::adjust : input is inbound");
                 adjustCounter(m_acceptCount, dir);
                 break;
 
-            case Slot::connect:
-            case Slot::connected:
+            case Slot::State::connect:
+            case Slot::State::connected:
                 XRPL_ASSERT(
                     !s.inbound(),
                     "xrpl::PeerFinder::Counts::adjust : input is not "
@@ -255,7 +255,7 @@ private:
                 adjustCounter(m_attempts, dir);
                 break;
 
-            case Slot::active:
+            case Slot::State::active:
                 if (s.fixed())
                     adjustCounter(m_fixed_active, dir);
                 if (!s.fixed() && !s.reserved())
@@ -272,7 +272,7 @@ private:
                 adjustCounter(m_active, dir);
                 break;
 
-            case Slot::closing:
+            case Slot::State::closing:
                 adjustCounter(m_closingCount, dir);
                 break;
 
diff --git a/src/xrpld/peerfinder/detail/Logic.h b/src/xrpld/peerfinder/detail/Logic.h
index 9e2cbedc64..c7e6c7d1f2 100644
--- a/src/xrpld/peerfinder/detail/Logic.h
+++ b/src/xrpld/peerfinder/detail/Logic.h
@@ -105,7 +105,7 @@ public:
     void
     load()
     {
-        std::lock_guard const _(lock_);
+        std::scoped_lock const _(lock_);
         bootcache_.load();
     }
 
@@ -118,7 +118,7 @@ public:
     void
     stop()
     {
-        std::lock_guard const _(lock_);
+        std::scoped_lock const _(lock_);
         stopping_ = true;
         if (fetchSource_ != nullptr)
             fetchSource_->cancel();
@@ -133,7 +133,7 @@ public:
     void
     config(Config const& c)
     {
-        std::lock_guard const _(lock_);
+        std::scoped_lock const _(lock_);
         config_ = c;
         counts_.onConfig(config_);
     }
@@ -141,7 +141,7 @@ public:
     Config
     config()
     {
-        std::lock_guard const _(lock_);
+        std::scoped_lock const _(lock_);
         return config_;
     }
 
@@ -154,7 +154,7 @@ public:
     void
     addFixedPeer(std::string const& name, std::vector<beast::IP::Endpoint> const& addresses)
     {
-        std::lock_guard const _(lock_);
+        std::scoped_lock const _(lock_);
 
         if (addresses.empty())
         {
@@ -196,7 +196,7 @@ public:
         if (ec == boost::asio::error::operation_aborted)
             return;
 
-        std::lock_guard const _(lock_);
+        std::scoped_lock const _(lock_);
         auto const iter(slots_.find(remoteAddress));
         if (iter == slots_.end())
         {
@@ -238,7 +238,7 @@ public:
         JLOG(m_journal.debug()) << beast::leftw(18) << "Logic accept" << remote_endpoint
                                 << " on local " << local_endpoint;
 
-        std::lock_guard const _(lock_);
+        std::scoped_lock const _(lock_);
 
         // Check for connection limit per address
         if (is_public(remote_endpoint))
@@ -286,7 +286,7 @@ public:
     {
         JLOG(m_journal.debug()) << beast::leftw(18) << "Logic connect " << remote_endpoint;
 
-        std::lock_guard const _(lock_);
+        std::scoped_lock const _(lock_);
 
         // Check for duplicate connection
         if (slots_.contains(remote_endpoint))
@@ -325,7 +325,7 @@ public:
 
         JLOG(journal.trace()) << "Logic connected on local " << local_endpoint;
 
-        std::lock_guard const _(lock_);
+        std::scoped_lock const _(lock_);
 
         // The object must exist in our table
         XRPL_ASSERT(
@@ -350,7 +350,7 @@ public:
 
         // Update counts
         counts_.remove(*slot);
-        slot->state(Slot::connected);
+        slot->state(Slot::State::connected);
         counts_.add(*slot);
         return true;
     }
@@ -364,7 +364,7 @@ public:
         JLOG(journal.debug()) << "Logic handshake " << slot->remote_endpoint() << " with "
                               << (reserved ? "reserved " : "") << "key " << key;
 
-        std::lock_guard const _(lock_);
+        std::scoped_lock const _(lock_);
 
         // The object must exist in our table
         XRPL_ASSERT(
@@ -372,7 +372,7 @@ public:
             "xrpl::PeerFinder::Logic::activate : valid slot input");
         // Must be accepted or connected
         XRPL_ASSERT(
-            slot->state() == Slot::accept || slot->state() == Slot::connected,
+            slot->state() == Slot::State::accept || slot->state() == Slot::State::connected,
             "xrpl::PeerFinder::Logic::activate : valid slot state");
 
         // Check for duplicate connection by key
@@ -437,7 +437,7 @@ public:
     std::vector<Endpoint>
     redirect(SlotImp::ptr const& slot)
     {
-        std::lock_guard const _(lock_);
+        std::scoped_lock const _(lock_);
         RedirectHandouts h(slot);
         livecache_.hops.shuffle();
         handout(&h, (&h) + 1, livecache_.hops.begin(), livecache_.hops.end());
@@ -455,7 +455,7 @@ public:
     {
         std::vector<beast::IP::Endpoint> none;
 
-        std::lock_guard const _(lock_);
+        std::scoped_lock const _(lock_);
 
         // Count how many more outbound attempts to make
         //
@@ -561,7 +561,7 @@ public:
     {
         std::vector<std::pair<std::shared_ptr<Slot>, std::vector<Endpoint>>> result;
 
-        std::lock_guard const _(lock_);
+        std::scoped_lock const _(lock_);
 
         clock_type::time_point const now = m_clock.now();
         if (m_whenBroadcast <= now)
@@ -574,7 +574,7 @@ public:
                 slots.reserve(slots_.size());
                 std::for_each(
                     slots_.cbegin(), slots_.cend(), [&slots](Slots::value_type const& value) {
-                        if (value.second->state() == Slot::active)
+                        if (value.second->state() == Slot::State::active)
                             slots.emplace_back(value.second);
                     });
                 std::shuffle(slots.begin(), slots.end(), default_prng());
@@ -640,7 +640,7 @@ public:
     void
     once_per_second()
     {
-        std::lock_guard const _(lock_);
+        std::scoped_lock const _(lock_);
 
         // Expire the Livecache
         livecache_.expire();
@@ -738,7 +738,7 @@ public:
         JLOG(journal.trace()) << "Endpoints contained " << list.size()
                               << ((list.size() > 1) ? " entries" : " entry");
 
-        std::lock_guard const _(lock_);
+        std::scoped_lock const _(lock_);
 
         // The object must exist in our table
         XRPL_ASSERT(
@@ -747,7 +747,7 @@ public:
 
         // Must be handshaked!
         XRPL_ASSERT(
-            slot->state() == Slot::active,
+            slot->state() == Slot::State::active,
             "xrpl::PeerFinder::Logic::on_endpoints : valid slot state");
 
         clock_type::time_point const now(m_clock.now());
@@ -870,7 +870,7 @@ public:
     void
     on_closed(SlotImp::ptr const& slot)
     {
-        std::lock_guard const _(lock_);
+        std::scoped_lock const _(lock_);
 
         remove(slot);
 
@@ -878,7 +878,7 @@ public:
         beast::Journal const journal{sink};
 
         // Mark fixed slot failure
-        if (slot->fixed() && !slot->inbound() && slot->state() != Slot::active)
+        if (slot->fixed() && !slot->inbound() && slot->state() != Slot::State::active)
         {
             auto iter(fixed_.find(slot->remote_endpoint()));
             if (iter == fixed_.end())
@@ -895,12 +895,12 @@ public:
         // Do state specific bookkeeping
         switch (slot->state())
         {
-            case Slot::accept:
+            case Slot::State::accept:
                 JLOG(journal.trace()) << "Logic accept failed";
                 break;
 
-            case Slot::connect:
-            case Slot::connected:
+            case Slot::State::connect:
+            case Slot::State::connected:
                 bootcache_.on_failure(slot->remote_endpoint());
                 // VFALCO TODO If the address exists in the ephemeral/live
                 //             endpoint livecache then we should mark the
@@ -909,11 +909,11 @@ public:
                 // avoid propagating the address.
                 break;
 
-            case Slot::active:
+            case Slot::State::active:
                 JLOG(journal.trace()) << "Logic close";
                 break;
 
-            case Slot::closing:
+            case Slot::State::closing:
                 JLOG(journal.trace()) << "Logic finished";
                 break;
 
@@ -930,7 +930,7 @@ public:
     void
     on_failure(SlotImp::ptr const& slot)
     {
-        std::lock_guard const _(lock_);
+        std::scoped_lock const _(lock_);
 
         bootcache_.on_failure(slot->remote_endpoint());
     }
@@ -1023,7 +1023,7 @@ public:
     addBootcacheAddresses(IPAddresses const& list)
     {
         int count(0);
-        std::lock_guard const _(lock_);
+        std::scoped_lock const _(lock_);
         for (auto const& addr : list)
         {
             if (bootcache_.insertStatic(addr))
@@ -1040,7 +1040,7 @@ public:
 
         {
             {
-                std::lock_guard const _(lock_);
+                std::scoped_lock const _(lock_);
                 if (stopping_)
                     return;
                 fetchSource_ = source;
@@ -1052,7 +1052,7 @@ public:
             source->fetch(results, m_journal);
 
             {
-                std::lock_guard const _(lock_);
+                std::scoped_lock const _(lock_);
                 if (stopping_)
                     return;
                 fetchSource_ = nullptr;
@@ -1123,7 +1123,7 @@ public:
     void
     onWrite(beast::PropertyStream::Map& map)
     {
-        std::lock_guard const _(lock_);
+        std::scoped_lock const _(lock_);
 
         // VFALCO NOTE These ugly casts are needed because
         //             of how std::size_t is declared on some linuxes
@@ -1174,15 +1174,15 @@ public:
     {
         switch (state)
         {
-            case Slot::accept:
+            case Slot::State::accept:
                 return "accept";
-            case Slot::connect:
+            case Slot::State::connect:
                 return "connect";
-            case Slot::connected:
+            case Slot::State::connected:
                 return "connected";
-            case Slot::active:
+            case Slot::State::active:
                 return "active";
-            case Slot::closing:
+            case Slot::State::closing:
                 return "closing";
             default:
                 break;
@@ -1201,7 +1201,7 @@ Logic<Checker>::onRedirects(
     FwdIter last,
     boost::asio::ip::tcp::endpoint const& remote_address)
 {
-    std::lock_guard const _(lock_);
+    std::scoped_lock const _(lock_);
     std::size_t n = 0;
     for (; first != last && n < Tuning::maxRedirects; ++first, ++n)
         bootcache_.insert(beast::IPAddressConversion::from_asio(*first));
diff --git a/src/xrpld/peerfinder/detail/PeerfinderManager.cpp b/src/xrpld/peerfinder/detail/PeerfinderManager.cpp
index 2858586120..d2378a2fbb 100644
--- a/src/xrpld/peerfinder/detail/PeerfinderManager.cpp
+++ b/src/xrpld/peerfinder/detail/PeerfinderManager.cpp
@@ -243,7 +243,7 @@ private:
     void
     collect_metrics()
     {
-        std::lock_guard const lock(m_statsMutex);
+        std::scoped_lock const lock(m_statsMutex);
         m_stats.activeInboundPeers = m_logic.counts_.inboundActive();
         m_stats.activeOutboundPeers = m_logic.counts_.out_active();
     }
diff --git a/src/xrpld/peerfinder/detail/SlotImp.cpp b/src/xrpld/peerfinder/detail/SlotImp.cpp
index f763a154aa..e7cc751472 100644
--- a/src/xrpld/peerfinder/detail/SlotImp.cpp
+++ b/src/xrpld/peerfinder/detail/SlotImp.cpp
@@ -22,7 +22,7 @@ SlotImp::SlotImp(
     , m_inbound(true)
     , m_fixed(fixed)
     , m_reserved(false)
-    , m_state(accept)
+    , m_state(State::accept)
     , m_remote_endpoint(std::move(remote_endpoint))
     , m_local_endpoint(local_endpoint)
     , m_listening_port(unknownPort)
@@ -37,7 +37,7 @@ SlotImp::SlotImp(beast::IP::Endpoint remote_endpoint, bool fixed, clock_type& cl
     , m_inbound(false)
     , m_fixed(fixed)
     , m_reserved(false)
-    , m_state(connect)
+    , m_state(State::connect)
     , m_remote_endpoint(std::move(remote_endpoint))
     , m_listening_port(unknownPort)
     , checked(true)
@@ -50,7 +50,8 @@ void
 SlotImp::state(State state_)
 {
     // Must go through activate() to set active state
-    XRPL_ASSERT(state_ != active, "xrpl::PeerFinder::SlotImp::state : input state is not active");
+    XRPL_ASSERT(
+        state_ != State::active, "xrpl::PeerFinder::SlotImp::state : input state is not active");
 
     // The state must be different
     XRPL_ASSERT(
@@ -60,18 +61,18 @@ SlotImp::state(State state_)
 
     // You can't transition into the initial states
     XRPL_ASSERT(
-        state_ != accept && state_ != connect,
+        state_ != State::accept && state_ != State::connect,
         "xrpl::PeerFinder::SlotImp::state : input state is not an initial");
 
     // Can only become connected from outbound connect state
     XRPL_ASSERT(
-        state_ != connected || (!m_inbound && m_state == connect),
+        state_ != State::connected || (!m_inbound && m_state == State::connect),
         "xrpl::PeerFinder::SlotImp::state : input state is not connected an "
         "invalid state");
 
     // Can't gracefully close on an outbound connection attempt
     XRPL_ASSERT(
-        state_ != closing || m_state != connect,
+        state_ != State::closing || m_state != State::connect,
         "xrpl::PeerFinder::SlotImp::state : input state is not closing an "
         "invalid state");
 
@@ -83,10 +84,10 @@ SlotImp::activate(clock_type::time_point const& now)
 {
     // Can only become active from the accept or connected state
     XRPL_ASSERT(
-        m_state == accept || m_state == connected,
+        m_state == State::accept || m_state == State::connected,
         "xrpl::PeerFinder::SlotImp::activate : valid state");
 
-    m_state = active;
+    m_state = State::active;
     whenAcceptEndpoints = now;
 }
 
diff --git a/src/xrpld/peerfinder/detail/StoreSqdb.h b/src/xrpld/peerfinder/detail/StoreSqdb.h
index 626a82c932..1d5ce50184 100644
--- a/src/xrpld/peerfinder/detail/StoreSqdb.h
+++ b/src/xrpld/peerfinder/detail/StoreSqdb.h
@@ -15,6 +15,8 @@ private:
     soci::session m_sqlDb;
 
 public:
+    // Need to be named before converting
+    // NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
     enum {
         // This determines the on-database format of the data
         currentSchemaVersion = 4
diff --git a/src/xrpld/peerfinder/detail/Tuning.h b/src/xrpld/peerfinder/detail/Tuning.h
index 23a96a7374..e166ae32b8 100644
--- a/src/xrpld/peerfinder/detail/Tuning.h
+++ b/src/xrpld/peerfinder/detail/Tuning.h
@@ -6,6 +6,8 @@
 /** @{ */
 namespace xrpl::PeerFinder::Tuning {
 
+// Need to be named before converting
+// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
 enum {
     //---------------------------------------------------------
     //
@@ -61,6 +63,8 @@ static std::array<int, 10> const connectionBackoff{{1, 1, 2, 3, 5, 8, 13, 21, 34
 //
 //------------------------------------------------------------------------------
 
+// Need to be named before converting
+// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
 enum {
     // Threshold of cache entries above which we trim.
     bootcacheSize = 1000
diff --git a/src/xrpld/perflog/detail/PerfLogImp.cpp b/src/xrpld/perflog/detail/PerfLogImp.cpp
index 6b80d29cc6..64950fc689 100644
--- a/src/xrpld/perflog/detail/PerfLogImp.cpp
+++ b/src/xrpld/perflog/detail/PerfLogImp.cpp
@@ -79,7 +79,7 @@ PerfLogImp::Counters::countersJson() const
     {
         Rpc value;
         {
-            std::lock_guard const lock(proc.second.mutex);
+            std::scoped_lock const lock(proc.second.mutex);
             if ((proc.second.value.started == 0u) && (proc.second.value.finished == 0u) &&
                 (proc.second.value.errored == 0u))
             {
@@ -117,7 +117,7 @@ PerfLogImp::Counters::countersJson() const
     {
         Jq value;
         {
-            std::lock_guard const lock(proc.second.mutex);
+            std::scoped_lock const lock(proc.second.mutex);
             if ((proc.second.value.queued == 0u) && (proc.second.value.started == 0u) &&
                 (proc.second.value.finished == 0u))
             {
@@ -166,7 +166,7 @@ PerfLogImp::Counters::currentJson() const
 
     Json::Value jobsArray(Json::arrayValue);
     auto const jobs = [this] {
-        std::lock_guard const lock(jobsMutex_);
+        std::scoped_lock const lock(jobsMutex_);
         return jobs_;
     }();
 
@@ -184,7 +184,7 @@ PerfLogImp::Counters::currentJson() const
     Json::Value methodsArray(Json::arrayValue);
     std::vector<MethodStart> methods;
     {
-        std::lock_guard const lock(methodsMutex_);
+        std::scoped_lock const lock(methodsMutex_);
         methods.reserve(methods_.size());
         for (auto const& m : methods_)
             methods.push_back(m.second);
@@ -280,7 +280,7 @@ PerfLogImp::report()
     Json::Value report(Json::objectValue);
     report[jss::time] = to_string(std::chrono::floor<microseconds>(present));
     {
-        std::lock_guard const lock{counters_.jobsMutex_};
+        std::scoped_lock const lock{counters_.jobsMutex_};
         report[jss::workers] = static_cast<unsigned int>(counters_.jobs_.size());
     }
     report[jss::hostid] = hostname_;
@@ -321,10 +321,10 @@ PerfLogImp::rpcStart(std::string const& method, std::uint64_t const requestId)
     }
 
     {
-        std::lock_guard const lock(counter->second.mutex);
+        std::scoped_lock const lock(counter->second.mutex);
         ++counter->second.value.started;
     }
-    std::lock_guard const lock(counters_.methodsMutex_);
+    std::scoped_lock const lock(counters_.methodsMutex_);
     counters_.methods_[requestId] = {counter->first.c_str(), steady_clock::now()};
 }
 
@@ -341,7 +341,7 @@ PerfLogImp::rpcEnd(std::string const& method, std::uint64_t const requestId, boo
     }
     steady_time_point startTime;
     {
-        std::lock_guard const lock(counters_.methodsMutex_);
+        std::scoped_lock const lock(counters_.methodsMutex_);
         auto const e = counters_.methods_.find(requestId);
         if (e != counters_.methods_.end())
         {
@@ -355,7 +355,7 @@ PerfLogImp::rpcEnd(std::string const& method, std::uint64_t const requestId, boo
             // LCOV_EXCL_STOP
         }
     }
-    std::lock_guard const lock(counter->second.mutex);
+    std::scoped_lock const lock(counter->second.mutex);
     if (finish)
     {
         ++counter->second.value.finished;
@@ -379,7 +379,7 @@ PerfLogImp::jobQueue(JobType const type)
         return;
         // LCOV_EXCL_STOP
     }
-    std::lock_guard const lock(counter->second.mutex);
+    std::scoped_lock const lock(counter->second.mutex);
     ++counter->second.value.queued;
 }
 
@@ -400,11 +400,11 @@ PerfLogImp::jobStart(
     }
 
     {
-        std::lock_guard const lock(counter->second.mutex);
+        std::scoped_lock const lock(counter->second.mutex);
         ++counter->second.value.started;
         counter->second.value.queuedDuration += dur;
     }
-    std::lock_guard const lock(counters_.jobsMutex_);
+    std::scoped_lock const lock(counters_.jobsMutex_);
     if (instance >= 0 && instance < counters_.jobs_.size())
         counters_.jobs_[instance] = {type, startTime};
 }
@@ -422,11 +422,11 @@ PerfLogImp::jobFinish(JobType const type, microseconds dur, int instance)
     }
 
     {
-        std::lock_guard const lock(counter->second.mutex);
+        std::scoped_lock const lock(counter->second.mutex);
         ++counter->second.value.finished;
         counter->second.value.runningDuration += dur;
     }
-    std::lock_guard const lock(counters_.jobsMutex_);
+    std::scoped_lock const lock(counters_.jobsMutex_);
     if (instance >= 0 && instance < counters_.jobs_.size())
         counters_.jobs_[instance] = {jtINVALID, steady_time_point()};
 }
@@ -434,7 +434,7 @@ PerfLogImp::jobFinish(JobType const type, microseconds dur, int instance)
 void
 PerfLogImp::resizeJobs(int const resize)
 {
-    std::lock_guard const lock(counters_.jobsMutex_);
+    std::scoped_lock const lock(counters_.jobsMutex_);
     if (resize > counters_.jobs_.size())
         counters_.jobs_.resize(resize, {jtINVALID, steady_time_point()});
 }
@@ -445,7 +445,7 @@ PerfLogImp::rotate()
     if (setup_.perfLog.empty())
         return;
 
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     rotate_ = true;
     cond_.notify_one();
 }
@@ -463,7 +463,7 @@ PerfLogImp::stop()
     if (thread_.joinable())
     {
         {
-            std::lock_guard const lock(mutex_);
+            std::scoped_lock const lock(mutex_);
             stop_ = true;
             cond_.notify_one();
         }
diff --git a/src/xrpld/rpc/detail/AssetCache.cpp b/src/xrpld/rpc/detail/AssetCache.cpp
index bbe8fefc98..28924ceb5f 100644
--- a/src/xrpld/rpc/detail/AssetCache.cpp
+++ b/src/xrpld/rpc/detail/AssetCache.cpp
@@ -45,7 +45,7 @@ AssetCache::getRippleLines(AccountID const& accountID, LineDirection direction)
         direction == LineDirection::outgoing ? LineDirection::incoming : LineDirection::outgoing,
         hash);
 
-    std::lock_guard const sl(mLock);
+    std::scoped_lock const sl(mLock);
 
     auto [it, inserted] = [&]() {
         if (auto otheriter = lines_.find(otherkey); otheriter != lines_.end())
@@ -118,7 +118,7 @@ AssetCache::getRippleLines(AccountID const& accountID, LineDirection direction)
 std::shared_ptr<std::vector<PathFindMPT>> const&
 AssetCache::getMPTs(xrpl::AccountID const& account)
 {
-    std::lock_guard const sl(mLock);
+    std::scoped_lock const sl(mLock);
 
     if (auto it = mpts_.find(account); it != mpts_.end())
         return it->second;
diff --git a/src/xrpld/rpc/detail/Handler.h b/src/xrpld/rpc/detail/Handler.h
index d249409ffe..94d0ca87cf 100644
--- a/src/xrpld/rpc/detail/Handler.h
+++ b/src/xrpld/rpc/detail/Handler.h
@@ -15,6 +15,8 @@ class Object;
 namespace xrpl::RPC {
 
 // Under what condition can we call this RPC?
+// Bitwise flags
+// NOLINTNEXTLINE(cppcoreguidelines-use-enum-class)
 enum Condition {
     NO_CONDITION = 0,
     NEEDS_NETWORK_CONNECTION = 1,
diff --git a/src/xrpld/rpc/detail/PathRequest.cpp b/src/xrpld/rpc/detail/PathRequest.cpp
index 1719567357..9707536cc8 100644
--- a/src/xrpld/rpc/detail/PathRequest.cpp
+++ b/src/xrpld/rpc/detail/PathRequest.cpp
@@ -121,7 +121,7 @@ PathRequest::~PathRequest()
 bool
 PathRequest::isNew()
 {
-    std::lock_guard const sl(mIndexLock);
+    std::scoped_lock const sl(mIndexLock);
 
     // does this path request still need its first full path
     return mLastIndex == 0;
@@ -130,7 +130,7 @@ PathRequest::isNew()
 bool
 PathRequest::needsUpdate(bool newOnly, LedgerIndex index)
 {
-    std::lock_guard const sl(mIndexLock);
+    std::scoped_lock const sl(mIndexLock);
 
     if (mInProgress)
     {
@@ -162,7 +162,7 @@ PathRequest::hasCompletion()
 void
 PathRequest::updateComplete()
 {
-    std::lock_guard const sl(mIndexLock);
+    std::scoped_lock const sl(mIndexLock);
 
     XRPL_ASSERT(mInProgress, "xrpl::PathRequest::updateComplete : in progress");
     mInProgress = false;
@@ -476,7 +476,7 @@ Json::Value
 PathRequest::doClose()
 {
     JLOG(m_journal.debug()) << iIdentifier << " closed";
-    std::lock_guard const sl(mLock);
+    std::scoped_lock const sl(mLock);
     jvStatus[jss::closed] = true;
     return jvStatus;
 }
@@ -484,7 +484,7 @@ PathRequest::doClose()
 Json::Value
 PathRequest::doStatus(Json::Value const&)
 {
-    std::lock_guard const sl(mLock);
+    std::scoped_lock const sl(mLock);
     jvStatus[jss::status] = jss::success;
     return jvStatus;
 }
@@ -714,7 +714,7 @@ PathRequest::doUpdate(
     JLOG(m_journal.debug()) << iIdentifier << " update " << (fast ? "fast" : "normal");
 
     {
-        std::lock_guard const sl(mLock);
+        std::scoped_lock const sl(mLock);
 
         if (!isValid(cache))
             return jvStatus;
@@ -805,7 +805,7 @@ PathRequest::doUpdate(
     }
 
     {
-        std::lock_guard const sl(mLock);
+        std::scoped_lock const sl(mLock);
         jvStatus = newStatus;
     }
 
diff --git a/src/xrpld/rpc/detail/PathRequestManager.cpp b/src/xrpld/rpc/detail/PathRequestManager.cpp
index 7508884be1..b05737197e 100644
--- a/src/xrpld/rpc/detail/PathRequestManager.cpp
+++ b/src/xrpld/rpc/detail/PathRequestManager.cpp
@@ -32,7 +32,7 @@ namespace xrpl {
 std::shared_ptr<AssetCache>
 PathRequestManager::getAssetCache(std::shared_ptr<ReadView const> const& ledger, bool authoritative)
 {
-    std::lock_guard const sl(mLock);
+    std::scoped_lock const sl(mLock);
 
     auto assetCache = assetCache_.lock();
 
@@ -66,7 +66,7 @@ PathRequestManager::updateAll(std::shared_ptr<ReadView const> const& inLedger)
 
     // Get the ledger and cache we should be using
     {
-        std::lock_guard const sl(mLock);
+        std::scoped_lock const sl(mLock);
         requests = requests_;
         cache = getAssetCache(inLedger, true);
     }
@@ -145,7 +145,7 @@ PathRequestManager::updateAll(std::shared_ptr<ReadView const> const& inLedger)
 
             if (remove)
             {
-                std::lock_guard const sl(mLock);
+                std::scoped_lock const sl(mLock);
 
                 // Remove any dangling weak pointers or weak
                 // pointers that refer to this path request.
@@ -189,7 +189,7 @@ PathRequestManager::updateAll(std::shared_ptr<ReadView const> const& inLedger)
         std::shared_ptr<AssetCache> lastCache;
         {
             // Get the latest requests, cache, and ledger for next pass
-            std::lock_guard const sl(mLock);
+            std::scoped_lock const sl(mLock);
 
             if (requests_.empty())
                 break;
@@ -206,14 +206,14 @@ PathRequestManager::updateAll(std::shared_ptr<ReadView const> const& inLedger)
 bool
 PathRequestManager::requestsPending() const
 {
-    std::lock_guard const sl(mLock);
+    std::scoped_lock const sl(mLock);
     return !requests_.empty();
 }
 
 void
 PathRequestManager::insertPathRequest(PathRequest::pointer const& req)
 {
-    std::lock_guard const sl(mLock);
+    std::scoped_lock const sl(mLock);
 
     // Insert after any older unserviced requests but before
     // any serviced requests
diff --git a/src/xrpld/rpc/detail/Pathfinder.cpp b/src/xrpld/rpc/detail/Pathfinder.cpp
index a31d4522a7..ed486c80a8 100644
--- a/src/xrpld/rpc/detail/Pathfinder.cpp
+++ b/src/xrpld/rpc/detail/Pathfinder.cpp
@@ -39,9 +39,23 @@
 #include <map>
 #include <memory>
 #include <optional>
+#include <ostream>
 #include <string>
 #include <vector>
 
+namespace xrpl {
+static std::ostream&
+operator<<(std::ostream& os, Pathfinder::NodeType t)
+{
+    return os << static_cast<int>(t);
+}
+static std::ostream&
+operator<<(std::ostream& os, Pathfinder::PaymentType t)
+{
+    return os << static_cast<int>(t);
+}
+}  // namespace xrpl
+
 /*
 
 Core Pathfinding Engine
@@ -139,22 +153,22 @@ pathTypeToString(Pathfinder::PathType const& type)
     {
         switch (node)
         {
-            case Pathfinder::nt_SOURCE:
+            case Pathfinder::NodeType::nt_SOURCE:
                 ret.append("s");
                 break;
-            case Pathfinder::nt_ACCOUNTS:
+            case Pathfinder::NodeType::nt_ACCOUNTS:
                 ret.append("a");
                 break;
-            case Pathfinder::nt_BOOKS:
+            case Pathfinder::NodeType::nt_BOOKS:
                 ret.append("b");
                 break;
-            case Pathfinder::nt_XRP_BOOK:
+            case Pathfinder::NodeType::nt_XRP_BOOK:
                 ret.append("x");
                 break;
-            case Pathfinder::nt_DEST_BOOK:
+            case Pathfinder::NodeType::nt_DEST_BOOK:
                 ret.append("f");
                 break;
-            case Pathfinder::nt_DESTINATION:
+            case Pathfinder::NodeType::nt_DESTINATION:
                 ret.append("d");
                 break;
         }
@@ -310,36 +324,36 @@ Pathfinder::findPaths(int searchLevel, std::function<bool(void)> const& continue
 
     // Now compute the payment type from the types of the source and destination
     // currencies.
-    PaymentType paymentType = pt_XRP_to_XRP;
+    PaymentType paymentType = PaymentType::pt_XRP_to_XRP;
     if (bSrcXrp && bDstXrp)
     {
         // XRP -> XRP
         JLOG(j_.debug()) << "XRP to XRP payment";
-        paymentType = pt_XRP_to_XRP;
+        paymentType = PaymentType::pt_XRP_to_XRP;
     }
     else if (bSrcXrp)
     {
         // XRP -> non-XRP
         JLOG(j_.debug()) << "XRP to non-XRP payment";
-        paymentType = pt_XRP_to_nonXRP;
+        paymentType = PaymentType::pt_XRP_to_nonXRP;
     }
     else if (bDstXrp)
     {
         // non-XRP -> XRP
         JLOG(j_.debug()) << "non-XRP to XRP payment";
-        paymentType = pt_nonXRP_to_XRP;
+        paymentType = PaymentType::pt_nonXRP_to_XRP;
     }
     else if (mSrcPathAsset == mDstAmount.asset())
     {
         // non-XRP -> non-XRP - Same currency
         JLOG(j_.debug()) << "non-XRP to non-XRP - same currency";
-        paymentType = pt_nonXRP_to_same;
+        paymentType = PaymentType::pt_nonXRP_to_same;
     }
     else
     {
         // non-XRP to non-XRP - Different currency
         JLOG(j_.debug()) << "non-XRP to non-XRP - cross currency";
-        paymentType = pt_nonXRP_to_nonXRP;
+        paymentType = PaymentType::pt_nonXRP_to_nonXRP;
     }
 
     // Now iterate over all paths for that paymentType.
@@ -888,29 +902,29 @@ Pathfinder::addPathsForType(
     auto nodeType = pathType.back();
     switch (nodeType)
     {
-        case nt_SOURCE:
+        case NodeType::nt_SOURCE:
             // Source must always be at the start, so pathsOut has to be empty.
             XRPL_ASSERT(pathsOut.empty(), "xrpl::Pathfinder::addPathsForType : empty paths");
             pathsOut.push_back(STPath());
             break;
 
-        case nt_ACCOUNTS:
+        case NodeType::nt_ACCOUNTS:
             addLinks(parentPaths, pathsOut, afADD_ACCOUNTS, continueCallback);
             break;
 
-        case nt_BOOKS:
+        case NodeType::nt_BOOKS:
             addLinks(parentPaths, pathsOut, afADD_BOOKS, continueCallback);
             break;
 
-        case nt_XRP_BOOK:
+        case NodeType::nt_XRP_BOOK:
             addLinks(parentPaths, pathsOut, afADD_BOOKS | afOB_XRP, continueCallback);
             break;
 
-        case nt_DEST_BOOK:
+        case NodeType::nt_DEST_BOOK:
             addLinks(parentPaths, pathsOut, afADD_BOOKS | afOB_LAST, continueCallback);
             break;
 
-        case nt_DESTINATION:
+        case NodeType::nt_DESTINATION:
             // FIXME: What if a different issuer was specified on the
             // destination amount?
             // TODO(tom): what does this even mean?  Should it be a JIRA?
@@ -1321,29 +1335,29 @@ makePath(char const* string)
         switch (*string++)
         {
             case 's':  // source
-                ret.push_back(Pathfinder::nt_SOURCE);
+                ret.push_back(Pathfinder::NodeType::nt_SOURCE);
                 break;
 
             case 'a':  // accounts
-                ret.push_back(Pathfinder::nt_ACCOUNTS);
+                ret.push_back(Pathfinder::NodeType::nt_ACCOUNTS);
                 break;
 
             case 'b':  // books
-                ret.push_back(Pathfinder::nt_BOOKS);
+                ret.push_back(Pathfinder::NodeType::nt_BOOKS);
                 break;
 
             case 'x':  // xrp book
-                ret.push_back(Pathfinder::nt_XRP_BOOK);
+                ret.push_back(Pathfinder::NodeType::nt_XRP_BOOK);
                 break;
 
             case 'f':  // book to final currency
-                ret.push_back(Pathfinder::nt_DEST_BOOK);
+                ret.push_back(Pathfinder::NodeType::nt_DEST_BOOK);
                 break;
 
             case 'd':
                 // Destination (with account, if required and not already
                 // present).
-                ret.push_back(Pathfinder::nt_DESTINATION);
+                ret.push_back(Pathfinder::NodeType::nt_DESTINATION);
                 break;
 
             case 0:
@@ -1376,11 +1390,11 @@ Pathfinder::initPathTable()
     // CAUTION: Do not include rules that build default paths
 
     mPathTable.clear();
-    fillPaths(pt_XRP_to_XRP, {});
+    fillPaths(PaymentType::pt_XRP_to_XRP, {});
     /* cspell: disable */
 
     fillPaths(
-        pt_XRP_to_nonXRP,
+        PaymentType::pt_XRP_to_nonXRP,
         {{1, "sfd"},    // source -> book -> gateway
          {3, "sfad"},   // source -> book -> account -> destination
          {5, "sfaad"},  // source -> book -> account -> account -> destination
@@ -1390,7 +1404,7 @@ Pathfinder::initPathTable()
          {10, "sbafad"}});
 
     fillPaths(
-        pt_nonXRP_to_XRP,
+        PaymentType::pt_nonXRP_to_XRP,
         {{1, "sxd"},   // gateway buys XRP
          {2, "saxd"},  // source -> gateway -> book(XRP) -> dest
          {6, "saaxd"},
@@ -1400,7 +1414,7 @@ Pathfinder::initPathTable()
 
     // non-XRP to non-XRP (same currency)
     fillPaths(
-        pt_nonXRP_to_same,
+        PaymentType::pt_nonXRP_to_same,
         {
             {1, "sad"},   // source -> gateway -> destination
             {1, "sfd"},   // source -> book -> destination
@@ -1419,7 +1433,7 @@ Pathfinder::initPathTable()
 
     // non-XRP to non-XRP (different currency)
     fillPaths(
-        pt_nonXRP_to_nonXRP,
+        PaymentType::pt_nonXRP_to_nonXRP,
         {
             {1, "sfad"},
             {1, "safd"},
diff --git a/src/xrpld/rpc/detail/Pathfinder.h b/src/xrpld/rpc/detail/Pathfinder.h
index 964ec8c1d1..b4380c04ca 100644
--- a/src/xrpld/rpc/detail/Pathfinder.h
+++ b/src/xrpld/rpc/detail/Pathfinder.h
@@ -60,7 +60,7 @@ public:
         AccountID const& srcIssuer,
         std::function<bool(void)> const& continueCallback = {});
 
-    enum NodeType {
+    enum class NodeType {
         nt_SOURCE,      // The source account: with an issuer account, if needed.
         nt_ACCOUNTS,    // Accounts that connect from this source/currency.
         nt_BOOKS,       // Order books that connect to this currency.
@@ -74,7 +74,7 @@ public:
 
     // PaymentType represents the types of the source and destination currencies
     // in a path request.
-    enum PaymentType {
+    enum class PaymentType {
         pt_XRP_to_XRP,
         pt_XRP_to_nonXRP,
         pt_nonXRP_to_XRP,
diff --git a/src/xrpld/rpc/detail/RPCSub.cpp b/src/xrpld/rpc/detail/RPCSub.cpp
index f9cd860908..f102f919c4 100644
--- a/src/xrpld/rpc/detail/RPCSub.cpp
+++ b/src/xrpld/rpc/detail/RPCSub.cpp
@@ -84,7 +84,7 @@ public:
     void
     send(Json::Value const& jvObj, bool broadcast) override
     {
-        std::lock_guard const sl(mLock);
+        std::scoped_lock const sl(mLock);
 
         auto jm = broadcast ? j_.debug() : j_.info();
         JLOG(jm) << "RPCCall::fromNetwork push: " << jvObj;
@@ -104,7 +104,7 @@ public:
     void
     setUsername(std::string const& strUsername) override
     {
-        std::lock_guard const sl(mLock);
+        std::scoped_lock const sl(mLock);
 
         mUsername = strUsername;
     }
@@ -112,7 +112,7 @@ public:
     void
     setPassword(std::string const& strPassword) override
     {
-        std::lock_guard const sl(mLock);
+        std::scoped_lock const sl(mLock);
 
         mPassword = strPassword;
     }
@@ -130,7 +130,7 @@ private:
         {
             {
                 // Obtain the lock to manipulate the queue and change sending.
-                std::lock_guard const sl(mLock);
+                std::scoped_lock const sl(mLock);
 
                 if (mDeque.empty())
                 {
diff --git a/src/xrpld/rpc/detail/ServerHandler.cpp b/src/xrpld/rpc/detail/ServerHandler.cpp
index db6dad2f1c..1000df064f 100644
--- a/src/xrpld/rpc/detail/ServerHandler.cpp
+++ b/src/xrpld/rpc/detail/ServerHandler.cpp
@@ -194,7 +194,7 @@ ServerHandler::onAccept(Session& session, boost::asio::ip::tcp::endpoint endpoin
     auto const& port = session.port();
 
     auto const c = [this, &port]() {
-        std::lock_guard const lock(mutex_);
+        std::scoped_lock const lock(mutex_);
         return ++count_[port];
     }();
 
@@ -378,14 +378,14 @@ ServerHandler::onWSMessage(
 void
 ServerHandler::onClose(Session& session, boost::system::error_code const&)
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     --count_[session.port()];
 }
 
 void
 ServerHandler::onStopped(Server&)
 {
-    std::lock_guard const lock(mutex_);
+    std::scoped_lock const lock(mutex_);
     stopped_ = true;
     condition_.notify_one();
 }
diff --git a/src/xrpld/rpc/detail/TransactionSign.cpp b/src/xrpld/rpc/detail/TransactionSign.cpp
index 85d5a62efc..7a60dc1f2c 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() != NEW)
+        if (tpTrans->getStatus() != TransStatus::NEW)
         {
             ret.first = RPC::make_error(rpcINTERNAL, "Unable to construct transaction: " + reason);
             return ret;
diff --git a/src/xrpld/rpc/handlers/transaction/Submit.cpp b/src/xrpld/rpc/handlers/transaction/Submit.cpp
index 73260c0661..936579c276 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() != NEW)
+    if (transaction->getStatus() != TransStatus::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 2c47515498..bf1b598620 100644
--- a/src/xrpld/shamap/NodeFamily.cpp
+++ b/src/xrpld/shamap/NodeFamily.cpp
@@ -53,12 +53,12 @@ void
 NodeFamily::reset()
 {
     {
-        std::lock_guard const lock(maxSeqMutex_);
+        std::scoped_lock const lock(maxSeqMutex_);
         maxSeq_ = 0;
     }
 
-    fbCache_->reset();
-    tnCache_->reset();
+    (*fbCache_).reset();
+    (*tnCache_).reset();
 }
 
 void