diff --git a/.clang-tidy b/.clang-tidy
index c13ca78ac2..84849db7a0 100644
--- a/.clang-tidy
+++ b/.clang-tidy
@@ -9,43 +9,90 @@ Checks: "-*,
 
   cppcoreguidelines-*,
   -cppcoreguidelines-avoid-c-arrays,
+  -cppcoreguidelines-avoid-capturing-lambda-coroutines,
   -cppcoreguidelines-avoid-const-or-ref-data-members,
   -cppcoreguidelines-avoid-do-while,
+  -cppcoreguidelines-avoid-goto,
   -cppcoreguidelines-avoid-magic-numbers,
   -cppcoreguidelines-avoid-non-const-global-variables,
+  -cppcoreguidelines-avoid-reference-coroutine-parameters,
   -cppcoreguidelines-c-copy-assignment-signature,
+  -cppcoreguidelines-explicit-virtual-functions,
   -cppcoreguidelines-interfaces-global-init,
+  -cppcoreguidelines-macro-to-enum,
   -cppcoreguidelines-macro-usage,
   -cppcoreguidelines-missing-std-forward,
   -cppcoreguidelines-narrowing-conversions,
+  -cppcoreguidelines-no-malloc,
+  -cppcoreguidelines-noexcept-destructor,
   -cppcoreguidelines-noexcept-move-operations,
+  -cppcoreguidelines-noexcept-swap,
   -cppcoreguidelines-non-private-member-variables-in-classes,
   -cppcoreguidelines-owning-memory,
+  -cppcoreguidelines-prefer-member-initializer,
   -cppcoreguidelines-pro-bounds-array-to-pointer-decay,
   -cppcoreguidelines-pro-bounds-avoid-unchecked-container-access,
   -cppcoreguidelines-pro-bounds-constant-array-index,
   -cppcoreguidelines-pro-bounds-pointer-arithmetic,
+  -cppcoreguidelines-pro-type-const-cast,
+  -cppcoreguidelines-pro-type-cstyle-cast,
   -cppcoreguidelines-pro-type-reinterpret-cast,
   -cppcoreguidelines-pro-type-union-access,
+  -cppcoreguidelines-pro-type-vararg,
+  -cppcoreguidelines-slicing,
   -cppcoreguidelines-special-member-functions,
 
   llvm-namespace-comment,
 
   misc-*,
+  -misc-anonymous-namespace-in-header,
+  -misc-confusable-identifiers,
+  -misc-coroutine-hostile-raii,
+  -misc-misleading-bidirectional,
+  -misc-misleading-identifier,
   -misc-multiple-inheritance,
+  -misc-new-delete-overloads,
   -misc-no-recursion,
+  -misc-non-copyable-objects,
   -misc-non-private-member-variables-in-classes,
   -misc-override-with-different-visibility,
+  -misc-predictable-rand,
+  -misc-unconventional-assign-operator,
+  -misc-uniqueptr-reset-release,
   -misc-unused-parameters,
   -misc-use-anonymous-namespace,
   -misc-use-internal-linkage,
 
   modernize-*,
+  -modernize-avoid-bind,
   -modernize-avoid-c-arrays,
   -modernize-avoid-c-style-cast,
+  -modernize-avoid-setjmp-longjmp,
+  -modernize-avoid-variadic-functions,
+  -modernize-deprecated-ios-base-aliases,
+  -modernize-loop-convert,
+  -modernize-macro-to-enum,
+  -modernize-min-max-use-initializer-list,
+  -modernize-raw-string-literal,
+  -modernize-redundant-void-arg,
+  -modernize-replace-auto-ptr,
+  -modernize-replace-disallow-copy-and-assign-macro,
+  -modernize-replace-random-shuffle,
   -modernize-return-braced-init-list,
+  -modernize-shrink-to-fit,
+  -modernize-unary-static-assert,
+  -modernize-use-auto,
+  -modernize-use-bool-literals,
+  -modernize-use-constraints,
+  -modernize-use-default-member-init,
   -modernize-use-integer-sign-comparison,
+  -modernize-use-noexcept,
+  -modernize-use-nullptr,
+  -modernize-use-std-format,
+  -modernize-use-std-print,
   -modernize-use-trailing-return-type,
+  -modernize-use-transparent-functors,
+  -modernize-use-uncaught-exceptions,
 
   performance-*,
   -performance-avoid-endl,
diff --git a/.github/scripts/levelization/results/ordering.txt b/.github/scripts/levelization/results/ordering.txt
index aee6f4c579..5cc49dd2f5 100644
--- a/.github/scripts/levelization/results/ordering.txt
+++ b/.github/scripts/levelization/results/ordering.txt
@@ -72,6 +72,7 @@ test.app > xrpl.server
 test.app > xrpl.shamap
 test.app > xrpl.tx
 test.basics > test.jtx
+test.basics > test.unit_test
 test.basics > xrpl.basics
 test.basics > xrpl.core
 test.basics > xrpld.rpc
@@ -161,6 +162,9 @@ test.protocol > test.unit_test
 test.protocol > xrpl.basics
 test.protocol > xrpl.json
 test.protocol > xrpl.protocol
+test.resource > test.unit_test
+test.resource > xrpl.basics
+test.resource > xrpl.resource
 test.rpc > test.jtx
 test.rpc > xrpl.basics
 test.rpc > xrpl.config
@@ -184,6 +188,12 @@ test.server > xrpld.core
 test.server > xrpl.json
 test.server > xrpl.protocol
 test.server > xrpl.server
+test.shamap > test.unit_test
+test.shamap > xrpl.basics
+test.shamap > xrpl.config
+test.shamap > xrpl.nodestore
+test.shamap > xrpl.protocol
+test.shamap > xrpl.shamap
 test.unit_test > xrpl.basics
 test.unit_test > xrpl.protocol
 tests.libxrpl > xrpl.basics
@@ -195,7 +205,6 @@ tests.libxrpl > xrpl.net
 tests.libxrpl > xrpl.nodestore
 tests.libxrpl > xrpl.protocol
 tests.libxrpl > xrpl.protocol_autogen
-tests.libxrpl > xrpl.resource
 tests.libxrpl > xrpl.server
 tests.libxrpl > xrpl.shamap
 tests.libxrpl > xrpl.tx
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 910bda8d4c..2e4521870d 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -90,19 +90,20 @@ repos:
   - repo: https://github.com/streetsidesoftware/cspell-cli
     rev: ea11f9efc0bec520073405bc30552da887ba71bc # frozen: v10.0.1
     hooks:
-      - id: cspell
-        name: check changed files spelling
+      - id: cspell # Spell check changed files
         exclude: |
           (?x)^(
-              \.cspell\.config\.yaml|
+              .config/cspell.config.yaml|
               include/xrpl/protocol_autogen/(transactions|ledger_entries)/.*
           )$
-      - id: cspell
+      - id: cspell # Spell check the commit message
         name: check commit message spelling
         args:
           - --no-must-find-files
           - --no-progress
           - --no-summary
+          - --files
+          - .git/COMMIT_EDITMSG
         stages: [commit-msg]
 
   - repo: local
diff --git a/BUILD.md b/BUILD.md
index a15c94edc9..6ccdde12d5 100644
--- a/BUILD.md
+++ b/BUILD.md
@@ -25,7 +25,7 @@ You can verify that the required tools are installed and runnable with:
 | ----------- | --------------- |
 | GCC         | 15.2            |
 | Clang       | 22              |
-| Apple Clang | 21              |
+| Apple Clang | 17              |
 | MSVC        | 19.44[^windows] |
 
 ## Operating Systems
diff --git a/bin/pre-commit/clang_tidy_check.py b/bin/pre-commit/clang_tidy_check.py
index 5b5792b405..d074c56acf 100755
--- a/bin/pre-commit/clang_tidy_check.py
+++ b/bin/pre-commit/clang_tidy_check.py
@@ -17,11 +17,9 @@ import subprocess
 import sys
 from pathlib import Path
 
-CLANG_TIDY_VERSION = 22
-
 
 def find_run_clang_tidy() -> str | None:
-    for candidate in (f"run-clang-tidy-{CLANG_TIDY_VERSION}", "run-clang-tidy"):
+    for candidate in ("run-clang-tidy-21", "run-clang-tidy"):
         if path := shutil.which(candidate):
             return path
     return None
@@ -46,8 +44,8 @@ def main():
     run_clang_tidy = find_run_clang_tidy()
     if not run_clang_tidy:
         print(
-            f"clang-tidy check failed: TIDY is enabled but neither "
-            f"'run-clang-tidy-{CLANG_TIDY_VERSION}' nor 'run-clang-tidy' was found in PATH.",
+            "clang-tidy check failed: TIDY is enabled but neither "
+            "'run-clang-tidy-21' nor 'run-clang-tidy' was found in PATH.",
             file=sys.stderr,
         )
         return 1
diff --git a/.cspell.config.yaml b/cspell.config.yaml
similarity index 96%
rename from .cspell.config.yaml
rename to cspell.config.yaml
index dc24bf833b..81216e9f29 100644
--- a/.cspell.config.yaml
+++ b/cspell.config.yaml
@@ -36,7 +36,9 @@ overrides:
       - /'[^']*'/g # single-quoted strings
       - /`[^`]*`/g # backtick strings
 suggestWords:
-  - unsynched->unsynced
+  - xprl->xrpl
+  - xprld->xrpld # cspell: disable-line not sure what this problem is....
+  - unsynched->unsynced # cspell: disable-line not sure what this problem is....
   - synched->synced
   - synch->sync
 words:
diff --git a/include/xrpl/basics/Slice.h b/include/xrpl/basics/Slice.h
index f87ca063b8..948d012958 100644
--- a/include/xrpl/basics/Slice.h
+++ b/include/xrpl/basics/Slice.h
@@ -211,17 +211,15 @@ operator<<(Stream& s, Slice const& v)
 }
 
 template <class T, std::size_t N>
-Slice
+std::enable_if_t<std::is_same_v<T, char> || std::is_same_v<T, unsigned char>, Slice>
 makeSlice(std::array<T, N> const& a)
-    requires(std::is_same_v<T, char> || std::is_same_v<T, unsigned char>)
 {
     return Slice(a.data(), a.size());
 }
 
 template <class T, class Alloc>
-Slice
+std::enable_if_t<std::is_same_v<T, char> || std::is_same_v<T, unsigned char>, Slice>
 makeSlice(std::vector<T, Alloc> const& v)
-    requires(std::is_same_v<T, char> || std::is_same_v<T, unsigned char>)
 {
     return Slice(v.data(), v.size());
 }
diff --git a/include/xrpl/basics/TaggedCache.h b/include/xrpl/basics/TaggedCache.h
index 16c87cf833..71ebfc57a4 100644
--- a/include/xrpl/basics/TaggedCache.h
+++ b/include/xrpl/basics/TaggedCache.h
@@ -212,13 +212,11 @@ public:
     */
     template <class ReturnType = bool>
     auto
-    insert(key_type const& key, T const& value) -> ReturnType
-        requires(!IsKeyCache);
+    insert(key_type const& key, T const& value) -> std::enable_if_t<!IsKeyCache, ReturnType>;
 
     template <class ReturnType = bool>
     auto
-    insert(key_type const& key) -> ReturnType
-        requires IsKeyCache;
+    insert(key_type const& key) -> std::enable_if_t<IsKeyCache, ReturnType>;
 
     // VFALCO NOTE It looks like this returns a copy of the data in
     //             the output parameter 'data'. This could be expensive.
diff --git a/include/xrpl/basics/TaggedCache.ipp b/include/xrpl/basics/TaggedCache.ipp
index b79561c71a..ffcd533216 100644
--- a/include/xrpl/basics/TaggedCache.ipp
+++ b/include/xrpl/basics/TaggedCache.ipp
@@ -57,10 +57,7 @@ inline TaggedCache<
         beast::insight::Collector::ptr const& collector)
     : journal_(journal)
     , clock_(clock)
-    , stats_(
-          name,
-          [this] { collectMetrics(); },
-          collector)
+    , stats_(name, std::bind(&TaggedCache::collectMetrics, this), collector)
     , name_(name)
     , targetSize_(size)
     , targetAge_(expiration)
@@ -503,8 +500,7 @@ template <
 template <class ReturnType>
 inline auto
 TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
-    insert(key_type const& key, T const& value) -> ReturnType
-    requires(!IsKeyCache)
+    insert(key_type const& key, T const& value) -> std::enable_if_t<!IsKeyCache, ReturnType>
 {
     static_assert(
         std::is_same_v<std::shared_ptr<T>, SharedPointerType> ||
@@ -534,8 +530,7 @@ template <
 template <class ReturnType>
 inline auto
 TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
-    insert(key_type const& key) -> ReturnType
-    requires IsKeyCache
+    insert(key_type const& key) -> std::enable_if_t<IsKeyCache, ReturnType>
 {
     std::scoped_lock const lock(mutex_);
     clock_type::time_point const now(clock_.now());
diff --git a/include/xrpl/basics/ToString.h b/include/xrpl/basics/ToString.h
index e9f8f43633..7764c1e3e3 100644
--- a/include/xrpl/basics/ToString.h
+++ b/include/xrpl/basics/ToString.h
@@ -12,9 +12,8 @@ namespace xrpl {
  */
 
 template <class T>
-std::string
+std::enable_if_t<std::is_arithmetic_v<T>, std::string>
 to_string(T t)  // NOLINT(readability-identifier-naming)
-    requires(std::is_arithmetic_v<T>)
 {
     return std::to_string(t);
 }
diff --git a/include/xrpl/basics/base_uint.h b/include/xrpl/basics/base_uint.h
index 481a7dbd77..e6ca1993f9 100644
--- a/include/xrpl/basics/base_uint.h
+++ b/include/xrpl/basics/base_uint.h
@@ -97,7 +97,7 @@ public:
     //
 
     static constexpr std::size_t kBytes = Bits / 8;
-    static_assert(sizeof(data_) == kBytes);
+    static_assert(sizeof(data_) == kBytes, "");
 
     using size_type = std::size_t;
     using difference_type = std::ptrdiff_t;
@@ -280,11 +280,12 @@ public:
     {
     }
 
-    template <class Container>
-    explicit BaseUInt(Container const& c)
-        requires(
+    template <
+        class Container,
+        class = std::enable_if_t<
             detail::IsContiguousContainer<Container>::value &&
-            std::is_trivially_copyable_v<typename Container::value_type>)
+            std::is_trivially_copyable_v<typename Container::value_type>>>
+    explicit BaseUInt(Container const& c)
     {
         // Use AlwaysFalseT so the static_assert condition is dependent
         // and only triggers when this constructor template is instantiated.
@@ -294,12 +295,13 @@ public:
             "Use base_uint::fromRaw instead.");
     }
 
-    template <class Container>
+    template <
+        class Container,
+        class = std::enable_if_t<
+            detail::IsContiguousContainer<Container>::value &&
+            std::is_trivially_copyable_v<typename Container::value_type>>>
     static BaseUInt
     fromRaw(Container const& c)
-        requires(
-            detail::IsContiguousContainer<Container>::value &&
-            std::is_trivially_copyable_v<typename Container::value_type>)
     {
         BaseUInt result;
         XRPL_ASSERT(
@@ -310,11 +312,11 @@ public:
     }
 
     template <class Container>
-    BaseUInt&
+    std::enable_if_t<
+        detail::IsContiguousContainer<Container>::value &&
+            std::is_trivially_copyable_v<typename Container::value_type>,
+        BaseUInt&>
     operator=(Container const& c)
-        requires(
-            detail::IsContiguousContainer<Container>::value &&
-            std::is_trivially_copyable_v<typename Container::value_type>)
     {
         XRPL_ASSERT(
             c.size() * sizeof(typename Container::value_type) == size(),
diff --git a/include/xrpl/basics/comparators.h b/include/xrpl/basics/comparators.h
new file mode 100644
index 0000000000..0e21d38d6b
--- /dev/null
+++ b/include/xrpl/basics/comparators.h
@@ -0,0 +1,54 @@
+#pragma once
+
+#include <functional>
+
+namespace xrpl {
+
+#ifdef _MSC_VER
+
+/*
+ * MSVC 2019 version 16.9.0 added [[nodiscard]] to the std comparison
+ * operator() functions. boost::bimap checks that the comparator is a
+ * BinaryFunction, in part by calling the function and ignoring the value.
+ * These two things don't play well together. These wrapper classes simply
+ * strip [[nodiscard]] from operator() for use in boost::bimap.
+ *
+ * See also:
+ *  https://www.boost.org/doc/libs/1_75_0/libs/bimap/doc/html/boost_bimap/the_tutorial/controlling_collection_types.html
+ */
+
+template <class T = void>
+struct less
+{
+    using result_type = bool;
+
+    constexpr bool
+    operator()(T const& left, T const& right) const
+    {
+        return std::less<T>()(left, right);
+    }
+};
+
+template <class T = void>
+struct equal_to
+{
+    using result_type = bool;
+
+    constexpr bool
+    operator()(T const& left, T const& right) const
+    {
+        return std::equal_to<T>()(left, right);
+    }
+};
+
+#else
+
+template <class T = void>
+using less = std::less<T>;
+
+template <class T = void>
+using equal_to = std::equal_to<T>;
+
+#endif
+
+}  // namespace xrpl
diff --git a/include/xrpl/basics/partitioned_unordered_map.h b/include/xrpl/basics/partitioned_unordered_map.h
index e78043e252..c2750a5769 100644
--- a/include/xrpl/basics/partitioned_unordered_map.h
+++ b/include/xrpl/basics/partitioned_unordered_map.h
@@ -138,8 +138,11 @@ public:
         {
         }
 
-        ConstIterator(Iterator const& orig) : map(orig.map), ait(orig.ait), mit(orig.mit)
+        ConstIterator(Iterator const& orig)
         {
+            map = orig.map;
+            ait = orig.ait;
+            mit = orig.mit;
         }
 
         const_reference
@@ -228,11 +231,11 @@ private:
 
 public:
     PartitionedUnorderedMap(std::optional<std::size_t> partitions = std::nullopt)
+    {
         // Set partitions to the number of hardware threads if the parameter
         // is either empty or set to 0.
-        : partitions_(
-              partitions && (*partitions != 0u) ? *partitions : std::thread::hardware_concurrency())
-    {
+        partitions_ =
+            partitions && (*partitions != 0u) ? *partitions : std::thread::hardware_concurrency();
         map_.resize(partitions_);
         XRPL_ASSERT(
             partitions_,
diff --git a/include/xrpl/basics/random.h b/include/xrpl/basics/random.h
index c544e7d0c8..cceaa6f029 100644
--- a/include/xrpl/basics/random.h
+++ b/include/xrpl/basics/random.h
@@ -91,9 +91,8 @@ defaultPrng()
 */
 /** @{ */
 template <class Engine, class Integral>
-Integral
+std::enable_if_t<std::is_integral_v<Integral> && detail::is_engine<Engine>::value, Integral>
 randInt(Engine& engine, Integral min, Integral max)
-    requires(std::is_integral_v<Integral> && detail::is_engine<Engine>::value)
 {
     XRPL_ASSERT(max > min, "xrpl::randInt : max over min inputs");
 
@@ -104,41 +103,36 @@ randInt(Engine& engine, Integral min, Integral max)
 }
 
 template <class Integral>
-Integral
+std::enable_if_t<std::is_integral_v<Integral>, Integral>
 randInt(Integral min, Integral max)
-    requires(std::is_integral_v<Integral>)
 {
     return randInt(defaultPrng(), min, max);
 }
 
 template <class Engine, class Integral>
-Integral
+std::enable_if_t<std::is_integral_v<Integral> && detail::is_engine<Engine>::value, Integral>
 randInt(Engine& engine, Integral max)
-    requires(std::is_integral_v<Integral> && detail::is_engine<Engine>::value)
 {
     return randInt(engine, Integral(0), max);
 }
 
 template <class Integral>
-Integral
+std::enable_if_t<std::is_integral_v<Integral>, Integral>
 randInt(Integral max)
-    requires(std::is_integral_v<Integral>)
 {
     return randInt(defaultPrng(), max);
 }
 
 template <class Integral, class Engine>
-Integral
+std::enable_if_t<std::is_integral_v<Integral> && detail::is_engine<Engine>::value, Integral>
 randInt(Engine& engine)
-    requires(std::is_integral_v<Integral> && detail::is_engine<Engine>::value)
 {
     return randInt(engine, std::numeric_limits<Integral>::max());
 }
 
 template <class Integral = int>
-Integral
+std::enable_if_t<std::is_integral_v<Integral>, Integral>
 randInt()
-    requires(std::is_integral_v<Integral>)
 {
     return randInt(defaultPrng(), std::numeric_limits<Integral>::max());
 }
@@ -147,20 +141,19 @@ randInt()
 /** Return a random byte */
 /** @{ */
 template <class Byte, class Engine>
-Byte
+std::enable_if_t<
+    (std::is_same_v<Byte, unsigned char> || std::is_same_v<Byte, std::uint8_t>) &&
+        detail::is_engine<Engine>::value,
+    Byte>
 randByte(Engine& engine)
-    requires(
-        (std::is_same_v<Byte, unsigned char> || std::is_same_v<Byte, std::uint8_t>) &&
-        detail::is_engine<Engine>::value)
 {
     return static_cast<Byte>(randInt<Engine, std::uint32_t>(
         engine, std::numeric_limits<Byte>::min(), std::numeric_limits<Byte>::max()));
 }
 
 template <class Byte = std::uint8_t>
-Byte
+std::enable_if_t<(std::is_same_v<Byte, unsigned char> || std::is_same_v<Byte, std::uint8_t>), Byte>
 randByte()
-    requires(std::is_same_v<Byte, unsigned char> || std::is_same_v<Byte, std::uint8_t>)
 {
     return randByte<Byte>(defaultPrng());
 }
diff --git a/include/xrpl/basics/safe_cast.h b/include/xrpl/basics/safe_cast.h
index 7f2b93a7eb..714146e089 100644
--- a/include/xrpl/basics/safe_cast.h
+++ b/include/xrpl/basics/safe_cast.h
@@ -1,7 +1,5 @@
 #pragma once
 
-#include <xrpl/beast/utility/instrumentation.h>  // IWYU pragma: keep
-
 #include <type_traits>
 
 namespace xrpl {
@@ -17,9 +15,8 @@ concept SafeToCast = (std::is_integral_v<Src> && std::is_integral_v<Dest>) &&
                                                      : sizeof(Dest) >= sizeof(Src));
 
 template <class Dest, class Src>
-constexpr Dest
+constexpr std::enable_if_t<std::is_integral_v<Dest> && std::is_integral_v<Src>, Dest>
 safeCast(Src s) noexcept
-    requires(std::is_integral_v<Dest> && std::is_integral_v<Src>)
 {
     static_assert(
         std::is_signed_v<Dest> || std::is_unsigned_v<Src>, "Cannot cast signed to unsigned");
@@ -31,17 +28,15 @@ safeCast(Src s) noexcept
 }
 
 template <class Dest, class Src>
-constexpr Dest
+constexpr std::enable_if_t<std::is_enum_v<Dest> && std::is_integral_v<Src>, Dest>
 safeCast(Src s) noexcept
-    requires(std::is_enum_v<Dest> && std::is_integral_v<Src>)
 {
     return static_cast<Dest>(safeCast<std::underlying_type_t<Dest>>(s));
 }
 
 template <class Dest, class Src>
-constexpr Dest
+constexpr std::enable_if_t<std::is_integral_v<Dest> && std::is_enum_v<Src>, Dest>
 safeCast(Src s) noexcept
-    requires(std::is_integral_v<Dest> && std::is_enum_v<Src>)
 {
     return safeCast<Dest>(static_cast<std::underlying_type_t<Src>>(s));
 }
@@ -51,9 +46,8 @@ safeCast(Src s) noexcept
 // underlying types become safe, it can be converted to a safe_cast.
 
 template <class Dest, class Src>
-constexpr Dest
+constexpr std::enable_if_t<std::is_integral_v<Dest> && std::is_integral_v<Src>, Dest>
 unsafeCast(Src s) noexcept
-    requires(std::is_integral_v<Dest> && std::is_integral_v<Src>)
 {
     static_assert(
         !SafeToCast<Src, Dest>,
@@ -63,17 +57,15 @@ unsafeCast(Src s) noexcept
 }
 
 template <class Dest, class Src>
-constexpr Dest
+constexpr std::enable_if_t<std::is_enum_v<Dest> && std::is_integral_v<Src>, Dest>
 unsafeCast(Src s) noexcept
-    requires(std::is_enum_v<Dest> && std::is_integral_v<Src>)
 {
     return static_cast<Dest>(unsafeCast<std::underlying_type_t<Dest>>(s));
 }
 
 template <class Dest, class Src>
-constexpr Dest
+constexpr std::enable_if_t<std::is_integral_v<Dest> && std::is_enum_v<Src>, Dest>
 unsafeCast(Src s) noexcept
-    requires(std::is_integral_v<Dest> && std::is_enum_v<Src>)
 {
     return unsafeCast<Dest>(static_cast<std::underlying_type_t<Src>>(s));
 }
diff --git a/include/xrpl/basics/scope.h b/include/xrpl/basics/scope.h
index e63bb69eb5..cfd21e6e30 100644
--- a/include/xrpl/basics/scope.h
+++ b/include/xrpl/basics/scope.h
@@ -46,9 +46,11 @@ public:
     operator=(ScopeExit&&) = delete;
 
     template <class EFP>
-    explicit ScopeExit(EFP&& f) noexcept
-        requires(
-            !std::is_same_v<std::remove_cv_t<EFP>, ScopeExit> && std::is_constructible_v<EF, EFP>)
+    explicit ScopeExit(
+        EFP&& f,
+        std::enable_if_t<
+            !std::is_same_v<std::remove_cv_t<EFP>, ScopeExit> &&
+            std::is_constructible_v<EF, EFP>>* = 0) noexcept
         : exitFunction_{std::forward<EFP>(f)}
     {
         static_assert(std::is_nothrow_constructible_v<EF, decltype(std::forward<EFP>(f))>);
@@ -91,9 +93,11 @@ public:
     operator=(ScopeFail&&) = delete;
 
     template <class EFP>
-    explicit ScopeFail(EFP&& f) noexcept
-        requires(
-            !std::is_same_v<std::remove_cv_t<EFP>, ScopeFail> && std::is_constructible_v<EF, EFP>)
+    explicit ScopeFail(
+        EFP&& f,
+        std::enable_if_t<
+            !std::is_same_v<std::remove_cv_t<EFP>, ScopeFail> &&
+            std::is_constructible_v<EF, EFP>>* = 0) noexcept
         : exitFunction_{std::forward<EFP>(f)}
     {
         static_assert(std::is_nothrow_constructible_v<EF, decltype(std::forward<EFP>(f))>);
@@ -136,11 +140,12 @@ public:
     operator=(ScopeSuccess&&) = delete;
 
     template <class EFP>
-    explicit ScopeSuccess(EFP&& f) noexcept(
-        std::is_nothrow_constructible_v<EF, EFP> || std::is_nothrow_constructible_v<EF, EFP&>)
-        requires(
+    explicit ScopeSuccess(
+        EFP&& f,
+        std::enable_if_t<
             !std::is_same_v<std::remove_cv_t<EFP>, ScopeSuccess> &&
-            std::is_constructible_v<EF, EFP>)
+            std::is_constructible_v<EF, EFP>>* =
+            0) noexcept(std::is_nothrow_constructible_v<EF, EFP> || std::is_nothrow_constructible_v<EF, EFP&>)
         : exitFunction_{std::forward<EFP>(f)}
     {
     }
diff --git a/include/xrpl/basics/tagged_integer.h b/include/xrpl/basics/tagged_integer.h
index 5a088db863..8fbd2a274b 100644
--- a/include/xrpl/basics/tagged_integer.h
+++ b/include/xrpl/basics/tagged_integer.h
@@ -43,10 +43,10 @@ public:
 
     TaggedInteger() = default;
 
-    template <class OtherInt>
-    explicit constexpr TaggedInteger(OtherInt value) noexcept
-        requires(std::is_integral_v<OtherInt> && sizeof(OtherInt) <= sizeof(Int))
-        : value_(value)
+    template <
+        class OtherInt,
+        class = std::enable_if_t<std::is_integral_v<OtherInt> && sizeof(OtherInt) <= sizeof(Int)>>
+    explicit constexpr TaggedInteger(OtherInt value) noexcept : value_(value)
     {
         static_assert(sizeof(TaggedInteger) == sizeof(Int), "tagged_integer is adding padding");
     }
diff --git a/include/xrpl/beast/container/aged_container_utility.h b/include/xrpl/beast/container/aged_container_utility.h
index f43e59b0f7..7cda863fab 100644
--- a/include/xrpl/beast/container/aged_container_utility.h
+++ b/include/xrpl/beast/container/aged_container_utility.h
@@ -4,14 +4,14 @@
 
 #include <chrono>
 #include <cstddef>
+#include <type_traits>
 
 namespace beast {
 
 /** Expire aged container items past the specified age. */
 template <class AgedContainer, class Rep, class Period>
-std::size_t
+std::enable_if_t<IsAgedContainer<AgedContainer>::value, std::size_t>
 expire(AgedContainer& c, std::chrono::duration<Rep, Period> const& age)
-    requires(IsAgedContainer<AgedContainer>::value)
 {
     std::size_t n(0);
     auto const expired(c.clock().now() - age);
diff --git a/include/xrpl/beast/container/detail/aged_container_iterator.h b/include/xrpl/beast/container/detail/aged_container_iterator.h
index d6c061bb86..02fb3927dd 100644
--- a/include/xrpl/beast/container/detail/aged_container_iterator.h
+++ b/include/xrpl/beast/container/detail/aged_container_iterator.h
@@ -30,19 +30,20 @@ public:
 
     // Disable constructing a const_iterator from a non-const_iterator.
     // Converting between reverse and non-reverse iterators should be explicit.
-    template <bool OtherIsConst, class OtherIterator>
-    explicit AgedContainerIterator(AgedContainerIterator<OtherIsConst, OtherIterator> const& other)
-        requires(
+    template <
+        bool OtherIsConst,
+        class OtherIterator,
+        class = std::enable_if_t<
             (!OtherIsConst || IsConst) &&
-            !static_cast<bool>(std::is_same_v<Iterator, OtherIterator>))
+            !static_cast<bool>(std::is_same_v<Iterator, OtherIterator>)>>
+    explicit AgedContainerIterator(AgedContainerIterator<OtherIsConst, OtherIterator> const& other)
         : iter_(other.iter_)
     {
     }
 
     // Disable constructing a const_iterator from a non-const_iterator.
-    template <bool OtherIsConst>
+    template <bool OtherIsConst, class = std::enable_if_t<!OtherIsConst || IsConst>>
     AgedContainerIterator(AgedContainerIterator<OtherIsConst, Iterator> const& other)
-        requires(!OtherIsConst || IsConst)
         : iter_(other.iter_)
     {
     }
@@ -51,8 +52,7 @@ public:
     template <bool OtherIsConst, class OtherIterator>
     auto
     operator=(AgedContainerIterator<OtherIsConst, OtherIterator> const& other)
-        -> AgedContainerIterator&
-        requires(!OtherIsConst || IsConst)
+        -> std::enable_if_t<!OtherIsConst || IsConst, AgedContainerIterator&>
     {
         iter_ = other.iter_;
         return *this;
diff --git a/include/xrpl/beast/container/detail/aged_ordered_container.h b/include/xrpl/beast/container/detail/aged_ordered_container.h
index c98f16022f..0533a51f00 100644
--- a/include/xrpl/beast/container/detail/aged_ordered_container.h
+++ b/include/xrpl/beast/container/detail/aged_ordered_container.h
@@ -111,9 +111,10 @@ private:
         {
         }
 
-        template <class... Args>
+        template <
+            class... Args,
+            class = std::enable_if_t<std::is_constructible_v<value_type, Args...>>>
         Element(time_point const& when, Args&&... args)
-            requires(std::is_constructible_v<value_type, Args...>)
             : value(std::forward<Args>(args)...), when(when)
         {
         }
@@ -359,7 +360,6 @@ private:
     deleteElement(Element const* p)
     {
         ElementAllocatorTraits::destroy(config_.alloc(), p);
-        // NOLINTNEXTLINE(cppcoreguidelines-pro-type-const-cast)
         ElementAllocatorTraits::deallocate(config_.alloc(), const_cast<Element*>(p), 1);
     }
 
@@ -608,25 +608,35 @@ public:
     //
     //--------------------------------------------------------------------------
 
-    template <class K, bool MaybeMulti = IsMulti, bool MaybeMap = IsMap>
+    template <
+        class K,
+        bool MaybeMulti = IsMulti,
+        bool MaybeMap = IsMap,
+        class = std::enable_if_t<MaybeMap && !MaybeMulti>>
     std::conditional_t<IsMap, T, void*>&
-    at(K const& k)
-        requires(MaybeMap && !MaybeMulti);
+    at(K const& k);
 
-    template <class K, bool MaybeMulti = IsMulti, bool MaybeMap = IsMap>
+    template <
+        class K,
+        bool MaybeMulti = IsMulti,
+        bool MaybeMap = IsMap,
+        class = std::enable_if_t<MaybeMap && !MaybeMulti>>
     std::conditional<IsMap, T, void*>::type const&
-    at(K const& k) const
-        requires(MaybeMap && !MaybeMulti);
+    at(K const& k) const;
 
-    template <bool MaybeMulti = IsMulti, bool MaybeMap = IsMap>
+    template <
+        bool MaybeMulti = IsMulti,
+        bool MaybeMap = IsMap,
+        class = std::enable_if_t<MaybeMap && !MaybeMulti>>
     std::conditional_t<IsMap, T, void*>&
-    operator[](Key const& key)
-        requires(MaybeMap && !MaybeMulti);
+    operator[](Key const& key);
 
-    template <bool MaybeMulti = IsMulti, bool MaybeMap = IsMap>
+    template <
+        bool MaybeMulti = IsMulti,
+        bool MaybeMap = IsMap,
+        class = std::enable_if_t<MaybeMap && !MaybeMulti>>
     std::conditional_t<IsMap, T, void*>&
-    operator[](Key&& key)
-        requires(MaybeMap && !MaybeMulti);
+    operator[](Key&& key);
 
     //--------------------------------------------------------------------------
     //
@@ -760,40 +770,35 @@ public:
     // map, set
     template <bool MaybeMulti = IsMulti>
     auto
-    insert(value_type const& value) -> std::pair<iterator, bool>
-        requires(!MaybeMulti);
+    insert(value_type const& value) -> std::enable_if_t<!MaybeMulti, std::pair<iterator, bool>>;
 
     // multimap, multiset
     template <bool MaybeMulti = IsMulti>
     auto
-    insert(value_type const& value) -> iterator
-        requires MaybeMulti;
+    insert(value_type const& value) -> std::enable_if_t<MaybeMulti, iterator>;
 
     // set
     template <bool MaybeMulti = IsMulti, bool MaybeMap = IsMap>
     auto
-    insert(value_type&& value) -> std::pair<iterator, bool>
-        requires(!MaybeMulti && !MaybeMap);
+    insert(value_type&& value)
+        -> std::enable_if_t<!MaybeMulti && !MaybeMap, std::pair<iterator, bool>>;
 
     // multiset
     template <bool MaybeMulti = IsMulti, bool MaybeMap = IsMap>
     auto
-    insert(value_type&& value) -> iterator
-        requires(MaybeMulti && !MaybeMap);
+    insert(value_type&& value) -> std::enable_if_t<MaybeMulti && !MaybeMap, iterator>;
 
     //---
 
     // map, set
     template <bool MaybeMulti = IsMulti>
     auto
-    insert(const_iterator hint, value_type const& value) -> iterator
-        requires(!MaybeMulti);
+    insert(const_iterator hint, value_type const& value) -> std::enable_if_t<!MaybeMulti, iterator>;
 
     // multimap, multiset
     template <bool MaybeMulti = IsMulti>
-    iterator
+    std::enable_if_t<MaybeMulti, iterator>
     insert(const_iterator /*hint*/, value_type const& value)
-        requires MaybeMulti
     {
         // VFALCO TODO Figure out how to utilize 'hint'
         return insert(value);
@@ -802,14 +807,12 @@ public:
     // map, set
     template <bool MaybeMulti = IsMulti>
     auto
-    insert(const_iterator hint, value_type&& value) -> iterator
-        requires(!MaybeMulti);
+    insert(const_iterator hint, value_type&& value) -> std::enable_if_t<!MaybeMulti, iterator>;
 
     // multimap, multiset
     template <bool MaybeMulti = IsMulti>
-    iterator
+    std::enable_if_t<MaybeMulti, iterator>
     insert(const_iterator /*hint*/, value_type&& value)
-        requires MaybeMulti
     {
         // VFALCO TODO Figure out how to utilize 'hint'
         return insert(std::move(value));
@@ -817,18 +820,20 @@ public:
 
     // map, multimap
     template <class P, bool MaybeMap = IsMap>
-    std::conditional_t<IsMulti, iterator, std::pair<iterator, bool>>
+    std::enable_if_t<
+        MaybeMap && std::is_constructible_v<value_type, P&&>,
+        std::conditional_t<IsMulti, iterator, std::pair<iterator, bool>>>
     insert(P&& value)
-        requires(MaybeMap && std::is_constructible_v<value_type, P &&>)
     {
         return emplace(std::forward<P>(value));
     }
 
     // map, multimap
     template <class P, bool MaybeMap = IsMap>
-    std::conditional_t<IsMulti, iterator, std::pair<iterator, bool>>
+    std::enable_if_t<
+        MaybeMap && std::is_constructible_v<value_type, P&&>,
+        std::conditional_t<IsMulti, iterator, std::pair<iterator, bool>>>
     insert(const_iterator hint, P&& value)
-        requires(MaybeMap && std::is_constructible_v<value_type, P &&>)
     {
         return emplaceHint(hint, std::forward<P>(value));
     }
@@ -850,45 +855,46 @@ public:
     // map, set
     template <bool MaybeMulti = IsMulti, class... Args>
     auto
-    emplace(Args&&... args) -> std::pair<iterator, bool>
-        requires(!MaybeMulti);
+    emplace(Args&&... args) -> std::enable_if_t<!MaybeMulti, std::pair<iterator, bool>>;
 
     // multiset, multimap
     template <bool MaybeMulti = IsMulti, class... Args>
     auto
-    emplace(Args&&... args) -> iterator
-        requires MaybeMulti;
+    emplace(Args&&... args) -> std::enable_if_t<MaybeMulti, iterator>;
 
     // map, set
     template <bool MaybeMulti = IsMulti, class... Args>
     auto
-    emplaceHint(const_iterator hint, Args&&... args) -> std::pair<iterator, bool>
-        requires(!MaybeMulti);
+    emplaceHint(const_iterator hint, Args&&... args)
+        -> std::enable_if_t<!MaybeMulti, std::pair<iterator, bool>>;
 
     // multiset, multimap
     template <bool MaybeMulti = IsMulti, class... Args>
-    iterator
+    std::enable_if_t<MaybeMulti, iterator>
     emplaceHint(const_iterator /*hint*/, Args&&... args)
-        requires MaybeMulti
     {
         // VFALCO TODO Figure out how to utilize 'hint'
         return emplace<MaybeMulti>(std::forward<Args>(args)...);
     }
 
-    // The constraint prevents erase (reverse_iterator pos) from compiling
-    template <bool IsConst, class Iterator>
+    // enable_if prevents erase (reverse_iterator pos) from compiling
+    template <
+        bool IsConst,
+        class Iterator,
+        class = std::enable_if_t<!IsBoostReverseIterator<Iterator>::value>>
     beast::detail::AgedContainerIterator<false, Iterator>
-    erase(beast::detail::AgedContainerIterator<IsConst, Iterator> pos)
-        requires(!IsBoostReverseIterator<Iterator>::value);
+    erase(beast::detail::AgedContainerIterator<IsConst, Iterator> pos);
 
-    // The constraint prevents erase (reverse_iterator first, reverse_iterator last)
+    // enable_if prevents erase (reverse_iterator first, reverse_iterator last)
     // from compiling
-    template <bool IsConst, class Iterator>
+    template <
+        bool IsConst,
+        class Iterator,
+        class = std::enable_if_t<!IsBoostReverseIterator<Iterator>::value>>
     beast::detail::AgedContainerIterator<false, Iterator>
     erase(
         beast::detail::AgedContainerIterator<IsConst, Iterator> first,
-        beast::detail::AgedContainerIterator<IsConst, Iterator> last)
-        requires(!IsBoostReverseIterator<Iterator>::value);
+        beast::detail::AgedContainerIterator<IsConst, Iterator> last);
 
     template <class K>
     auto
@@ -899,11 +905,13 @@ public:
 
     //--------------------------------------------------------------------------
 
-    // The constraint prevents touch (reverse_iterator pos) from compiling
-    template <bool IsConst, class Iterator>
+    // enable_if prevents touch (reverse_iterator pos) from compiling
+    template <
+        bool IsConst,
+        class Iterator,
+        class = std::enable_if_t<!IsBoostReverseIterator<Iterator>::value>>
     void
     touch(beast::detail::AgedContainerIterator<IsConst, Iterator> pos)
-        requires(!IsBoostReverseIterator<Iterator>::value)
     {
         touch(pos, clock().now());
     }
@@ -1134,25 +1142,25 @@ public:
     }
 
 private:
-    // The constraint prevents erase (reverse_iterator pos, now) from compiling
-    template <bool IsConst, class Iterator>
+    // enable_if prevents erase (reverse_iterator pos, now) from compiling
+    template <
+        bool IsConst,
+        class Iterator,
+        class = std::enable_if_t<!IsBoostReverseIterator<Iterator>::value>>
     void
     touch(
         beast::detail::AgedContainerIterator<IsConst, Iterator> pos,
-        clock_type::time_point const& now)
-        requires(!IsBoostReverseIterator<Iterator>::value);
+        clock_type::time_point const& now);
 
     template <
         bool MaybePropagate = std::allocator_traits<Allocator>::propagate_on_container_swap::value>
-    void
-    swapData(AgedOrderedContainer& other) noexcept
-        requires MaybePropagate;
+    std::enable_if_t<MaybePropagate>
+    swapData(AgedOrderedContainer& other) noexcept;
 
     template <
         bool MaybePropagate = std::allocator_traits<Allocator>::propagate_on_container_swap::value>
-    void
-    swapData(AgedOrderedContainer& other) noexcept
-        requires(!MaybePropagate);
+    std::enable_if_t<!MaybePropagate>
+    swapData(AgedOrderedContainer& other) noexcept;
 
 private:
     ConfigT config_;
@@ -1361,10 +1369,9 @@ AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::operato
 //------------------------------------------------------------------------------
 
 template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
-template <class K, bool MaybeMulti, bool MaybeMap>
+template <class K, bool MaybeMulti, bool MaybeMap, class>
 std::conditional_t<IsMap, T, void*>&
 AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::at(K const& k)
-    requires(MaybeMap && !MaybeMulti)
 {
     auto const iter(cont_.find(k, std::cref(config_.keyCompare())));
     if (iter == cont_.end())
@@ -1373,10 +1380,9 @@ AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::at(K co
 }
 
 template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
-template <class K, bool MaybeMulti, bool MaybeMap>
+template <class K, bool MaybeMulti, bool MaybeMap, class>
 std::conditional<IsMap, T, void*>::type const&
 AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::at(K const& k) const
-    requires(MaybeMap && !MaybeMulti)
 {
     auto const iter(cont_.find(k, std::cref(config_.keyCompare())));
     if (iter == cont_.end())
@@ -1385,10 +1391,9 @@ AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::at(K co
 }
 
 template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
-template <bool MaybeMulti, bool MaybeMap>
+template <bool MaybeMulti, bool MaybeMap, class>
 std::conditional_t<IsMap, T, void*>&
 AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::operator[](Key const& key)
-    requires(MaybeMap && !MaybeMulti)
 {
     typename cont_type::insert_commit_data d;
     auto const result(cont_.insert_check(key, std::cref(config_.keyCompare()), d));
@@ -1404,10 +1409,9 @@ AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::operato
 }
 
 template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
-template <bool MaybeMulti, bool MaybeMap>
+template <bool MaybeMulti, bool MaybeMap, class>
 std::conditional_t<IsMap, T, void*>&
 AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::operator[](Key&& key)
-    requires(MaybeMap && !MaybeMulti)
 {
     typename cont_type::insert_commit_data d;
     auto const result(cont_.insert_check(key, std::cref(config_.keyCompare()), d));
@@ -1441,8 +1445,7 @@ template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compa
 template <bool MaybeMulti>
 auto
 AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::insert(
-    value_type const& value) -> std::pair<iterator, bool>
-    requires(!MaybeMulti)
+    value_type const& value) -> std::enable_if_t<!MaybeMulti, std::pair<iterator, bool>>
 {
     typename cont_type::insert_commit_data d;
     auto const result(cont_.insert_check(extract(value), std::cref(config_.keyCompare()), d));
@@ -1461,8 +1464,7 @@ template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compa
 template <bool MaybeMulti>
 auto
 AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::insert(
-    value_type const& value) -> iterator
-    requires MaybeMulti
+    value_type const& value) -> std::enable_if_t<MaybeMulti, iterator>
 {
     auto const before(cont_.upper_bound(extract(value), std::cref(config_.keyCompare())));
     Element* const p(newElement(value));
@@ -1476,8 +1478,7 @@ template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compa
 template <bool MaybeMulti, bool MaybeMap>
 auto
 AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::insert(value_type&& value)
-    -> std::pair<iterator, bool>
-    requires(!MaybeMulti && !MaybeMap)
+    -> std::enable_if_t<!MaybeMulti && !MaybeMap, std::pair<iterator, bool>>
 {
     typename cont_type::insert_commit_data d;
     auto const result(cont_.insert_check(extract(value), std::cref(config_.keyCompare()), d));
@@ -1496,8 +1497,7 @@ template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compa
 template <bool MaybeMulti, bool MaybeMap>
 auto
 AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::insert(value_type&& value)
-    -> iterator
-    requires(MaybeMulti && !MaybeMap)
+    -> std::enable_if_t<MaybeMulti && !MaybeMap, iterator>
 {
     auto const before(cont_.upper_bound(extract(value), std::cref(config_.keyCompare())));
     Element* const p(newElement(std::move(value)));
@@ -1514,8 +1514,7 @@ template <bool MaybeMulti>
 auto
 AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::insert(
     const_iterator hint,
-    value_type const& value) -> iterator
-    requires(!MaybeMulti)
+    value_type const& value) -> std::enable_if_t<!MaybeMulti, iterator>
 {
     typename cont_type::insert_commit_data d;
     auto const result(
@@ -1536,8 +1535,7 @@ template <bool MaybeMulti>
 auto
 AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::insert(
     const_iterator hint,
-    value_type&& value) -> iterator
-    requires(!MaybeMulti)
+    value_type&& value) -> std::enable_if_t<!MaybeMulti, iterator>
 {
     typename cont_type::insert_commit_data d;
     auto const result(
@@ -1557,8 +1555,7 @@ template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compa
 template <bool MaybeMulti, class... Args>
 auto
 AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::emplace(Args&&... args)
-    -> std::pair<iterator, bool>
-    requires(!MaybeMulti)
+    -> std::enable_if_t<!MaybeMulti, std::pair<iterator, bool>>
 {
     // VFALCO NOTE Its unfortunate that we need to
     //             construct element here
@@ -1580,8 +1577,7 @@ template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compa
 template <bool MaybeMulti, class... Args>
 auto
 AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::emplace(Args&&... args)
-    -> iterator
-    requires MaybeMulti
+    -> std::enable_if_t<MaybeMulti, iterator>
 {
     Element* const p(newElement(std::forward<Args>(args)...));
     auto const before(cont_.upper_bound(extract(p->value), std::cref(config_.keyCompare())));
@@ -1596,8 +1592,7 @@ template <bool MaybeMulti, class... Args>
 auto
 AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::emplaceHint(
     const_iterator hint,
-    Args&&... args) -> std::pair<iterator, bool>
-    requires(!MaybeMulti)
+    Args&&... args) -> std::enable_if_t<!MaybeMulti, std::pair<iterator, bool>>
 {
     // VFALCO NOTE Its unfortunate that we need to
     //             construct element here
@@ -1616,23 +1611,21 @@ AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::emplace
 }
 
 template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
-template <bool IsConst, class Iterator>
+template <bool IsConst, class Iterator, class>
 beast::detail::AgedContainerIterator<false, Iterator>
 AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::erase(
     beast::detail::AgedContainerIterator<IsConst, Iterator> pos)
-    requires(!IsBoostReverseIterator<Iterator>::value)
 {
     unlinkAndDeleteElement(&*((pos++).iterator()));
     return beast::detail::AgedContainerIterator<false, Iterator>(pos.iterator());
 }
 
 template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
-template <bool IsConst, class Iterator>
+template <bool IsConst, class Iterator, class>
 beast::detail::AgedContainerIterator<false, Iterator>
 AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::erase(
     beast::detail::AgedContainerIterator<IsConst, Iterator> first,
     beast::detail::AgedContainerIterator<IsConst, Iterator> last)
-    requires(!IsBoostReverseIterator<Iterator>::value)
 {
     for (; first != last;)
         unlinkAndDeleteElement(&*((first++).iterator()));
@@ -1735,12 +1728,11 @@ AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::operato
 //------------------------------------------------------------------------------
 
 template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
-template <bool IsConst, class Iterator>
+template <bool IsConst, class Iterator, class>
 void
 AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::touch(
     beast::detail::AgedContainerIterator<IsConst, Iterator> pos,
     clock_type::time_point const& now)
-    requires(!IsBoostReverseIterator<Iterator>::value)
 {
     auto& e(*pos.iterator());
     e.when = now;
@@ -1750,10 +1742,9 @@ AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::touch(
 
 template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
 template <bool MaybePropagate>
-void
+std::enable_if_t<MaybePropagate>
 AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::swapData(
     AgedOrderedContainer& other) noexcept
-    requires MaybePropagate
 {
     std::swap(config_.keyCompare(), other.config_.keyCompare());
     std::swap(config_.alloc(), other.config_.alloc());
@@ -1762,10 +1753,9 @@ AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::swapDat
 
 template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
 template <bool MaybePropagate>
-void
+std::enable_if_t<!MaybePropagate>
 AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::swapData(
     AgedOrderedContainer& other) noexcept
-    requires(!MaybePropagate)
 {
     std::swap(config_.keyCompare(), other.config_.keyCompare());
     std::swap(config_.clock, other.config_.clock);
diff --git a/include/xrpl/beast/container/detail/aged_unordered_container.h b/include/xrpl/beast/container/detail/aged_unordered_container.h
index 9be9e96ba2..782f36cd52 100644
--- a/include/xrpl/beast/container/detail/aged_unordered_container.h
+++ b/include/xrpl/beast/container/detail/aged_unordered_container.h
@@ -117,9 +117,10 @@ private:
         {
         }
 
-        template <class... Args>
+        template <
+            class... Args,
+            class = std::enable_if_t<std::is_constructible_v<value_type, Args...>>>
         Element(time_point const& when, Args&&... args)
-            requires(std::is_constructible_v<value_type, Args...>)
             : value(std::forward<Args>(args)...), when(when)
         {
         }
@@ -528,7 +529,6 @@ private:
     deleteElement(Element const* p)
     {
         ElementAllocatorTraits::destroy(config_.alloc(), p);
-        // NOLINTNEXTLINE(cppcoreguidelines-pro-type-const-cast)
         ElementAllocatorTraits::deallocate(config_.alloc(), const_cast<Element*>(p), 1);
     }
 
@@ -841,25 +841,35 @@ public:
     //
     //--------------------------------------------------------------------------
 
-    template <class K, bool MaybeMulti = IsMulti, bool MaybeMap = IsMap>
+    template <
+        class K,
+        bool MaybeMulti = IsMulti,
+        bool MaybeMap = IsMap,
+        class = std::enable_if_t<MaybeMap && !MaybeMulti>>
     std::conditional_t<IsMap, T, void*>&
-    at(K const& k)
-        requires(MaybeMap && !MaybeMulti);
+    at(K const& k);
 
-    template <class K, bool MaybeMulti = IsMulti, bool MaybeMap = IsMap>
+    template <
+        class K,
+        bool MaybeMulti = IsMulti,
+        bool MaybeMap = IsMap,
+        class = std::enable_if_t<MaybeMap && !MaybeMulti>>
     std::conditional<IsMap, T, void*>::type const&
-    at(K const& k) const
-        requires(MaybeMap && !MaybeMulti);
+    at(K const& k) const;
 
-    template <bool MaybeMulti = IsMulti, bool MaybeMap = IsMap>
+    template <
+        bool MaybeMulti = IsMulti,
+        bool MaybeMap = IsMap,
+        class = std::enable_if_t<MaybeMap && !MaybeMulti>>
     std::conditional_t<IsMap, T, void*>&
-    operator[](Key const& key)
-        requires(MaybeMap && !MaybeMulti);
+    operator[](Key const& key);
 
-    template <bool MaybeMulti = IsMulti, bool MaybeMap = IsMap>
+    template <
+        bool MaybeMulti = IsMulti,
+        bool MaybeMap = IsMap,
+        class = std::enable_if_t<MaybeMap && !MaybeMulti>>
     std::conditional_t<IsMap, T, void*>&
-    operator[](Key&& key)
-        requires(MaybeMap && !MaybeMulti);
+    operator[](Key&& key);
 
     //--------------------------------------------------------------------------
     //
@@ -957,32 +967,28 @@ public:
     // map, set
     template <bool MaybeMulti = IsMulti>
     auto
-    insert(value_type const& value) -> std::pair<iterator, bool>
-        requires(!MaybeMulti);
+    insert(value_type const& value) -> std::enable_if_t<!MaybeMulti, std::pair<iterator, bool>>;
 
     // multimap, multiset
     template <bool MaybeMulti = IsMulti>
     auto
-    insert(value_type const& value) -> iterator
-        requires MaybeMulti;
+    insert(value_type const& value) -> std::enable_if_t<MaybeMulti, iterator>;
 
     // map, set
     template <bool MaybeMulti = IsMulti, bool MaybeMap = IsMap>
     auto
-    insert(value_type&& value) -> std::pair<iterator, bool>
-        requires(!MaybeMulti && !MaybeMap);
+    insert(value_type&& value)
+        -> std::enable_if_t<!MaybeMulti && !MaybeMap, std::pair<iterator, bool>>;
 
     // multimap, multiset
     template <bool MaybeMulti = IsMulti, bool MaybeMap = IsMap>
     auto
-    insert(value_type&& value) -> iterator
-        requires(MaybeMulti && !MaybeMap);
+    insert(value_type&& value) -> std::enable_if_t<MaybeMulti && !MaybeMap, iterator>;
 
     // map, set
     template <bool MaybeMulti = IsMulti>
-    iterator
+    std::enable_if_t<!MaybeMulti, iterator>
     insert(const_iterator /*hint*/, value_type const& value)
-        requires(!MaybeMulti)
     {
         // Hint is ignored but we provide the interface so
         // callers may use ordered and unordered interchangeably.
@@ -991,9 +997,8 @@ public:
 
     // multimap, multiset
     template <bool MaybeMulti = IsMulti>
-    iterator
+    std::enable_if_t<MaybeMulti, iterator>
     insert(const_iterator /*hint*/, value_type const& value)
-        requires MaybeMulti
     {
         // VFALCO TODO The hint could be used to let
         //             the client order equal ranges
@@ -1002,9 +1007,8 @@ public:
 
     // map, set
     template <bool MaybeMulti = IsMulti>
-    iterator
+    std::enable_if_t<!MaybeMulti, iterator>
     insert(const_iterator /*hint*/, value_type&& value)
-        requires(!MaybeMulti)
     {
         // Hint is ignored but we provide the interface so
         // callers may use ordered and unordered interchangeably.
@@ -1013,9 +1017,8 @@ public:
 
     // multimap, multiset
     template <bool MaybeMulti = IsMulti>
-    iterator
+    std::enable_if_t<MaybeMulti, iterator>
     insert(const_iterator /*hint*/, value_type&& value)
-        requires MaybeMulti
     {
         // VFALCO TODO The hint could be used to let
         //             the client order equal ranges
@@ -1024,18 +1027,20 @@ public:
 
     // map, multimap
     template <class P, bool MaybeMap = IsMap>
-    std::conditional_t<IsMulti, iterator, std::pair<iterator, bool>>
+    std::enable_if_t<
+        MaybeMap && std::is_constructible_v<value_type, P&&>,
+        std::conditional_t<IsMulti, iterator, std::pair<iterator, bool>>>
     insert(P&& value)
-        requires(MaybeMap && std::is_constructible_v<value_type, P &&>)
     {
         return emplace(std::forward<P>(value));
     }
 
     // map, multimap
     template <class P, bool MaybeMap = IsMap>
-    std::conditional_t<IsMulti, iterator, std::pair<iterator, bool>>
+    std::enable_if_t<
+        MaybeMap && std::is_constructible_v<value_type, P&&>,
+        std::conditional_t<IsMulti, iterator, std::pair<iterator, bool>>>
     insert(const_iterator hint, P&& value)
-        requires(MaybeMap && std::is_constructible_v<value_type, P &&>)
     {
         return emplaceHint(hint, std::forward<P>(value));
     }
@@ -1056,26 +1061,23 @@ public:
     // set, map
     template <bool MaybeMulti = IsMulti, class... Args>
     auto
-    emplace(Args&&... args) -> std::pair<iterator, bool>
-        requires(!MaybeMulti);
+    emplace(Args&&... args) -> std::enable_if_t<!MaybeMulti, std::pair<iterator, bool>>;
 
     // multiset, multimap
     template <bool MaybeMulti = IsMulti, class... Args>
     auto
-    emplace(Args&&... args) -> iterator
-        requires MaybeMulti;
+    emplace(Args&&... args) -> std::enable_if_t<MaybeMulti, iterator>;
 
     // set, map
     template <bool MaybeMulti = IsMulti, class... Args>
     auto
-    emplaceHint(const_iterator /*hint*/, Args&&... args) -> std::pair<iterator, bool>
-        requires(!MaybeMulti);
+    emplaceHint(const_iterator /*hint*/, Args&&... args)
+        -> std::enable_if_t<!MaybeMulti, std::pair<iterator, bool>>;
 
     // multiset, multimap
     template <bool MaybeMulti = IsMulti, class... Args>
-    iterator
+    std::enable_if_t<MaybeMulti, iterator>
     emplaceHint(const_iterator /*hint*/, Args&&... args)
-        requires MaybeMulti
     {
         // VFALCO TODO The hint could be used for multi, to let
         //             the client order equal ranges
@@ -1306,7 +1308,7 @@ public:
         class OtherHash,
         class OtherAllocator,
         bool MaybeMulti = IsMulti>
-    bool
+    std::enable_if_t<!MaybeMulti, bool>
     operator==(AgedUnorderedContainer<
                false,
                OtherIsMap,
@@ -1315,8 +1317,7 @@ public:
                OtherDuration,
                OtherHash,
                KeyEqual,
-               OtherAllocator> const& other) const
-        requires(!MaybeMulti);
+               OtherAllocator> const& other) const;
 
     template <
         bool OtherIsMap,
@@ -1326,7 +1327,7 @@ public:
         class OtherHash,
         class OtherAllocator,
         bool MaybeMulti = IsMulti>
-    bool
+    std::enable_if_t<MaybeMulti, bool>
     operator==(AgedUnorderedContainer<
                true,
                OtherIsMap,
@@ -1335,8 +1336,7 @@ public:
                OtherDuration,
                OtherHash,
                KeyEqual,
-               OtherAllocator> const& other) const
-        requires MaybeMulti;
+               OtherAllocator> const& other) const;
 
     template <
         bool OtherIsMulti,
@@ -1381,14 +1381,13 @@ private:
     // map, set
     template <bool MaybeMulti = IsMulti>
     auto
-    insertUnchecked(value_type const& value) -> std::pair<iterator, bool>
-        requires(!MaybeMulti);
+    insertUnchecked(value_type const& value)
+        -> std::enable_if_t<!MaybeMulti, std::pair<iterator, bool>>;
 
     // multimap, multiset
     template <bool MaybeMulti = IsMulti>
     auto
-    insertUnchecked(value_type const& value) -> iterator
-        requires MaybeMulti;
+    insertUnchecked(value_type const& value) -> std::enable_if_t<MaybeMulti, iterator>;
 
     template <class InputIt>
     void
@@ -1429,9 +1428,8 @@ private:
 
     template <
         bool MaybePropagate = std::allocator_traits<Allocator>::propagate_on_container_swap::value>
-    void
+    std::enable_if_t<MaybePropagate>
     swapData(AgedUnorderedContainer& other) noexcept
-        requires MaybePropagate
     {
         std::swap(config_.hashFunction(), other.config_.hashFunction());
         std::swap(config_.keyEq(), other.config_.keyEq());
@@ -1441,9 +1439,8 @@ private:
 
     template <
         bool MaybePropagate = std::allocator_traits<Allocator>::propagate_on_container_swap::value>
-    void
+    std::enable_if_t<!MaybePropagate>
     swapData(AgedUnorderedContainer& other) noexcept
-        requires(!MaybePropagate)
     {
         std::swap(config_.hashFunction(), other.config_.hashFunction());
         std::swap(config_.keyEq(), other.config_.keyEq());
@@ -2097,10 +2094,9 @@ template <
     class Hash,
     class KeyEqual,
     class Allocator>
-template <class K, bool MaybeMulti, bool MaybeMap>
+template <class K, bool MaybeMulti, bool MaybeMap, class>
 std::conditional_t<IsMap, T, void*>&
 AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::at(K const& k)
-    requires(MaybeMap && !MaybeMulti)
 {
     auto const iter(
         cont_.find(k, std::cref(config_.hashFunction()), std::cref(config_.keyValueEqual())));
@@ -2118,11 +2114,10 @@ template <
     class Hash,
     class KeyEqual,
     class Allocator>
-template <class K, bool MaybeMulti, bool MaybeMap>
+template <class K, bool MaybeMulti, bool MaybeMap, class>
 std::conditional<IsMap, T, void*>::type const&
 AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::at(
     K const& k) const
-    requires(MaybeMap && !MaybeMulti)
 {
     auto const iter(
         cont_.find(k, std::cref(config_.hashFunction()), std::cref(config_.keyValueEqual())));
@@ -2140,11 +2135,10 @@ template <
     class Hash,
     class KeyEqual,
     class Allocator>
-template <bool MaybeMulti, bool MaybeMap>
+template <bool MaybeMulti, bool MaybeMap, class>
 std::conditional_t<IsMap, T, void*>&
 AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::operator[](
     Key const& key)
-    requires(MaybeMap && !MaybeMulti)
 {
     maybeRehash(1);
     typename cont_type::insert_commit_data d;
@@ -2170,11 +2164,10 @@ template <
     class Hash,
     class KeyEqual,
     class Allocator>
-template <bool MaybeMulti, bool MaybeMap>
+template <bool MaybeMulti, bool MaybeMap, class>
 std::conditional_t<IsMap, T, void*>&
 AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::operator[](
     Key&& key)
-    requires(MaybeMap && !MaybeMulti)
 {
     maybeRehash(1);
     typename cont_type::insert_commit_data d;
@@ -2227,8 +2220,7 @@ template <
 template <bool MaybeMulti>
 auto
 AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::insert(
-    value_type const& value) -> std::pair<iterator, bool>
-    requires(!MaybeMulti)
+    value_type const& value) -> std::enable_if_t<!MaybeMulti, std::pair<iterator, bool>>
 {
     maybeRehash(1);
     typename cont_type::insert_commit_data d;
@@ -2257,8 +2249,7 @@ template <
 template <bool MaybeMulti>
 auto
 AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::insert(
-    value_type const& value) -> iterator
-    requires MaybeMulti
+    value_type const& value) -> std::enable_if_t<MaybeMulti, iterator>
 {
     maybeRehash(1);
     Element* const p(newElement(value));
@@ -2280,8 +2271,7 @@ template <
 template <bool MaybeMulti, bool MaybeMap>
 auto
 AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::insert(
-    value_type&& value) -> std::pair<iterator, bool>
-    requires(!MaybeMulti && !MaybeMap)
+    value_type&& value) -> std::enable_if_t<!MaybeMulti && !MaybeMap, std::pair<iterator, bool>>
 {
     maybeRehash(1);
     typename cont_type::insert_commit_data d;
@@ -2310,8 +2300,7 @@ template <
 template <bool MaybeMulti, bool MaybeMap>
 auto
 AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::insert(
-    value_type&& value) -> iterator
-    requires(MaybeMulti && !MaybeMap)
+    value_type&& value) -> std::enable_if_t<MaybeMulti && !MaybeMap, iterator>
 {
     maybeRehash(1);
     Element* const p(newElement(std::move(value)));
@@ -2320,6 +2309,7 @@ AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>
     return iterator(iter);
 }
 
+#if 1  // Use insert() instead of insert_check() insert_commit()
 // set, map
 template <
     bool IsMulti,
@@ -2333,8 +2323,7 @@ template <
 template <bool MaybeMulti, class... Args>
 auto
 AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::emplace(
-    Args&&... args) -> std::pair<iterator, bool>
-    requires(!MaybeMulti)
+    Args&&... args) -> std::enable_if_t<!MaybeMulti, std::pair<iterator, bool>>
 {
     maybeRehash(1);
     // VFALCO NOTE Its unfortunate that we need to
@@ -2349,6 +2338,42 @@ AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>
     deleteElement(p);
     return std::make_pair(iterator(result.first), false);
 }
+#else   // As original, use insert_check() / insert_commit () pair.
+// set, map
+template <
+    bool IsMulti,
+    bool IsMap,
+    class Key,
+    class T,
+    class Clock,
+    class Hash,
+    class KeyEqual,
+    class Allocator>
+template <bool maybe_multi, class... Args>
+auto
+AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::emplace(
+    Args&&... args) -> typename std::enable_if<!maybe_multi, std::pair<iterator, bool>>::type
+{
+    maybe_rehash(1);
+    // VFALCO NOTE Its unfortunate that we need to
+    //             construct element here
+    element* const p(new_element(std::forward<Args>(args)...));
+    typename cont_type::insert_commit_data d;
+    auto const result(m_cont.insert_check(
+        extract(p->value),
+        std::cref(m_config.hashFunction()),
+        std::cref(m_config.keyValueEqual()),
+        d));
+    if (result.second)
+    {
+        auto const iter(m_cont.insert_commit(*p, d));
+        chronological.list.push_back(*p);
+        return std::make_pair(iterator(iter), true);
+    }
+    delete_element(p);
+    return std::make_pair(iterator(result.first), false);
+}
+#endif  // 0
 
 // multiset, multimap
 template <
@@ -2363,8 +2388,7 @@ template <
 template <bool MaybeMulti, class... Args>
 auto
 AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::emplace(
-    Args&&... args) -> iterator
-    requires MaybeMulti
+    Args&&... args) -> std::enable_if_t<MaybeMulti, iterator>
 {
     maybeRehash(1);
     Element* const p(newElement(std::forward<Args>(args)...));
@@ -2387,8 +2411,7 @@ template <bool MaybeMulti, class... Args>
 auto
 AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::emplaceHint(
     const_iterator /*hint*/,
-    Args&&... args) -> std::pair<iterator, bool>
-    requires(!MaybeMulti)
+    Args&&... args) -> std::enable_if_t<!MaybeMulti, std::pair<iterator, bool>>
 {
     maybeRehash(1);
     // VFALCO NOTE Its unfortunate that we need to
@@ -2539,7 +2562,7 @@ template <
     class OtherHash,
     class OtherAllocator,
     bool MaybeMulti>
-bool
+std::enable_if_t<!MaybeMulti, bool>
 AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::operator==(
     AgedUnorderedContainer<
         false,
@@ -2550,7 +2573,6 @@ AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>
         OtherHash,
         KeyEqual,
         OtherAllocator> const& other) const
-    requires(!MaybeMulti)
 {
     if (size() != other.size())
         return false;
@@ -2580,7 +2602,7 @@ template <
     class OtherHash,
     class OtherAllocator,
     bool MaybeMulti>
-bool
+std::enable_if_t<MaybeMulti, bool>
 AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::operator==(
     AgedUnorderedContainer<
         true,
@@ -2591,7 +2613,6 @@ AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>
         OtherHash,
         KeyEqual,
         OtherAllocator> const& other) const
-    requires MaybeMulti
 {
     if (size() != other.size())
         return false;
@@ -2628,8 +2649,7 @@ template <
 template <bool MaybeMulti>
 auto
 AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::insertUnchecked(
-    value_type const& value) -> std::pair<iterator, bool>
-    requires(!MaybeMulti)
+    value_type const& value) -> std::enable_if_t<!MaybeMulti, std::pair<iterator, bool>>
 {
     typename cont_type::insert_commit_data d;
     auto const result(cont_.insert_check(
@@ -2657,8 +2677,7 @@ template <
 template <bool MaybeMulti>
 auto
 AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::insertUnchecked(
-    value_type const& value) -> iterator
-    requires MaybeMulti
+    value_type const& value) -> std::enable_if_t<MaybeMulti, iterator>
 {
     Element* const p(newElement(value));
     chronological.list_.push_back(*p);
diff --git a/include/xrpl/beast/core/LexicalCast.h b/include/xrpl/beast/core/LexicalCast.h
index 1162d83078..8faf90f53d 100644
--- a/include/xrpl/beast/core/LexicalCast.h
+++ b/include/xrpl/beast/core/LexicalCast.h
@@ -29,18 +29,16 @@ struct LexicalCast<std::string, In>
     explicit LexicalCast() = default;
 
     template <class Arithmetic = In>
-    bool
+    std::enable_if_t<std::is_arithmetic_v<Arithmetic>, bool>
     operator()(std::string& out, Arithmetic in)
-        requires(std::is_arithmetic_v<Arithmetic>)
     {
         out = std::to_string(in);
         return true;
     }
 
     template <class Enumeration = In>
-    bool
+    std::enable_if_t<std::is_enum_v<Enumeration>, bool>
     operator()(std::string& out, Enumeration in)
-        requires(std::is_enum_v<Enumeration>)
     {
         out = std::to_string(static_cast<std::underlying_type_t<Enumeration>>(in));
         return true;
@@ -58,9 +56,8 @@ struct LexicalCast<Out, std::string_view>
         "beast::LexicalCast can only be used with integral types");
 
     template <class Integral = Out>
-    bool
+    std::enable_if_t<std::is_integral_v<Integral> && !std::is_same_v<Integral, bool>, bool>
     operator()(Integral& out, std::string_view in) const
-        requires(std::is_integral_v<Integral> && !std::is_same_v<Integral, bool>)
     {
         auto first = in.data();
         auto last = in.data() + in.size();
diff --git a/include/xrpl/beast/core/LockFreeStack.h b/include/xrpl/beast/core/LockFreeStack.h
index dd135d2d98..19225a4343 100644
--- a/include/xrpl/beast/core/LockFreeStack.h
+++ b/include/xrpl/beast/core/LockFreeStack.h
@@ -41,7 +41,7 @@ public:
     operator=(NodePtr node)
     {
         node_ = node;
-        return *this;
+        return static_cast<LockFreeStackIterator&>(*this);
     }
 
     LockFreeStackIterator&
diff --git a/include/xrpl/beast/hash/hash_append.h b/include/xrpl/beast/hash/hash_append.h
index 3592ffbfe8..0b36d4c983 100644
--- a/include/xrpl/beast/hash/hash_append.h
+++ b/include/xrpl/beast/hash/hash_append.h
@@ -26,7 +26,7 @@ template <class T>
 inline void
 reverseBytes(T& t)
 {
-    auto* bytes =
+    unsigned char* bytes =
         static_cast<unsigned char*>(std::memmove(std::addressof(t), std::addressof(t), sizeof(T)));
     for (unsigned i = 0; i < sizeof(T) / 2; ++i)
         std::swap(bytes[i], bytes[sizeof(T) - 1 - i]);
@@ -200,29 +200,26 @@ struct IsContiguouslyHashable<T[N], HashAlgorithm>
 // scalars
 
 template <class Hasher, class T>
-inline void
+inline std::enable_if_t<IsContiguouslyHashable<T, Hasher>::value>
 hash_append(Hasher& h, T const& t) noexcept
-    requires(IsContiguouslyHashable<T, Hasher>::value)
 {
     // NOLINTNEXTLINE(bugprone-sizeof-expression)
     h(static_cast<void const*>(std::addressof(t)), sizeof(t));
 }
 
 template <class Hasher, class T>
-inline void
+inline std::enable_if_t<
+    !IsContiguouslyHashable<T, Hasher>::value &&
+    (std::is_integral_v<T> || std::is_pointer_v<T> || std::is_enum_v<T>)>
 hash_append(Hasher& h, T t) noexcept
-    requires(
-        !IsContiguouslyHashable<T, Hasher>::value &&
-        (std::is_integral_v<T> || std::is_pointer_v<T> || std::is_enum_v<T>))
 {
     detail::reverseBytes(t);
     h(std::addressof(t), sizeof(t));
 }
 
 template <class Hasher, class T>
-inline void
+inline std::enable_if_t<std::is_floating_point_v<T>>
 hash_append(Hasher& h, T t) noexcept
-    requires(std::is_floating_point_v<T>)
 {
     if (t == 0)
         t = 0;
@@ -242,44 +239,36 @@ hash_append(Hasher& h, std::nullptr_t) noexcept
 // Forward declarations for ADL purposes
 
 template <class Hasher, class T, std::size_t N>
-void
-hash_append(Hasher& h, T (&a)[N]) noexcept
-    requires(!IsContiguouslyHashable<T, Hasher>::value);
+std::enable_if_t<!IsContiguouslyHashable<T, Hasher>::value>
+hash_append(Hasher& h, T (&a)[N]) noexcept;
 
 template <class Hasher, class CharT, class Traits, class Alloc>
-void
-hash_append(Hasher& h, std::basic_string<CharT, Traits, Alloc> const& s) noexcept
-    requires(!IsContiguouslyHashable<CharT, Hasher>::value);
+std::enable_if_t<!IsContiguouslyHashable<CharT, Hasher>::value>
+hash_append(Hasher& h, std::basic_string<CharT, Traits, Alloc> const& s) noexcept;
 
 template <class Hasher, class CharT, class Traits, class Alloc>
-void
-hash_append(Hasher& h, std::basic_string<CharT, Traits, Alloc> const& s) noexcept
-    requires(IsContiguouslyHashable<CharT, Hasher>::value);
+std::enable_if_t<IsContiguouslyHashable<CharT, Hasher>::value>
+hash_append(Hasher& h, std::basic_string<CharT, Traits, Alloc> const& s) noexcept;
 
 template <class Hasher, class T, class U>
-void
-hash_append(Hasher& h, std::pair<T, U> const& p) noexcept
-    requires(!IsContiguouslyHashable<std::pair<T, U>, Hasher>::value);
+std::enable_if_t<!IsContiguouslyHashable<std::pair<T, U>, Hasher>::value>
+hash_append(Hasher& h, std::pair<T, U> const& p) noexcept;
 
 template <class Hasher, class T, class Alloc>
-void
-hash_append(Hasher& h, std::vector<T, Alloc> const& v) noexcept
-    requires(!IsContiguouslyHashable<T, Hasher>::value);
+std::enable_if_t<!IsContiguouslyHashable<T, Hasher>::value>
+hash_append(Hasher& h, std::vector<T, Alloc> const& v) noexcept;
 
 template <class Hasher, class T, class Alloc>
-void
-hash_append(Hasher& h, std::vector<T, Alloc> const& v) noexcept
-    requires(IsContiguouslyHashable<T, Hasher>::value);
+std::enable_if_t<IsContiguouslyHashable<T, Hasher>::value>
+hash_append(Hasher& h, std::vector<T, Alloc> const& v) noexcept;
 
 template <class Hasher, class T, std::size_t N>
-void
-hash_append(Hasher& h, std::array<T, N> const& a) noexcept
-    requires(!IsContiguouslyHashable<std::array<T, N>, Hasher>::value);
+std::enable_if_t<!IsContiguouslyHashable<std::array<T, N>, Hasher>::value>
+hash_append(Hasher& h, std::array<T, N> const& a) noexcept;
 
 template <class Hasher, class... T>
-void
-hash_append(Hasher& h, std::tuple<T...> const& t) noexcept
-    requires(!IsContiguouslyHashable<std::tuple<T...>, Hasher>::value);
+std::enable_if_t<!IsContiguouslyHashable<std::tuple<T...>, Hasher>::value>
+hash_append(Hasher& h, std::tuple<T...> const& t) noexcept;
 
 template <class Hasher, class Key, class T, class Hash, class Pred, class Alloc>
 void
@@ -290,13 +279,11 @@ void
 hash_append(Hasher& h, std::unordered_set<Key, Hash, Pred, Alloc> const& s);
 
 template <class Hasher, class Key, class Compare, class Alloc>
-void
-hash_append(Hasher& h, boost::container::flat_set<Key, Compare, Alloc> const& v) noexcept
-    requires(!IsContiguouslyHashable<Key, Hasher>::value);
+std::enable_if_t<!IsContiguouslyHashable<Key, Hasher>::value>
+hash_append(Hasher& h, boost::container::flat_set<Key, Compare, Alloc> const& v) noexcept;
 template <class Hasher, class Key, class Compare, class Alloc>
-void
-hash_append(Hasher& h, boost::container::flat_set<Key, Compare, Alloc> const& v) noexcept
-    requires(IsContiguouslyHashable<Key, Hasher>::value);
+std::enable_if_t<IsContiguouslyHashable<Key, Hasher>::value>
+hash_append(Hasher& h, boost::container::flat_set<Key, Compare, Alloc> const& v) noexcept;
 template <class Hasher, class T0, class T1, class... T>
 void
 hash_append(Hasher& h, T0 const& t0, T1 const& t1, T const&... t) noexcept;
@@ -304,9 +291,8 @@ hash_append(Hasher& h, T0 const& t0, T1 const& t1, T const&... t) noexcept;
 // c-array
 
 template <class Hasher, class T, std::size_t N>
-void
+std::enable_if_t<!IsContiguouslyHashable<T, Hasher>::value>
 hash_append(Hasher& h, T (&a)[N]) noexcept
-    requires(!IsContiguouslyHashable<T, Hasher>::value)
 {
     for (auto const& t : a)
         hash_append(h, t);
@@ -315,9 +301,8 @@ hash_append(Hasher& h, T (&a)[N]) noexcept
 // basic_string
 
 template <class Hasher, class CharT, class Traits, class Alloc>
-inline void
+inline std::enable_if_t<!IsContiguouslyHashable<CharT, Hasher>::value>
 hash_append(Hasher& h, std::basic_string<CharT, Traits, Alloc> const& s) noexcept
-    requires(!IsContiguouslyHashable<CharT, Hasher>::value)
 {
     for (auto c : s)
         hash_append(h, c);
@@ -325,9 +310,8 @@ hash_append(Hasher& h, std::basic_string<CharT, Traits, Alloc> const& s) noexcep
 }
 
 template <class Hasher, class CharT, class Traits, class Alloc>
-inline void
+inline std::enable_if_t<IsContiguouslyHashable<CharT, Hasher>::value>
 hash_append(Hasher& h, std::basic_string<CharT, Traits, Alloc> const& s) noexcept
-    requires(IsContiguouslyHashable<CharT, Hasher>::value)
 {
     h(s.data(), s.size() * sizeof(CharT));
     hash_append(h, s.size());
@@ -336,9 +320,8 @@ hash_append(Hasher& h, std::basic_string<CharT, Traits, Alloc> const& s) noexcep
 // pair
 
 template <class Hasher, class T, class U>
-inline void
+inline std::enable_if_t<!IsContiguouslyHashable<std::pair<T, U>, Hasher>::value>
 hash_append(Hasher& h, std::pair<T, U> const& p) noexcept
-    requires(!IsContiguouslyHashable<std::pair<T, U>, Hasher>::value)
 {
     hash_append(h, p.first, p.second);
 }
@@ -346,9 +329,8 @@ hash_append(Hasher& h, std::pair<T, U> const& p) noexcept
 // vector
 
 template <class Hasher, class T, class Alloc>
-inline void
+inline std::enable_if_t<!IsContiguouslyHashable<T, Hasher>::value>
 hash_append(Hasher& h, std::vector<T, Alloc> const& v) noexcept
-    requires(!IsContiguouslyHashable<T, Hasher>::value)
 {
     for (auto const& t : v)
         hash_append(h, t);
@@ -356,9 +338,8 @@ hash_append(Hasher& h, std::vector<T, Alloc> const& v) noexcept
 }
 
 template <class Hasher, class T, class Alloc>
-inline void
+inline std::enable_if_t<IsContiguouslyHashable<T, Hasher>::value>
 hash_append(Hasher& h, std::vector<T, Alloc> const& v) noexcept
-    requires(IsContiguouslyHashable<T, Hasher>::value)
 {
     h(v.data(), v.size() * sizeof(T));
     hash_append(h, v.size());
@@ -367,37 +348,57 @@ hash_append(Hasher& h, std::vector<T, Alloc> const& v) noexcept
 // array
 
 template <class Hasher, class T, std::size_t N>
-void
+std::enable_if_t<!IsContiguouslyHashable<std::array<T, N>, Hasher>::value>
 hash_append(Hasher& h, std::array<T, N> const& a) noexcept
-    requires(!IsContiguouslyHashable<std::array<T, N>, Hasher>::value)
 {
     for (auto const& t : a)
         hash_append(h, t);
 }
 
 template <class Hasher, class Key, class Compare, class Alloc>
-void
+std::enable_if_t<!IsContiguouslyHashable<Key, Hasher>::value>
 hash_append(Hasher& h, boost::container::flat_set<Key, Compare, Alloc> const& v) noexcept
-    requires(!IsContiguouslyHashable<Key, Hasher>::value)
 {
     for (auto const& t : v)
         hash_append(h, t);
 }
 template <class Hasher, class Key, class Compare, class Alloc>
-void
+std::enable_if_t<IsContiguouslyHashable<Key, Hasher>::value>
 hash_append(Hasher& h, boost::container::flat_set<Key, Compare, Alloc> const& v) noexcept
-    requires(IsContiguouslyHashable<Key, Hasher>::value)
 {
     h(&(v.begin()), v.size() * sizeof(Key));
 }
 // tuple
 
-template <class Hasher, class... T>
+namespace detail {
+
 inline void
-hash_append(Hasher& h, std::tuple<T...> const& t) noexcept
-    requires(!IsContiguouslyHashable<std::tuple<T...>, Hasher>::value)
+forEachItem(...) noexcept
 {
-    std::apply([&h](auto const&... item) { (hash_append(h, item), ...); }, t);
+}
+
+template <class Hasher, class T>
+inline int
+hashOne(Hasher& h, T const& t) noexcept
+{
+    hash_append(h, t);
+    return 0;
+}
+
+template <class Hasher, class... T, std::size_t... I>
+inline void
+tuple_hash(Hasher& h, std::tuple<T...> const& t, std::index_sequence<I...>) noexcept
+{
+    for_each_item(hash_one(h, std::get<I>(t))...);
+}
+
+}  // namespace detail
+
+template <class Hasher, class... T>
+inline std::enable_if_t<!IsContiguouslyHashable<std::tuple<T...>, Hasher>::value>
+hash_append(Hasher& h, std::tuple<T...> const& t) noexcept
+{
+    detail::tuple_hash(h, t, std::index_sequence_for<T...>{});
 }
 
 // shared_ptr
diff --git a/include/xrpl/beast/hash/xxhasher.h b/include/xrpl/beast/hash/xxhasher.h
index 73dbb8e8ab..978bbc6917 100644
--- a/include/xrpl/beast/hash/xxhasher.h
+++ b/include/xrpl/beast/hash/xxhasher.h
@@ -124,18 +124,14 @@ public:
         }
     }
 
-    template <class Seed>
-    explicit Xxhasher(Seed seed)
-        requires(std::is_unsigned_v<Seed>)
-        : seed_(seed)
+    template <class Seed, std::enable_if_t<std::is_unsigned_v<Seed>>* = nullptr>
+    explicit Xxhasher(Seed seed) : seed_(seed)
     {
         resetBuffers();
     }
 
-    template <class Seed>
-    Xxhasher(Seed seed, Seed)
-        requires(std::is_unsigned_v<Seed>)
-        : seed_(seed)
+    template <class Seed, std::enable_if_t<std::is_unsigned_v<Seed>>* = nullptr>
+    Xxhasher(Seed seed, Seed) : seed_(seed)
     {
         resetBuffers();
     }
diff --git a/include/xrpl/beast/insight/Gauge.h b/include/xrpl/beast/insight/Gauge.h
index 9a23ea6665..b24c4366c3 100644
--- a/include/xrpl/beast/insight/Gauge.h
+++ b/include/xrpl/beast/insight/Gauge.h
@@ -49,11 +49,6 @@ public:
             impl_->set(value);
     }
 
-    // This is a write-through handle: assignment sets the value of the
-    // referenced metric.  It is const-qualified and returns Gauge const&
-    // (a non-const Gauge& would require a const_cast), so it does not follow
-    // the conventional assignment-operator signature.
-    // NOLINTNEXTLINE(misc-unconventional-assign-operator)
     Gauge const&
     operator=(value_type value) const
     {
diff --git a/include/xrpl/beast/type_name.h b/include/xrpl/beast/type_name.h
index 85fd9ae6a2..ae7b681af9 100644
--- a/include/xrpl/beast/type_name.h
+++ b/include/xrpl/beast/type_name.h
@@ -23,7 +23,6 @@ typeName()
     if (auto s = abi::__cxa_demangle(name.c_str(), nullptr, nullptr, nullptr))
     {
         name = s;
-        // NOLINTNEXTLINE(cppcoreguidelines-no-malloc)
         std::free(s);
     }
 #endif
diff --git a/include/xrpl/beast/unit_test/suite_list.h b/include/xrpl/beast/unit_test/suite_list.h
index 7dd0dd80f0..cf9fb9c5b1 100644
--- a/include/xrpl/beast/unit_test/suite_list.h
+++ b/include/xrpl/beast/unit_test/suite_list.h
@@ -10,9 +10,9 @@
 #include <boost/assert.hpp>
 
 #include <set>
-#include <string>         // IWYU pragma: keep
-#include <typeindex>      // IWYU pragma: keep
-#include <unordered_set>  // IWYU pragma: keep
+#include <string>
+#include <typeindex>
+#include <unordered_set>
 
 namespace beast::unit_test {
 
diff --git a/include/xrpl/beast/unit_test/thread.h b/include/xrpl/beast/unit_test/thread.h
index 91d8cf3cab..0de039cb89 100644
--- a/include/xrpl/beast/unit_test/thread.h
+++ b/include/xrpl/beast/unit_test/thread.h
@@ -45,10 +45,7 @@ public:
     template <class F, class... Args>
     explicit Thread(Suite& s, F&& f, Args&&... args) : s_(&s)
     {
-        std::function<void(void)> b = [f = std::forward<F>(f),
-                                       ... args = std::forward<Args>(args)]() mutable {
-            std::invoke(f, args...);
-        };
+        std::function<void(void)> b = std::bind(std::forward<F>(f), std::forward<Args>(args)...);
         t_ = std::thread(&Thread::run, this, std::move(b));
     }
 
diff --git a/include/xrpl/beast/utility/Journal.h b/include/xrpl/beast/utility/Journal.h
index 3de3cfb0e0..ac08b1384b 100644
--- a/include/xrpl/beast/utility/Journal.h
+++ b/include/xrpl/beast/utility/Journal.h
@@ -108,12 +108,12 @@ public:
     };
 
 #ifndef __INTELLISENSE__
-    static_assert(!std::is_default_constructible_v<Sink>);
-    static_assert(!std::is_copy_constructible_v<Sink>);
-    static_assert(!std::is_move_constructible_v<Sink>);
-    static_assert(!std::is_copy_assignable_v<Sink>);
-    static_assert(!std::is_move_assignable_v<Sink>);
-    static_assert(std::is_nothrow_destructible_v<Sink>);
+    static_assert(!std::is_default_constructible_v<Sink>, "");
+    static_assert(!std::is_copy_constructible_v<Sink>, "");
+    static_assert(!std::is_move_constructible_v<Sink>, "");
+    static_assert(!std::is_copy_assignable_v<Sink>, "");
+    static_assert(!std::is_move_assignable_v<Sink>, "");
+    static_assert(std::is_nothrow_destructible_v<Sink>, "");
 #endif
 
     /** Returns a Sink which does nothing. */
@@ -164,12 +164,12 @@ public:
     };
 
 #ifndef __INTELLISENSE__
-    static_assert(!std::is_default_constructible_v<ScopedStream>);
-    static_assert(std::is_copy_constructible_v<ScopedStream>);
-    static_assert(std::is_move_constructible_v<ScopedStream>);
-    static_assert(!std::is_copy_assignable_v<ScopedStream>);
-    static_assert(!std::is_move_assignable_v<ScopedStream>);
-    static_assert(std::is_nothrow_destructible_v<ScopedStream>);
+    static_assert(!std::is_default_constructible_v<ScopedStream>, "");
+    static_assert(std::is_copy_constructible_v<ScopedStream>, "");
+    static_assert(std::is_move_constructible_v<ScopedStream>, "");
+    static_assert(!std::is_copy_assignable_v<ScopedStream>, "");
+    static_assert(!std::is_move_assignable_v<ScopedStream>, "");
+    static_assert(std::is_nothrow_destructible_v<ScopedStream>, "");
 #endif
 
     //--------------------------------------------------------------------------
@@ -246,12 +246,12 @@ public:
     };
 
 #ifndef __INTELLISENSE__
-    static_assert(std::is_default_constructible_v<Stream>);
-    static_assert(std::is_copy_constructible_v<Stream>);
-    static_assert(std::is_move_constructible_v<Stream>);
-    static_assert(!std::is_copy_assignable_v<Stream>);
-    static_assert(!std::is_move_assignable_v<Stream>);
-    static_assert(std::is_nothrow_destructible_v<Stream>);
+    static_assert(std::is_default_constructible_v<Stream>, "");
+    static_assert(std::is_copy_constructible_v<Stream>, "");
+    static_assert(std::is_move_constructible_v<Stream>, "");
+    static_assert(!std::is_copy_assignable_v<Stream>, "");
+    static_assert(!std::is_move_assignable_v<Stream>, "");
+    static_assert(std::is_nothrow_destructible_v<Stream>, "");
 #endif
 
     //--------------------------------------------------------------------------
@@ -329,12 +329,12 @@ public:
 };
 
 #ifndef __INTELLISENSE__
-static_assert(!std::is_default_constructible_v<Journal>);
-static_assert(std::is_copy_constructible_v<Journal>);
-static_assert(std::is_move_constructible_v<Journal>);
-static_assert(std::is_copy_assignable_v<Journal>);
-static_assert(std::is_move_assignable_v<Journal>);
-static_assert(std::is_nothrow_destructible_v<Journal>);
+static_assert(!std::is_default_constructible_v<Journal>, "");
+static_assert(std::is_copy_constructible_v<Journal>, "");
+static_assert(std::is_move_constructible_v<Journal>, "");
+static_assert(std::is_copy_assignable_v<Journal>, "");
+static_assert(std::is_move_assignable_v<Journal>, "");
+static_assert(std::is_nothrow_destructible_v<Journal>, "");
 #endif
 
 //------------------------------------------------------------------------------
diff --git a/include/xrpl/beast/utility/Zero.h b/include/xrpl/beast/utility/Zero.h
index e28589760b..f54345d437 100644
--- a/include/xrpl/beast/utility/Zero.h
+++ b/include/xrpl/beast/utility/Zero.h
@@ -26,7 +26,9 @@ struct Zero
     explicit Zero() = default;
 };
 
-inline constexpr Zero kZero{};
+namespace {
+constexpr Zero kZero{};
+}  // namespace
 
 /** Default implementation of signum calls the method on the class. */
 template <typename T>
diff --git a/include/xrpl/beast/utility/rngfill.h b/include/xrpl/beast/utility/rngfill.h
index 5bd9d8bc5c..0fc3ffe0d0 100644
--- a/include/xrpl/beast/utility/rngfill.h
+++ b/include/xrpl/beast/utility/rngfill.h
@@ -3,6 +3,7 @@
 #include <array>
 #include <cstdint>
 #include <cstring>
+#include <type_traits>
 
 namespace beast {
 
@@ -13,7 +14,7 @@ rngfill(void* const buffer, std::size_t const bytes, Generator& g)
     using result_type = Generator::result_type;
     constexpr std::size_t kResultSize = sizeof(result_type);
 
-    auto* const bufferStart = static_cast<std::uint8_t*>(buffer);
+    std::uint8_t* const bufferStart = static_cast<std::uint8_t*>(buffer);
     std::size_t const completeIterations = bytes / kResultSize;
     std::size_t const bytesRemaining = bytes % kResultSize;
 
@@ -32,14 +33,16 @@ rngfill(void* const buffer, std::size_t const bytes, Generator& g)
     }
 }
 
-template <class Generator, std::size_t N>
+template <
+    class Generator,
+    std::size_t N,
+    class = std::enable_if_t<N % sizeof(typename Generator::result_type) == 0>>
 void
 rngfill(std::array<std::uint8_t, N>& a, Generator& g)
-    requires(N % sizeof(typename Generator::result_type) == 0)
 {
     using result_type = Generator::result_type;
     auto i = N / sizeof(result_type);
-    auto* p = reinterpret_cast<result_type*>(a.data());
+    result_type* p = reinterpret_cast<result_type*>(a.data());
     while (i--)
         *p++ = g();
 }
diff --git a/include/xrpl/core/HashRouter.h b/include/xrpl/core/HashRouter.h
index dad1afb405..ef8f24d43c 100644
--- a/include/xrpl/core/HashRouter.h
+++ b/include/xrpl/core/HashRouter.h
@@ -127,7 +127,7 @@ private:
         }
 
         [[nodiscard]] HashRouterFlags
-        getFlags() const
+        getFlags(void) const
         {
             return flags_;
         }
diff --git a/include/xrpl/core/JobQueue.h b/include/xrpl/core/JobQueue.h
index e4b64546f3..14170a39be 100644
--- a/include/xrpl/core/JobQueue.h
+++ b/include/xrpl/core/JobQueue.h
@@ -154,14 +154,16 @@ public:
 
         @param type The type of job.
         @param name Name of the job.
-        @param jobHandler Callable with signature void(). Called when the job is executed.
+        @param jobHandler Lambda with signature void (Job&).  Called when the
+       job is executed.
 
         @return true if jobHandler added to queue.
     */
-    template <typename JobHandler>
+    template <
+        typename JobHandler,
+        typename = std::enable_if_t<std::is_same_v<decltype(std::declval<JobHandler&&>()()), void>>>
     bool
     addJob(JobType type, std::string const& name, JobHandler&& jobHandler)
-        requires(std::is_void_v<std::invoke_result_t<JobHandler>>)
     {
         if (auto optionalCountedJob = jobCounter_.wrap(std::forward<JobHandler>(jobHandler)))
         {
diff --git a/include/xrpl/core/JobTypes.h b/include/xrpl/core/JobTypes.h
index cc2f3ecbf5..f338b19f6c 100644
--- a/include/xrpl/core/JobTypes.h
+++ b/include/xrpl/core/JobTypes.h
@@ -118,7 +118,7 @@ public:
     [[nodiscard]] JobTypeInfo const&
     get(JobType jt) const
     {
-        auto const iter = map.find(jt);
+        Map::const_iterator const iter(map.find(jt));
         XRPL_ASSERT(iter != map.end(), "xrpl::JobTypes::get : valid input");
 
         if (iter != map.end())
diff --git a/include/xrpl/json/json_reader.h b/include/xrpl/json/json_reader.h
index d1e4ada579..c1535bfb55 100644
--- a/include/xrpl/json/json_reader.h
+++ b/include/xrpl/json/json_reader.h
@@ -154,7 +154,7 @@ private:
         Location end,
         unsigned int& unicode);
     bool
-    addError(std::string const& message, Token& token, Location extra = nullptr);
+    addError(std::string const& message, Token& token, Location extra = 0);
     bool
     recoverFromError(TokenType skipUntilToken);
     bool
diff --git a/include/xrpl/ledger/ApplyView.h b/include/xrpl/ledger/ApplyView.h
index 2aba93d504..35fa059981 100644
--- a/include/xrpl/ledger/ApplyView.h
+++ b/include/xrpl/ledger/ApplyView.h
@@ -5,7 +5,7 @@
 #include <xrpl/beast/utility/instrumentation.h>
 #include <xrpl/ledger/ReadView.h>
 #include <xrpl/protocol/AccountID.h>
-#include <xrpl/protocol/Issue.h>  // IWYU pragma: keep
+#include <xrpl/protocol/Issue.h>
 #include <xrpl/protocol/Keylet.h>
 #include <xrpl/protocol/LedgerFormats.h>
 #include <xrpl/protocol/MPTIssue.h>
diff --git a/include/xrpl/ledger/CachedView.h b/include/xrpl/ledger/CachedView.h
index 1da3a67563..f83c3e1297 100644
--- a/include/xrpl/ledger/CachedView.h
+++ b/include/xrpl/ledger/CachedView.h
@@ -141,7 +141,7 @@ template <class Base>
 class CachedView : public detail::CachedViewImpl
 {
 private:
-    static_assert(std::is_base_of_v<DigestAwareReadView, Base>);
+    static_assert(std::is_base_of_v<DigestAwareReadView, Base>, "");
 
     std::shared_ptr<Base const> sp_;
 
diff --git a/include/xrpl/ledger/OpenView.h b/include/xrpl/ledger/OpenView.h
index 875909715c..de81787906 100644
--- a/include/xrpl/ledger/OpenView.h
+++ b/include/xrpl/ledger/OpenView.h
@@ -82,7 +82,7 @@ private:
     using txs_map = std::map<
         key_type,
         TxData,
-        std::less<>,
+        std::less<key_type>,
         boost::container::pmr::polymorphic_allocator<std::pair<key_type const, TxData>>>;
 
     // monotonic_resource_ must outlive `items_`. Make a pointer so it may be
diff --git a/include/xrpl/ledger/ReadView.h b/include/xrpl/ledger/ReadView.h
index 2c33c511fd..b47f28d91c 100644
--- a/include/xrpl/ledger/ReadView.h
+++ b/include/xrpl/ledger/ReadView.h
@@ -7,7 +7,7 @@
 #include <xrpl/ledger/detail/ReadViewFwdRange.h>
 #include <xrpl/protocol/AccountID.h>
 #include <xrpl/protocol/Fees.h>
-#include <xrpl/protocol/Issue.h>  // IWYU pragma: keep
+#include <xrpl/protocol/Issue.h>
 #include <xrpl/protocol/Keylet.h>
 #include <xrpl/protocol/LedgerFormats.h>
 #include <xrpl/protocol/LedgerHeader.h>
diff --git a/include/xrpl/ledger/detail/RawStateTable.h b/include/xrpl/ledger/detail/RawStateTable.h
index 2e36a42eaf..cfa528d355 100644
--- a/include/xrpl/ledger/detail/RawStateTable.h
+++ b/include/xrpl/ledger/detail/RawStateTable.h
@@ -105,7 +105,7 @@ private:
     using items_t = std::map<
         key_type,
         SleAction,
-        std::less<>,
+        std::less<key_type>,
         boost::container::pmr::polymorphic_allocator<std::pair<key_type const, SleAction>>>;
     // monotonic_resource_ must outlive `items_`. Make a pointer so it may be
     // easily moved.
diff --git a/include/xrpl/ledger/detail/ReadViewFwdRange.h b/include/xrpl/ledger/detail/ReadViewFwdRange.h
index 19ac0698c2..82d8b59c6a 100644
--- a/include/xrpl/ledger/detail/ReadViewFwdRange.h
+++ b/include/xrpl/ledger/detail/ReadViewFwdRange.h
@@ -108,8 +108,8 @@ public:
         std::optional<value_type> mutable cache_;
     };
 
-    static_assert(std::is_nothrow_move_constructible<Iterator>{});
-    static_assert(std::is_nothrow_move_assignable<Iterator>{});
+    static_assert(std::is_nothrow_move_constructible<Iterator>{}, "");
+    static_assert(std::is_nothrow_move_assignable<Iterator>{}, "");
 
     using const_iterator = Iterator;
 
diff --git a/include/xrpl/ledger/helpers/DirectoryHelpers.h b/include/xrpl/ledger/helpers/DirectoryHelpers.h
index a95b9bc95a..76a5f3bdad 100644
--- a/include/xrpl/ledger/helpers/DirectoryHelpers.h
+++ b/include/xrpl/ledger/helpers/DirectoryHelpers.h
@@ -19,7 +19,11 @@ namespace xrpl {
 
 namespace detail {
 
-template <class V, class N>
+template <
+    class V,
+    class N,
+    class = std::enable_if_t<
+        std::is_same_v<std::remove_cv_t<N>, SLE> && std::is_base_of_v<ReadView, V>>>
 bool
 internalDirNext(
     V& view,
@@ -27,7 +31,6 @@ internalDirNext(
     std::shared_ptr<N>& page,
     unsigned int& index,
     uint256& entry)
-    requires(std::is_same_v<std::remove_cv_t<N>, SLE> && std::is_base_of_v<ReadView, V>)
 {
     auto const& svIndexes = page->getFieldV256(sfIndexes);
     XRPL_ASSERT(index <= svIndexes.size(), "xrpl::detail::internalDirNext : index inside range");
@@ -65,7 +68,11 @@ internalDirNext(
     return true;
 }
 
-template <class V, class N>
+template <
+    class V,
+    class N,
+    class = std::enable_if_t<
+        std::is_same_v<std::remove_cv_t<N>, SLE> && std::is_base_of_v<ReadView, V>>>
 bool
 internalDirFirst(
     V& view,
@@ -73,7 +80,6 @@ internalDirFirst(
     std::shared_ptr<N>& page,
     unsigned int& index,
     uint256& entry)
-    requires(std::is_same_v<std::remove_cv_t<N>, SLE> && std::is_base_of_v<ReadView, V>)
 {
     if constexpr (std::is_const_v<N>)
     {
diff --git a/include/xrpl/ledger/helpers/EscrowHelpers.h b/include/xrpl/ledger/helpers/EscrowHelpers.h
index b4093d121b..65f19dc3d7 100644
--- a/include/xrpl/ledger/helpers/EscrowHelpers.h
+++ b/include/xrpl/ledger/helpers/EscrowHelpers.h
@@ -53,7 +53,7 @@ escrowUnlockApplyHelper<Issue>(
     bool createAsset,
     beast::Journal journal)
 {
-    auto const& issue = amount.get<Issue>();
+    Issue const& issue = amount.get<Issue>();
     Keylet const trustLineKey = keylet::trustLine(receiver, issue);
     bool const recvLow = issuer > receiver;
     bool const senderIssuer = issuer == sender;
diff --git a/include/xrpl/ledger/helpers/LendingHelpers.h b/include/xrpl/ledger/helpers/LendingHelpers.h
index 873abae272..c21e5bf0ce 100644
--- a/include/xrpl/ledger/helpers/LendingHelpers.h
+++ b/include/xrpl/ledger/helpers/LendingHelpers.h
@@ -8,7 +8,7 @@
 #include <xrpl/ledger/ApplyView.h>
 #include <xrpl/ledger/ReadView.h>
 #include <xrpl/protocol/Asset.h>
-#include <xrpl/protocol/LedgerFormats.h>  // IWYU pragma: keep
+#include <xrpl/protocol/LedgerFormats.h>
 #include <xrpl/protocol/Protocol.h>
 #include <xrpl/protocol/Rules.h>
 #include <xrpl/protocol/SField.h>
diff --git a/include/xrpl/net/AutoSocket.h b/include/xrpl/net/AutoSocket.h
index b98885959d..72eaed7439 100644
--- a/include/xrpl/net/AutoSocket.h
+++ b/include/xrpl/net/AutoSocket.h
@@ -120,9 +120,12 @@ public:
             socket_->next_layer().async_receive(
                 boost::asio::buffer(buffer_),
                 boost::asio::socket_base::message_peek,
-                [this, cbFunc](error_code const& ec, size_t bytesTransferred) {
-                    handleAutodetect(cbFunc, ec, bytesTransferred);
-                });
+                std::bind(
+                    &AutoSocket::handleAutodetect,
+                    this,
+                    cbFunc,
+                    std::placeholders::_1,
+                    std::placeholders::_2));
         }
     }
 
diff --git a/include/xrpl/net/HTTPClientSSLContext.h b/include/xrpl/net/HTTPClientSSLContext.h
index 51b50a084c..4192455ec9 100644
--- a/include/xrpl/net/HTTPClientSSLContext.h
+++ b/include/xrpl/net/HTTPClientSSLContext.h
@@ -13,6 +13,7 @@
 #include <openssl/err.h>
 #include <openssl/tls1.h>
 
+#include <functional>
 #include <stdexcept>
 #include <string>
 #include <type_traits>
@@ -83,12 +84,13 @@ public:
      *
      * @return error_code indicating failures, if any
      */
-    template <class T>
+    template <
+        class T,
+        class = std::enable_if_t<
+            std::is_same_v<T, boost::asio::ssl::stream<boost::asio::ip::tcp::socket>> ||
+            std::is_same_v<T, boost::asio::ssl::stream<boost::asio::ip::tcp::socket&>>>>
     boost::system::error_code
     preConnectVerify(T& strm, std::string const& host)
-        requires(
-            std::is_same_v<T, boost::asio::ssl::stream<boost::asio::ip::tcp::socket>> ||
-            std::is_same_v<T, boost::asio::ssl::stream<boost::asio::ip::tcp::socket&>>)
     {
         boost::system::error_code ec;
         if (!SSL_set_tlsext_host_name(strm.native_handle(), host.c_str()))
@@ -102,7 +104,11 @@ public:
         return ec;
     }
 
-    template <class T>
+    template <
+        class T,
+        class = std::enable_if_t<
+            std::is_same_v<T, boost::asio::ssl::stream<boost::asio::ip::tcp::socket>> ||
+            std::is_same_v<T, boost::asio::ssl::stream<boost::asio::ip::tcp::socket&>>>>
     /**
      * @brief invoked after connect/async_connect but before sending data
      * on an ssl stream - to setup name verification.
@@ -112,9 +118,6 @@ public:
      */
     boost::system::error_code
     postConnectVerify(T& strm, std::string const& host)
-        requires(
-            std::is_same_v<T, boost::asio::ssl::stream<boost::asio::ip::tcp::socket>> ||
-            std::is_same_v<T, boost::asio::ssl::stream<boost::asio::ip::tcp::socket&>>)
     {
         boost::system::error_code ec;
 
@@ -124,9 +127,8 @@ public:
             if (!ec)
             {
                 strm.set_verify_callback(
-                    [host, j = j_](bool preverified, boost::asio::ssl::verify_context& ctx) {
-                        return rfc6125Verify(host, preverified, ctx, j);
-                    },
+                    std::bind(
+                        &rfc6125Verify, host, std::placeholders::_1, std::placeholders::_2, j_),
                     ec);
             }
         }
diff --git a/include/xrpl/nodestore/detail/DecodedBlob.h b/include/xrpl/nodestore/detail/DecodedBlob.h
index 02ccd5787a..b2d5fc9c26 100644
--- a/include/xrpl/nodestore/detail/DecodedBlob.h
+++ b/include/xrpl/nodestore/detail/DecodedBlob.h
@@ -34,11 +34,11 @@ public:
     createObject();
 
 private:
-    bool success_{false};
+    bool success_;
 
     void const* key_;
-    NodeObjectType objectType_{NodeObjectType::Unknown};
-    unsigned char const* objectData_{nullptr};
+    NodeObjectType objectType_;
+    unsigned char const* objectData_;
     int dataBytes_;
 };
 
diff --git a/include/xrpl/nodestore/detail/codec.h b/include/xrpl/nodestore/detail/codec.h
index 2f69d532be..56e1fbcf73 100644
--- a/include/xrpl/nodestore/detail/codec.h
+++ b/include/xrpl/nodestore/detail/codec.h
@@ -62,7 +62,7 @@ lz4Compress(void const* in, std::size_t inSize, BufferFactory&& bf)
     std::array<std::uint8_t, varint_traits<std::size_t>::kMax> vi{};
     auto const n = writeVarint(vi.data(), inSize);
     auto const outMax = LZ4_compressBound(inSize);
-    auto* out = reinterpret_cast<std::uint8_t*>(bf(n + outMax));
+    std::uint8_t* out = reinterpret_cast<std::uint8_t*>(bf(n + outMax));
     result.first = out;
     std::memcpy(out, vi.data(), n);
     auto const outSize = LZ4_compress_default(
@@ -90,7 +90,7 @@ nodeobjectDecompress(void const* in, std::size_t inSize, BufferFactory&& bf)
 {
     using namespace nudb::detail;
 
-    auto const* p = reinterpret_cast<std::uint8_t const*>(in);
+    std::uint8_t const* p = reinterpret_cast<std::uint8_t const*>(in);
     std::size_t type = 0;
     auto const vn = readVarint(p, inSize, type);
     if (vn == 0)
@@ -237,7 +237,7 @@ nodeobjectCompress(void const* in, std::size_t inSize, BufferFactory&& bf)
                 auto const vs = sizeVarint(type);
                 result.second = vs + field<std::uint16_t>::size +  // mask
                     (n * 32);                                      // hashes
-                auto* out = reinterpret_cast<std::uint8_t*>(bf(result.second));
+                std::uint8_t* out = reinterpret_cast<std::uint8_t*>(bf(result.second));
                 result.first = out;
                 ostream os(out, result.second);
                 write<varint>(os, type);
@@ -249,7 +249,7 @@ nodeobjectCompress(void const* in, std::size_t inSize, BufferFactory&& bf)
             auto const type = 3U;
             auto const vs = sizeVarint(type);
             result.second = vs + (n * 32);  // hashes
-            auto* out = reinterpret_cast<std::uint8_t*>(bf(result.second));
+            std::uint8_t* out = reinterpret_cast<std::uint8_t*>(bf(result.second));
             result.first = out;
             ostream os(out, result.second);
             write<varint>(os, type);
diff --git a/include/xrpl/nodestore/detail/varint.h b/include/xrpl/nodestore/detail/varint.h
index 5a65545d3a..21a13bd6de 100644
--- a/include/xrpl/nodestore/detail/varint.h
+++ b/include/xrpl/nodestore/detail/varint.h
@@ -39,7 +39,7 @@ readVarint(void const* buf, std::size_t buflen, std::size_t& t)
     if (buflen == 0)
         return 0;
     t = 0;
-    auto const* p = reinterpret_cast<std::uint8_t const*>(buf);
+    std::uint8_t const* p = reinterpret_cast<std::uint8_t const*>(buf);
     std::size_t n = 0;
     while (p[n] & 0x80)
     {
@@ -68,10 +68,9 @@ readVarint(void const* buf, std::size_t buflen, std::size_t& t)
     return used;
 }
 
-template <class T>
+template <class T, std::enable_if_t<std::is_unsigned_v<T>>* = nullptr>
 std::size_t
 sizeVarint(T v)
-    requires(std::is_unsigned_v<T>)
 {
     std::size_t n = 0;
     do
@@ -87,7 +86,7 @@ std::size_t
 writeVarint(void* p0, std::size_t v)
 {
     // NOLINTNEXTLINE(misc-const-correctness)
-    auto* p = reinterpret_cast<std::uint8_t*>(p0);
+    std::uint8_t* p = reinterpret_cast<std::uint8_t*>(p0);
     do
     {
         std::uint8_t d = v % 127;
@@ -101,10 +100,9 @@ writeVarint(void* p0, std::size_t v)
 
 // input stream
 
-template <class T>
+template <class T, std::enable_if_t<std::is_same_v<T, varint>>* = nullptr>
 void
 read(nudb::detail::istream& is, std::size_t& u)
-    requires(std::is_same_v<T, varint>)
 {
     auto p0 = is(1);
     auto p1 = p0;
@@ -115,10 +113,9 @@ read(nudb::detail::istream& is, std::size_t& u)
 
 // output stream
 
-template <class T>
+template <class T, std::enable_if_t<std::is_same_v<T, varint>>* = nullptr>
 void
 write(nudb::detail::ostream& os, std::size_t t)
-    requires(std::is_same_v<T, varint>)
 {
     writeVarint(os.data(sizeVarint(t)), t);
 }
diff --git a/include/xrpl/protocol/AmountConversions.h b/include/xrpl/protocol/AmountConversions.h
index 3bcd80e827..66ada68d6f 100644
--- a/include/xrpl/protocol/AmountConversions.h
+++ b/include/xrpl/protocol/AmountConversions.h
@@ -13,7 +13,7 @@
 #include <xrpl/protocol/XRPAmount.h>
 
 #include <cstdint>
-#include <limits>  // IWYU pragma: keep
+#include <limits>
 #include <stdexcept>
 #include <type_traits>
 
diff --git a/include/xrpl/protocol/Quality.h b/include/xrpl/protocol/Quality.h
index de61d79ca5..6bb2033dc0 100644
--- a/include/xrpl/protocol/Quality.h
+++ b/include/xrpl/protocol/Quality.h
@@ -282,7 +282,7 @@ public:
         auto const maxVMantissa = mantissa(maxV);
         auto const expDiff = exponent(maxV) - exponent(minV);
 
-        auto const minVD = static_cast<double>(minVMantissa);
+        double const minVD = static_cast<double>(minVMantissa);
         double const maxVD =
             (expDiff != 0) ? maxVMantissa * pow(10, expDiff) : static_cast<double>(maxVMantissa);
 
diff --git a/include/xrpl/protocol/STArray.h b/include/xrpl/protocol/STArray.h
index 573bb6dad8..ed39e65026 100644
--- a/include/xrpl/protocol/STArray.h
+++ b/include/xrpl/protocol/STArray.h
@@ -32,13 +32,17 @@ public:
     STArray() = default;
     STArray(STArray const&) = default;
 
-    template <class Iter>
-    explicit STArray(Iter first, Iter last)
-        requires(std::is_convertible_v<typename std::iterator_traits<Iter>::reference, STObject>);
+    template <
+        class Iter,
+        class = std::enable_if_t<
+            std::is_convertible_v<typename std::iterator_traits<Iter>::reference, STObject>>>
+    explicit STArray(Iter first, Iter last);
 
-    template <class Iter>
-    STArray(SField const& f, Iter first, Iter last)
-        requires(std::is_convertible_v<typename std::iterator_traits<Iter>::reference, STObject>);
+    template <
+        class Iter,
+        class = std::enable_if_t<
+            std::is_convertible_v<typename std::iterator_traits<Iter>::reference, STObject>>>
+    STArray(SField const& f, Iter first, Iter last);
 
     STArray&
     operator=(STArray const&) = default;
@@ -166,17 +170,13 @@ private:
     friend class detail::STVar;
 };
 
-template <class Iter>
-STArray::STArray(Iter first, Iter last)
-    requires(std::is_convertible_v<typename std::iterator_traits<Iter>::reference, STObject>)
-    : v_(first, last)
+template <class Iter, class>
+STArray::STArray(Iter first, Iter last) : v_(first, last)
 {
 }
 
-template <class Iter>
-STArray::STArray(SField const& f, Iter first, Iter last)
-    requires(std::is_convertible_v<typename std::iterator_traits<Iter>::reference, STObject>)
-    : STBase(f), v_(first, last)
+template <class Iter, class>
+STArray::STArray(SField const& f, Iter first, Iter last) : STBase(f), v_(first, last)
 {
 }
 
diff --git a/include/xrpl/protocol/STBitString.h b/include/xrpl/protocol/STBitString.h
index 6f71f48f25..4f25eccca6 100644
--- a/include/xrpl/protocol/STBitString.h
+++ b/include/xrpl/protocol/STBitString.h
@@ -148,7 +148,7 @@ template <int Bits>
 bool
 STBitString<Bits>::isEquivalent(STBase const& t) const
 {
-    auto const* v = dynamic_cast<STBitString const*>(&t);
+    STBitString const* v = dynamic_cast<STBitString const*>(&t);
     return v && (value_ == v->value_);
 }
 
diff --git a/include/xrpl/protocol/STInteger.h b/include/xrpl/protocol/STInteger.h
index 951c4fc52f..1c7ac98f3e 100644
--- a/include/xrpl/protocol/STInteger.h
+++ b/include/xrpl/protocol/STInteger.h
@@ -115,7 +115,7 @@ template <typename Integer>
 inline bool
 STInteger<Integer>::isEquivalent(STBase const& t) const
 {
-    auto const* v = dynamic_cast<STInteger const*>(&t);
+    STInteger const* v = dynamic_cast<STInteger const*>(&t);
     return v && (value_ == v->value_);
 }
 
diff --git a/include/xrpl/protocol/STObject.h b/include/xrpl/protocol/STObject.h
index 9abf56e91b..b115e5646d 100644
--- a/include/xrpl/protocol/STObject.h
+++ b/include/xrpl/protocol/STObject.h
@@ -555,14 +555,9 @@ public:
     ValueProxy&
     operator=(ValueProxy const&) = delete;
 
-    // Write-through proxy: assignment sets the referenced field to the given
-    // value, so it intentionally takes the assigned value rather than a
-    // ValueProxy.
     template <class U>
-    // NOLINTNEXTLINE(misc-unconventional-assign-operator)
-    ValueProxy&
-    operator=(U&& u)
-        requires(std::is_assignable_v<T, U>);
+    std::enable_if_t<std::is_assignable_v<T, U>, ValueProxy&>
+    operator=(U&& u);
 
     // Convenience operators for value types supporting
     // arithmetic operations
@@ -696,9 +691,8 @@ public:
     operator=(optional_type const& v);
 
     template <class U>
-    OptionalProxy&
-    operator=(U&& u)
-        requires(std::is_assignable_v<T, U>);
+    std::enable_if_t<std::is_assignable_v<T, U>, OptionalProxy&>
+    operator=(U&& u);
 
 private:
     friend class STObject;
@@ -804,10 +798,8 @@ STObject::Proxy<T>::assign(U&& u)
 
 template <class T>
 template <class U>
-// NOLINTNEXTLINE(misc-unconventional-assign-operator)
-STObject::ValueProxy<T>&
+std::enable_if_t<std::is_assignable_v<T, U>, STObject::ValueProxy<T>&>
 STObject::ValueProxy<T>::operator=(U&& u)
-    requires(std::is_assignable_v<T, U>)
 {
     this->assign(std::forward<U>(u));
     return *this;
@@ -910,9 +902,8 @@ STObject::OptionalProxy<T>::operator=(optional_type const& v) -> OptionalProxy&
 
 template <class T>
 template <class U>
-STObject::OptionalProxy<T>&
+std::enable_if_t<std::is_assignable_v<T, U>, STObject::OptionalProxy<T>&>
 STObject::OptionalProxy<T>::operator=(U&& u)
-    requires(std::is_assignable_v<T, U>)
 {
     this->assign(std::forward<U>(u));
     return *this;
@@ -1250,7 +1241,7 @@ template <typename T, typename V>
 void
 STObject::setFieldUsingSetValue(SField const& field, V value)
 {
-    static_assert(!std::is_lvalue_reference_v<V>);
+    static_assert(!std::is_lvalue_reference_v<V>, "");
 
     STBase* rf = getPField(field, true);
 
diff --git a/include/xrpl/protocol/STPathSet.h b/include/xrpl/protocol/STPathSet.h
index 23f4e653c4..f6b0fde7da 100644
--- a/include/xrpl/protocol/STPathSet.h
+++ b/include/xrpl/protocol/STPathSet.h
@@ -240,9 +240,6 @@ private:
 
 inline STPathElement::STPathElement() : type_(TypeNone), isOffer_(true)
 {
-    // hashValue_ is derived from the whole object, so it is computed in the body
-    // once every other member is initialized (as in the other constructors).
-    // NOLINTNEXTLINE(cppcoreguidelines-prefer-member-initializer)
     hashValue_ = getHash(*this);
 }
 
@@ -318,9 +315,6 @@ inline STPathElement::STPathElement(
     assetID_.visit(
         [&](Currency const&) { type_ = type_ & (~Type::TypeMpt); },
         [&](MPTID const&) { type_ = type_ & (~Type::TypeCurrency); });
-    // hashValue_ must be computed after type_ is adjusted above, so this cannot
-    // be a member initializer.
-    // NOLINTNEXTLINE(cppcoreguidelines-prefer-member-initializer)
     hashValue_ = getHash(*this);
 }
 
diff --git a/include/xrpl/protocol/Serializer.h b/include/xrpl/protocol/Serializer.h
index 73bd9c8289..1d0453d6aa 100644
--- a/include/xrpl/protocol/Serializer.h
+++ b/include/xrpl/protocol/Serializer.h
@@ -334,7 +334,7 @@ public:
     template <int N>
     explicit SerialIter(std::uint8_t const (&data)[N]) : SerialIter(&data[0], N)
     {
-        static_assert(N > 0);
+        static_assert(N > 0, "");
     }
 
     [[nodiscard]] bool
diff --git a/include/xrpl/protocol/TER.h b/include/xrpl/protocol/TER.h
index dc8cb31e30..d24e3ee6e9 100644
--- a/include/xrpl/protocol/TER.h
+++ b/include/xrpl/protocol/TER.h
@@ -413,7 +413,7 @@ TERtoInt(TECcodes v)
 
 //------------------------------------------------------------------------------
 // Template class that is specific to selected ranges of error codes.  The
-// Trait tells the requires-clause which ranges are allowed.
+// Trait tells std::enable_if which ranges are allowed.
 template <template <typename> class Trait>
 class TERSubset
 {
@@ -439,11 +439,11 @@ public:
         return TERSubset(from);
     }
 
-    // Trait tells the requires-clause which types are allowed for construction.
-    template <typename T>
-    constexpr TERSubset(T rhs)
-        requires(Trait<std::remove_cv_t<std::remove_reference_t<T>>>::value)
-        : code_(TERtoInt(rhs))
+    // Trait tells enable_if which types are allowed for construction.
+    template <
+        typename T,
+        typename = std::enable_if_t<Trait<std::remove_cv_t<std::remove_reference_t<T>>>::value>>
+    constexpr TERSubset(T rhs) : code_(TERtoInt(rhs))
     {
     }
 
@@ -453,11 +453,10 @@ public:
     constexpr TERSubset&
     operator=(TERSubset&& rhs) = default;
 
-    // Trait tells the requires-clause which types are allowed for assignment.
+    // Trait tells enable_if which types are allowed for assignment.
     template <typename T>
     constexpr auto
-    operator=(T rhs) -> TERSubset&
-        requires(Trait<T>::value)
+    operator=(T rhs) -> std::enable_if_t<Trait<T>::value, TERSubset&>
     {
         code_ = TERtoInt(rhs);
         return *this;
@@ -511,60 +510,54 @@ public:
 // Only enabled if both arguments return int if TERtiInt is called with them.
 template <typename L, typename R>
 constexpr auto
-operator==(L const& lhs, R const& rhs) -> bool
-    requires(
-        std::is_same_v<decltype(TERtoInt(lhs)), int> &&
-        std::is_same_v<decltype(TERtoInt(rhs)), int>)
+operator==(L const& lhs, R const& rhs) -> std::enable_if_t<
+    std::is_same_v<decltype(TERtoInt(lhs)), int> && std::is_same_v<decltype(TERtoInt(rhs)), int>,
+    bool>
 {
     return TERtoInt(lhs) == TERtoInt(rhs);
 }
 
 template <typename L, typename R>
 constexpr auto
-operator!=(L const& lhs, R const& rhs) -> bool
-    requires(
-        std::is_same_v<decltype(TERtoInt(lhs)), int> &&
-        std::is_same_v<decltype(TERtoInt(rhs)), int>)
+operator!=(L const& lhs, R const& rhs) -> std::enable_if_t<
+    std::is_same_v<decltype(TERtoInt(lhs)), int> && std::is_same_v<decltype(TERtoInt(rhs)), int>,
+    bool>
 {
     return TERtoInt(lhs) != TERtoInt(rhs);
 }
 
 template <typename L, typename R>
 constexpr auto
-operator<(L const& lhs, R const& rhs) -> bool
-    requires(
-        std::is_same_v<decltype(TERtoInt(lhs)), int> &&
-        std::is_same_v<decltype(TERtoInt(rhs)), int>)
+operator<(L const& lhs, R const& rhs) -> std::enable_if_t<
+    std::is_same_v<decltype(TERtoInt(lhs)), int> && std::is_same_v<decltype(TERtoInt(rhs)), int>,
+    bool>
 {
     return TERtoInt(lhs) < TERtoInt(rhs);
 }
 
 template <typename L, typename R>
 constexpr auto
-operator<=(L const& lhs, R const& rhs) -> bool
-    requires(
-        std::is_same_v<decltype(TERtoInt(lhs)), int> &&
-        std::is_same_v<decltype(TERtoInt(rhs)), int>)
+operator<=(L const& lhs, R const& rhs) -> std::enable_if_t<
+    std::is_same_v<decltype(TERtoInt(lhs)), int> && std::is_same_v<decltype(TERtoInt(rhs)), int>,
+    bool>
 {
     return TERtoInt(lhs) <= TERtoInt(rhs);
 }
 
 template <typename L, typename R>
 constexpr auto
-operator>(L const& lhs, R const& rhs) -> bool
-    requires(
-        std::is_same_v<decltype(TERtoInt(lhs)), int> &&
-        std::is_same_v<decltype(TERtoInt(rhs)), int>)
+operator>(L const& lhs, R const& rhs) -> std::enable_if_t<
+    std::is_same_v<decltype(TERtoInt(lhs)), int> && std::is_same_v<decltype(TERtoInt(rhs)), int>,
+    bool>
 {
     return TERtoInt(lhs) > TERtoInt(rhs);
 }
 
 template <typename L, typename R>
 constexpr auto
-operator>=(L const& lhs, R const& rhs) -> bool
-    requires(
-        std::is_same_v<decltype(TERtoInt(lhs)), int> &&
-        std::is_same_v<decltype(TERtoInt(rhs)), int>)
+operator>=(L const& lhs, R const& rhs) -> std::enable_if_t<
+    std::is_same_v<decltype(TERtoInt(lhs)), int> && std::is_same_v<decltype(TERtoInt(rhs)), int>,
+    bool>
 {
     return TERtoInt(lhs) >= TERtoInt(rhs);
 }
diff --git a/include/xrpl/protocol/detail/STVar.h b/include/xrpl/protocol/detail/STVar.h
index e95461c253..6853166174 100644
--- a/include/xrpl/protocol/detail/STVar.h
+++ b/include/xrpl/protocol/detail/STVar.h
@@ -50,13 +50,14 @@ public:
     STVar&
     operator=(STVar&& rhs);
 
-    // NOLINTNEXTLINE(cppcoreguidelines-rvalue-reference-param-not-moved)
-    STVar(STBase&& t) : p_(t.move(kMaxSize, &d_))
+    STVar(STBase&& t)  // NOLINT(cppcoreguidelines-rvalue-reference-param-not-moved)
     {
+        p_ = t.move(kMaxSize, &d_);
     }
 
-    STVar(STBase const& t) : p_(t.copy(kMaxSize, &d_))
+    STVar(STBase const& t)
     {
+        p_ = t.copy(kMaxSize, &d_);
     }
 
     STVar(DefaultObjectT, SField const& name);
diff --git a/include/xrpl/protocol/detail/features.macro b/include/xrpl/protocol/detail/features.macro
index 368b1a67ce..3aa21a61cd 100644
--- a/include/xrpl/protocol/detail/features.macro
+++ b/include/xrpl/protocol/detail/features.macro
@@ -16,9 +16,9 @@
 // Keep it sorted in reverse chronological order.
 
 XRPL_FEATURE(Sponsor,                     Supported::No,  VoteBehavior::DefaultNo)
-XRPL_FEATURE(BatchV1_1,                   Supported::Yes, VoteBehavior::DefaultNo)
+XRPL_FEATURE(BatchV1_1,                   Supported::No,  VoteBehavior::DefaultNo)
 XRPL_FEATURE(LendingProtocolV1_1,         Supported::No,  VoteBehavior::DefaultNo)
-XRPL_FEATURE(ConfidentialTransfer,        Supported::Yes, VoteBehavior::DefaultNo)
+XRPL_FEATURE(ConfidentialTransfer,        Supported::No,  VoteBehavior::DefaultNo)
 XRPL_FIX    (Cleanup3_3_0,                Supported::Yes, VoteBehavior::DefaultNo)
 XRPL_FIX    (Cleanup3_2_0,                Supported::Yes, VoteBehavior::DefaultNo)
 XRPL_FEATURE(MPTokensV2,                  Supported::No,  VoteBehavior::DefaultNo)
@@ -61,6 +61,7 @@ XRPL_FEATURE(PriceOracle,                Supported::Yes, VoteBehavior::DefaultNo
 XRPL_FIX    (AMMOverflowOffer,           Supported::Yes, VoteBehavior::DefaultYes)
 XRPL_FIX    (FillOrKill,                 Supported::Yes, VoteBehavior::DefaultNo)
 XRPL_FEATURE(DID,                        Supported::Yes, VoteBehavior::DefaultNo)
+XRPL_FIX    (DisallowIncomingV1,         Supported::Yes, VoteBehavior::DefaultNo)
 XRPL_FEATURE(XChainBridge,               Supported::Yes, VoteBehavior::DefaultNo)
 XRPL_FEATURE(AMM,                        Supported::Yes, VoteBehavior::DefaultNo)
 XRPL_FEATURE(XRPFees,                    Supported::Yes, VoteBehavior::DefaultNo)
@@ -100,7 +101,6 @@ XRPL_RETIRE_FIX(1623)
 XRPL_RETIRE_FIX(1781)
 XRPL_RETIRE_FIX(AmendmentMajorityCalc)
 XRPL_RETIRE_FIX(CheckThreading)
-XRPL_RETIRE_FIX(DisallowIncomingV1)
 XRPL_RETIRE_FIX(InnerObjTemplate)
 XRPL_RETIRE_FIX(MasterKeyAsRegularKey)
 XRPL_RETIRE_FIX(NonFungibleTokensV1_2)
diff --git a/include/xrpl/resource/detail/Logic.h b/include/xrpl/resource/detail/Logic.h
index 78cd0ac36c..6b1c5e7397 100644
--- a/include/xrpl/resource/detail/Logic.h
+++ b/include/xrpl/resource/detail/Logic.h
@@ -351,9 +351,10 @@ public:
             Import& import(iter->second);
             if (iter->second.whenExpires <= elapsed)
             {
-                for (auto& item : import.items)
+                for (auto itemIter(import.items.begin()); itemIter != import.items.end();
+                     ++itemIter)
                 {
-                    item.consumer.entry().remoteBalance -= item.balance;
+                    itemIter->consumer.entry().remoteBalance -= itemIter->balance;
                 }
 
                 iter = importTable_.erase(iter);
diff --git a/include/xrpl/server/Manifest.h b/include/xrpl/server/Manifest.h
index c58c784de3..eb625d220a 100644
--- a/include/xrpl/server/Manifest.h
+++ b/include/xrpl/server/Manifest.h
@@ -161,12 +161,13 @@ deserializeManifest(
     return deserializeManifest(makeSlice(s), journal);
 }
 
-template <class T>
+template <
+    class T,
+    class = std::enable_if_t<std::is_same_v<T, char> || std::is_same_v<T, unsigned char>>>
 std::optional<Manifest>
 deserializeManifest(
     std::vector<T> const& v,
     beast::Journal journal = beast::Journal(beast::Journal::getNullSink()))
-    requires(std::is_same_v<T, char> || std::is_same_v<T, unsigned char>)
 {
     return deserializeManifest(makeSlice(v), journal);
 }
diff --git a/include/xrpl/server/detail/BaseHTTPPeer.h b/include/xrpl/server/detail/BaseHTTPPeer.h
index 7b35dbd4be..f096d3c5a9 100644
--- a/include/xrpl/server/detail/BaseHTTPPeer.h
+++ b/include/xrpl/server/detail/BaseHTTPPeer.h
@@ -223,7 +223,10 @@ BaseHTTPPeer<Handler, Impl>::close()
 {
     if (!strand_.running_in_this_thread())
     {
-        return post(strand_, [self = impl().shared_from_this()] { self->close(); });
+        return post(
+            strand_,
+            std::bind(
+                (void (BaseHTTPPeer::*)(void))&BaseHTTPPeer::close, impl().shared_from_this()));
     }
     boost::beast::get_lowest_layer(impl().stream_).close();
 }
@@ -319,18 +322,22 @@ BaseHTTPPeer<Handler, Impl>::onWrite(error_code const& ec, std::size_t bytesTran
             v,
             bind_executor(
                 strand_,
-                [self = impl().shared_from_this()](
-                    error_code const& ec, std::size_t bytesTransferred) {
-                    self->onWrite(ec, bytesTransferred);
-                }));
+                std::bind(
+                    &BaseHTTPPeer::onWrite,
+                    impl().shared_from_this(),
+                    std::placeholders::_1,
+                    std::placeholders::_2)));
     }
     if (!complete_)
         return;
     if (graceful_)
         return doClose();
-    util::spawn(strand_, [self = impl().shared_from_this()](yield_context doYield) {
-        self->doRead(doYield);
-    });
+    util::spawn(
+        strand_,
+        std::bind(
+            &BaseHTTPPeer<Handler, Impl>::doRead,
+            impl().shared_from_this(),
+            std::placeholders::_1));
 }
 
 template <class Handler, class Impl>
@@ -344,9 +351,14 @@ BaseHTTPPeer<Handler, Impl>::doWriter(
     {
         auto const p = impl().shared_from_this();
         resume = std::function<void(void)>([this, p, writer, keepAlive]() {
-            util::spawn(strand_, [p, writer, keepAlive](yield_context doYield) {
-                p->doWriter(writer, keepAlive, doYield);
-            });
+            util::spawn(
+                strand_,
+                std::bind(
+                    &BaseHTTPPeer<Handler, Impl>::doWriter,
+                    p,
+                    writer,
+                    keepAlive,
+                    std::placeholders::_1));
         });
     }
 
@@ -367,9 +379,12 @@ BaseHTTPPeer<Handler, Impl>::doWriter(
     if (!keepAlive)
         return doClose();
 
-    util::spawn(strand_, [self = impl().shared_from_this()](yield_context doYield) {
-        self->doRead(doYield);
-    });
+    util::spawn(
+        strand_,
+        std::bind(
+            &BaseHTTPPeer<Handler, Impl>::doRead,
+            impl().shared_from_this(),
+            std::placeholders::_1));
 }
 
 //------------------------------------------------------------------------------
@@ -390,7 +405,8 @@ BaseHTTPPeer<Handler, Impl>::write(void const* buf, std::size_t bytes)
         if (!strand_.running_in_this_thread())
         {
             return post(
-                strand_, [self = impl().shared_from_this()] { self->onWrite(error_code{}, 0); });
+                strand_,
+                std::bind(&BaseHTTPPeer::onWrite, impl().shared_from_this(), error_code{}, 0));
         }
         return onWrite(error_code{}, 0);
     }
@@ -401,9 +417,13 @@ void
 BaseHTTPPeer<Handler, Impl>::write(std::shared_ptr<Writer> const& writer, bool keepAlive)
 {
     util::spawn(
-        strand_, [self = impl().shared_from_this(), writer, keepAlive](yield_context doYield) {
-            self->doWriter(writer, keepAlive, doYield);
-        });
+        strand_,
+        std::bind(
+            &BaseHTTPPeer<Handler, Impl>::doWriter,
+            impl().shared_from_this(),
+            writer,
+            keepAlive,
+            std::placeholders::_1));
 }
 
 // DEPRECATED
@@ -423,7 +443,8 @@ BaseHTTPPeer<Handler, Impl>::complete()
 {
     if (!strand_.running_in_this_thread())
     {
-        return post(strand_, [self = impl().shared_from_this()] { self->complete(); });
+        return post(
+            strand_, std::bind(&BaseHTTPPeer<Handler, Impl>::complete, impl().shared_from_this()));
     }
 
     message_ = {};
@@ -436,9 +457,12 @@ BaseHTTPPeer<Handler, Impl>::complete()
     }
 
     // keep-alive
-    util::spawn(strand_, [self = impl().shared_from_this()](yield_context doYield) {
-        self->doRead(doYield);
-    });
+    util::spawn(
+        strand_,
+        std::bind(
+            &BaseHTTPPeer<Handler, Impl>::doRead,
+            impl().shared_from_this(),
+            std::placeholders::_1));
 }
 
 // DEPRECATED
@@ -450,7 +474,11 @@ BaseHTTPPeer<Handler, Impl>::close(bool graceful)
     if (!strand_.running_in_this_thread())
     {
         return post(
-            strand_, [self = impl().shared_from_this(), graceful] { self->close(graceful); });
+            strand_,
+            std::bind(
+                (void (BaseHTTPPeer::*)(bool))&BaseHTTPPeer<Handler, Impl>::close,
+                impl().shared_from_this(),
+                graceful));
     }
 
     complete_ = true;
diff --git a/include/xrpl/server/detail/BasePeer.h b/include/xrpl/server/detail/BasePeer.h
index 84aa1e0da9..5301a2f018 100644
--- a/include/xrpl/server/detail/BasePeer.h
+++ b/include/xrpl/server/detail/BasePeer.h
@@ -10,6 +10,7 @@
 
 #include <atomic>
 #include <chrono>
+#include <functional>
 #include <string>
 #include <utility>
 
@@ -83,7 +84,7 @@ void
 BasePeer<Handler, Impl>::close()
 {
     if (!strand_.running_in_this_thread())
-        return post(strand_, [self = impl().shared_from_this()] { self->close(); });
+        return post(strand_, std::bind(&BasePeer::close, impl().shared_from_this()));
     error_code ec;
     xrpl::getLowestLayer(impl().ws_).socket().close(ec);
 }
diff --git a/include/xrpl/server/detail/BaseWSPeer.h b/include/xrpl/server/detail/BaseWSPeer.h
index d557140bd4..1b6a9faca3 100644
--- a/include/xrpl/server/detail/BaseWSPeer.h
+++ b/include/xrpl/server/detail/BaseWSPeer.h
@@ -20,7 +20,6 @@
 
 #include <algorithm>
 #include <chrono>
-#include <cstddef>
 #include <functional>
 #include <iterator>
 #include <list>
@@ -181,13 +180,12 @@ void
 BaseWSPeer<Handler, Impl>::run()
 {
     if (!strand_.running_in_this_thread())
-        return post(strand_, [self = impl().shared_from_this()] { self->run(); });
+        return post(strand_, std::bind(&BaseWSPeer::run, impl().shared_from_this()));
     impl().ws_.set_option(port().pmdOptions);
     // Must manage the control callback memory outside of the `control_callback`
     // function
-    controlCallback_ = [this](
-                           boost::beast::websocket::frame_type kind,
-                           boost::beast::string_view payload) { onPingPong(kind, payload); };
+    controlCallback_ =
+        std::bind(&BaseWSPeer::onPingPong, this, std::placeholders::_1, std::placeholders::_2);
     impl().ws_.control_callback(controlCallback_);
     startTimer();
     closeOnTimer_ = true;
@@ -195,9 +193,11 @@ BaseWSPeer<Handler, Impl>::run()
         res.set(boost::beast::http::field::server, BuildInfo::getFullVersionString());
     }));
     impl().ws_.async_accept(
-        request_, bind_executor(strand_, [self = impl().shared_from_this()](error_code const& ec) {
-            self->onWsHandshake(ec);
-        }));
+        request_,
+        bind_executor(
+            strand_,
+            std::bind(
+                &BaseWSPeer::onWsHandshake, impl().shared_from_this(), std::placeholders::_1)));
 }
 
 template <class Handler, class Impl>
@@ -205,10 +205,7 @@ void
 BaseWSPeer<Handler, Impl>::send(std::shared_ptr<WSMsg> w)
 {
     if (!strand_.running_in_this_thread())
-    {
-        return post(
-            strand_, [self = impl().shared_from_this(), w = std::move(w)] { self->send(w); });
-    }
+        return post(strand_, std::bind(&BaseWSPeer::send, impl().shared_from_this(), std::move(w)));
     if (doClose_)
         return;
     if (wq_.size() > port().wsQueueLimit)
@@ -261,7 +258,7 @@ void
 BaseWSPeer<Handler, Impl>::complete()
 {
     if (!strand_.running_in_this_thread())
-        return post(strand_, [self = impl().shared_from_this()] { self->complete(); });
+        return post(strand_, std::bind(&BaseWSPeer::complete, impl().shared_from_this()));
     doRead();
 }
 
@@ -280,7 +277,7 @@ void
 BaseWSPeer<Handler, Impl>::doWrite()
 {
     if (!strand_.running_in_this_thread())
-        return post(strand_, [self = impl().shared_from_this()] { self->doWrite(); });
+        return post(strand_, std::bind(&BaseWSPeer::doWrite, impl().shared_from_this()));
     onWrite({});
 }
 
@@ -291,7 +288,8 @@ BaseWSPeer<Handler, Impl>::onWrite(error_code const& ec)
     if (ec)
         return fail(ec, "write");
     auto& w = *wq_.front();
-    auto const result = w.prepare(65536, [self = impl().shared_from_this()] { self->doWrite(); });
+    auto const result =
+        w.prepare(65536, std::bind(&BaseWSPeer::doWrite, impl().shared_from_this()));
     if (boost::indeterminate(result.first))
         return;
     startTimer();
@@ -301,9 +299,8 @@ BaseWSPeer<Handler, Impl>::onWrite(error_code const& ec)
             static_cast<bool>(result.first),
             result.second,
             bind_executor(
-                strand_, [self = impl().shared_from_this()](error_code const& ec, std::size_t) {
-                    self->onWrite(ec);
-                }));
+                strand_,
+                std::bind(&BaseWSPeer::onWrite, impl().shared_from_this(), std::placeholders::_1)));
     }
     else
     {
@@ -311,9 +308,9 @@ BaseWSPeer<Handler, Impl>::onWrite(error_code const& ec)
             static_cast<bool>(result.first),
             result.second,
             bind_executor(
-                strand_, [self = impl().shared_from_this()](error_code const& ec, std::size_t) {
-                    self->onWriteFin(ec);
-                }));
+                strand_,
+                std::bind(
+                    &BaseWSPeer::onWriteFin, impl().shared_from_this(), std::placeholders::_1)));
     }
 }
 
@@ -327,9 +324,10 @@ BaseWSPeer<Handler, Impl>::onWriteFin(error_code const& ec)
     if (doClose_)
     {
         impl().ws_.async_close(
-            cr_, bind_executor(strand_, [self = impl().shared_from_this()](error_code const& ec) {
-                self->onClose(ec);
-            }));
+            cr_,
+            bind_executor(
+                strand_,
+                std::bind(&BaseWSPeer::onClose, impl().shared_from_this(), std::placeholders::_1)));
     }
     else if (!wq_.empty())
     {
@@ -342,13 +340,12 @@ void
 BaseWSPeer<Handler, Impl>::doRead()
 {
     if (!strand_.running_in_this_thread())
-        return post(strand_, [self = impl().shared_from_this()] { self->doRead(); });
+        return post(strand_, std::bind(&BaseWSPeer::doRead, impl().shared_from_this()));
     impl().ws_.async_read(
         rb_,
         bind_executor(
-            strand_, [self = impl().shared_from_this()](error_code const& ec, std::size_t) {
-                self->onRead(ec);
-            }));
+            strand_,
+            std::bind(&BaseWSPeer::onRead, impl().shared_from_this(), std::placeholders::_1)));
 }
 
 template <class Handler, class Impl>
@@ -392,7 +389,11 @@ BaseWSPeer<Handler, Impl>::startTimer()
     }
 
     timer_.async_wait(bind_executor(
-        strand_, [self = impl().shared_from_this()](error_code const& ec) { self->onTimer(ec); }));
+        strand_,
+        std::bind(
+            &BaseWSPeer<Handler, Impl>::onTimer,
+            impl().shared_from_this(),
+            std::placeholders::_1)));
 }
 
 // Convenience for discarding the error code
@@ -460,9 +461,10 @@ BaseWSPeer<Handler, Impl>::onTimer(error_code ec)
             beast::rngfill(payload_.begin(), payload_.size(), cryptoPrng());
             impl().ws_.async_ping(
                 payload_,
-                bind_executor(strand_, [self = impl().shared_from_this()](error_code const& ec) {
-                    self->onPing(ec);
-                }));
+                bind_executor(
+                    strand_,
+                    std::bind(
+                        &BaseWSPeer::onPing, impl().shared_from_this(), std::placeholders::_1)));
             JLOG(this->j_.trace()) << "sent ping";
             return;
         }
diff --git a/include/xrpl/server/detail/Door.h b/include/xrpl/server/detail/Door.h
index d2d7a7baf4..09b0adc5f2 100644
--- a/include/xrpl/server/detail/Door.h
+++ b/include/xrpl/server/detail/Door.h
@@ -33,6 +33,7 @@
 #include <algorithm>
 #include <chrono>
 #include <cstdint>
+#include <functional>
 #include <memory>
 #include <optional>
 #include <sstream>
@@ -181,7 +182,7 @@ void
 Door<Handler>::Detector::run()
 {
     util::spawn(
-        strand_, [self = this->shared_from_this()](yield_context yield) { self->doDetect(yield); });
+        strand_, std::bind(&Detector::doDetect, this->shared_from_this(), std::placeholders::_1));
 }
 
 template <class Handler>
@@ -296,7 +297,8 @@ void
 Door<Handler>::run()
 {
     util::spawn(
-        strand_, [self = this->shared_from_this()](yield_context yield) { self->doAccept(yield); });
+        strand_,
+        std::bind(&Door<Handler>::doAccept, this->shared_from_this(), std::placeholders::_1));
 }
 
 template <class Handler>
@@ -305,7 +307,8 @@ Door<Handler>::close()
 {
     if (!strand_.running_in_this_thread())
     {
-        return boost::asio::post(strand_, [self = this->shared_from_this()] { self->close(); });
+        return boost::asio::post(
+            strand_, std::bind(&Door<Handler>::close, this->shared_from_this()));
     }
     backoffTimer_.cancel();
     error_code ec;
diff --git a/include/xrpl/server/detail/PlainHTTPPeer.h b/include/xrpl/server/detail/PlainHTTPPeer.h
index 688fbbd425..b89272fe9e 100644
--- a/include/xrpl/server/detail/PlainHTTPPeer.h
+++ b/include/xrpl/server/detail/PlainHTTPPeer.h
@@ -9,6 +9,7 @@
 
 #include <boost/beast/core/tcp_stream.hpp>
 
+#include <functional>
 #include <memory>
 #include <utility>
 
@@ -88,9 +89,7 @@ PlainHTTPPeer<Handler>::run()
 {
     if (!this->handler_.onAccept(this->session(), this->remoteAddress_))
     {
-        util::spawn(this->strand_, [self = this->shared_from_this()](boost::asio::yield_context) {
-            self->doClose();
-        });
+        util::spawn(this->strand_, std::bind(&PlainHTTPPeer::doClose, this->shared_from_this()));
         return;
     }
 
@@ -98,9 +97,8 @@ PlainHTTPPeer<Handler>::run()
         return;
 
     util::spawn(
-        this->strand_, [self = this->shared_from_this()](boost::asio::yield_context doYield) {
-            self->doRead(doYield);
-        });
+        this->strand_,
+        std::bind(&PlainHTTPPeer::doRead, this->shared_from_this(), std::placeholders::_1));
 }
 
 template <class Handler>
diff --git a/include/xrpl/server/detail/SSLHTTPPeer.h b/include/xrpl/server/detail/SSLHTTPPeer.h
index 7fe21ed6b5..ea2108b917 100644
--- a/include/xrpl/server/detail/SSLHTTPPeer.h
+++ b/include/xrpl/server/detail/SSLHTTPPeer.h
@@ -13,6 +13,7 @@
 #include <boost/beast/core/tcp_stream.hpp>
 #include <boost/beast/ssl/ssl_stream.hpp>
 
+#include <functional>
 #include <memory>
 #include <utility>
 
@@ -98,15 +99,14 @@ SSLHTTPPeer<Handler>::run()
 {
     if (!this->handler_.onAccept(this->session(), this->remoteAddress_))
     {
-        util::spawn(
-            this->strand_, [self = this->shared_from_this()](yield_context) { self->doClose(); });
+        util::spawn(this->strand_, std::bind(&SSLHTTPPeer::doClose, this->shared_from_this()));
         return;
     }
     if (!socket_.is_open())
         return;
-    util::spawn(this->strand_, [self = this->shared_from_this()](yield_context doYield) {
-        self->doHandshake(doYield);
-    });
+    util::spawn(
+        this->strand_,
+        std::bind(&SSLHTTPPeer::doHandshake, this->shared_from_this(), std::placeholders::_1));
 }
 
 template <class Handler>
@@ -142,9 +142,9 @@ SSLHTTPPeer<Handler>::doHandshake(yield_context doYield)
         this->port().protocol.count("https") > 0;
     if (http)
     {
-        util::spawn(this->strand_, [self = this->shared_from_this()](yield_context doYield) {
-            self->doRead(doYield);
-        });
+        util::spawn(
+            this->strand_,
+            std::bind(&SSLHTTPPeer::doRead, this->shared_from_this(), std::placeholders::_1));
         return;
     }
     // `this` will be destroyed
@@ -172,7 +172,7 @@ SSLHTTPPeer<Handler>::doClose()
     this->startTimer();
     stream_.async_shutdown(bind_executor(
         this->strand_,
-        [self = this->shared_from_this()](error_code const& ec) { self->onShutdown(ec); }));
+        std::bind(&SSLHTTPPeer::onShutdown, this->shared_from_this(), std::placeholders::_1)));
 }
 
 template <class Handler>
diff --git a/include/xrpl/shamap/FullBelowCache.h b/include/xrpl/shamap/FullBelowCache.h
index b6d1142eb4..dc597278df 100644
--- a/include/xrpl/shamap/FullBelowCache.h
+++ b/include/xrpl/shamap/FullBelowCache.h
@@ -103,7 +103,7 @@ public:
 
     /** generation determines whether cached entry is valid */
     std::uint32_t
-    getGeneration() const
+    getGeneration(void) const
     {
         return gen_;
     }
diff --git a/include/xrpl/shamap/SHAMapItem.h b/include/xrpl/shamap/SHAMapItem.h
index d45d75a942..846f0bab4e 100644
--- a/include/xrpl/shamap/SHAMapItem.h
+++ b/include/xrpl/shamap/SHAMapItem.h
@@ -138,7 +138,6 @@ intrusive_ptr_release(SHAMapItem const* x)
 
         // If the slabber doesn't claim this pointer, it was allocated
         // manually, so we free it manually.
-        // NOLINTNEXTLINE(cppcoreguidelines-pro-type-const-cast)
         if (!detail::gSlabber.deallocate(const_cast<std::uint8_t*>(p)))
             delete[] p;
     }
diff --git a/include/xrpl/tx/paths/OfferStream.h b/include/xrpl/tx/paths/OfferStream.h
index 8ecd495d1a..98c58876c9 100644
--- a/include/xrpl/tx/paths/OfferStream.h
+++ b/include/xrpl/tx/paths/OfferStream.h
@@ -92,7 +92,6 @@ public:
     [[nodiscard]] TOffer<TIn, TOut>&
     tip() const
     {
-        // NOLINTNEXTLINE(cppcoreguidelines-pro-type-const-cast)
         return const_cast<TOfferStreamBase*>(this)->offer_;
     }
 
diff --git a/include/xrpl/tx/paths/detail/EitherAmount.h b/include/xrpl/tx/paths/detail/EitherAmount.h
index bc9488d5db..68ad90d2d4 100644
--- a/include/xrpl/tx/paths/detail/EitherAmount.h
+++ b/include/xrpl/tx/paths/detail/EitherAmount.h
@@ -6,7 +6,7 @@
 #include <xrpl/protocol/MPTAmount.h>  // IWYU pragma: keep
 #include <xrpl/protocol/XRPAmount.h>
 
-#include <ostream>  // IWYU pragma: keep
+#include <ostream>
 #include <stdexcept>
 #include <variant>
 
diff --git a/nix/packages.nix b/nix/packages.nix
index bcadfe7456..6202168733 100644
--- a/nix/packages.nix
+++ b/nix/packages.nix
@@ -32,15 +32,6 @@ in
     perl # needed for openssl
     pkg-config
     pre-commit
-    # protoc generates the Go gRPC bindings and embeds its own version string into every committed
-    # .pb.go file. To allow CI to verify those files with a plain `git diff`, we pin the version to
-    # `protobuf_34` rather than the rolling `protobuf` to keep regeneration reproducible across the
-    # Nix frequently changing unstable channel. The protoc-gen-go* plugins have no versioned
-    # attributes in nixpkgs; protoc-gen-go's version is in turn constrained by the go.mod require
-    # on google.golang.org/protobuf.
-    protobuf_34 # provides protoc
-    protoc-gen-go # protoc plugin for the Go message bindings
-    protoc-gen-go-grpc # protoc plugin for the Go gRPC service stubs
     python3
     runClangTidy
     vim
diff --git a/src/libxrpl/basics/Number.cpp b/src/libxrpl/basics/Number.cpp
index 4d7a821040..23e913bbdc 100644
--- a/src/libxrpl/basics/Number.cpp
+++ b/src/libxrpl/basics/Number.cpp
@@ -876,7 +876,7 @@ Number::operator/=(Number const& y)
     int const ds = (dp ? -1 : 1);
     // Create the denominator as 128-bit unsigned, since that's what we
     // need to work with.
-    auto const dm = static_cast<uint128_t>(y.mantissa_);
+    uint128_t const dm = static_cast<uint128_t>(y.mantissa_);
     auto const de = y.exponent_;
 
     auto const& range = kRange.get();
diff --git a/src/libxrpl/basics/ResolverAsio.cpp b/src/libxrpl/basics/ResolverAsio.cpp
index 7e1b56f87a..ddf006b681 100644
--- a/src/libxrpl/basics/ResolverAsio.cpp
+++ b/src/libxrpl/basics/ResolverAsio.cpp
@@ -192,7 +192,7 @@ public:
             boost::asio::dispatch(
                 ioContext,
                 boost::asio::bind_executor(
-                    strand, [this, counter = CompletionCounter(this)] { doStop(counter); }));
+                    strand, std::bind(&ResolverAsioImpl::doStop, this, CompletionCounter(this))));
 
             JLOG(journal.debug()) << "Queued a stop request";
         }
@@ -221,9 +221,9 @@ public:
         boost::asio::dispatch(
             ioContext,
             boost::asio::bind_executor(
-                strand, [this, names, handler, counter = CompletionCounter(this)] {
-                    doResolve(names, handler, counter);
-                }));
+                strand,
+                std::bind(
+                    &ResolverAsioImpl::doResolve, this, names, handler, CompletionCounter(this))));
     }
 
     //-------------------------------------------------------------------------
@@ -272,7 +272,7 @@ public:
         boost::asio::post(
             ioContext,
             boost::asio::bind_executor(
-                strand, [this, counter = CompletionCounter(this)] { doWork(counter); }));
+                strand, std::bind(&ResolverAsioImpl::doWork, this, CompletionCounter(this))));
     }
 
     static HostAndPort
@@ -291,10 +291,8 @@ public:
         // a port separator
 
         // Attempt to find the first and last non-whitespace
-        std::locale const loc;
-        auto const findWhitespace = [&loc](std::string::value_type c) {
-            return std::isspace<std::string::value_type>(c, loc);
-        };
+        auto const findWhitespace =
+            std::bind(&std::isspace<std::string::value_type>, std::placeholders::_1, std::locale());
 
         auto hostFirst = std::ranges::find_if_not(str, findWhitespace);
 
@@ -350,7 +348,7 @@ public:
             boost::asio::post(
                 ioContext,
                 boost::asio::bind_executor(
-                    strand, [this, counter = CompletionCounter(this)] { doWork(counter); }));
+                    strand, std::bind(&ResolverAsioImpl::doWork, this, CompletionCounter(this))));
 
             return;
         }
@@ -358,11 +356,14 @@ public:
         resolver.async_resolve(
             host,
             port,
-            [this, name, handler, counter = CompletionCounter(this)](
-                boost::system::error_code const& ec,
-                boost::asio::ip::tcp::resolver::results_type results) {
-                doFinish(name, ec, handler, results, counter);
-            });
+            std::bind(
+                &ResolverAsioImpl::doFinish,
+                this,
+                name,
+                std::placeholders::_1,
+                handler,
+                std::placeholders::_2,
+                CompletionCounter(this)));
     }
 
     void
@@ -382,7 +383,8 @@ public:
                 boost::asio::post(
                     ioContext,
                     boost::asio::bind_executor(
-                        strand, [this, counter = CompletionCounter(this)] { doWork(counter); }));
+                        strand,
+                        std::bind(&ResolverAsioImpl::doWork, this, CompletionCounter(this))));
             }
         }
     }
diff --git a/src/libxrpl/beast/insight/StatsDCollector.cpp b/src/libxrpl/beast/insight/StatsDCollector.cpp
index 3cff5d93b5..0d0e013274 100644
--- a/src/libxrpl/beast/insight/StatsDCollector.cpp
+++ b/src/libxrpl/beast/insight/StatsDCollector.cpp
@@ -325,9 +325,9 @@ public:
     postBuffer(std::string&& buffer)
     {
         boost::asio::dispatch(
-            ioContext_, boost::asio::bind_executor(strand_, [this, buffer = std::move(buffer)] {
-                doPostBuffer(buffer);
-            }));
+            ioContext_,
+            boost::asio::bind_executor(
+                strand_, std::bind(&StatsDCollectorImp::doPostBuffer, this, std::move(buffer))));
     }
 
     // The keepAlive parameter makes sure the buffers sent to
@@ -392,10 +392,12 @@ public:
                 log(buffers);
                 socket_.async_send(
                     buffers,
-                    [this, keepAlive](
-                        boost::system::error_code const& ec, std::size_t bytesTransferred) {
-                        onSend(keepAlive, ec, bytesTransferred);
-                    });
+                    std::bind(
+                        &StatsDCollectorImp::onSend,
+                        this,
+                        keepAlive,
+                        std::placeholders::_1,
+                        std::placeholders::_2));
                 buffers.clear();
                 size = 0;
             }
@@ -409,10 +411,12 @@ public:
             log(buffers);
             socket_.async_send(
                 buffers,
-                [this, keepAlive](
-                    boost::system::error_code const& ec, std::size_t bytesTransferred) {
-                    onSend(keepAlive, ec, bytesTransferred);
-                });
+                std::bind(
+                    &StatsDCollectorImp::onSend,
+                    this,
+                    keepAlive,
+                    std::placeholders::_1,
+                    std::placeholders::_2));
         }
     }
 
@@ -421,7 +425,7 @@ public:
     {
         using namespace std::chrono_literals;
         timer_.expires_after(1s);
-        timer_.async_wait([this](boost::system::error_code const& ec) { onTimer(ec); });
+        timer_.async_wait(std::bind(&StatsDCollectorImp::onTimer, this, std::placeholders::_1));
     }
 
     void
@@ -509,9 +513,10 @@ StatsDCounterImpl::increment(CounterImpl::value_type amount)
 {
     boost::asio::dispatch(
         impl_->getIoContext(),
-        [self = std::static_pointer_cast<StatsDCounterImpl>(shared_from_this()), amount] {
-            self->doIncrement(amount);
-        });
+        std::bind(
+            &StatsDCounterImpl::doIncrement,
+            std::static_pointer_cast<StatsDCounterImpl>(shared_from_this()),
+            amount));
 }
 
 void
@@ -553,9 +558,10 @@ StatsDEventImpl::notify(EventImpl::value_type const& value)
 {
     boost::asio::dispatch(
         impl_->getIoContext(),
-        [self = std::static_pointer_cast<StatsDEventImpl>(shared_from_this()), value] {
-            self->doNotify(value);
-        });
+        std::bind(
+            &StatsDEventImpl::doNotify,
+            std::static_pointer_cast<StatsDEventImpl>(shared_from_this()),
+            value));
 }
 
 void
@@ -585,9 +591,10 @@ StatsDGaugeImpl::set(GaugeImpl::value_type value)
 {
     boost::asio::dispatch(
         impl_->getIoContext(),
-        [self = std::static_pointer_cast<StatsDGaugeImpl>(shared_from_this()), value] {
-            self->doSet(value);
-        });
+        std::bind(
+            &StatsDGaugeImpl::doSet,
+            std::static_pointer_cast<StatsDGaugeImpl>(shared_from_this()),
+            value));
 }
 
 void
@@ -595,9 +602,10 @@ StatsDGaugeImpl::increment(GaugeImpl::difference_type amount)
 {
     boost::asio::dispatch(
         impl_->getIoContext(),
-        [self = std::static_pointer_cast<StatsDGaugeImpl>(shared_from_this()), amount] {
-            self->doIncrement(amount);
-        });
+        std::bind(
+            &StatsDGaugeImpl::doIncrement,
+            std::static_pointer_cast<StatsDGaugeImpl>(shared_from_this()),
+            amount));
 }
 
 void
@@ -632,14 +640,14 @@ StatsDGaugeImpl::doIncrement(GaugeImpl::difference_type amount)
 
     if (amount > 0)
     {
-        auto const d = static_cast<GaugeImpl::value_type>(amount);
+        GaugeImpl::value_type const d(static_cast<GaugeImpl::value_type>(amount));
         value += (d >= std::numeric_limits<GaugeImpl::value_type>::max() - value_)
             ? std::numeric_limits<GaugeImpl::value_type>::max() - value_
             : d;
     }
     else if (amount < 0)
     {
-        auto const d = static_cast<GaugeImpl::value_type>(-amount);
+        GaugeImpl::value_type const d(static_cast<GaugeImpl::value_type>(-amount));
         value = (d >= value) ? 0 : value - d;
     }
 
@@ -670,9 +678,10 @@ StatsDMeterImpl::increment(MeterImpl::value_type amount)
 {
     boost::asio::dispatch(
         impl_->getIoContext(),
-        [self = std::static_pointer_cast<StatsDMeterImpl>(shared_from_this()), amount] {
-            self->doIncrement(amount);
-        });
+        std::bind(
+            &StatsDMeterImpl::doIncrement,
+            std::static_pointer_cast<StatsDMeterImpl>(shared_from_this()),
+            amount));
 }
 
 void
diff --git a/src/libxrpl/core/detail/JobQueue.cpp b/src/libxrpl/core/detail/JobQueue.cpp
index 8f95a8a5fa..ffb91db72d 100644
--- a/src/libxrpl/core/detail/JobQueue.cpp
+++ b/src/libxrpl/core/detail/JobQueue.cpp
@@ -13,6 +13,7 @@
 
 #include <algorithm>
 #include <chrono>
+#include <functional>
 #include <memory>
 #include <mutex>
 #include <set>
@@ -35,7 +36,7 @@ JobQueue::JobQueue(
 {
     JLOG(journal_.info()) << "Using " << threadCount << "  threads";
 
-    hook_ = collector_->makeHook([this] { collect(); });
+    hook_ = collector_->makeHook(std::bind(&JobQueue::collect, this));
     jobCount_ = collector_->makeGauge("job_count");
 
     {
@@ -121,7 +122,7 @@ JobQueue::getJobCount(JobType t) const
 {
     std::scoped_lock const lock(mutex_);
 
-    auto const c = jobData_.find(t);
+    JobDataMap::const_iterator const c = jobData_.find(t);
 
     return (c == jobData_.end()) ? 0 : c->second.waiting;
 }
@@ -131,7 +132,7 @@ JobQueue::getJobCountTotal(JobType t) const
 {
     std::scoped_lock const lock(mutex_);
 
-    auto const c = jobData_.find(t);
+    JobDataMap::const_iterator const c = jobData_.find(t);
 
     return (c == jobData_.end()) ? 0 : (c->second.waiting + c->second.running);
 }
@@ -156,7 +157,7 @@ JobQueue::getJobCountGE(JobType t) const
 std::unique_ptr<LoadEvent>
 JobQueue::makeLoadEvent(JobType t, std::string const& name)
 {
-    auto const iter = jobData_.find(t);
+    JobDataMap::iterator const iter(jobData_.find(t));
     XRPL_ASSERT(iter != jobData_.end(), "xrpl::JobQueue::makeLoadEvent : valid job type input");
 
     if (iter == jobData_.end())
@@ -171,7 +172,7 @@ JobQueue::addLoadEvents(JobType t, int count, std::chrono::milliseconds elapsed)
     if (isStopped())
         logicError("JobQueue::addLoadEvents() called after JobQueue stopped");
 
-    auto const iter = jobData_.find(t);
+    JobDataMap::iterator const iter(jobData_.find(t));
     XRPL_ASSERT(iter != jobData_.end(), "xrpl::JobQueue::addLoadEvents : valid job type input");
     iter->second.load().addSamples(count, elapsed);
 }
@@ -249,7 +250,7 @@ JobQueue::rendezvous()
 JobTypeData&
 JobQueue::getJobTypeData(JobType type)
 {
-    auto const c = jobData_.find(type);
+    JobDataMap::iterator const c(jobData_.find(type));
     XRPL_ASSERT(c != jobData_.end(), "xrpl::JobQueue::getJobTypeData : valid job type input");
 
     // NIKB: This is ugly and I hate it. We must remove JtInvalid completely
diff --git a/src/libxrpl/crypto/RFC1751.cpp b/src/libxrpl/crypto/RFC1751.cpp
index 41e29ee00c..16482945d2 100644
--- a/src/libxrpl/crypto/RFC1751.cpp
+++ b/src/libxrpl/crypto/RFC1751.cpp
@@ -434,7 +434,7 @@ RFC1751::getWordFromBlob(void const* blob, size_t bytes)
     // This is a simple implementation of the Jenkins one-at-a-time hash
     // algorithm:
     // http://en.wikipedia.org/wiki/Jenkins_hash_function#one-at-a-time
-    auto const* data = static_cast<unsigned char const*>(blob);
+    unsigned char const* data = static_cast<unsigned char const*>(blob);
     std::uint32_t hash = 0;
 
     for (size_t i = 0; i < bytes; ++i)
diff --git a/src/libxrpl/json/Writer.cpp b/src/libxrpl/json/Writer.cpp
index b21013cda7..c5c4b3cd31 100644
--- a/src/libxrpl/json/Writer.cpp
+++ b/src/libxrpl/json/Writer.cpp
@@ -230,8 +230,9 @@ Writer::~Writer()
         impl_->finishAll();
 }
 
-Writer::Writer(Writer&& w) noexcept : impl_(std::move(w.impl_))
+Writer::Writer(Writer&& w) noexcept
 {
+    impl_ = std::move(w.impl_);
 }
 
 Writer&
diff --git a/src/libxrpl/json/json_reader.cpp b/src/libxrpl/json/json_reader.cpp
index f37cca506b..3786f51fdd 100644
--- a/src/libxrpl/json/json_reader.cpp
+++ b/src/libxrpl/json/json_reader.cpp
@@ -86,8 +86,8 @@ Reader::parse(char const* beginDoc, char const* endDoc, Value& root)
     begin_ = beginDoc;
     end_ = endDoc;
     current_ = begin_;
-    lastValueEnd_ = nullptr;
-    lastValue_ = nullptr;
+    lastValueEnd_ = 0;
+    lastValue_ = 0;
     errors_.clear();
 
     while (!nodes_.empty())
@@ -624,13 +624,11 @@ Reader::decodeDouble(Token& token)
         Char buffer[bufferSize + 1];
         memcpy(buffer, token.start, length);
         buffer[length] = 0;
-        // NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg)
         count = sscanf(buffer, format, &value);
     }
     else
     {
         std::string const buffer(token.start, token.end);
-        // NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg)
         count = sscanf(buffer.c_str(), format, &value);
     }
     if (count != 1)
@@ -910,8 +908,9 @@ Reader::getFormattedErrorMessages() const
 {
     std::string formattedMessage;
 
-    for (auto const& error : errors_)
+    for (Errors::const_iterator itError = errors_.begin(); itError != errors_.end(); ++itError)
     {
+        ErrorInfo const& error = *itError;
         formattedMessage += "* " + getLocationLineAndColumn(error.token.start) + "\n";
         formattedMessage += "  " + error.message + "\n";
 
diff --git a/src/libxrpl/json/json_value.cpp b/src/libxrpl/json/json_value.cpp
index ce208418de..074a88428c 100644
--- a/src/libxrpl/json/json_value.cpp
+++ b/src/libxrpl/json/json_value.cpp
@@ -48,7 +48,6 @@ public:
         if (length == kUnknown)
             length = (value != nullptr) ? (unsigned int)strlen(value) : 0;
 
-        // NOLINTNEXTLINE(cppcoreguidelines-no-malloc)
         char* newString = static_cast<char*>(malloc(length + 1));
         if (value != nullptr)
             memcpy(newString, value, length);
@@ -60,10 +59,7 @@ public:
     releaseStringValue(char* value) override
     {
         if (value != nullptr)
-        {
-            // NOLINTNEXTLINE(cppcoreguidelines-no-malloc)
             free(value);
-        }
     }
 };
 
@@ -94,7 +90,7 @@ static struct DummyValueAllocatorInitializer
 // Notes: index_ indicates if the string was allocated when
 // a string is stored.
 
-Value::CZString::CZString(int index) : cstr_(nullptr), index_(index)
+Value::CZString::CZString(int index) : cstr_(0), index_(index)
 {
 }
 
@@ -107,8 +103,7 @@ Value::CZString::CZString(char const* cstr, DuplicationPolicy allocate)
 
 Value::CZString::CZString(CZString const& other)
     : cstr_(
-          other.index_ != static_cast<int>(DuplicationPolicy::NoDuplication) &&
-                  other.cstr_ != nullptr
+          other.index_ != static_cast<int>(DuplicationPolicy::NoDuplication) && other.cstr_ != 0
               ? valueAllocator()->makeMemberName(other.cstr_)
               : other.cstr_)
     , index_([&]() -> int {
@@ -124,10 +119,7 @@ Value::CZString::CZString(CZString const& other)
 Value::CZString::~CZString()
 {
     if ((cstr_ != nullptr) && index_ == static_cast<int>(DuplicationPolicy::Duplicate))
-    {
-        // NOLINTNEXTLINE(cppcoreguidelines-pro-type-const-cast)
         valueAllocator()->releaseMemberName(const_cast<char*>(cstr_));
-    }
 }
 
 bool
@@ -195,7 +187,7 @@ Value::Value(ValueType type) : type_(type)
             break;
 
         case ValueType::String:
-            value_.stringVal = nullptr;
+            value_.stringVal = 0;
             break;
 
         case ValueType::Array:
@@ -248,7 +240,6 @@ Value::Value(std::string const& value) : type_(ValueType::String), allocated_(tr
 
 Value::Value(StaticString const& value) : type_(ValueType::String)
 {
-    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-const-cast)
     value_.stringVal = const_cast<char*>(value.cStr());
 }
 
@@ -277,7 +268,7 @@ Value::Value(Value const& other) : type_(other.type_)
             }
             else
             {
-                value_.stringVal = nullptr;
+                value_.stringVal = 0;
             }
 
             break;
@@ -414,7 +405,7 @@ operator<(Value const& x, Value const& y)
             return static_cast<int>(x.value_.boolVal) < static_cast<int>(y.value_.boolVal);
 
         case ValueType::String:
-            return (x.value_.stringVal == nullptr && (y.value_.stringVal != nullptr)) ||
+            return (x.value_.stringVal == 0 && (y.value_.stringVal != nullptr)) ||
                 ((y.value_.stringVal != nullptr) && (x.value_.stringVal != nullptr) &&
                  strcmp(x.value_.stringVal, y.value_.stringVal) < 0);
 
@@ -811,7 +802,7 @@ Value::size() const
         case ValueType::Array:  // size of the array is highest index + 1
             if (!value_.mapVal->empty())
             {
-                auto itLast = value_.mapVal->end();
+                ObjectValues::const_iterator itLast = value_.mapVal->end();
                 --itLast;
                 return (*itLast).first.index() + 1;
             }
@@ -875,7 +866,7 @@ Value::operator[](UInt index)
         *this = Value(ValueType::Array);
 
     CZString const key(index);
-    auto it = value_.mapVal->lower_bound(key);
+    ObjectValues::iterator it = value_.mapVal->lower_bound(key);
 
     if (it != value_.mapVal->end() && (*it).first == key)
         return (*it).second;
@@ -896,7 +887,7 @@ Value::operator[](UInt index) const
         return kNull;
 
     CZString const key(index);
-    auto const it = value_.mapVal->find(key);
+    ObjectValues::const_iterator const it = value_.mapVal->find(key);
 
     if (it == value_.mapVal->end())
         return kNull;
@@ -924,7 +915,7 @@ Value::resolveReference(char const* key, bool isStatic)
         key,
         isStatic ? CZString::DuplicationPolicy::NoDuplication
                  : CZString::DuplicationPolicy::DuplicateOnCopy);
-    auto it = value_.mapVal->lower_bound(actualKey);
+    ObjectValues::iterator it = value_.mapVal->lower_bound(actualKey);
 
     if (it != value_.mapVal->end() && (*it).first == actualKey)
         return (*it).second;
@@ -959,7 +950,7 @@ Value::operator[](char const* key) const
         return kNull;
 
     CZString const actualKey(key, CZString::DuplicationPolicy::NoDuplication);
-    auto const it = value_.mapVal->find(actualKey);
+    ObjectValues::const_iterator const it = value_.mapVal->find(actualKey);
 
     if (it == value_.mapVal->end())
         return kNull;
@@ -1027,7 +1018,7 @@ Value::removeMember(char const* key)
         return kNull;
 
     CZString const actualKey(key, CZString::DuplicationPolicy::NoDuplication);
-    auto const it = value_.mapVal->find(actualKey);
+    ObjectValues::iterator const it = value_.mapVal->find(actualKey);
 
     if (it == value_.mapVal->end())
         return kNull;
@@ -1077,8 +1068,8 @@ Value::getMemberNames() const
 
     Members members;
     members.reserve(value_.mapVal->size());
-    auto it = value_.mapVal->begin();
-    auto const itEnd = value_.mapVal->end();
+    ObjectValues::const_iterator it = value_.mapVal->begin();
+    ObjectValues::const_iterator const itEnd = value_.mapVal->end();
 
     for (; it != itEnd; ++it)
         members.emplace_back((*it).first.cStr());
diff --git a/src/libxrpl/json/json_writer.cpp b/src/libxrpl/json/json_writer.cpp
index 853dd9a5ac..4c38bdcf92 100644
--- a/src/libxrpl/json/json_writer.cpp
+++ b/src/libxrpl/json/json_writer.cpp
@@ -86,7 +86,6 @@ valueToString(double value)
                                                        // to avoid warning.
     sprintf_s(buffer, sizeof(buffer), "%.16g", value);
 #else
-    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg)
     snprintf(buffer, sizeof(buffer), "%.16g", value);
 #endif
     return buffer;
@@ -233,7 +232,7 @@ FastWriter::writeValue(Value const& value)
             Value::Members members(value.getMemberNames());
             document_ += "{";
 
-            for (auto it = members.begin(); it != members.end(); ++it)
+            for (Value::Members::iterator it = members.begin(); it != members.end(); ++it)
             {
                 std::string const& name = *it;
 
@@ -311,7 +310,7 @@ StyledWriter::writeValue(Value const& value)
             {
                 writeWithIndent("{");
                 indent();
-                auto it = members.begin();
+                Value::Members::iterator it = members.begin();
 
                 while (true)
                 {
@@ -546,7 +545,7 @@ StyledStreamWriter::writeValue(Value const& value)
             {
                 writeWithIndent("{");
                 indent();
-                auto it = members.begin();
+                Value::Members::iterator it = members.begin();
 
                 while (true)
                 {
diff --git a/src/libxrpl/ledger/helpers/NFTokenHelpers.cpp b/src/libxrpl/ledger/helpers/NFTokenHelpers.cpp
index fd3c5483c5..eb0c96f79f 100644
--- a/src/libxrpl/ledger/helpers/NFTokenHelpers.cpp
+++ b/src/libxrpl/ledger/helpers/NFTokenHelpers.cpp
@@ -24,7 +24,7 @@
 #include <xrpl/protocol/SeqProxy.h>
 #include <xrpl/protocol/TER.h>
 #include <xrpl/protocol/TxFlags.h>
-#include <xrpl/protocol/UintTypes.h>  // IWYU pragma: keep
+#include <xrpl/protocol/UintTypes.h>
 #include <xrpl/protocol/XRPAmount.h>
 #include <xrpl/protocol/nft.h>
 #include <xrpl/protocol/nftPageMask.h>
diff --git a/src/libxrpl/ledger/helpers/OfferHelpers.cpp b/src/libxrpl/ledger/helpers/OfferHelpers.cpp
index caa6ffb8ae..d1c83f752e 100644
--- a/src/libxrpl/ledger/helpers/OfferHelpers.cpp
+++ b/src/libxrpl/ledger/helpers/OfferHelpers.cpp
@@ -6,7 +6,7 @@
 #include <xrpl/ledger/ApplyView.h>
 #include <xrpl/ledger/helpers/AccountRootHelpers.h>
 #include <xrpl/protocol/Indexes.h>
-#include <xrpl/protocol/LedgerFormats.h>  // IWYU pragma: keep
+#include <xrpl/protocol/LedgerFormats.h>
 #include <xrpl/protocol/SField.h>
 #include <xrpl/protocol/STArray.h>  // IWYU pragma: keep
 #include <xrpl/protocol/STLedgerEntry.h>
diff --git a/src/libxrpl/ledger/helpers/VaultHelpers.cpp b/src/libxrpl/ledger/helpers/VaultHelpers.cpp
index b5b076d1cb..3a3a756499 100644
--- a/src/libxrpl/ledger/helpers/VaultHelpers.cpp
+++ b/src/libxrpl/ledger/helpers/VaultHelpers.cpp
@@ -5,7 +5,7 @@
 #include <xrpl/ledger/ReadView.h>
 #include <xrpl/protocol/AccountID.h>
 #include <xrpl/protocol/Indexes.h>
-#include <xrpl/protocol/LedgerFormats.h>  // IWYU pragma: keep
+#include <xrpl/protocol/LedgerFormats.h>
 #include <xrpl/protocol/SField.h>
 #include <xrpl/protocol/STAmount.h>
 #include <xrpl/protocol/STLedgerEntry.h>
diff --git a/src/libxrpl/net/HTTPClient.cpp b/src/libxrpl/net/HTTPClient.cpp
index 5edd8b5b47..4b9cc9d6e6 100644
--- a/src/libxrpl/net/HTTPClient.cpp
+++ b/src/libxrpl/net/HTTPClient.cpp
@@ -134,10 +134,12 @@ public:
         request(
             bSSL,
             deqSites,
-            [self = shared_from_this(), strPath](
-                boost::asio::streambuf& sb, std::string const& strHost) {
-                self->makeGet(strPath, sb, strHost);
-            },
+            std::bind(
+                &HTTPClientImp::makeGet,
+                shared_from_this(),
+                strPath,
+                std::placeholders::_1,
+                std::placeholders::_2),
             timeout,
             complete);
     }
@@ -164,9 +166,9 @@ public:
             shutdown_ = e.code();
 
             JLOG(j_.trace()) << "expires_after: " << shutdown_.message();
-            deadline_.async_wait([self = shared_from_this()](boost::system::error_code const& ec) {
-                self->handleDeadline(ec);
-            });
+            deadline_.async_wait(
+                std::bind(
+                    &HTTPClientImp::handleDeadline, shared_from_this(), std::placeholders::_1));
         }
 
         if (!shutdown_)
@@ -177,11 +179,11 @@ public:
                 query_->host,
                 query_->port,
                 query_->flags,
-                [self = shared_from_this()](
-                    boost::system::error_code const& ecResult,
-                    boost::asio::ip::tcp::resolver::results_type results) {
-                    self->handleResolve(ecResult, results);
-                });
+                std::bind(
+                    &HTTPClientImp::handleResolve,
+                    shared_from_this(),
+                    std::placeholders::_1,
+                    std::placeholders::_2));
         }
 
         if (shutdown_)
@@ -218,9 +220,9 @@ public:
             resolver_.cancel();
 
             // Stop the transaction.
-            socket_.asyncShutdown([self = shared_from_this()](boost::system::error_code const& ec) {
-                self->handleShutdown(ec);
-            });
+            socket_.asyncShutdown(
+                std::bind(
+                    &HTTPClientImp::handleShutdown, shared_from_this(), std::placeholders::_1));
         }
     }
 
@@ -260,9 +262,8 @@ public:
             boost::asio::async_connect(
                 socket_.lowestLayer(),
                 result,
-                [self = shared_from_this()](
-                    boost::system::error_code const& ecResult,
-                    boost::asio::ip::tcp::endpoint const&) { self->handleConnect(ecResult); });
+                std::bind(
+                    &HTTPClientImp::handleConnect, shared_from_this(), std::placeholders::_1));
         }
     }
 
@@ -300,9 +301,8 @@ public:
         {
             socket_.asyncHandshake(
                 AutoSocket::ssl_socket::client,
-                [self = shared_from_this()](boost::system::error_code const& ec) {
-                    self->handleRequest(ec);
-                });
+                std::bind(
+                    &HTTPClientImp::handleRequest, shared_from_this(), std::placeholders::_1));
         }
         else
         {
@@ -330,10 +330,11 @@ public:
 
             socket_.asyncWrite(
                 request_,
-                [self = shared_from_this()](
-                    boost::system::error_code const& ecResult, std::size_t bytesTransferred) {
-                    self->handleWrite(ecResult, bytesTransferred);
-                });
+                std::bind(
+                    &HTTPClientImp::handleWrite,
+                    shared_from_this(),
+                    std::placeholders::_1,
+                    std::placeholders::_2));
         }
     }
 
@@ -356,10 +357,11 @@ public:
             socket_.asyncReadUntil(
                 header_,
                 "\r\n\r\n",
-                [self = shared_from_this()](
-                    boost::system::error_code const& ecResult, std::size_t bytesTransferred) {
-                    self->handleHeader(ecResult, bytesTransferred);
-                });
+                std::bind(
+                    &HTTPClientImp::handleHeader,
+                    shared_from_this(),
+                    std::placeholders::_1,
+                    std::placeholders::_2));
         }
     }
 
@@ -370,10 +372,10 @@ public:
             {std::istreambuf_iterator<char>(&header_)}, std::istreambuf_iterator<char>()};
         JLOG(j_.trace()) << "Header: \"" << strHeader << "\"";
 
-        static boost::regex const kReStatus{R"(\`HTTP/1\S+ (\d{3}) .*\')"};  // HTTP/1.1 200 OK
+        static boost::regex const kReStatus{"\\`HTTP/1\\S+ (\\d{3}) .*\\'"};  // HTTP/1.1 200 OK
         static boost::regex const kReSize{
-            R"(\`.*\r\nContent-Length:\s+([0-9]+).*\')", boost::regex::icase};
-        static boost::regex const kReBody{R"(\`.*\r\n\r\n(.*)\')"};
+            "\\`.*\\r\\nContent-Length:\\s+([0-9]+).*\\'", boost::regex::icase};
+        static boost::regex const kReBody{"\\`.*\\r\\n\\r\\n(.*)\\'"};
 
         boost::smatch smMatch;
         // Match status code.
@@ -422,10 +424,11 @@ public:
             socket_.asyncRead(
                 response_.prepare(responseSize - body_.size()),
                 boost::asio::transfer_all(),
-                [self = shared_from_this()](
-                    boost::system::error_code const& ecResult, std::size_t bytesTransferred) {
-                    self->handleData(ecResult, bytesTransferred);
-                });
+                std::bind(
+                    &HTTPClientImp::handleData,
+                    shared_from_this(),
+                    std::placeholders::_1,
+                    std::placeholders::_2));
         }
     }
 
diff --git a/src/libxrpl/nodestore/DecodedBlob.cpp b/src/libxrpl/nodestore/DecodedBlob.cpp
index 9740462ae8..fb7569bd8c 100644
--- a/src/libxrpl/nodestore/DecodedBlob.cpp
+++ b/src/libxrpl/nodestore/DecodedBlob.cpp
@@ -12,7 +12,7 @@
 
 namespace xrpl::NodeStore {
 
-DecodedBlob::DecodedBlob(void const* key, void const* value, int valueBytes) : key_(key)
+DecodedBlob::DecodedBlob(void const* key, void const* value, int valueBytes)
 {
     /*  Data format:
 
@@ -23,13 +23,17 @@ DecodedBlob::DecodedBlob(void const* key, void const* value, int valueBytes) : k
         9...end                     The body of the object data
     */
 
+    success_ = false;
+    key_ = key;
+    objectType_ = NodeObjectType::Unknown;
+    objectData_ = nullptr;
     dataBytes_ = std::max(0, valueBytes - 9);
 
     // VFALCO NOTE What about bytes 4 through 7 inclusive?
 
     if (valueBytes > 8)
     {
-        auto const* byte = static_cast<unsigned char const*>(value);
+        unsigned char const* byte = static_cast<unsigned char const*>(value);
         objectType_ = safeCast<NodeObjectType>(byte[8]);
     }
 
diff --git a/src/libxrpl/nodestore/backend/MemoryFactory.cpp b/src/libxrpl/nodestore/backend/MemoryFactory.cpp
index 22557d652e..70578c8613 100644
--- a/src/libxrpl/nodestore/backend/MemoryFactory.cpp
+++ b/src/libxrpl/nodestore/backend/MemoryFactory.cpp
@@ -136,7 +136,7 @@ public:
 
         std::scoped_lock const _(db_->mutex);
 
-        auto const iter = db_->table.find(hash);
+        Map::iterator const iter = db_->table.find(hash);
         if (iter == db_->table.end())
         {
             pObject->reset();
diff --git a/src/libxrpl/nodestore/backend/NuDBFactory.cpp b/src/libxrpl/nodestore/backend/NuDBFactory.cpp
index 38ea34258f..749d4020b5 100644
--- a/src/libxrpl/nodestore/backend/NuDBFactory.cpp
+++ b/src/libxrpl/nodestore/backend/NuDBFactory.cpp
@@ -367,7 +367,7 @@ private:
 
         try
         {
-            auto const parsedBlockSize = beast::lexicalCastThrow<std::size_t>(blockSizeStr);
+            std::size_t const parsedBlockSize = beast::lexicalCastThrow<std::size_t>(blockSizeStr);
 
             // Validate: must be power of 2 between 4K and 32K
             if (parsedBlockSize < 4096 || parsedBlockSize > 32768 ||
diff --git a/src/libxrpl/nodestore/backend/RocksDBFactory.cpp b/src/libxrpl/nodestore/backend/RocksDBFactory.cpp
index bcf4ba4a49..69a648f2f4 100644
--- a/src/libxrpl/nodestore/backend/RocksDBFactory.cpp
+++ b/src/libxrpl/nodestore/backend/RocksDBFactory.cpp
@@ -80,7 +80,7 @@ public:
     void
     StartThread(void (*f)(void*), void* a) override
     {
-        auto* const p = new ThreadParams(f, a);
+        ThreadParams* const p(new ThreadParams(f, a));
         EnvWrapper::StartThread(&RocksDBEnv::threadEntry, p);
     }
 };
diff --git a/src/libxrpl/protocol/IOUAmount.cpp b/src/libxrpl/protocol/IOUAmount.cpp
index 111edbf8b5..acbf6724e1 100644
--- a/src/libxrpl/protocol/IOUAmount.cpp
+++ b/src/libxrpl/protocol/IOUAmount.cpp
@@ -181,7 +181,7 @@ mulRatio(IOUAmount const& amt, std::uint32_t num, std::uint32_t den, bool roundU
             hasRem = bool(sav - low * kPowerTable[mustShrink]);
     }
 
-    auto mantissa = low.convert_to<std::int64_t>();
+    std::int64_t mantissa = low.convert_to<std::int64_t>();
 
     // normalize before rounding
     if (neg)
diff --git a/src/libxrpl/protocol/Indexes.cpp b/src/libxrpl/protocol/Indexes.cpp
index ced18d4db6..25d64858ab 100644
--- a/src/libxrpl/protocol/Indexes.cpp
+++ b/src/libxrpl/protocol/Indexes.cpp
@@ -153,12 +153,7 @@ std::uint64_t
 getQuality(uint256 const& uBase)
 {
     // VFALCO [base_uint] This assumes a certain storage format
-    //
-    // Load the final 8 bytes as a big-endian integer.  load_big_u64 reads
-    // through unaligned byte storage (via memcpy) and applies the endian
-    // conversion, avoiding the alignment/strict-aliasing UB of casting the
-    // unsigned char* returned by end() to a std::uint64_t*.
-    return boost::endian::load_big_u64(uBase.end() - 8);
+    return boost::endian::big_to_native(((std::uint64_t*)uBase.end())[-1]);
 }
 
 uint256
@@ -284,11 +279,8 @@ quality(Keylet const& k, std::uint64_t q) noexcept
     // for indexes.
     uint256 x = k.key;
 
-    // Store the quality as a big-endian integer in the final 8 bytes.
-    // store_big_u64 writes through unaligned byte storage (via memcpy) and
-    // applies the endian conversion, avoiding the alignment/strict-aliasing UB
-    // of casting the unsigned char* returned by end() to a std::uint64_t*.
-    boost::endian::store_big_u64(x.end() - 8, q);
+    // FIXME This is ugly and we can and should do better...
+    ((std::uint64_t*)x.end())[-1] = boost::endian::native_to_big(q);
 
     return {ltDIR_NODE, x};
 }
diff --git a/src/libxrpl/protocol/MPTIssue.cpp b/src/libxrpl/protocol/MPTIssue.cpp
index 35ee743b2a..e9ec852d1d 100644
--- a/src/libxrpl/protocol/MPTIssue.cpp
+++ b/src/libxrpl/protocol/MPTIssue.cpp
@@ -31,7 +31,8 @@ MPTIssue::getIssuer() const
     // MPTID is concatenation of sequence + account
     static_assert(sizeof(MPTID) == (sizeof(std::uint32_t) + sizeof(AccountID)));
     // copy from id skipping the sequence
-    auto const* account = reinterpret_cast<AccountID const*>(mptID_.data() + sizeof(std::uint32_t));
+    AccountID const* account =
+        reinterpret_cast<AccountID const*>(mptID_.data() + sizeof(std::uint32_t));
 
     return *account;
 }
diff --git a/src/libxrpl/protocol/NFTokenID.cpp b/src/libxrpl/protocol/NFTokenID.cpp
index 729f052101..cd2c46b66b 100644
--- a/src/libxrpl/protocol/NFTokenID.cpp
+++ b/src/libxrpl/protocol/NFTokenID.cpp
@@ -72,7 +72,8 @@ getNFTokenIDFromPage(TxMeta const& transactionMeta)
             // However, there will always be NFTs listed in the final fields,
             // as xrpld outputs all fields in final fields even if they were
             // not changed.
-            auto const& previousFields = node.peekAtField(sfPreviousFields).downcast<STObject>();
+            STObject const& previousFields =
+                node.peekAtField(sfPreviousFields).downcast<STObject>();
             if (!previousFields.isFieldPresent(sfNFTokens))
                 continue;
 
diff --git a/src/libxrpl/protocol/PublicKey.cpp b/src/libxrpl/protocol/PublicKey.cpp
index 97948fcae3..c6e6c1d324 100644
--- a/src/libxrpl/protocol/PublicKey.cpp
+++ b/src/libxrpl/protocol/PublicKey.cpp
@@ -87,11 +87,11 @@ sliceToHex(Slice const& slice)
         s.reserve(2 * (slice.size() + 1));
         s = "0x";
     }
-    for (std::uint8_t const byte : slice)
+    for (int i = 0; i < slice.size(); ++i)
     {
         static constexpr char kHex[] = "0123456789ABCDEF";
-        s += kHex[((byte & 0xf0) >> 4)];
-        s += kHex[((byte & 0x0f) >> 0)];
+        s += kHex[((slice[i] & 0xf0) >> 4)];
+        s += kHex[((slice[i] & 0x0f) >> 0)];
     }
     return s;
 }
diff --git a/src/libxrpl/protocol/Quality.cpp b/src/libxrpl/protocol/Quality.cpp
index dde7921a76..7ad426bef7 100644
--- a/src/libxrpl/protocol/Quality.cpp
+++ b/src/libxrpl/protocol/Quality.cpp
@@ -1,12 +1,12 @@
 #include <xrpl/protocol/Quality.h>
 
-#include <xrpl/beast/utility/Zero.h>  // IWYU pragma: keep
+#include <xrpl/beast/utility/Zero.h>
 #include <xrpl/beast/utility/instrumentation.h>
 #include <xrpl/protocol/Asset.h>
 #include <xrpl/protocol/STAmount.h>
 
 #include <cstdint>
-#include <limits>  // IWYU pragma: keep
+#include <limits>
 
 namespace xrpl {
 
diff --git a/src/libxrpl/protocol/SOTemplate.cpp b/src/libxrpl/protocol/SOTemplate.cpp
index 171f96e1ed..708fd465e2 100644
--- a/src/libxrpl/protocol/SOTemplate.cpp
+++ b/src/libxrpl/protocol/SOTemplate.cpp
@@ -21,12 +21,11 @@ SOTemplate::SOTemplate(
 }
 
 SOTemplate::SOTemplate(std::vector<SOElement> uniqueFields, std::vector<SOElement> commonFields)
-    : elements_(std::move(uniqueFields))
-    , indices_(SField::getNumFields() + 1, -1)  // Unmapped indices == -1
+    : indices_(SField::getNumFields() + 1, -1)  // Unmapped indices == -1
 {
     // Add all SOElements.
     //
-
+    elements_ = std::move(uniqueFields);
     std::ranges::move(commonFields, std::back_inserter(elements_));
 
     // Validate and index elements_.
diff --git a/src/libxrpl/protocol/STAmount.cpp b/src/libxrpl/protocol/STAmount.cpp
index 212c34322b..748d00f25a 100644
--- a/src/libxrpl/protocol/STAmount.cpp
+++ b/src/libxrpl/protocol/STAmount.cpp
@@ -789,7 +789,7 @@ STAmount::add(Serializer& s) const
 bool
 STAmount::isEquivalent(STBase const& t) const
 {
-    auto const* v = dynamic_cast<STAmount const*>(&t);
+    STAmount const* v = dynamic_cast<STAmount const*>(&t);
     return (v != nullptr) && (*v == *this);
 }
 
diff --git a/src/libxrpl/protocol/STBlob.cpp b/src/libxrpl/protocol/STBlob.cpp
index 14d09b633c..3f44c9b529 100644
--- a/src/libxrpl/protocol/STBlob.cpp
+++ b/src/libxrpl/protocol/STBlob.cpp
@@ -53,7 +53,7 @@ STBlob::add(Serializer& s) const
 bool
 STBlob::isEquivalent(STBase const& t) const
 {
-    auto const* v = dynamic_cast<STBlob const*>(&t);
+    STBlob const* v = dynamic_cast<STBlob const*>(&t);
     return (v != nullptr) && (value_ == v->value_);
 }
 
diff --git a/src/libxrpl/protocol/STCurrency.cpp b/src/libxrpl/protocol/STCurrency.cpp
index fc8bd756ed..9b761864d9 100644
--- a/src/libxrpl/protocol/STCurrency.cpp
+++ b/src/libxrpl/protocol/STCurrency.cpp
@@ -56,7 +56,7 @@ STCurrency::add(Serializer& s) const
 bool
 STCurrency::isEquivalent(STBase const& t) const
 {
-    auto const* v = dynamic_cast<STCurrency const*>(&t);
+    STCurrency const* v = dynamic_cast<STCurrency const*>(&t);
     return (v != nullptr) && (*v == *this);
 }
 
diff --git a/src/libxrpl/protocol/STInteger.cpp b/src/libxrpl/protocol/STInteger.cpp
index b65504dd5f..5f3fb6ffa4 100644
--- a/src/libxrpl/protocol/STInteger.cpp
+++ b/src/libxrpl/protocol/STInteger.cpp
@@ -16,7 +16,7 @@
 #include <cstdint>
 #include <iterator>
 #include <string>
-#include <system_error>  // IWYU pragma: keep
+#include <system_error>
 
 namespace xrpl {
 
diff --git a/src/libxrpl/protocol/STIssue.cpp b/src/libxrpl/protocol/STIssue.cpp
index 10403d2c50..c9b8109e32 100644
--- a/src/libxrpl/protocol/STIssue.cpp
+++ b/src/libxrpl/protocol/STIssue.cpp
@@ -107,7 +107,7 @@ STIssue::add(Serializer& s) const
 bool
 STIssue::isEquivalent(STBase const& t) const
 {
-    auto const* v = dynamic_cast<STIssue const*>(&t);
+    STIssue const* v = dynamic_cast<STIssue const*>(&t);
     return (v != nullptr) && (*v == *this);
 }
 
diff --git a/src/libxrpl/protocol/STNumber.cpp b/src/libxrpl/protocol/STNumber.cpp
index 79f7655869..fcc0077f6b 100644
--- a/src/libxrpl/protocol/STNumber.cpp
+++ b/src/libxrpl/protocol/STNumber.cpp
@@ -142,7 +142,7 @@ STNumber::isEquivalent(STBase const& t) const
 {
     XRPL_ASSERT(
         t.getSType() == this->getSType(), "xrpl::STNumber::isEquivalent : field type match");
-    auto const& v = dynamic_cast<STNumber const&>(t);
+    STNumber const& v = dynamic_cast<STNumber const&>(t);
     return value_ == v;
 }
 
diff --git a/src/libxrpl/protocol/STObject.cpp b/src/libxrpl/protocol/STObject.cpp
index b67b472f3a..3f8075f7b9 100644
--- a/src/libxrpl/protocol/STObject.cpp
+++ b/src/libxrpl/protocol/STObject.cpp
@@ -338,7 +338,7 @@ STObject::getText() const
 bool
 STObject::isEquivalent(STBase const& t) const
 {
-    auto const* v = dynamic_cast<STObject const*>(&t);
+    STObject const* v = dynamic_cast<STObject const*>(&t);
 
     if (v == nullptr)
         return false;
@@ -474,7 +474,7 @@ STObject::peekFieldArray(SField const& field)
 bool
 STObject::setFlag(std::uint32_t f)
 {
-    auto* t = dynamic_cast<STUInt32*>(getPField(sfFlags, true));
+    STUInt32* t = dynamic_cast<STUInt32*>(getPField(sfFlags, true));
 
     if (t == nullptr)
         return false;
@@ -486,7 +486,7 @@ STObject::setFlag(std::uint32_t f)
 bool
 STObject::clearFlag(std::uint32_t f)
 {
-    auto* t = dynamic_cast<STUInt32*>(getPField(sfFlags));
+    STUInt32* t = dynamic_cast<STUInt32*>(getPField(sfFlags));
 
     if (t == nullptr)
         return false;
@@ -502,9 +502,9 @@ STObject::isFlag(std::uint32_t f) const
 }
 
 std::uint32_t
-STObject::getFlags() const
+STObject::getFlags(void) const
 {
-    auto const* t = dynamic_cast<STUInt32 const*>(peekAtPField(sfFlags));
+    STUInt32 const* t = dynamic_cast<STUInt32 const*>(peekAtPField(sfFlags));
 
     if (t == nullptr)
         return 0;
@@ -651,7 +651,7 @@ Blob
 STObject::getFieldVL(SField const& field) const
 {
     STBlob const empty;
-    auto const& b = getFieldByConstRef<STBlob>(field, empty);
+    STBlob const& b = getFieldByConstRef<STBlob>(field, empty);
     return Blob(b.data(), b.data() + b.size());
 }
 
diff --git a/src/libxrpl/protocol/STParsedJSON.cpp b/src/libxrpl/protocol/STParsedJSON.cpp
index d3342ef728..64c4dfd1be 100644
--- a/src/libxrpl/protocol/STParsedJSON.cpp
+++ b/src/libxrpl/protocol/STParsedJSON.cpp
@@ -50,9 +50,8 @@ namespace xrpl {
 
 namespace STParsedJSONDetail {
 template <typename U, typename S>
-constexpr U
+constexpr std::enable_if_t<std::is_unsigned_v<U> && std::is_signed_v<S>, U>
 toUnsigned(S value)
-    requires(std::is_unsigned_v<U> && std::is_signed_v<S>)
 {
     if (value < 0 || std::numeric_limits<U>::max() < value)
         Throw<std::runtime_error>("Value out of range");
@@ -60,9 +59,8 @@ toUnsigned(S value)
 }
 
 template <typename U1, typename U2>
-constexpr U1
+constexpr std::enable_if_t<std::is_unsigned_v<U1> && std::is_unsigned_v<U2>, U1>
 toUnsigned(U2 value)
-    requires(std::is_unsigned_v<U1> && std::is_unsigned_v<U2>)
 {
     if (std::numeric_limits<U1>::max() < value)
         Throw<std::runtime_error>("Value out of range");
diff --git a/src/libxrpl/protocol/STPathSet.cpp b/src/libxrpl/protocol/STPathSet.cpp
index d61f17ecc6..cb70ac36fe 100644
--- a/src/libxrpl/protocol/STPathSet.cpp
+++ b/src/libxrpl/protocol/STPathSet.cpp
@@ -127,7 +127,7 @@ STPathSet::assembleAdd(STPath const& base, STPathElement const& tail)
 {  // assemble base+tail and add it to the set if it's not a duplicate
     value_.push_back(base);
 
-    auto it = value_.rbegin();
+    std::vector<STPath>::reverse_iterator it = value_.rbegin();
 
     STPath& newPath = *it;
     newPath.pushBack(tail);
@@ -146,7 +146,7 @@ STPathSet::assembleAdd(STPath const& base, STPathElement const& tail)
 bool
 STPathSet::isEquivalent(STBase const& t) const
 {
-    auto const* v = dynamic_cast<STPathSet const*>(&t);
+    STPathSet const* v = dynamic_cast<STPathSet const*>(&t);
     return (v != nullptr) && (value_ == v->value_);
 }
 
diff --git a/src/libxrpl/protocol/STTx.cpp b/src/libxrpl/protocol/STTx.cpp
index be4ba2e8e5..dd2ec92c90 100644
--- a/src/libxrpl/protocol/STTx.cpp
+++ b/src/libxrpl/protocol/STTx.cpp
@@ -67,9 +67,9 @@ getTxFormat(TxType type)
     return format;
 }
 
-STTx::STTx(STObject&& object)
-    : STObject(std::move(object)), txType_(safeCast<TxType>(getFieldU16(sfTransactionType)))
+STTx::STTx(STObject&& object) : STObject(std::move(object))
 {
+    txType_ = safeCast<TxType>(getFieldU16(sfTransactionType));
     applyTemplate(getTxFormat(txType_)->getSOTemplate());  //  may throw
     tid_ = getHash(HashPrefix::TransactionId);
     buildBatchTxnIds();
@@ -101,9 +101,6 @@ STTx::STTx(TxType type, std::function<void(STObject&)> assembler) : STObject(sfT
 
     assembler(*this);
 
-    // txType_ must be read after the object is assembled, so this cannot be a
-    // member initializer.
-    // NOLINTNEXTLINE(cppcoreguidelines-prefer-member-initializer)
     txType_ = safeCast<TxType>(getFieldU16(sfTransactionType));
 
     if (txType_ != type)
@@ -607,7 +604,6 @@ STTx::getBatchTransactionIDs() const
     XRPL_ASSERT(
         batchTxnIds_->size() == getFieldArray(sfRawTransactions).size(),
         "STTx::getBatchTransactionIDs : batch transaction IDs size mismatch");
-    // NOLINTNEXTLINE(bugprone-unchecked-optional-access): guarded by assert above
     return *batchTxnIds_;
 }
 
@@ -785,7 +781,7 @@ isBatchRawTransactionOkay(STObject const& st, std::string& reason)
     {
         try
         {
-            auto const tt = safeCast<TxType>(raw.getFieldU16(sfTransactionType));
+            TxType const tt = safeCast<TxType>(raw.getFieldU16(sfTransactionType));
             if (tt == ttBATCH)
             {
                 reason = "Raw Transactions may not contain batch transactions.";
diff --git a/src/libxrpl/protocol/STValidation.cpp b/src/libxrpl/protocol/STValidation.cpp
index 1656aad3a2..5eafb407ec 100644
--- a/src/libxrpl/protocol/STValidation.cpp
+++ b/src/libxrpl/protocol/STValidation.cpp
@@ -6,7 +6,7 @@
 #include <xrpl/basics/chrono.h>
 #include <xrpl/beast/utility/instrumentation.h>
 #include <xrpl/protocol/HashPrefix.h>
-#include <xrpl/protocol/KeyType.h>  // IWYU pragma: keep
+#include <xrpl/protocol/KeyType.h>
 #include <xrpl/protocol/PublicKey.h>
 #include <xrpl/protocol/SField.h>
 #include <xrpl/protocol/SOTemplate.h>
diff --git a/src/libxrpl/protocol/STVector256.cpp b/src/libxrpl/protocol/STVector256.cpp
index 877e34c73c..7aca309667 100644
--- a/src/libxrpl/protocol/STVector256.cpp
+++ b/src/libxrpl/protocol/STVector256.cpp
@@ -68,7 +68,7 @@ STVector256::add(Serializer& s) const
 bool
 STVector256::isEquivalent(STBase const& t) const
 {
-    auto const* v = dynamic_cast<STVector256 const*>(&t);
+    STVector256 const* v = dynamic_cast<STVector256 const*>(&t);
     return (v != nullptr) && (value_ == v->value_);
 }
 
diff --git a/src/libxrpl/protocol/STXChainBridge.cpp b/src/libxrpl/protocol/STXChainBridge.cpp
index 005c9ccbce..ce6ad2368a 100644
--- a/src/libxrpl/protocol/STXChainBridge.cpp
+++ b/src/libxrpl/protocol/STXChainBridge.cpp
@@ -168,7 +168,7 @@ STXChainBridge::getSType() const
 bool
 STXChainBridge::isEquivalent(STBase const& t) const
 {
-    auto const* v = dynamic_cast<STXChainBridge const*>(&t);
+    STXChainBridge const* v = dynamic_cast<STXChainBridge const*>(&t);
     return (v != nullptr) && (*v == *this);
 }
 
diff --git a/src/libxrpl/protocol/Serializer.cpp b/src/libxrpl/protocol/Serializer.cpp
index 80ecdee6c8..d500919df9 100644
--- a/src/libxrpl/protocol/Serializer.cpp
+++ b/src/libxrpl/protocol/Serializer.cpp
@@ -99,7 +99,7 @@ int
 Serializer::addRaw(void const* ptr, int len)
 {
     int const ret = data_.size();
-    data_.insert(data_.end(), static_cast<char const*>(ptr), static_cast<char const*>(ptr) + len);
+    data_.insert(data_.end(), (char const*)ptr, ((char const*)ptr) + len);
     return ret;
 }
 
@@ -444,7 +444,7 @@ template <class T>
 T
 SerialIter::getRawHelper(int size)
 {
-    static_assert(std::is_same_v<T, Blob> || std::is_same_v<T, Buffer>);
+    static_assert(std::is_same_v<T, Blob> || std::is_same_v<T, Buffer>, "");
     if (remain_ < size)
         Throw<std::runtime_error>("invalid SerialIter getRaw");
     T result(size);
diff --git a/src/libxrpl/protocol/TxMeta.cpp b/src/libxrpl/protocol/TxMeta.cpp
index b743598a76..0373706e84 100644
--- a/src/libxrpl/protocol/TxMeta.cpp
+++ b/src/libxrpl/protocol/TxMeta.cpp
@@ -23,16 +23,16 @@
 namespace xrpl {
 
 TxMeta::TxMeta(uint256 const& txid, std::uint32_t ledger, STObject const& obj)
-    : transactionID_(txid)
-    , ledgerSeq_(ledger)
-    , index_(obj.getFieldU32(sfTransactionIndex))
-    , result_(obj.getFieldU8(sfTransactionResult))
-    , nodes_([&obj] {
-        auto const affectedNodes = dynamic_cast<STArray const*>(obj.peekAtPField(sfAffectedNodes));
-        XRPL_ASSERT(affectedNodes, "xrpl::TxMeta::TxMeta(STObject) : type cast succeeded");
-        return affectedNodes != nullptr ? *affectedNodes : obj.getFieldArray(sfAffectedNodes);
-    }())
+    : transactionID_(txid), ledgerSeq_(ledger), nodes_(obj.getFieldArray(sfAffectedNodes))
 {
+    result_ = obj.getFieldU8(sfTransactionResult);
+    index_ = obj.getFieldU32(sfTransactionIndex);
+
+    auto affectedNodes = dynamic_cast<STArray const*>(obj.peekAtPField(sfAffectedNodes));
+    XRPL_ASSERT(affectedNodes, "xrpl::TxMeta::TxMeta(STObject) : type cast succeeded");
+    if (affectedNodes != nullptr)
+        nodes_ = *affectedNodes;
+
     setAdditionalFields(obj);
 }
 
diff --git a/src/libxrpl/protocol/digest.cpp b/src/libxrpl/protocol/digest.cpp
index 1d84f8779e..2e1b2b25cf 100644
--- a/src/libxrpl/protocol/digest.cpp
+++ b/src/libxrpl/protocol/digest.cpp
@@ -9,7 +9,7 @@ namespace xrpl {
 
 OpensslRipemd160Hasher::OpensslRipemd160Hasher()
 {
-    static_assert(sizeof(decltype(OpensslRipemd160Hasher::ctx_)) == sizeof(RIPEMD160_CTX));
+    static_assert(sizeof(decltype(OpensslRipemd160Hasher::ctx_)) == sizeof(RIPEMD160_CTX), "");
     auto const ctx = reinterpret_cast<RIPEMD160_CTX*>(ctx_);
     RIPEMD160_Init(ctx);
 }
@@ -34,7 +34,7 @@ operator result_type() noexcept
 
 OpensslSha512Hasher::OpensslSha512Hasher()
 {
-    static_assert(sizeof(decltype(OpensslSha512Hasher::ctx_)) == sizeof(SHA512_CTX));
+    static_assert(sizeof(decltype(OpensslSha512Hasher::ctx_)) == sizeof(SHA512_CTX), "");
     auto const ctx = reinterpret_cast<SHA512_CTX*>(ctx_);
     SHA512_Init(ctx);
 }
@@ -59,7 +59,7 @@ operator result_type() noexcept
 
 OpensslSha256Hasher::OpensslSha256Hasher()
 {
-    static_assert(sizeof(decltype(OpensslSha256Hasher::ctx_)) == sizeof(SHA256_CTX));
+    static_assert(sizeof(decltype(OpensslSha256Hasher::ctx_)) == sizeof(SHA256_CTX), "");
     auto const ctx = reinterpret_cast<SHA256_CTX*>(ctx_);
     SHA256_Init(ctx);
 }
diff --git a/src/libxrpl/protocol/tokens.cpp b/src/libxrpl/protocol/tokens.cpp
index 21984c67e7..d04ceaa3a6 100644
--- a/src/libxrpl/protocol/tokens.cpp
+++ b/src/libxrpl/protocol/tokens.cpp
@@ -23,7 +23,6 @@
 #include <cstdint>
 #include <cstring>
 #include <expected>
-#include <ranges>
 #include <span>
 #include <string>
 #include <string_view>
@@ -144,10 +143,9 @@ digest(void const* data, std::size_t size) noexcept
     return static_cast<Hasher::result_type>(h);
 }
 
-template <class Hasher, class T, std::size_t N>
+template <class Hasher, class T, std::size_t N, class = std::enable_if_t<sizeof(T) == 1>>
 static Hasher::result_type
 digest(std::array<T, N> const& v)
-    requires(sizeof(T) == 1)
 {
     return digest<Hasher>(v.data(), v.size());
 }
@@ -266,17 +264,17 @@ decodeBase58(std::string const& s)
 
     // Allocate enough space in big-endian base256 representation.
     // log(58) / log(256), rounded up.
-    std::vector<std::uint8_t> b256((remain * 733 / 1000) + 1);
+    std::vector<unsigned char> b256((remain * 733 / 1000) + 1);
     while (remain > 0)
     {
         auto carry = kAlphabetReverse[*psz];
         if (carry == -1)
             return {};
         // Apply "b256 = b256 * 58 + carry".
-        for (std::uint8_t& byte : std::views::reverse(b256))
+        for (auto iter = b256.rbegin(); iter != b256.rend(); ++iter)
         {
-            carry += 58 * byte;
-            byte = carry % 256;
+            carry += 58 * *iter;
+            *iter = carry % 256;
             carry /= 256;
         }
         XRPL_ASSERT(carry == 0, "xrpl::b58_ref::detail::decodeBase58 : zero carry");
@@ -284,7 +282,7 @@ decodeBase58(std::string const& s)
         --remain;
     }
     // Skip leading zeroes in b256.
-    auto iter = std::ranges::find_if(b256, [](std::uint8_t c) { return c != 0; });
+    auto iter = std::ranges::find_if(b256, [](unsigned char c) { return c != 0; });
     std::string result;
     result.reserve(zeroes + (b256.end() - iter));
     result.assign(zeroes, 0x00);
diff --git a/src/libxrpl/shamap/SHAMap.cpp b/src/libxrpl/shamap/SHAMap.cpp
index 0df0430a5f..8a521f6a47 100644
--- a/src/libxrpl/shamap/SHAMap.cpp
+++ b/src/libxrpl/shamap/SHAMap.cpp
@@ -838,7 +838,6 @@ SHAMap::getHash() const
     auto hash = root_->getHash();
     if (hash.isZero())
     {
-        // NOLINTNEXTLINE(cppcoreguidelines-pro-type-const-cast)
         const_cast<SHAMap&>(*this).unshare();
         hash = root_->getHash();
     }
diff --git a/src/libxrpl/tx/transactors/bridge/XChainBridge.cpp b/src/libxrpl/tx/transactors/bridge/XChainBridge.cpp
index 471ac63d28..d2b1c5ad10 100644
--- a/src/libxrpl/tx/transactors/bridge/XChainBridge.cpp
+++ b/src/libxrpl/tx/transactors/bridge/XChainBridge.cpp
@@ -1155,11 +1155,7 @@ toClaim(STTx const& tx)
 
     try
     {
-        // Copy just the field bag out of the transaction (explicitly, via the
-        // STObject base) so it can be reinterpreted as a cross-chain attestation
-        // below, with sfAccount replaced by sfOtherChainSource. STTx-specific
-        // state (txType_, tid_) is intentionally not needed here.
-        STObject o{static_cast<STObject const&>(tx)};
+        STObject o{tx};
         o.setAccountID(sfAccount, o[sfOtherChainSource]);
         return TAttestation(o);
     }
diff --git a/src/libxrpl/tx/transactors/escrow/EscrowCreate.cpp b/src/libxrpl/tx/transactors/escrow/EscrowCreate.cpp
index 51b887d879..b1de636cbf 100644
--- a/src/libxrpl/tx/transactors/escrow/EscrowCreate.cpp
+++ b/src/libxrpl/tx/transactors/escrow/EscrowCreate.cpp
@@ -196,7 +196,7 @@ escrowCreatePreclaimHelper<Issue>(
     AccountID const& dest,
     STAmount const& amount)
 {
-    auto const& issue = amount.get<Issue>();
+    Issue const& issue = amount.get<Issue>();
     AccountID const& issuer = amount.getIssuer();
     // If the issuer is the same as the account, return tecNO_PERMISSION
     if (issuer == account)
diff --git a/src/libxrpl/tx/transactors/token/TrustSet.cpp b/src/libxrpl/tx/transactors/token/TrustSet.cpp
index 8cffeb47ed..5a7a62b00a 100644
--- a/src/libxrpl/tx/transactors/token/TrustSet.cpp
+++ b/src/libxrpl/tx/transactors/token/TrustSet.cpp
@@ -185,10 +185,22 @@ TrustSet::preclaim(PreclaimContext const& ctx)
 
     // If the destination has opted to disallow incoming trustlines
     // then honour that flag
-    if (sleDst && sleDst->isFlag(lsfDisallowIncomingTrustline) &&
-        !ctx.view.exists(keylet::trustLine(id, uDstAccountID, currency)))
+    if (sleDst->isFlag(lsfDisallowIncomingTrustline))
     {
-        return tecNO_PERMISSION;
+        // The original implementation of featureDisallowIncoming was
+        // too restrictive. If
+        //   o fixDisallowIncomingV1 is enabled and
+        //   o The trust line already exists
+        // Then allow the TrustSet.
+        if (ctx.view.rules().enabled(fixDisallowIncomingV1) &&
+            ctx.view.exists(keylet::trustLine(id, uDstAccountID, currency)))
+        {
+            // pass
+        }
+        else
+        {
+            return tecNO_PERMISSION;
+        }
     }
 
     // In general, trust lines to pseudo accounts are not permitted, unless
diff --git a/src/libxrpl/tx/transactors/vault/VaultWithdraw.cpp b/src/libxrpl/tx/transactors/vault/VaultWithdraw.cpp
index 353b72c30d..ec63b7d769 100644
--- a/src/libxrpl/tx/transactors/vault/VaultWithdraw.cpp
+++ b/src/libxrpl/tx/transactors/vault/VaultWithdraw.cpp
@@ -11,7 +11,7 @@
 #include <xrpl/protocol/AccountID.h>
 #include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/Indexes.h>
-#include <xrpl/protocol/LedgerFormats.h>  // IWYU pragma: keep
+#include <xrpl/protocol/LedgerFormats.h>
 #include <xrpl/protocol/MPTIssue.h>
 #include <xrpl/protocol/Protocol.h>
 #include <xrpl/protocol/SField.h>
diff --git a/src/test/app/AMMMPT_test.cpp b/src/test/app/AMMMPT_test.cpp
index bf0bc5c7d7..525ecee624 100644
--- a/src/test/app/AMMMPT_test.cpp
+++ b/src/test/app/AMMMPT_test.cpp
@@ -3482,8 +3482,8 @@ private:
             // The vote is not added to the slots
             ammAlice.vote(carol_, 1'000);
             auto const info = ammAlice.ammRpcInfo()[jss::amm][jss::vote_slots];
-            for (auto const& entry : info)
-                BEAST_EXPECT(entry[jss::account] != carol_.human());
+            for (auto i = 0; i < info.size(); ++i)
+                BEAST_EXPECT(info[i][jss::account] != carol_.human());
             // But the slots are refreshed and the fee is changed
             BEAST_EXPECT(ammAlice.expectTradingFee(82));
         }
@@ -6270,7 +6270,7 @@ private:
                 auto const info = env.rpc(
                     "json",
                     "account_info",
-                    std::string(R"({"account": ")" + to_string(amm.ammAccount()) + "\"}"));
+                    std::string("{\"account\": \"" + to_string(amm.ammAccount()) + "\"}"));
                 try
                 {
                     BEAST_EXPECT(
diff --git a/src/test/app/AMM_test.cpp b/src/test/app/AMM_test.cpp
index f19743026c..d4b6ba5429 100644
--- a/src/test/app/AMM_test.cpp
+++ b/src/test/app/AMM_test.cpp
@@ -2463,8 +2463,8 @@ private:
             // The vote is not added to the slots
             ammAlice.vote(carol_, 1'000);
             auto const info = ammAlice.ammRpcInfo()[jss::amm][jss::vote_slots];
-            for (auto const& entry : info)
-                BEAST_EXPECT(entry[jss::account] != carol_.human());
+            for (std::uint32_t i = 0; i < info.size(); ++i)
+                BEAST_EXPECT(info[i][jss::account] != carol_.human());
             // But the slots are refreshed and the fee is changed
             BEAST_EXPECT(ammAlice.expectTradingFee(82));
         });
@@ -4436,7 +4436,7 @@ private:
             auto const info = env.rpc(
                 "json",
                 "account_info",
-                std::string(R"({"account": ")" + to_string(ammAlice.ammAccount()) + "\"}"));
+                std::string("{\"account\": \"" + to_string(ammAlice.ammAccount()) + "\"}"));
             auto const flags = info[jss::result][jss::account_data][jss::Flags].asUInt();
             BEAST_EXPECT(flags == (lsfDisableMaster | lsfDefaultRipple | lsfDepositAuth));
         });
@@ -5265,7 +5265,7 @@ private:
             auto const info = env.rpc(
                 "json",
                 "account_info",
-                std::string(R"({"account": ")" + to_string(amm.ammAccount()) + "\"}"));
+                std::string("{\"account\": \"" + to_string(amm.ammAccount()) + "\"}"));
             try
             {
                 BEAST_EXPECT(
diff --git a/src/test/app/ConfidentialTransfer_test.cpp b/src/test/app/ConfidentialTransfer_test.cpp
index d3e0182db5..e6faf0a2ae 100644
--- a/src/test/app/ConfidentialTransfer_test.cpp
+++ b/src/test/app/ConfidentialTransfer_test.cpp
@@ -6920,7 +6920,7 @@ class ConfidentialTransfer_test : public ConfidentialTransferTestBase
         auto& mptAlice = confEnv.mpt;
 
         uint64_t const sendAmount = 10;
-        auto const negativeRemaining = static_cast<uint64_t>(-10);  // 0xFFFFFFFFFFFFFFF6
+        uint64_t const negativeRemaining = static_cast<uint64_t>(-10);  // 0xFFFFFFFFFFFFFFF6
 
         ConfidentialSendSetup const setup(mptAlice, bob, carol, alice, sendAmount);
 
diff --git a/src/test/app/LedgerReplay_test.cpp b/src/test/app/LedgerReplay_test.cpp
index 4cc83608d6..bac1d8b61f 100644
--- a/src/test/app/LedgerReplay_test.cpp
+++ b/src/test/app/LedgerReplay_test.cpp
@@ -28,7 +28,6 @@
 
 #include <xrpl/basics/Slice.h>
 #include <xrpl/basics/base_uint.h>
-#include <xrpl/basics/random.h>
 #include <xrpl/beast/net/IPAddress.h>
 #include <xrpl/beast/net/IPEndpoint.h>
 #include <xrpl/beast/unit_test/suite.h>
@@ -453,7 +452,7 @@ struct TestPeerSet : public PeerSet
             dropRate = 100;
         }
 
-        if (randInt(1, 100) <= dropRate)
+        if (((rand() % 100) + 1) <= dropRate)
             return;
 
         switch (type)
diff --git a/src/test/app/Loan_test.cpp b/src/test/app/Loan_test.cpp
index 3a43dd3f51..ee9691c5d2 100644
--- a/src/test/app/Loan_test.cpp
+++ b/src/test/app/Loan_test.cpp
@@ -8672,7 +8672,7 @@ protected:
         Account const borrower("borrower");
 
         // Determine all the random parameters at once
-        auto const assetType = static_cast<AssetType>(assetDist_(engine_));
+        AssetType const assetType = static_cast<AssetType>(assetDist_(engine_));
         auto const principalRequest = principalDist_(engine_);
         TenthBips16 const managementFeeRate{managementFeeRateDist_(engine_)};
         auto const serviceFee = serviceFeeDist_(engine_);
diff --git a/src/test/app/NFToken_test.cpp b/src/test/app/NFToken_test.cpp
index acd54ae26a..f1b6bb1e0f 100644
--- a/src/test/app/NFToken_test.cpp
+++ b/src/test/app/NFToken_test.cpp
@@ -2404,7 +2404,7 @@ class NFTokenBaseUtil_test : public beast::unit_test::Suite
         // Do some touch testing to show that the taxon is recoverable no
         // matter what else changes around it in the nft ID.
         {
-            auto const taxon = randInt<std::uint32_t>();
+            std::uint32_t const taxon = randInt<std::uint32_t>();
             for (int i = 0; i < 10; ++i)
             {
                 // lambda to produce a useful message on error.
diff --git a/src/test/app/Offer_test.cpp b/src/test/app/Offer_test.cpp
index 7fc7161e36..2ffdb95780 100644
--- a/src/test/app/Offer_test.cpp
+++ b/src/test/app/Offer_test.cpp
@@ -2195,7 +2195,7 @@ public:
         jtx::Account const& account,
         jtx::PrettyAmount const& expectBalance)
     {
-        auto const& issue = expectBalance.value().get<Issue>();
+        Issue const& issue = expectBalance.value().get<Issue>();
         auto const sleTrust = env.le(keylet::trustLine(account.id(), issue));
         BEAST_EXPECT(sleTrust);
         if (sleTrust)
diff --git a/src/test/app/PayChan_test.cpp b/src/test/app/PayChan_test.cpp
index 5068472135..fd2c7790d5 100644
--- a/src/test/app/PayChan_test.cpp
+++ b/src/test/app/PayChan_test.cpp
@@ -19,7 +19,7 @@
 #include <xrpl/basics/chrono.h>
 #include <xrpl/basics/strHex.h>
 #include <xrpl/beast/unit_test/suite.h>
-#include <xrpl/beast/utility/Zero.h>  // IWYU pragma: keep
+#include <xrpl/beast/utility/Zero.h>
 #include <xrpl/core/ServiceRegistry.h>
 #include <xrpl/json/json_value.h>
 #include <xrpl/json/to_string.h>
@@ -1323,10 +1323,10 @@ struct PayChan_test : public beast::unit_test::Suite
         auto sliceToHex = [](Slice const& slice) {
             std::string s;
             s.reserve(2 * slice.size());
-            for (std::uint8_t const byte : slice)
+            for (int i = 0; i < slice.size(); ++i)
             {
-                s += "0123456789ABCDEF"[((byte & 0xf0) >> 4)];
-                s += "0123456789ABCDEF"[((byte & 0x0f) >> 0)];
+                s += "0123456789ABCDEF"[((slice[i] & 0xf0) >> 4)];
+                s += "0123456789ABCDEF"[((slice[i] & 0x0f) >> 0)];
             }
             return s;
         };
diff --git a/src/test/app/PayStrand_test.cpp b/src/test/app/PayStrand_test.cpp
index 967f84f275..11a0e5bab0 100644
--- a/src/test/app/PayStrand_test.cpp
+++ b/src/test/app/PayStrand_test.cpp
@@ -40,6 +40,7 @@
 #include <cassert>
 #include <cstddef>
 #include <cstdint>
+#include <cstdio>
 #include <initializer_list>
 #include <optional>
 #include <stdexcept>
@@ -111,7 +112,7 @@ class ElementComboIter
         };
 
     std::uint16_t state_ = 0;
-    static_assert(safeCast<size_t>(SB::Last) <= sizeof(decltype(state_)) * 8);
+    static_assert(safeCast<size_t>(SB::Last) <= sizeof(decltype(state_)) * 8, "");
     STPathElement const* prev_ = nullptr;
     // disallow iss and cur to be specified with acc is specified (simplifies
     // some tests)
@@ -308,26 +309,31 @@ struct ExistingElementPool
         currencyNames.clear();
         currencyNames.reserve(numCur);
 
+        static constexpr size_t kBufSize = 32;
+        char buf[kBufSize];
+
         for (size_t id = 0; id < numAct; ++id)
-            accounts.emplace_back("A" + std::to_string(id));
+        {
+            snprintf(buf, kBufSize, "A%zu", id);
+            accounts.emplace_back(buf);
+        }
 
         for (size_t id = 0; id < numCur; ++id)
         {
-            std::string name;
             if (id < 10)
             {
-                name = "CC" + std::to_string(id);
+                snprintf(buf, kBufSize, "CC%zu", id);
             }
             else if (id < 100)
             {
-                name = "C" + std::to_string(id);
+                snprintf(buf, kBufSize, "C%zu", id);
             }
             else
             {
-                name = std::to_string(id);
+                snprintf(buf, kBufSize, "%zu", id);
             }
-            currencies.emplace_back(toCurrency(name));
-            currencyNames.emplace_back(name);
+            currencies.emplace_back(toCurrency(buf));
+            currencyNames.emplace_back(buf);
         }
 
         for (auto const& a : accounts)
diff --git a/src/test/app/PermissionedDomains_test.cpp b/src/test/app/PermissionedDomains_test.cpp
index 784c2b4f56..2cffc18682 100644
--- a/src/test/app/PermissionedDomains_test.cpp
+++ b/src/test/app/PermissionedDomains_test.cpp
@@ -289,8 +289,8 @@ class PermissionedDomains_test : public beast::unit_test::Suite
         for (auto const& c : alice)
             human2Acc.emplace(c.human(), c);
 
-        for (auto const& account : alice)
-            env.fund(XRP(1000), account);
+        for (int i = 0; i < accNum; ++i)
+            env.fund(XRP(1000), alice[i]);
 
         // Create new from existing account with a single credential.
         pdomain::Credentials const credentials1{{.issuer = alice[2], .credType = "credential1"}};
diff --git a/src/test/app/TrustSet_test.cpp b/src/test/app/TrustSet_test.cpp
index e24373fd21..51cc4c2433 100644
--- a/src/test/app/TrustSet_test.cpp
+++ b/src/test/app/TrustSet_test.cpp
@@ -474,38 +474,6 @@ public:
         checkQuality(!createQuality);
     }
 
-    void
-    testDisallowIncomingWithRequireAuth()
-    {
-        testcase("Create trustline with disallow incoming requiring auth");
-
-        using namespace test::jtx;
-
-        Env env{*this};
-        auto const dist = Account("dist");
-        auto const gw = Account("gw");
-        auto const usd = gw["USD"];
-        auto const distUSD = dist["USD"];
-
-        env.fund(XRP(1000), gw, dist);
-        env.close();
-
-        env(fset(gw, asfRequireAuth));
-        env.close();
-
-        env(fset(dist, asfDisallowIncomingTrustline));
-        env.close();
-
-        env(trust(dist, usd(10000)));
-        env.close();
-
-        env(trust(gw, distUSD(10000)), Txflags(tfSetfAuth), Ter(tesSUCCESS));
-        env.close();
-
-        env(pay(gw, dist, usd(1000)), Ter(tesSUCCESS));
-        env.close();
-    }
-
     void
     testDisallowIncoming(FeatureBitset features)
     {
@@ -513,6 +481,42 @@ public:
 
         using namespace test::jtx;
 
+        // fixDisallowIncomingV1
+        {
+            for (bool const withFix : {true, false})
+            {
+                auto const amend = withFix ? features : features - fixDisallowIncomingV1;
+
+                Env env{*this, amend};
+                auto const dist = Account("dist");
+                auto const gw = Account("gw");
+                auto const usd = gw["USD"];
+                auto const distUSD = dist["USD"];
+
+                env.fund(XRP(1000), gw, dist);
+                env.close();
+
+                env(fset(gw, asfRequireAuth));
+                env.close();
+
+                env(fset(dist, asfDisallowIncomingTrustline));
+                env.close();
+
+                env(trust(dist, usd(10000)));
+                env.close();
+
+                // withFix: can set trustline
+                // withOutFix: cannot set trustline
+                auto const trustResult = withFix ? Ter(tesSUCCESS) : Ter(tecNO_PERMISSION);
+                env(trust(gw, distUSD(10000)), Txflags(tfSetfAuth), trustResult);
+                env.close();
+
+                auto const txResult = withFix ? Ter(tesSUCCESS) : Ter(tecPATH_DRY);
+                env(pay(gw, dist, usd(1000)), txResult);
+                env.close();
+            }
+        }
+
         Env env{*this, features};
 
         auto const gw = Account{"gateway"};
@@ -597,7 +601,6 @@ public:
         testModifyQualityOfTrustline(features, false, true);
         testModifyQualityOfTrustline(features, true, false);
         testModifyQualityOfTrustline(features, true, true);
-        testDisallowIncomingWithRequireAuth();
         testDisallowIncoming(features);
         testTrustLineResetWithAuthFlag();
         testTrustLineDelete();
diff --git a/src/test/app/ValidatorList_test.cpp b/src/test/app/ValidatorList_test.cpp
index 8077c21863..d71554f714 100644
--- a/src/test/app/ValidatorList_test.cpp
+++ b/src/test/app/ValidatorList_test.cpp
@@ -146,8 +146,8 @@ private:
 
         for (auto const& val : validators)
         {
-            data += R"({"validation_public_key":")" + strHex(val.masterPublic) +
-                R"(","manifest":")" + val.manifest + "\"},";
+            data += "{\"validation_public_key\":\"" + strHex(val.masterPublic) +
+                "\",\"manifest\":\"" + val.manifest + "\"},";
         }
 
         data.pop_back();
diff --git a/src/test/app/Vault_test.cpp b/src/test/app/Vault_test.cpp
index 4de8c9c616..7e6b2612d1 100644
--- a/src/test/app/Vault_test.cpp
+++ b/src/test/app/Vault_test.cpp
@@ -7544,7 +7544,7 @@ class Vault_test : public beast::unit_test::Suite
         // Transaction fails if the data field is set, but is empty
         {
             testcase("VaultDelete memo data featureLendingProtocolV1_1 enabled data empty");
-            delTx[sfMemoData] = strHex(std::string());
+            delTx[sfMemoData] = std::string();
             env(delTx, Ter(temMALFORMED));
             env.close();
         }
diff --git a/src/test/app/XChain_test.cpp b/src/test/app/XChain_test.cpp
index 4b007eea13..f57ad325fb 100644
--- a/src/test/app/XChain_test.cpp
+++ b/src/test/app/XChain_test.cpp
@@ -245,9 +245,9 @@ struct Balance
     T& env;
     STAmount startAmount;
 
-    Balance(T& env, jtx::Account const& account)
-        : account(account), env(env), startAmount(env.balance(account))
+    Balance(T& env, jtx::Account const& account) : account(account), env(env)
     {
+        startAmount = env.balance(account);
     }
 
     [[nodiscard]] STAmount
diff --git a/src/test/basics/Buffer_test.cpp b/src/test/basics/Buffer_test.cpp
new file mode 100644
index 0000000000..816a697ca4
--- /dev/null
+++ b/src/test/basics/Buffer_test.cpp
@@ -0,0 +1,268 @@
+#include <xrpl/basics/Buffer.h>
+#include <xrpl/basics/Slice.h>
+#include <xrpl/beast/unit_test/suite.h>
+
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <type_traits>
+#include <utility>
+
+namespace xrpl::test {
+
+struct Buffer_test : beast::unit_test::Suite
+{
+    static bool
+    sane(Buffer const& b)
+    {
+        if (b.empty())
+            return b.data() == nullptr;
+
+        return b.data() != nullptr;
+    }
+
+    void
+    run() override
+    {
+        std::uint8_t const data[] = {0xa8, 0xa1, 0x38, 0x45, 0x23, 0xec, 0xe4, 0x23,
+                                     0x71, 0x6d, 0x2a, 0x18, 0xb4, 0x70, 0xcb, 0xf5,
+                                     0xac, 0x2d, 0x89, 0x4d, 0x19, 0x9c, 0xf0, 0x2c,
+                                     0x15, 0xd1, 0xf9, 0x9b, 0x66, 0xd2, 0x30, 0xd3};
+
+        Buffer const b0;
+        BEAST_EXPECT(sane(b0));
+        BEAST_EXPECT(b0.empty());
+
+        Buffer b1{0};
+        BEAST_EXPECT(sane(b1));
+        BEAST_EXPECT(b1.empty());
+        std::memcpy(b1.alloc(16), data, 16);
+        BEAST_EXPECT(sane(b1));
+        BEAST_EXPECT(!b1.empty());
+        BEAST_EXPECT(b1.size() == 16);
+
+        Buffer b2{b1.size()};
+        BEAST_EXPECT(sane(b2));
+        BEAST_EXPECT(!b2.empty());
+        BEAST_EXPECT(b2.size() == b1.size());
+        std::memcpy(b2.data(), data + 16, 16);
+
+        Buffer b3{data, sizeof(data)};
+        BEAST_EXPECT(sane(b3));
+        BEAST_EXPECT(!b3.empty());
+        BEAST_EXPECT(b3.size() == sizeof(data));
+        BEAST_EXPECT(std::memcmp(b3.data(), data, b3.size()) == 0);
+
+        // Check equality and inequality comparisons
+        BEAST_EXPECT(b0 == b0);
+        BEAST_EXPECT(b0 != b1);
+        BEAST_EXPECT(b1 == b1);
+        BEAST_EXPECT(b1 != b2);
+        BEAST_EXPECT(b2 != b3);
+
+        // Check copy constructors and copy assignments:
+        {
+            testcase("Copy Construction / Assignment");
+
+            Buffer x{b0};
+            BEAST_EXPECT(x == b0);
+            BEAST_EXPECT(sane(x));
+            Buffer y{b1};
+            BEAST_EXPECT(y == b1);
+            BEAST_EXPECT(sane(y));
+            x = b2;
+            BEAST_EXPECT(x == b2);
+            BEAST_EXPECT(sane(x));
+            x = y;
+            BEAST_EXPECT(x == y);
+            BEAST_EXPECT(sane(x));
+            y = b3;
+            BEAST_EXPECT(y == b3);
+            BEAST_EXPECT(sane(y));
+            x = b0;
+            BEAST_EXPECT(x == b0);
+            BEAST_EXPECT(sane(x));
+#if defined(__clang__)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wself-assign-overloaded"
+#endif
+
+            x = x;
+            BEAST_EXPECT(x == b0);
+            BEAST_EXPECT(sane(x));
+            y = y;
+            BEAST_EXPECT(y == b3);
+            BEAST_EXPECT(sane(y));
+
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#endif
+        }
+
+        // Check move constructor & move assignments:
+        {
+            testcase("Move Construction / Assignment");
+
+            static_assert(std::is_nothrow_move_constructible_v<Buffer>, "");
+            static_assert(std::is_nothrow_move_assignable_v<Buffer>, "");
+
+            {  // Move-construct from empty buf
+                Buffer x;
+                Buffer const y{std::move(x)};
+                BEAST_EXPECT(sane(x));    // NOLINT(bugprone-use-after-move)
+                BEAST_EXPECT(x.empty());  // NOLINT(bugprone-use-after-move)
+                BEAST_EXPECT(sane(y));
+                BEAST_EXPECT(y.empty());
+                BEAST_EXPECT(x == y);  // NOLINT(bugprone-use-after-move)
+            }
+
+            {  // Move-construct from non-empty buf
+                Buffer x{b1};
+                Buffer const y{std::move(x)};
+                BEAST_EXPECT(sane(x));    // NOLINT(bugprone-use-after-move)
+                BEAST_EXPECT(x.empty());  // NOLINT(bugprone-use-after-move)
+                BEAST_EXPECT(sane(y));
+                BEAST_EXPECT(y == b1);
+            }
+
+            {  // Move assign empty buf to empty buf
+                Buffer x;
+                Buffer y;
+
+                x = std::move(y);
+                BEAST_EXPECT(sane(x));
+                BEAST_EXPECT(x.empty());
+                BEAST_EXPECT(sane(y));    // NOLINT(bugprone-use-after-move)
+                BEAST_EXPECT(y.empty());  // NOLINT(bugprone-use-after-move)
+            }
+
+            {  // Move assign non-empty buf to empty buf
+                Buffer x;
+                Buffer y{b1};
+
+                x = std::move(y);
+                BEAST_EXPECT(sane(x));
+                BEAST_EXPECT(x == b1);
+                BEAST_EXPECT(sane(y));    // NOLINT(bugprone-use-after-move)
+                BEAST_EXPECT(y.empty());  // NOLINT(bugprone-use-after-move)
+            }
+
+            {  // Move assign empty buf to non-empty buf
+                Buffer x{b1};
+                Buffer y;
+
+                x = std::move(y);
+                BEAST_EXPECT(sane(x));
+                BEAST_EXPECT(x.empty());
+                BEAST_EXPECT(sane(y));    // NOLINT(bugprone-use-after-move)
+                BEAST_EXPECT(y.empty());  // NOLINT(bugprone-use-after-move)
+            }
+
+            {  // Move assign non-empty buf to non-empty buf
+                Buffer x{b1};
+                Buffer y{b2};
+                Buffer z{b3};
+
+                x = std::move(y);
+                BEAST_EXPECT(sane(x));
+                BEAST_EXPECT(!x.empty());
+                BEAST_EXPECT(sane(y));    // NOLINT(bugprone-use-after-move)
+                BEAST_EXPECT(y.empty());  // NOLINT(bugprone-use-after-move)
+
+                x = std::move(z);
+                BEAST_EXPECT(sane(x));
+                BEAST_EXPECT(!x.empty());
+                BEAST_EXPECT(sane(z));    // NOLINT(bugprone-use-after-move)
+                BEAST_EXPECT(z.empty());  // NOLINT(bugprone-use-after-move)
+            }
+        }
+
+        {
+            testcase("Slice Conversion / Construction / Assignment");
+
+            Buffer w{static_cast<Slice>(b0)};
+            BEAST_EXPECT(sane(w));
+            BEAST_EXPECT(w == b0);
+
+            Buffer x{static_cast<Slice>(b1)};
+            BEAST_EXPECT(sane(x));
+            BEAST_EXPECT(x == b1);
+
+            Buffer y{static_cast<Slice>(b2)};
+            BEAST_EXPECT(sane(y));
+            BEAST_EXPECT(y == b2);
+
+            Buffer z{static_cast<Slice>(b3)};
+            BEAST_EXPECT(sane(z));
+            BEAST_EXPECT(z == b3);
+
+            // Assign empty slice to empty buffer
+            w = static_cast<Slice>(b0);
+            BEAST_EXPECT(sane(w));
+            BEAST_EXPECT(w == b0);
+
+            // Assign non-empty slice to empty buffer
+            w = static_cast<Slice>(b1);
+            BEAST_EXPECT(sane(w));
+            BEAST_EXPECT(w == b1);
+
+            // Assign non-empty slice to non-empty buffer
+            x = static_cast<Slice>(b2);
+            BEAST_EXPECT(sane(x));
+            BEAST_EXPECT(x == b2);
+
+            // Assign non-empty slice to non-empty buffer
+            y = static_cast<Slice>(z);
+            BEAST_EXPECT(sane(y));
+            BEAST_EXPECT(y == z);
+
+            // Assign empty slice to non-empty buffer:
+            z = static_cast<Slice>(b0);
+            BEAST_EXPECT(sane(z));
+            BEAST_EXPECT(z == b0);
+        }
+
+        {
+            testcase("Allocation, Deallocation and Clearing");
+
+            auto test = [this](Buffer const& b, std::size_t i) {
+                Buffer x{b};
+
+                // Try to allocate some number of bytes, possibly
+                // zero (which means clear) and sanity check
+                x(i);
+                BEAST_EXPECT(sane(x));
+                BEAST_EXPECT(x.size() == i);
+                BEAST_EXPECT((x.data() == nullptr) == (i == 0));
+
+                // Try to allocate some more data (always non-zero)
+                x(i + 1);
+                BEAST_EXPECT(sane(x));
+                BEAST_EXPECT(x.size() == i + 1);
+                BEAST_EXPECT(x.data() != nullptr);
+
+                // Try to clear:
+                x.clear();
+                BEAST_EXPECT(sane(x));
+                BEAST_EXPECT(x.empty());
+                BEAST_EXPECT(x.data() == nullptr);
+
+                // Try to clear again:
+                x.clear();
+                BEAST_EXPECT(sane(x));
+                BEAST_EXPECT(x.empty());
+                BEAST_EXPECT(x.data() == nullptr);
+            };
+
+            for (std::size_t i = 0; i < 16; ++i)
+            {
+                test(b0, i);
+                test(b1, i);
+            }
+        }
+    }
+};
+
+BEAST_DEFINE_TESTSUITE(Buffer, basics, xrpl);
+
+}  // namespace xrpl::test
diff --git a/src/test/basics/FileUtilities_test.cpp b/src/test/basics/FileUtilities_test.cpp
new file mode 100644
index 0000000000..0e050b5168
--- /dev/null
+++ b/src/test/basics/FileUtilities_test.cpp
@@ -0,0 +1,64 @@
+#include <test/unit_test/FileDirGuard.h>
+
+#include <xrpl/basics/ByteUtilities.h>
+#include <xrpl/basics/FileUtilities.h>
+#include <xrpl/beast/unit_test/suite.h>
+
+#include <boost/system/detail/errc.hpp>
+#include <boost/system/detail/error_code.hpp>
+
+namespace xrpl {
+
+class FileUtilities_test : public beast::unit_test::Suite
+{
+public:
+    void
+    testGetFileContents()
+    {
+        using namespace xrpl::detail;
+        using namespace boost::system;
+
+        static constexpr char const* kExpectedContents =
+            "This file is very short. That's all we need.";
+
+        FileDirGuard const file(
+            *this, "test_file", "test.txt", "This is temporary text that should get overwritten");
+
+        error_code ec;
+        auto const path = file.file();
+
+        writeFileContents(ec, path, kExpectedContents);
+        BEAST_EXPECT(!ec);
+
+        {
+            // Test with no max
+            auto const good = getFileContents(ec, path);
+            BEAST_EXPECT(!ec);
+            BEAST_EXPECT(good == kExpectedContents);
+        }
+
+        {
+            // Test with large max
+            auto const good = getFileContents(ec, path, kilobytes(1));
+            BEAST_EXPECT(!ec);
+            BEAST_EXPECT(good == kExpectedContents);
+        }
+
+        {
+            // Test with small max
+            auto const bad = getFileContents(ec, path, 16);
+            BEAST_EXPECT(ec && ec.value() == boost::system::errc::file_too_large);
+            BEAST_EXPECT(bad.empty());
+        }
+    }
+
+    void
+    run() override
+    {
+        testGetFileContents();
+    }
+};
+
+BEAST_DEFINE_TESTSUITE(FileUtilities, basics, xrpl);
+
+}  // namespace xrpl
diff --git a/src/test/basics/IOUAmount_test.cpp b/src/test/basics/IOUAmount_test.cpp
new file mode 100644
index 0000000000..b652d27625
--- /dev/null
+++ b/src/test/basics/IOUAmount_test.cpp
@@ -0,0 +1,276 @@
+#include <xrpl/basics/Number.h>
+#include <xrpl/beast/unit_test/suite.h>
+#include <xrpl/beast/utility/Zero.h>
+#include <xrpl/protocol/IOUAmount.h>
+
+#include <cstdint>
+#include <limits>
+#include <sstream>
+
+namespace xrpl {
+
+class IOUAmount_test : public beast::unit_test::Suite
+{
+public:
+    void
+    testZero()
+    {
+        testcase("zero");
+
+        IOUAmount const z(0, 0);
+
+        BEAST_EXPECT(z.mantissa() == 0);
+        BEAST_EXPECT(z.exponent() == -100);
+        BEAST_EXPECT(!z);
+        BEAST_EXPECT(z.signum() == 0);
+        BEAST_EXPECT(z == beast::kZero);
+
+        BEAST_EXPECT((z + z) == z);
+        BEAST_EXPECT((z - z) == z);
+        BEAST_EXPECT(z == -z);
+
+        IOUAmount const zz(beast::kZero);
+        BEAST_EXPECT(z == zz);
+
+        // https://github.com/XRPLF/rippled/issues/5170
+        IOUAmount const zzz{};
+        BEAST_EXPECT(zzz == beast::kZero);
+        // BEAST_EXPECT(zzz == zz);
+    }
+
+    void
+    testSigNum()
+    {
+        testcase("signum");
+
+        IOUAmount const neg(-1, 0);
+        BEAST_EXPECT(neg.signum() < 0);
+
+        IOUAmount const zer(0, 0);
+        BEAST_EXPECT(zer.signum() == 0);
+
+        IOUAmount const pos(1, 0);
+        BEAST_EXPECT(pos.signum() > 0);
+    }
+
+    void
+    testBeastZero()
+    {
+        testcase("beast::Zero Comparisons");
+
+        using beast::kZero;
+
+        {
+            IOUAmount const z(kZero);
+            BEAST_EXPECT(z == kZero);
+            BEAST_EXPECT(z >= kZero);
+            BEAST_EXPECT(z <= kZero);
+            unexpected(z != kZero);
+            unexpected(z > kZero);
+            unexpected(z < kZero);
+        }
+
+        {
+            IOUAmount const neg(-2, 0);
+            BEAST_EXPECT(neg < kZero);
+            BEAST_EXPECT(neg <= kZero);
+            BEAST_EXPECT(neg != kZero);
+            unexpected(neg == kZero);
+        }
+
+        {
+            IOUAmount const pos(2, 0);
+            BEAST_EXPECT(pos > kZero);
+            BEAST_EXPECT(pos >= kZero);
+            BEAST_EXPECT(pos != kZero);
+            unexpected(pos == kZero);
+        }
+    }
+
+    void
+    testComparisons()
+    {
+        testcase("IOU Comparisons");
+
+        IOUAmount const n(-2, 0);
+        IOUAmount const z(0, 0);
+        IOUAmount const p(2, 0);
+
+        BEAST_EXPECT(z == z);
+        BEAST_EXPECT(z >= z);
+        BEAST_EXPECT(z <= z);
+        BEAST_EXPECT(z == -z);
+        // NOLINTBEGIN(misc-redundant-expression)
+        unexpected(z > z);
+        unexpected(z < z);
+        unexpected(z != z);
+        // NOLINTEND(misc-redundant-expression)
+        unexpected(z != -z);
+
+        BEAST_EXPECT(n < z);
+        BEAST_EXPECT(n <= z);
+        BEAST_EXPECT(n != z);
+        unexpected(n > z);
+        unexpected(n >= z);
+        unexpected(n == z);
+
+        BEAST_EXPECT(p > z);
+        BEAST_EXPECT(p >= z);
+        BEAST_EXPECT(p != z);
+        unexpected(p < z);
+        unexpected(p <= z);
+        unexpected(p == z);
+
+        BEAST_EXPECT(n < p);
+        BEAST_EXPECT(n <= p);
+        BEAST_EXPECT(n != p);
+        unexpected(n > p);
+        unexpected(n >= p);
+        unexpected(n == p);
+
+        BEAST_EXPECT(p > n);
+        BEAST_EXPECT(p >= n);
+        BEAST_EXPECT(p != n);
+        unexpected(p < n);
+        unexpected(p <= n);
+        unexpected(p == n);
+
+        BEAST_EXPECT(p > -p);
+        BEAST_EXPECT(p >= -p);
+        BEAST_EXPECT(p != -p);
+
+        BEAST_EXPECT(n < -n);
+        BEAST_EXPECT(n <= -n);
+        BEAST_EXPECT(n != -n);
+    }
+
+    void
+    testToString()
+    {
+        testcase("IOU strings");
+
+        auto test = [this](IOUAmount const& n, std::string const& expected) {
+            auto const result = to_string(n);
+            std::stringstream ss;
+            ss << "to_string(" << result << "). Expected: " << expected;
+            BEAST_EXPECTS(result == expected, ss.str());
+        };
+
+        for (auto const mantissaSize : MantissaRange::getAllScales())
+        {
+            NumberMantissaScaleGuard const mg(mantissaSize);
+
+            test(IOUAmount(-2, 0), "-2");
+            test(IOUAmount(0, 0), "0");
+            test(IOUAmount(2, 0), "2");
+            test(IOUAmount(25, -3), "0.025");
+            test(IOUAmount(-25, -3), "-0.025");
+            test(IOUAmount(25, 1), "250");
+            test(IOUAmount(-25, 1), "-250");
+            test(IOUAmount(2, 20), "2e20");
+            test(IOUAmount(-2, -20), "-2e-20");
+        }
+    }
+
+    void
+    testMulRatio()
+    {
+        testcase("mulRatio");
+
+        /* The range for the mantissa when normalized */
+        static constexpr std::int64_t kMinMantissa = 1000000000000000ull;
+        static constexpr std::int64_t kMaxMantissa = 9999999999999999ull;
+        // log(2,maxMantissa) ~ 53.15
+        /* The range for the exponent when normalized */
+        static constexpr int kMinExponent = -96;
+        static constexpr int kMaxExponent = 80;
+        constexpr auto kMaxUInt = std::numeric_limits<std::uint32_t>::max();
+
+        {
+            // multiply by a number that would overflow the mantissa, then
+            // divide by the same number, and check we didn't lose any value
+            IOUAmount const bigMan(kMaxMantissa, 0);
+            BEAST_EXPECT(bigMan == mulRatio(bigMan, kMaxUInt, kMaxUInt, true));
+            // rounding mode shouldn't matter as the result is exact
+            BEAST_EXPECT(bigMan == mulRatio(bigMan, kMaxUInt, kMaxUInt, false));
+        }
+        {
+            // Similar test as above, but for negative values
+            IOUAmount const bigMan(-kMaxMantissa, 0);
+            BEAST_EXPECT(bigMan == mulRatio(bigMan, kMaxUInt, kMaxUInt, true));
+            // rounding mode shouldn't matter as the result is exact
+            BEAST_EXPECT(bigMan == mulRatio(bigMan, kMaxUInt, kMaxUInt, false));
+        }
+
+        {
+            // small amounts
+            IOUAmount const tiny(kMinMantissa, kMinExponent);
+            // Round up should give the smallest allowable number
+            BEAST_EXPECT(tiny == mulRatio(tiny, 1, kMaxUInt, true));
+            BEAST_EXPECT(tiny == mulRatio(tiny, kMaxUInt - 1, kMaxUInt, true));
+            // rounding down should be zero
+            BEAST_EXPECT(beast::kZero == mulRatio(tiny, 1, kMaxUInt, false));
+            BEAST_EXPECT(beast::kZero == mulRatio(tiny, kMaxUInt - 1, kMaxUInt, false));
+
+            // tiny negative numbers
+            IOUAmount const tinyNeg(-kMinMantissa, kMinExponent);
+            // Round up should give zero
+            BEAST_EXPECT(beast::kZero == mulRatio(tinyNeg, 1, kMaxUInt, true));
+            BEAST_EXPECT(beast::kZero == mulRatio(tinyNeg, kMaxUInt - 1, kMaxUInt, true));
+            // rounding down should be tiny
+            BEAST_EXPECT(tinyNeg == mulRatio(tinyNeg, 1, kMaxUInt, false));
+            BEAST_EXPECT(tinyNeg == mulRatio(tinyNeg, kMaxUInt - 1, kMaxUInt, false));
+        }
+
+        {  // rounding
+            {
+                IOUAmount const one(1, 0);
+                auto const rup = mulRatio(one, kMaxUInt - 1, kMaxUInt, true);
+                auto const rdown = mulRatio(one, kMaxUInt - 1, kMaxUInt, false);
+                BEAST_EXPECT(rup.mantissa() - rdown.mantissa() == 1);
+            }
+            {
+                IOUAmount const big(kMaxMantissa, kMaxExponent);
+                auto const rup = mulRatio(big, kMaxUInt - 1, kMaxUInt, true);
+                auto const rdown = mulRatio(big, kMaxUInt - 1, kMaxUInt, false);
+                BEAST_EXPECT(rup.mantissa() - rdown.mantissa() == 1);
+            }
+
+            {
+                IOUAmount const negOne(-1, 0);
+                auto const rup = mulRatio(negOne, kMaxUInt - 1, kMaxUInt, true);
+                auto const rdown = mulRatio(negOne, kMaxUInt - 1, kMaxUInt, false);
+                BEAST_EXPECT(rup.mantissa() - rdown.mantissa() == 1);
+            }
+        }
+
+        {
+            // division by zero
+            IOUAmount one(1, 0);
+            except([&] { mulRatio(one, 1, 0, true); });
+        }
+
+        {
+            // overflow
+            IOUAmount big(kMaxMantissa, kMaxExponent);
+            except([&] { mulRatio(big, 2, 0, true); });
+        }
+    }  // namespace xrpl
+
+    //--------------------------------------------------------------------------
+
+    void
+    run() override
+    {
+        testZero();
+        testSigNum();
+        testBeastZero();
+        testComparisons();
+        testToString();
+        testMulRatio();
+    }
+};
+
+BEAST_DEFINE_TESTSUITE(IOUAmount, basics, xrpl);
+
+}  // namespace xrpl
diff --git a/src/test/basics/IntrusiveShared_test.cpp b/src/test/basics/IntrusiveShared_test.cpp
new file mode 100644
index 0000000000..185b877f23
--- /dev/null
+++ b/src/test/basics/IntrusiveShared_test.cpp
@@ -0,0 +1,879 @@
+
+#include <xrpl/basics/IntrusivePointer.h>    // IWYU pragma: keep
+#include <xrpl/basics/IntrusivePointer.ipp>  // IWYU pragma: keep
+#include <xrpl/basics/IntrusiveRefCounts.h>
+#include <xrpl/beast/unit_test/suite.h>
+
+#include <algorithm>
+#include <array>
+#include <atomic>
+#include <cassert>
+#include <chrono>  // IWYU pragma: keep
+#include <condition_variable>
+#include <cstddef>
+#include <cstdint>
+#include <functional>
+#include <latch>
+#include <mutex>
+#include <optional>
+#include <random>
+#include <string>
+#include <thread>
+#include <utility>
+#include <variant>
+#include <vector>
+
+namespace xrpl::tests {
+
+/**
+Experimentally, we discovered that using std::barrier performs extremely
+poorly (~1 hour vs ~1 minute to run the test suite) in certain macOS
+environments. To unblock our macOS CI pipeline, we replaced std::barrier with a
+custom mutex-based barrier (Barrier) that significantly improves performance
+without compromising correctness. For future reference, if we ever consider
+reintroducing std::barrier, the following configuration is known to exhibit the
+problem:
+
+    Model Name: Mac mini
+    Model Identifier: Mac14,3
+    Model Number: Z16K000R4LL/A
+    Chip: Apple M2
+    Total Number of Cores: 8 (4 performance and 4 efficiency)
+    Memory: 24 GB
+    System Firmware Version: 11881.41.5
+    OS Loader Version: 11881.1.1
+    Apple clang version 16.0.0 (clang-1600.0.26.3)
+    Target: arm64-apple-darwin24.0.0
+    Thread model: posix
+
+ */
+struct Barrier
+{
+    std::mutex mtx;
+    std::condition_variable cv;
+    int count;
+    int const initial;
+
+    Barrier(int n) : count(n), initial(n)
+    {
+    }
+
+    void
+    arriveAndWait()
+    {
+        std::unique_lock lock(mtx);
+        if (--count == 0)
+        {
+            count = initial;
+            cv.notify_all();
+        }
+        else
+        {
+            cv.wait(lock, [&] { return count == initial; });
+        }
+    }
+};
+
+namespace {
+enum class TrackedState : std::uint8_t {
+    Uninitialized,
+    Alive,
+    PartiallyDeletedStarted,
+    PartiallyDeleted,
+    DeletedStarted,
+    Deleted
+};
+
+class TIBase : public IntrusiveRefCounts
+{
+public:
+    static constexpr std::size_t kMaxStates = 128;
+    static std::array<std::atomic<TrackedState>, kMaxStates> state;
+    static std::atomic<int> nextId;
+    static TrackedState
+    getState(int id)
+    {
+        assert(id < state.size());
+        return state[id].load(std::memory_order_acquire);
+    }
+    static void
+    resetStates(bool resetCallback)
+    {
+        for (int i = 0; i < kMaxStates; ++i)
+        {
+            state[i].store(TrackedState::Uninitialized, std::memory_order_release);
+        }
+        nextId.store(0, std::memory_order_release);
+        if (resetCallback)
+            TIBase::tracingCallback = [](TrackedState, std::optional<TrackedState>) {};
+    }
+
+    struct ResetStatesGuard
+    {
+        bool resetCallback{false};
+
+        ResetStatesGuard(bool resetCallback) : resetCallback{resetCallback}
+        {
+            TIBase::resetStates(resetCallback);
+        }
+        ~ResetStatesGuard()
+        {
+            TIBase::resetStates(resetCallback);
+        }
+    };
+
+    TIBase() : id{checkoutID()}
+    {
+        assert(state.size() > id);
+        state[id].store(TrackedState::Alive, std::memory_order_relaxed);
+    }
+    ~TIBase() override
+    {
+        using enum TrackedState;
+
+        assert(state.size() > id);
+        tracingCallback(state[id].load(std::memory_order_relaxed), DeletedStarted);
+
+        assert(state.size() > id);
+        // Use relaxed memory order to try to avoid atomic operations from
+        // adding additional memory synchronizations that may hide threading
+        // errors in the underlying shared pointer class.
+        state[id].store(DeletedStarted, std::memory_order_relaxed);
+
+        tracingCallback(DeletedStarted, Deleted);
+
+        assert(state.size() > id);
+        state[id].store(TrackedState::Deleted, std::memory_order_relaxed);
+
+        tracingCallback(TrackedState::Deleted, std::nullopt);
+    }
+
+    void
+    partialDestructor() const
+    {
+        using enum TrackedState;
+
+        assert(state.size() > id);
+        tracingCallback(state[id].load(std::memory_order_relaxed), PartiallyDeletedStarted);
+
+        assert(state.size() > id);
+        state[id].store(PartiallyDeletedStarted, std::memory_order_relaxed);
+
+        tracingCallback(PartiallyDeletedStarted, PartiallyDeleted);
+
+        assert(state.size() > id);
+        state[id].store(PartiallyDeleted, std::memory_order_relaxed);
+
+        tracingCallback(PartiallyDeleted, std::nullopt);
+    }
+
+    static std::function<void(TrackedState, std::optional<TrackedState>)> tracingCallback;
+
+    int id;
+
+private:
+    static int
+    checkoutID()
+    {
+        return nextId.fetch_add(1, std::memory_order_acq_rel);
+    }
+};
+
+std::array<std::atomic<TrackedState>, TIBase::kMaxStates> TIBase::state;
+std::atomic<int> TIBase::nextId{0};
+
+std::function<void(TrackedState, std::optional<TrackedState>)> TIBase::tracingCallback =
+    [](TrackedState, std::optional<TrackedState>) {};
+
+}  // namespace
+
+class IntrusiveShared_test : public beast::unit_test::Suite
+{
+public:
+    void
+    testBasics()
+    {
+        testcase("Basics");
+
+        {
+            TIBase::ResetStatesGuard const rsg{true};
+
+            TIBase const b;
+            BEAST_EXPECT(b.useCount() == 1);
+            b.addWeakRef();
+            BEAST_EXPECT(b.useCount() == 1);
+            auto s = b.releaseStrongRef();
+            BEAST_EXPECT(s == ReleaseStrongRefAction::PartialDestroy);
+            BEAST_EXPECT(b.useCount() == 0);
+            TIBase const* pb = &b;
+            partialDestructorFinished(&pb);
+            BEAST_EXPECT(!pb);
+            auto w = b.releaseWeakRef();
+            BEAST_EXPECT(w == ReleaseWeakRefAction::Destroy);
+        }
+
+        std::vector<SharedIntrusive<TIBase>> strong;
+        std::vector<WeakIntrusive<TIBase>> weak;
+        {
+            TIBase::ResetStatesGuard const rsg{true};
+
+            using enum TrackedState;
+            auto b = makeSharedIntrusive<TIBase>();
+            auto id = b->id;
+            BEAST_EXPECT(TIBase::getState(id) == Alive);
+            BEAST_EXPECT(b->useCount() == 1);
+            for (int i = 0; i < 10; ++i)
+            {
+                strong.push_back(b);
+            }
+            b.reset();
+            BEAST_EXPECT(TIBase::getState(id) == Alive);
+            strong.resize(strong.size() - 1);
+            BEAST_EXPECT(TIBase::getState(id) == Alive);
+            strong.clear();
+            BEAST_EXPECT(TIBase::getState(id) == Deleted);
+
+            b = makeSharedIntrusive<TIBase>();
+            id = b->id;
+            BEAST_EXPECT(TIBase::getState(id) == Alive);
+            BEAST_EXPECT(b->useCount() == 1);
+            for (int i = 0; i < 10; ++i)
+            {
+                weak.emplace_back(b);
+                BEAST_EXPECT(b->useCount() == 1);
+            }
+            BEAST_EXPECT(TIBase::getState(id) == Alive);
+            weak.resize(weak.size() - 1);
+            BEAST_EXPECT(TIBase::getState(id) == Alive);
+            b.reset();
+            BEAST_EXPECT(TIBase::getState(id) == PartiallyDeleted);
+            while (!weak.empty())
+            {
+                weak.resize(weak.size() - 1);
+                if (!weak.empty())
+                    BEAST_EXPECT(TIBase::getState(id) == PartiallyDeleted);
+            }
+            BEAST_EXPECT(TIBase::getState(id) == Deleted);
+        }
+        {
+            TIBase::ResetStatesGuard const rsg{true};
+
+            using enum TrackedState;
+            auto b = makeSharedIntrusive<TIBase>();
+            auto id = b->id;
+            BEAST_EXPECT(TIBase::getState(id) == Alive);
+            WeakIntrusive<TIBase> w{b};
+            BEAST_EXPECT(TIBase::getState(id) == Alive);
+            auto s = w.lock();
+            BEAST_EXPECT(s && s->useCount() == 2);
+            b.reset();
+            BEAST_EXPECT(TIBase::getState(id) == Alive);
+            BEAST_EXPECT(s && s->useCount() == 1);
+            s.reset();
+            BEAST_EXPECT(TIBase::getState(id) == PartiallyDeleted);
+            BEAST_EXPECT(w.expired());
+            s = w.lock();
+            // Cannot convert a weak pointer to a strong pointer if object is
+            // already partially deleted
+            BEAST_EXPECT(!s);
+            w.reset();
+            BEAST_EXPECT(TIBase::getState(id) == Deleted);
+        }
+        {
+            TIBase::ResetStatesGuard const rsg{true};
+
+            using enum TrackedState;
+            using swu = SharedWeakUnion<TIBase>;
+            swu b = makeSharedIntrusive<TIBase>();
+            BEAST_EXPECT(b.isStrong() && b.useCount() == 1);
+            auto id = b.get()->id;
+            BEAST_EXPECT(TIBase::getState(id) == Alive);
+            swu w = b;
+            BEAST_EXPECT(TIBase::getState(id) == Alive);
+            BEAST_EXPECT(w.isStrong() && b.useCount() == 2);
+            w.convertToWeak();
+            BEAST_EXPECT(w.isWeak() && b.useCount() == 1);
+            swu s = w;
+            BEAST_EXPECT(s.isWeak() && b.useCount() == 1);
+            s.convertToStrong();
+            BEAST_EXPECT(s.isStrong() && b.useCount() == 2);
+            b.reset();
+            BEAST_EXPECT(TIBase::getState(id) == Alive);
+            BEAST_EXPECT(s.useCount() == 1);
+            BEAST_EXPECT(!w.expired());
+            s.reset();
+            BEAST_EXPECT(TIBase::getState(id) == PartiallyDeleted);
+            BEAST_EXPECT(w.expired());
+            w.convertToStrong();
+            // Cannot convert a weak pointer to a strong pointer if object is
+            // already partially deleted
+            BEAST_EXPECT(w.isWeak());
+            w.reset();
+            BEAST_EXPECT(TIBase::getState(id) == Deleted);
+        }
+        {
+            // Testing SharedWeakUnion assignment operator
+
+            TIBase::ResetStatesGuard const rsg{true};
+
+            auto strong1 = makeSharedIntrusive<TIBase>();
+            auto strong2 = makeSharedIntrusive<TIBase>();
+
+            auto id1 = strong1->id;
+            auto id2 = strong2->id;
+
+            BEAST_EXPECT(id1 != id2);
+
+            SharedWeakUnion<TIBase> union1 = strong1;
+            SharedWeakUnion<TIBase> union2 = strong2;
+
+            BEAST_EXPECT(union1.isStrong());
+            BEAST_EXPECT(union2.isStrong());
+            BEAST_EXPECT(union1.get() == strong1.get());
+            BEAST_EXPECT(union2.get() == strong2.get());
+
+            // 1) Normal assignment: explicitly calls SharedWeakUnion assignment
+            union1 = union2;
+            BEAST_EXPECT(union1.isStrong());
+            BEAST_EXPECT(union2.isStrong());
+            BEAST_EXPECT(union1.get() == union2.get());
+            BEAST_EXPECT(TIBase::getState(id1) == TrackedState::Alive);
+            BEAST_EXPECT(TIBase::getState(id2) == TrackedState::Alive);
+
+            // 2) Test self-assignment
+            BEAST_EXPECT(union1.isStrong());
+            BEAST_EXPECT(TIBase::getState(id1) == TrackedState::Alive);
+            int const initialRefCount = strong1->useCount();
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wself-assign-overloaded"
+            union1 = union1;  // Self-assignment
+#pragma clang diagnostic pop
+            BEAST_EXPECT(union1.isStrong());
+            BEAST_EXPECT(TIBase::getState(id1) == TrackedState::Alive);
+            BEAST_EXPECT(strong1->useCount() == initialRefCount);
+
+            // 3) Test assignment from null union pointer
+            union1 = SharedWeakUnion<TIBase>();
+            BEAST_EXPECT(union1.get() == nullptr);
+
+            // 4) Test assignment to expired union pointer
+            strong2.reset();
+            union2.reset();
+            union1 = union2;
+            BEAST_EXPECT(union1.get() == nullptr);
+            BEAST_EXPECT(TIBase::getState(id2) == TrackedState::Deleted);
+        }
+    }
+
+    void
+    testPartialDelete()
+    {
+        testcase("Partial Delete");
+
+        // This test creates two threads. One with a strong pointer and one
+        // with a weak pointer. The strong pointer is reset while the weak
+        // pointer still holds a reference, triggering a partial delete.
+        // While the partial delete function runs (a sleep is inserted) the
+        // weak pointer is reset. The destructor should wait to run until
+        // after the partial delete function has completed running.
+
+        using enum TrackedState;
+
+        TIBase::ResetStatesGuard const rsg{true};
+
+        auto strong = makeSharedIntrusive<TIBase>();
+        WeakIntrusive<TIBase> weak{strong};
+        bool destructorRan = false;
+        bool partialDeleteRan = false;
+        std::latch partialDeleteStartedSyncPoint{2};
+        strong->tracingCallback = [&](TrackedState cur, std::optional<TrackedState> next) {
+            using enum TrackedState;
+            if (next == DeletedStarted)
+            {
+                // strong goes out of scope while weak is still in scope
+                // This checks that partialDelete has run to completion
+                // before the destructor is called. A sleep is inserted
+                // inside the partial delete to make sure the destructor is
+                // given an opportunity to run during partial delete.
+                BEAST_EXPECT(cur == PartiallyDeleted);
+            }
+            if (next == PartiallyDeletedStarted)
+            {
+                partialDeleteStartedSyncPoint.arrive_and_wait();
+                using namespace std::chrono_literals;
+                // Sleep and let the weak pointer go out of scope,
+                // potentially triggering a destructor while partial delete
+                // is running. The test is to make sure that doesn't happen.
+                std::this_thread::sleep_for(800ms);
+            }
+            if (next == PartiallyDeleted)
+            {
+                BEAST_EXPECT(!partialDeleteRan && !destructorRan);
+                partialDeleteRan = true;
+            }
+            if (next == Deleted)
+            {
+                BEAST_EXPECT(!destructorRan);
+                destructorRan = true;
+            }
+        };
+        std::thread t1{[&] {
+            partialDeleteStartedSyncPoint.arrive_and_wait();
+            weak.reset();  // Trigger a full delete as soon as the partial
+                           // delete starts
+        }};
+        std::thread t2{[&] {
+            strong.reset();  // Trigger a partial delete
+        }};
+        t1.join();
+        t2.join();
+
+        BEAST_EXPECT(destructorRan && partialDeleteRan);
+    }
+
+    void
+    testDestructor()
+    {
+        testcase("Destructor");
+
+        // This test creates two threads. One with a strong pointer and one
+        // with a weak pointer. The weak pointer is reset while the strong
+        // pointer still holds a reference. Then the strong pointer is
+        // reset. Only the destructor should run. The partial destructor
+        // should not be called. Since the weak reset runs to completion
+        // before the strong pointer is reset, threading doesn't add much to
+        // this test, but there is no harm in keeping it.
+
+        using enum TrackedState;
+
+        TIBase::ResetStatesGuard const rsg{true};
+
+        auto strong = makeSharedIntrusive<TIBase>();
+        WeakIntrusive<TIBase> weak{strong};
+        bool destructorRan = false;
+        bool partialDeleteRan = false;
+        std::latch weakResetSyncPoint{2};
+        strong->tracingCallback = [&](TrackedState cur, std::optional<TrackedState> next) {
+            using enum TrackedState;
+            if (next == PartiallyDeleted)
+            {
+                BEAST_EXPECT(!partialDeleteRan && !destructorRan);
+                partialDeleteRan = true;
+            }
+            if (next == Deleted)
+            {
+                BEAST_EXPECT(!destructorRan);
+                destructorRan = true;
+            }
+        };
+        std::thread t1{[&] {
+            weak.reset();
+            weakResetSyncPoint.arrive_and_wait();
+        }};
+        std::thread t2{[&] {
+            weakResetSyncPoint.arrive_and_wait();
+            strong.reset();  // Trigger a partial delete
+        }};
+        t1.join();
+        t2.join();
+
+        BEAST_EXPECT(destructorRan && !partialDeleteRan);
+    }
+
+    void
+    testMultithreadedClearMixedVariant()
+    {
+        testcase("Multithreaded Clear Mixed Variant");
+
+        // This test creates and destroys many strong and weak pointers in a
+        // loop. There is a random mix of strong and weak pointers stored in
+        // a vector (held as a variant). Both threads clear all the pointers
+        // and check that the invariants hold.
+
+        using enum TrackedState;
+        TIBase::ResetStatesGuard const rsg{true};
+
+        std::atomic<int> destructionState{0};
+        // returns destructorRan and partialDestructorRan (in that order)
+        auto getDestructorState = [&]() -> std::pair<bool, bool> {
+            int const s = destructionState.load(std::memory_order_relaxed);
+            return {(s & 1) != 0, (s & 2) != 0};
+        };
+        auto setDestructorRan = [&]() -> void {
+            destructionState.fetch_or(1, std::memory_order_acq_rel);
+        };
+        auto setPartialDeleteRan = [&]() -> void {
+            destructionState.fetch_or(2, std::memory_order_acq_rel);
+        };
+        auto tracingCallback = [&](TrackedState cur, std::optional<TrackedState> next) {
+            using enum TrackedState;
+            auto [destructorRan, partialDeleteRan] = getDestructorState();
+            if (next == PartiallyDeleted)
+            {
+                BEAST_EXPECT(!partialDeleteRan && !destructorRan);
+                setPartialDeleteRan();
+            }
+            if (next == Deleted)
+            {
+                BEAST_EXPECT(!destructorRan);
+                setDestructorRan();
+            }
+        };
+        auto createVecOfPointers = [&](auto const& toClone, std::default_random_engine& eng)
+            -> std::vector<std::variant<SharedIntrusive<TIBase>, WeakIntrusive<TIBase>>> {
+            std::vector<std::variant<SharedIntrusive<TIBase>, WeakIntrusive<TIBase>>> result;
+            std::uniform_int_distribution<> toCreateDist(4, 64);
+            std::uniform_int_distribution<> isStrongDist(0, 1);
+            auto numToCreate = toCreateDist(eng);
+            result.reserve(numToCreate);
+            for (int i = 0; i < numToCreate; ++i)
+            {
+                if (isStrongDist(eng))
+                {
+                    result.emplace_back(SharedIntrusive<TIBase>(toClone));
+                }
+                else
+                {
+                    result.emplace_back(WeakIntrusive<TIBase>(toClone));
+                }
+            }
+            return result;
+        };
+        static constexpr int kLoopIters = 2 * 1024;
+        static constexpr int kNumThreads = 16;
+        std::vector<SharedIntrusive<TIBase>> toClone;
+        Barrier loopStartSyncPoint{kNumThreads};
+        Barrier postCreateToCloneSyncPoint{kNumThreads};
+        Barrier postCreateVecOfPointersSyncPoint{kNumThreads};
+        auto engines = [&]() -> std::vector<std::default_random_engine> {
+            std::random_device rd;
+            std::vector<std::default_random_engine> result;
+            result.reserve(kNumThreads);
+            for (int i = 0; i < kNumThreads; ++i)
+                result.emplace_back(rd());
+            return result;
+        }();
+
+        // cloneAndDestroy clones the strong pointer into a vector of mixed
+        // strong and weak pointers and destroys them all at once.
+        // threadId==0 is special.
+        auto cloneAndDestroy = [&](int threadId) {
+            for (int i = 0; i < kLoopIters; ++i)
+            {
+                // ------ Sync Point ------
+                loopStartSyncPoint.arriveAndWait();
+
+                // only thread 0 should reset the state
+                std::optional<TIBase::ResetStatesGuard> rsg;
+                if (threadId == 0)
+                {
+                    // Thread 0 is the genesis thread. It creates the strong
+                    // pointers to be cloned by the other threads. This
+                    // thread will also check that the destructor ran and
+                    // clear the temporary variables.
+
+                    rsg.emplace(false);
+                    auto [destructorRan, partialDeleteRan] = getDestructorState();
+                    BEAST_EXPECT(!i || destructorRan);
+                    destructionState.store(0, std::memory_order_release);
+
+                    toClone.clear();
+                    toClone.resize(kNumThreads);
+                    auto strong = makeSharedIntrusive<TIBase>();
+                    strong->tracingCallback = tracingCallback;
+                    std::ranges::fill(toClone, strong);
+                }
+
+                // ------ Sync Point ------
+                postCreateToCloneSyncPoint.arriveAndWait();
+
+                auto v = createVecOfPointers(toClone[threadId], engines[threadId]);
+                toClone[threadId].reset();
+
+                // ------ Sync Point ------
+                postCreateVecOfPointersSyncPoint.arriveAndWait();
+
+                v.clear();
+            }
+        };
+        std::vector<std::thread> threads;
+        threads.reserve(kNumThreads);
+        for (int i = 0; i < kNumThreads; ++i)
+        {
+            threads.emplace_back(cloneAndDestroy, i);
+        }
+        for (int i = 0; i < kNumThreads; ++i)
+        {
+            threads[i].join();
+        }
+    }
+
+    void
+    testMultithreadedClearMixedUnion()
+    {
+        testcase("Multithreaded Clear Mixed Union");
+
+        // This test creates and destroys many SharedWeak pointers in a
+        // loop. All the pointers start as strong and a loop randomly
+        // convert them between strong and weak pointers. Both threads clear
+        // all the pointers and check that the invariants hold.
+        //
+        // Note: This test also differs from the test above in that the pointers
+        // randomly change from strong to weak and from weak to strong in a
+        // loop. This can't be done in the variant test above because variant is
+        // not thread safe while the SharedWeakUnion is thread safe.
+
+        using enum TrackedState;
+
+        TIBase::ResetStatesGuard const rsg{true};
+
+        std::atomic<int> destructionState{0};
+        // returns destructorRan and partialDestructorRan (in that order)
+        auto getDestructorState = [&]() -> std::pair<bool, bool> {
+            int const s = destructionState.load(std::memory_order_relaxed);
+            return {(s & 1) != 0, (s & 2) != 0};
+        };
+        auto setDestructorRan = [&]() -> void {
+            destructionState.fetch_or(1, std::memory_order_acq_rel);
+        };
+        auto setPartialDeleteRan = [&]() -> void {
+            destructionState.fetch_or(2, std::memory_order_acq_rel);
+        };
+        auto tracingCallback = [&](TrackedState cur, std::optional<TrackedState> next) {
+            using enum TrackedState;
+            auto [destructorRan, partialDeleteRan] = getDestructorState();
+            if (next == PartiallyDeleted)
+            {
+                BEAST_EXPECT(!partialDeleteRan && !destructorRan);
+                setPartialDeleteRan();
+            }
+            if (next == Deleted)
+            {
+                BEAST_EXPECT(!destructorRan);
+                setDestructorRan();
+            }
+        };
+        auto createVecOfPointers =
+            [&](auto const& toClone,
+                std::default_random_engine& eng) -> std::vector<SharedWeakUnion<TIBase>> {
+            std::vector<SharedWeakUnion<TIBase>> result;
+            std::uniform_int_distribution<> toCreateDist(4, 64);
+            auto numToCreate = toCreateDist(eng);
+            result.reserve(numToCreate);
+            for (int i = 0; i < numToCreate; ++i)
+                result.emplace_back(SharedIntrusive<TIBase>(toClone));
+            return result;
+        };
+        static constexpr int kLoopIters = 2 * 1024;
+        static constexpr int kFlipPointersLoopIters = 256;
+        static constexpr int kNumThreads = 16;
+        std::vector<SharedIntrusive<TIBase>> toClone;
+        Barrier loopStartSyncPoint{kNumThreads};
+        Barrier postCreateToCloneSyncPoint{kNumThreads};
+        Barrier postCreateVecOfPointersSyncPoint{kNumThreads};
+        Barrier postFlipPointersLoopSyncPoint{kNumThreads};
+        auto engines = [&]() -> std::vector<std::default_random_engine> {
+            std::random_device rd;
+            std::vector<std::default_random_engine> result;
+            result.reserve(kNumThreads);
+            for (int i = 0; i < kNumThreads; ++i)
+                result.emplace_back(rd());
+            return result;
+        }();
+
+        // cloneAndDestroy clones the strong pointer into a vector of
+        // mixed strong and weak pointers, runs a loop that randomly
+        // changes strong pointers to weak pointers,  and destroys them
+        // all at once.
+        auto cloneAndDestroy = [&](int threadId) {
+            for (int i = 0; i < kLoopIters; ++i)
+            {
+                // ------ Sync Point ------
+                loopStartSyncPoint.arriveAndWait();
+
+                // only thread 0 should reset the state
+                std::optional<TIBase::ResetStatesGuard> rsg;
+                if (threadId == 0)
+                {
+                    // threadId 0 is the genesis thread. It creates the
+                    // strong point to be cloned by the other threads. This
+                    // thread will also check that the destructor ran and
+                    // clear the temporary variables.
+                    rsg.emplace(false);
+                    auto [destructorRan, partialDeleteRan] = getDestructorState();
+                    BEAST_EXPECT(!i || destructorRan);
+                    destructionState.store(0, std::memory_order_release);
+
+                    toClone.clear();
+                    toClone.resize(kNumThreads);
+                    auto strong = makeSharedIntrusive<TIBase>();
+                    strong->tracingCallback = tracingCallback;
+                    std::ranges::fill(toClone, strong);
+                }
+
+                // ------ Sync Point ------
+                postCreateToCloneSyncPoint.arriveAndWait();
+
+                auto v = createVecOfPointers(toClone[threadId], engines[threadId]);
+                toClone[threadId].reset();
+
+                // ------ Sync Point ------
+                postCreateVecOfPointersSyncPoint.arriveAndWait();
+
+                std::uniform_int_distribution<> isStrongDist(0, 1);
+                for (int f = 0; f < kFlipPointersLoopIters; ++f)
+                {
+                    for (auto& p : v)
+                    {
+                        if (isStrongDist(engines[threadId]))
+                        {
+                            p.convertToStrong();
+                        }
+                        else
+                        {
+                            p.convertToWeak();
+                        }
+                    }
+                }
+
+                // ------ Sync Point ------
+                postFlipPointersLoopSyncPoint.arriveAndWait();
+
+                v.clear();
+            }
+        };
+        std::vector<std::thread> threads;
+        threads.reserve(kNumThreads);
+        for (int i = 0; i < kNumThreads; ++i)
+        {
+            threads.emplace_back(cloneAndDestroy, i);
+        }
+        for (int i = 0; i < kNumThreads; ++i)
+        {
+            threads[i].join();
+        }
+    }
+
+    void
+    testMultithreadedLockingWeak()
+    {
+        testcase("Multithreaded Locking Weak");
+
+        // This test creates a single shared atomic pointer that multiple thread
+        // create weak pointers from. The threads then lock the weak pointers.
+        // Both threads clear all the pointers and check that the invariants
+        // hold.
+
+        using enum TrackedState;
+
+        TIBase::ResetStatesGuard const rsg{true};
+
+        std::atomic<int> destructionState{0};
+        // returns destructorRan and partialDestructorRan (in that order)
+        auto getDestructorState = [&]() -> std::pair<bool, bool> {
+            int const s = destructionState.load(std::memory_order_relaxed);
+            return {(s & 1) != 0, (s & 2) != 0};
+        };
+        auto setDestructorRan = [&]() -> void {
+            destructionState.fetch_or(1, std::memory_order_acq_rel);
+        };
+        auto setPartialDeleteRan = [&]() -> void {
+            destructionState.fetch_or(2, std::memory_order_acq_rel);
+        };
+        auto tracingCallback = [&](TrackedState cur, std::optional<TrackedState> next) {
+            using enum TrackedState;
+            auto [destructorRan, partialDeleteRan] = getDestructorState();
+            if (next == PartiallyDeleted)
+            {
+                BEAST_EXPECT(!partialDeleteRan && !destructorRan);
+                setPartialDeleteRan();
+            }
+            if (next == Deleted)
+            {
+                BEAST_EXPECT(!destructorRan);
+                setDestructorRan();
+            }
+        };
+
+        static constexpr int kLoopIters = 2 * 1024;
+        static constexpr int kLockWeakLoopIters = 256;
+        static constexpr int kNumThreads = 16;
+        std::vector<SharedIntrusive<TIBase>> toLock;
+        Barrier loopStartSyncPoint{kNumThreads};
+        Barrier postCreateToLockSyncPoint{kNumThreads};
+        Barrier postLockWeakLoopSyncPoint{kNumThreads};
+
+        // lockAndDestroy creates weak pointers from the strong pointer
+        // and runs a loop that locks the weak pointer. At the end of the loop
+        // all the pointers are destroyed all at once.
+        auto lockAndDestroy = [&](int threadId) {
+            for (int i = 0; i < kLoopIters; ++i)
+            {
+                // ------ Sync Point ------
+                loopStartSyncPoint.arriveAndWait();
+
+                // only thread 0 should reset the state
+                std::optional<TIBase::ResetStatesGuard> rsg;
+                if (threadId == 0)
+                {
+                    // threadId 0 is the genesis thread. It creates the
+                    // strong point to be locked by the other threads. This
+                    // thread will also check that the destructor ran and
+                    // clear the temporary variables.
+                    rsg.emplace(false);
+                    auto [destructorRan, partialDeleteRan] = getDestructorState();
+                    BEAST_EXPECT(!i || destructorRan);
+                    destructionState.store(0, std::memory_order_release);
+
+                    toLock.clear();
+                    toLock.resize(kNumThreads);
+                    auto strong = makeSharedIntrusive<TIBase>();
+                    strong->tracingCallback = tracingCallback;
+                    std::ranges::fill(toLock, strong);
+                }
+
+                // ------ Sync Point ------
+                postCreateToLockSyncPoint.arriveAndWait();
+
+                // Multiple threads all create a weak pointer from the same
+                // strong pointer
+                WeakIntrusive const weak{toLock[threadId]};
+                for (int wi = 0; wi < kLockWeakLoopIters; ++wi)
+                {
+                    BEAST_EXPECT(!weak.expired());
+                    auto strong = weak.lock();
+                    BEAST_EXPECT(strong);
+                }
+
+                // ------ Sync Point ------
+                postLockWeakLoopSyncPoint.arriveAndWait();
+
+                toLock[threadId].reset();
+            }
+        };
+        std::vector<std::thread> threads;
+        threads.reserve(kNumThreads);
+        for (int i = 0; i < kNumThreads; ++i)
+        {
+            threads.emplace_back(lockAndDestroy, i);
+        }
+        for (int i = 0; i < kNumThreads; ++i)
+        {
+            threads[i].join();
+        }
+    }
+
+    void
+    run() override
+    {
+        testBasics();
+        testPartialDelete();
+        testDestructor();
+        testMultithreadedClearMixedVariant();
+        testMultithreadedClearMixedUnion();
+        testMultithreadedLockingWeak();
+    }
+};  // namespace tests
+
+BEAST_DEFINE_TESTSUITE(IntrusiveShared, basics, xrpl);
+}  // namespace xrpl::tests
diff --git a/src/test/basics/KeyCache_test.cpp b/src/test/basics/KeyCache_test.cpp
new file mode 100644
index 0000000000..e83ae4c277
--- /dev/null
+++ b/src/test/basics/KeyCache_test.cpp
@@ -0,0 +1,82 @@
+#include <test/unit_test/SuiteJournal.h>
+
+#include <xrpl/basics/TaggedCache.h>
+#include <xrpl/basics/TaggedCache.ipp>  // IWYU pragma: keep
+#include <xrpl/basics/chrono.h>
+#include <xrpl/beast/unit_test/suite.h>
+#include <xrpl/protocol/Protocol.h>
+
+#include <string>
+
+namespace xrpl {
+
+class KeyCache_test : public beast::unit_test::Suite
+{
+public:
+    void
+    run() override
+    {
+        using namespace std::chrono_literals;
+        TestStopwatch clock;
+        clock.set(0);
+
+        using Key = std::string;
+        using Cache = TaggedCache<Key, int, true>;
+
+        test::SuiteJournal j("KeyCacheTest", *this);
+
+        // Insert an item, retrieve it, and age it so it gets purged.
+        {
+            Cache c("test", LedgerIndex(1), 2s, clock, j);
+
+            BEAST_EXPECT(c.size() == 0);
+            BEAST_EXPECT(c.insert("one"));
+            BEAST_EXPECT(!c.insert("one"));
+            BEAST_EXPECT(c.size() == 1);
+            BEAST_EXPECT(c.touchIfExists("one"));
+            ++clock;
+            c.sweep();
+            BEAST_EXPECT(c.size() == 1);
+            ++clock;
+            c.sweep();
+            BEAST_EXPECT(c.size() == 0);
+            BEAST_EXPECT(!c.touchIfExists("one"));
+        }
+
+        // Insert two items, have one expire
+        {
+            Cache c("test", LedgerIndex(2), 2s, clock, j);
+
+            BEAST_EXPECT(c.insert("one"));
+            BEAST_EXPECT(c.size() == 1);
+            BEAST_EXPECT(c.insert("two"));
+            BEAST_EXPECT(c.size() == 2);
+            ++clock;
+            c.sweep();
+            BEAST_EXPECT(c.size() == 2);
+            BEAST_EXPECT(c.touchIfExists("two"));
+            ++clock;
+            c.sweep();
+            BEAST_EXPECT(c.size() == 1);
+        }
+
+        // Insert three items (1 over limit), sweep
+        {
+            Cache c("test", LedgerIndex(2), 3s, clock, j);
+
+            BEAST_EXPECT(c.insert("one"));
+            ++clock;
+            BEAST_EXPECT(c.insert("two"));
+            ++clock;
+            BEAST_EXPECT(c.insert("three"));
+            ++clock;
+            BEAST_EXPECT(c.size() == 3);
+            c.sweep();
+            BEAST_EXPECT(c.size() < 3);
+        }
+    }
+};
+
+BEAST_DEFINE_TESTSUITE(KeyCache, basics, xrpl);
+
+}  // namespace xrpl
diff --git a/src/tests/libxrpl/basics/Number.cpp b/src/test/basics/Number_test.cpp
similarity index 73%
rename from src/tests/libxrpl/basics/Number.cpp
rename to src/test/basics/Number_test.cpp
index e8c4e4209f..2d2745de14 100644
--- a/src/tests/libxrpl/basics/Number.cpp
+++ b/src/test/basics/Number_test.cpp
@@ -1,5 +1,5 @@
 #include <xrpl/basics/Number.h>
-
+#include <xrpl/beast/unit_test/suite.h>
 #include <xrpl/protocol/IOUAmount.h>
 #include <xrpl/protocol/Issue.h>
 #include <xrpl/protocol/STAmount.h>
@@ -10,8 +10,6 @@
 #include <boost/multiprecision/cpp_dec_float.hpp>
 #include <boost/multiprecision/number.hpp>
 
-#include <gtest/gtest.h>
-
 #include <algorithm>
 #include <array>
 #include <cctype>
@@ -19,7 +17,6 @@
 #include <iomanip>
 #include <limits>
 #include <map>
-#include <ranges>
 #include <sstream>
 #include <stdexcept>
 #include <string>
@@ -29,81 +26,82 @@
 
 namespace xrpl {
 
-using BigInt = boost::multiprecision::cpp_int;
-using Dec = boost::multiprecision::cpp_dec_float_50;
-
-static std::string
-fmt(BigInt const& value)
+class Number_test : public beast::unit_test::Suite
 {
-    auto s = to_string(value);
-    std::string out;
-    int count = 0;
-    for (char const& ch : std::views::reverse(s))
-    {
-        if (count != 0 && count % 3 == 0 && (isdigit(ch) != 0))
-            out.insert(out.begin(), '_');
-        out.insert(out.begin(), ch);
-        ++count;
-    }
-    return out;
-}
+    using BigInt = boost::multiprecision::cpp_int;
 
-template <class T = Dec>
-static T
-pow10(int n)
-{
-    if (n == 0)
-        return 1;
-    if (n == 1)
-        return 10;
-
-    if (n > 1)
+    static std::string
+    fmt(BigInt const& value)
     {
-        auto r = pow10<T>(n / 2);
-        r *= r;
-        if (n % 2 != 0)
-            r *= 10;
-        return r;
+        auto s = to_string(value);
+        std::string out;
+        int count = 0;
+        for (auto it = s.rbegin(); it != s.rend(); ++it)
+        {
+            if (count != 0 && count % 3 == 0 && (isdigit(*it) != 0))
+                out.insert(out.begin(), '_');
+            out.insert(out.begin(), *it);
+            ++count;
+        }
+        return out;
     }
 
-    T p = 1;
-    p /= pow10<T>(-n);
-    return p;
-}
+    using dec = boost::multiprecision::cpp_dec_float_50;
 
-static std::string
-fmt(Dec const& value)
-{
-    std::ostringstream os;
-    os << std::setprecision(40) << value;
-    return os.str();
-}
-
-TEST(NumberTest, zero)
-{
-    for (auto const mantissaScale : MantissaRange::getAllScales())
+    template <class T = dec>
+    static T
+    pow10(int n)
     {
-        NumberMantissaScaleGuard const sg(mantissaScale);
+        if (n == 0)
+            return 1;
+        if (n == 1)
+            return 10;
+
+        if (n > 1)
+        {
+            auto r = pow10<T>(n / 2);
+            r *= r;
+            if (n % 2 != 0)
+                r *= 10;
+            return r;
+        }
+
+        // n < 0
+        T p = 1;
+        p /= pow10<T>(-n);
+        return p;
+    }
+
+    static std::string
+    fmt(dec const& v)
+    {
+        std::ostringstream os;
+        os << std::setprecision(40) << v;
+        return os.str();
+    }
+
+public:
+    void
+    testZero()
+    {
+        testcase << "zero " << to_string(Number::getMantissaScale());
 
         for (Number const& z : {Number{0, 0}, Number{0}})
         {
-            EXPECT_EQ(z.mantissa(), 0);
-            EXPECT_EQ(z.exponent(), Number{}.exponent());
+            BEAST_EXPECT(z.mantissa() == 0);
+            BEAST_EXPECT(z.exponent() == Number{}.exponent());
 
-            EXPECT_EQ((z + z), z);
-            EXPECT_EQ((z - z), z);
-            EXPECT_EQ(z, -z);
+            BEAST_EXPECT((z + z) == z);
+            BEAST_EXPECT((z - z) == z);
+            BEAST_EXPECT(z == -z);
         }
     }
-}
 
-TEST(NumberTest, limits)
-{
-    for (auto const mantissaScale : MantissaRange::getAllScales())
+    void
+    testLimits()
     {
-        NumberMantissaScaleGuard const sg(mantissaScale);
-
         auto const scale = Number::getMantissaScale();
+        testcase << "test_limits " << to_string(scale);
         bool caught = false;
         auto const minMantissa = Number::minMantissa();
         try
@@ -115,13 +113,13 @@ TEST(NumberTest, limits)
         {
             caught = true;
         }
-        EXPECT_TRUE(caught);
+        BEAST_EXPECT(caught);
 
-        auto test = [](auto const& x, auto const& y, int line) {
+        auto test = [this](auto const& x, auto const& y, int line) {
             auto const result = x == y;
             std::stringstream ss;
             ss << x << " == " << y << " -> " << (result ? "true" : "false");
-            EXPECT_TRUE(result) << ss.str() << " (" << __FILE__ << ":" << line << ")";
+            expect(result, ss.str(), __FILE__, line);
         };
 
         test(
@@ -165,17 +163,14 @@ TEST(NumberTest, limits)
         {
             caught = true;
         }
-        EXPECT_TRUE(caught);
+        BEAST_EXPECT(caught);
     }
-}
 
-TEST(NumberTest, add)
-{
-    for (auto const mantissaScale : MantissaRange::getAllScales())
+    void
+    testAdd()
     {
-        NumberMantissaScaleGuard const sg(mantissaScale);
-
         auto const scale = Number::getMantissaScale();
+        testcase << "test_add " << to_string(scale);
 
         using Case = std::tuple<Number, Number, Number>;
         auto const cSmall = std::to_array<Case>(
@@ -254,11 +249,11 @@ TEST(NumberTest, add)
                     Number{2, 19},
                 },
                 {
-                    // Does not round. Mantissas are going to be > maxRep, so if
+                    // Does not round. Mantissas are going to be > kMaxRep, so if
                     // added together as uint64_t's, the result will overflow.
                     // With addition using uint128_t, there's no problem. After
                     // normalizing, the resulting mantissa ends up less than
-                    // maxRep.
+                    // kMaxRep.
                     Number{false, 9'999'999'999'999'999'990ULL, 0, Number::Normalized{}},
                     Number{false, 9'999'999'999'999'999'990ULL, 0, Number::Normalized{}},
                     Number{false, 1'999'999'999'999'999'998ULL, 1, Number::Normalized{}},
@@ -270,13 +265,13 @@ TEST(NumberTest, add)
         auto const cLargeCorrected = std::to_array<Case>({
             {Number{Number::kMaxRep}, Number{6, -1}, Number{(Number::kMaxRep / 10) + 1, 1}},
         });
-        auto test = [](auto const& c) {
+        auto test = [this](auto const& c) {
             for (auto const& [x, y, z] : c)
             {
                 auto const result = x + y;
                 std::stringstream ss;
                 ss << x << " + " << y << " = " << result << ". Expected: " << z;
-                EXPECT_EQ(result, z) << ss.str();
+                BEAST_EXPECTS(result == z, ss.str());
             }
         };
         if (scale == MantissaRange::MantissaScale::Small)
@@ -306,18 +301,15 @@ TEST(NumberTest, add)
             {
                 caught = true;
             }
-            EXPECT_TRUE(caught);
+            BEAST_EXPECT(caught);
         }
     }
-}
 
-TEST(NumberTest, sub)
-{
-    for (auto const mantissaScale : MantissaRange::getAllScales())
+    void
+    testSub()
     {
-        NumberMantissaScaleGuard const sg(mantissaScale);
-
         auto const scale = Number::getMantissaScale();
+        testcase << "test_sub " << to_string(scale);
 
         using Case = std::tuple<Number, Number, Number>;
         auto const cSmall = std::to_array<Case>(
@@ -377,13 +369,13 @@ TEST(NumberTest, sub)
                  Number{Number::kMaxRep}},
                 {power(2, 63), Number{3, 0}, Number{Number::kMaxRep}},
             });
-        auto test = [](auto const& c) {
+        auto test = [this](auto const& c) {
             for (auto const& [x, y, z] : c)
             {
                 auto const result = x - y;
                 std::stringstream ss;
                 ss << x << " - " << y << " = " << result << ". Expected: " << z;
-                EXPECT_EQ(result, z) << ss.str();
+                BEAST_EXPECTS(result == z, ss.str());
             }
         };
         if (scale == MantissaRange::MantissaScale::Small)
@@ -395,24 +387,21 @@ TEST(NumberTest, sub)
             test(cLarge);
         }
     }
-}
 
-TEST(NumberTest, mul)
-{
-    for (auto const mantissaScale : MantissaRange::getAllScales())
+    void
+    testMul()
     {
-        NumberMantissaScaleGuard const sg(mantissaScale);
-
         auto const scale = Number::getMantissaScale();
+        testcase << "test_mul " << to_string(scale);
 
         using Case = std::tuple<Number, Number, Number>;
-        auto test = [](auto const& c) {
+        auto test = [this](auto const& c) {
             for (auto const& [x, y, z] : c)
             {
                 auto const result = x * y;
                 std::stringstream ss;
                 ss << x << " * " << y << " = " << result << ". Expected: " << z;
-                EXPECT_EQ(result, z) << ss.str();
+                BEAST_EXPECTS(result == z, ss.str());
             }
         };
         auto tests = [&](auto const& cSmall, auto const& cLarge) {
@@ -494,6 +483,7 @@ TEST(NumberTest, mul)
             tests(cSmall, cLarge);
         }
         Number::setround(Number::RoundingMode::TowardsZero);
+        testcase << "test_mul " << to_string(Number::getMantissaScale()) << " towards_zero";
         {
             auto const cSmall = std::to_array<Case>(
                 {{Number{7}, Number{8}, Number{56}},
@@ -560,6 +550,7 @@ TEST(NumberTest, mul)
             tests(cSmall, cLarge);
         }
         Number::setround(Number::RoundingMode::Downward);
+        testcase << "test_mul " << to_string(Number::getMantissaScale()) << " downward";
         {
             auto const cSmall = std::to_array<Case>(
                 {{Number{7}, Number{8}, Number{56}},
@@ -626,6 +617,7 @@ TEST(NumberTest, mul)
             tests(cSmall, cLarge);
         }
         Number::setround(Number::RoundingMode::Upward);
+        testcase << "test_mul " << to_string(Number::getMantissaScale()) << " upward";
         {
             auto const cSmall = std::to_array<Case>(
                 {{Number{7}, Number{8}, Number{56}},
@@ -691,6 +683,7 @@ TEST(NumberTest, mul)
                 });
             tests(cSmall, cLarge);
         }
+        testcase << "test_mul " << to_string(Number::getMantissaScale()) << " overflow";
         {
             bool caught = false;
             try
@@ -702,27 +695,24 @@ TEST(NumberTest, mul)
             {
                 caught = true;
             }
-            EXPECT_TRUE(caught);
+            BEAST_EXPECT(caught);
         }
     }
-}
 
-TEST(NumberTest, div)
-{
-    for (auto const mantissaScale : MantissaRange::getAllScales())
+    void
+    testDiv()
     {
-        NumberMantissaScaleGuard const sg(mantissaScale);
-
         auto const scale = Number::getMantissaScale();
+        testcase << "test_div " << to_string(scale);
 
         using Case = std::tuple<Number, Number, Number>;
-        auto test = [](auto const& c) {
+        auto test = [this](auto const& c) {
             for (auto const& [x, y, z] : c)
             {
                 auto const result = x / y;
                 std::stringstream ss;
                 ss << x << " / " << y << " = " << result << ". Expected: " << z;
-                EXPECT_EQ(result, z) << ss.str();
+                BEAST_EXPECTS(result == z, ss.str());
             }
         };
         auto const maxMantissa = Number::maxMantissa();
@@ -773,6 +763,7 @@ TEST(NumberTest, div)
                   Number{false, maxMantissa, -18, Number::Normalized{}}}});
             tests(cSmall, cLarge);
         }
+        testcase << "test_div " << to_string(Number::getMantissaScale()) << " towards_zero";
         Number::setround(Number::RoundingMode::TowardsZero);
         {
             auto const cSmall = std::to_array<Case>(
@@ -810,6 +801,7 @@ TEST(NumberTest, div)
                   Number{false, maxMantissa, -18, Number::Normalized{}}}});
             tests(cSmall, cLarge);
         }
+        testcase << "test_div " << to_string(Number::getMantissaScale()) << " downward";
         Number::setround(Number::RoundingMode::Downward);
         {
             auto const cSmall = std::to_array<Case>(
@@ -847,6 +839,7 @@ TEST(NumberTest, div)
                   Number{false, maxMantissa, -18, Number::Normalized{}}}});
             tests(cSmall, cLarge);
         }
+        testcase << "test_div " << to_string(Number::getMantissaScale()) << " upward";
         Number::setround(Number::RoundingMode::Upward);
         {
             auto const cSmall = std::to_array<Case>(
@@ -884,6 +877,7 @@ TEST(NumberTest, div)
                   Number{false, maxMantissa, -18, Number::Normalized{}}}});
             tests(cSmall, cLarge);
         }
+        testcase << "test_div " << to_string(Number::getMantissaScale()) << " overflow";
         bool caught = false;
         try
         {
@@ -893,30 +887,29 @@ TEST(NumberTest, div)
         {
             caught = true;
         }
-        EXPECT_TRUE(caught);
+        BEAST_EXPECT(caught);
     }
-}
 
-TEST(NumberTest, root)
-{
-    for (auto const mantissaScale : MantissaRange::getAllScales())
+    void
+    testRoot()
     {
-        NumberMantissaScaleGuard const sg(mantissaScale);
+        auto const scale = Number::getMantissaScale();
+        testcase << "test_root " << to_string(scale);
 
         using Case = std::tuple<Number, unsigned, Number>;
-        auto test = [](auto const& c) {
+        auto test = [this](auto const& c) {
             for (auto const& [x, y, z] : c)
             {
                 auto const result = root(x, y);
                 std::stringstream ss;
                 ss << "root(" << x << ", " << y << ") = " << result << ". Expected: " << z;
-                EXPECT_EQ(result, z) << ss.str();
+                BEAST_EXPECTS(result == z, ss.str());
             }
         };
         /*
         auto tests = [&](auto const& cSmall, auto const& cLarge) {
             test(cSmall);
-            if (scale != MantissaRange::mantissa_scale::small)
+            if (scale != MantissaRange::MantissaScale::Small)
                 test(cLarge);
         };
         */
@@ -960,7 +953,7 @@ TEST(NumberTest, root)
         {
             caught = true;
         }
-        EXPECT_TRUE(caught);
+        BEAST_EXPECT(caught);
         caught = false;
         try
         {
@@ -970,24 +963,23 @@ TEST(NumberTest, root)
         {
             caught = true;
         }
-        EXPECT_TRUE(caught);
+        BEAST_EXPECT(caught);
     }
-}
 
-TEST(NumberTest, root2)
-{
-    for (auto const mantissaScale : MantissaRange::getAllScales())
+    void
+    testRoot2()
     {
-        NumberMantissaScaleGuard const sg(mantissaScale);
+        auto const scale = Number::getMantissaScale();
+        testcase << "test_root2 " << to_string(scale);
 
-        auto test = [](auto const& c) {
+        auto test = [this](auto const& c) {
             for (auto const& x : c)
             {
                 auto const expected = root(x, 2);
                 auto const result = root2(x);
                 std::stringstream ss;
                 ss << "root2(" << x << ") = " << result << ". Expected: " << expected;
-                EXPECT_EQ(result, expected) << ss.str();
+                BEAST_EXPECTS(result == expected, ss.str());
             }
         };
 
@@ -1012,16 +1004,13 @@ TEST(NumberTest, root2)
         {
             caught = true;
         }
-        EXPECT_TRUE(caught);
+        BEAST_EXPECT(caught);
     }
-}
 
-TEST(NumberTest, power1)
-{
-    for (auto const mantissaScale : MantissaRange::getAllScales())
+    void
+    testPower1()
     {
-        NumberMantissaScaleGuard const sg(mantissaScale);
-
+        testcase << "test_power1 " << to_string(Number::getMantissaScale());
         using Case = std::tuple<Number, unsigned, Number>;
         Case const c[]{
             {Number{64}, 0, Number{1}},
@@ -1033,16 +1022,13 @@ TEST(NumberTest, power1)
             {Number{64}, 11, Number{false, 7378697629483820646ULL, 1, Number::Normalized{}}},
             {Number{-64}, 11, Number{true, 7378697629483820646ULL, 1, Number::Normalized{}}}};
         for (auto const& [x, y, z] : c)
-            EXPECT_EQ(power(x, y), z);
+            BEAST_EXPECT((power(x, y) == z));
     }
-}
 
-TEST(NumberTest, power2)
-{
-    for (auto const mantissaScale : MantissaRange::getAllScales())
+    void
+    testPower2()
     {
-        NumberMantissaScaleGuard const sg(mantissaScale);
-
+        testcase << "test_power2 " << to_string(Number::getMantissaScale());
         using Case = std::tuple<Number, unsigned, unsigned, Number>;
         Case const c[]{
             {Number{1}, 3, 7, Number{1}},
@@ -1052,7 +1038,7 @@ TEST(NumberTest, power2)
             {Number{34}, 3, 3, Number{34}},
             {Number{4}, 3, 2, Number{8}}};
         for (auto const& [x, n, d, z] : c)
-            EXPECT_EQ(power(x, n, d), z);
+            BEAST_EXPECT((power(x, n, d) == z));
         bool caught = false;
         try
         {
@@ -1062,7 +1048,7 @@ TEST(NumberTest, power2)
         {
             caught = true;
         }
-        EXPECT_TRUE(caught);
+        BEAST_EXPECT(caught);
         caught = false;
         try
         {
@@ -1072,7 +1058,7 @@ TEST(NumberTest, power2)
         {
             caught = true;
         }
-        EXPECT_TRUE(caught);
+        BEAST_EXPECT(caught);
         caught = false;
         try
         {
@@ -1082,44 +1068,39 @@ TEST(NumberTest, power2)
         {
             caught = true;
         }
-        EXPECT_TRUE(caught);
+        BEAST_EXPECT(caught);
     }
-}
 
-TEST(NumberTest, conversions)
-{
-    for (auto const mantissaScale : MantissaRange::getAllScales())
+    void
+    testConversions()
     {
-        NumberMantissaScaleGuard const sg(mantissaScale);
+        testcase << "testConversions " << to_string(Number::getMantissaScale());
 
         IOUAmount const x{5, 6};
         Number const y = x;
-        EXPECT_EQ(y, (Number{5, 6}));
+        BEAST_EXPECT((y == Number{5, 6}));
         IOUAmount const z{y};
-        EXPECT_EQ(x, z);
+        BEAST_EXPECT(x == z);
         XRPAmount const xrp{500};
         STAmount const st = xrp;
         Number const n = st;
-        EXPECT_EQ(XRPAmount{n}, xrp);
+        BEAST_EXPECT(XRPAmount{n} == xrp);
         IOUAmount const x0{0, 0};
         Number const y0 = x0;
-        EXPECT_EQ(y0, Number{0});
+        BEAST_EXPECT((y0 == Number{0}));
         IOUAmount const z0{y0};
-        EXPECT_EQ(x0, z0);
+        BEAST_EXPECT(x0 == z0);
         XRPAmount const xrp0{0};
         Number const n0 = xrp0;
-        EXPECT_EQ(n0, Number{0});
-        XRPAmount const xrp1{n0};  // NOLINT misc-confusable-identifiers
-        EXPECT_EQ(xrp1, xrp0);
+        BEAST_EXPECT(n0 == Number{0});
+        XRPAmount const xrp1{n0};
+        BEAST_EXPECT(xrp1 == xrp0);
     }
-}
 
-TEST(NumberTest, to_integer)
-{
-    for (auto const mantissaScale : MantissaRange::getAllScales())
+    void
+    testToInteger()
     {
-        NumberMantissaScaleGuard const sg(mantissaScale);
-
+        testcase << "test_to_integer " << to_string(Number::getMantissaScale());
         using Case = std::tuple<Number, std::int64_t>;
         SaveNumberRoundMode const save{Number::setround(Number::RoundingMode::ToNearest)};
         {
@@ -1155,11 +1136,11 @@ TEST(NumberTest, to_integer)
             for (auto const& [x, y] : c)
             {
                 auto j = static_cast<std::int64_t>(x);
-                EXPECT_EQ(j, y);
+                BEAST_EXPECT(j == y);
             }
         }
         auto prevMode = Number::setround(Number::RoundingMode::TowardsZero);
-        EXPECT_EQ(prevMode, Number::RoundingMode::ToNearest);
+        BEAST_EXPECT(prevMode == Number::RoundingMode::ToNearest);
         {
             Case const c[]{
                 {Number{0}, 0},
@@ -1193,11 +1174,11 @@ TEST(NumberTest, to_integer)
             for (auto const& [x, y] : c)
             {
                 auto j = static_cast<std::int64_t>(x);
-                EXPECT_EQ(j, y);
+                BEAST_EXPECT(j == y);
             }
         }
         prevMode = Number::setround(Number::RoundingMode::Downward);
-        EXPECT_EQ(prevMode, Number::RoundingMode::TowardsZero);
+        BEAST_EXPECT(prevMode == Number::RoundingMode::TowardsZero);
         {
             Case const c[]{
                 {Number{0}, 0},
@@ -1231,11 +1212,11 @@ TEST(NumberTest, to_integer)
             for (auto const& [x, y] : c)
             {
                 auto j = static_cast<std::int64_t>(x);
-                EXPECT_EQ(j, y);
+                BEAST_EXPECT(j == y);
             }
         }
         prevMode = Number::setround(Number::RoundingMode::Upward);
-        EXPECT_EQ(prevMode, Number::RoundingMode::Downward);
+        BEAST_EXPECT(prevMode == Number::RoundingMode::Downward);
         {
             Case const c[]{
                 {Number{0}, 0},
@@ -1269,7 +1250,7 @@ TEST(NumberTest, to_integer)
             for (auto const& [x, y] : c)
             {
                 auto j = static_cast<std::int64_t>(x);
-                EXPECT_EQ(j, y);
+                BEAST_EXPECT(j == y);
             }
         }
         bool caught = false;
@@ -1281,39 +1262,33 @@ TEST(NumberTest, to_integer)
         {
             caught = true;
         }
-        EXPECT_TRUE(caught);
+        BEAST_EXPECT(caught);
     }
-}
 
-TEST(NumberTest, squelch)
-{
-    for (auto const mantissaScale : MantissaRange::getAllScales())
+    void
+    testSquelch()
     {
-        NumberMantissaScaleGuard const sg(mantissaScale);
-
+        testcase << "test_squelch " << to_string(Number::getMantissaScale());
         Number const limit{1, -6};
-        EXPECT_EQ(squelch(Number{2, -6}, limit), (Number{2, -6}));
-        EXPECT_EQ(squelch(Number{1, -6}, limit), (Number{1, -6}));
-        EXPECT_EQ(squelch(Number{9, -7}, limit), Number{0});
-        EXPECT_EQ(squelch(Number{-2, -6}, limit), (Number{-2, -6}));
-        EXPECT_EQ(squelch(Number{-1, -6}, limit), (Number{-1, -6}));
-        EXPECT_EQ(squelch(Number{-9, -7}, limit), Number{0});
+        BEAST_EXPECT((squelch(Number{2, -6}, limit) == Number{2, -6}));
+        BEAST_EXPECT((squelch(Number{1, -6}, limit) == Number{1, -6}));
+        BEAST_EXPECT((squelch(Number{9, -7}, limit) == Number{0}));
+        BEAST_EXPECT((squelch(Number{-2, -6}, limit) == Number{-2, -6}));
+        BEAST_EXPECT((squelch(Number{-1, -6}, limit) == Number{-1, -6}));
+        BEAST_EXPECT((squelch(Number{-9, -7}, limit) == Number{0}));
     }
-}
 
-TEST(NumberTest, to_string)
-{
-    for (auto const mantissaScale : MantissaRange::getAllScales())
+    void
+    testToString()
     {
-        NumberMantissaScaleGuard const sg(mantissaScale);
-
         auto const scale = Number::getMantissaScale();
+        testcase << "testToString " << to_string(scale);
 
-        auto test = [](Number const& n, std::string const& expected) {
+        auto test = [this](Number const& n, std::string const& expected) {
             auto const result = to_string(n);
             std::stringstream ss;
             ss << "to_string(" << result << "). Expected: " << expected;
-            EXPECT_EQ(result, expected) << ss.str();
+            BEAST_EXPECTS(result == expected, ss.str());
         };
 
         test(Number(-2, 0), "-2");
@@ -1345,7 +1320,7 @@ TEST(NumberTest, to_string)
                     NumberRoundModeGuard const mg(Number::RoundingMode::TowardsZero);
 
                     auto const maxMantissa = Number::maxMantissa();
-                    EXPECT_EQ(maxMantissa, (9'999'999'999'999'999));
+                    BEAST_EXPECT(maxMantissa == 9'999'999'999'999'999);
                     test(
                         Number{false, (maxMantissa * 1000) + 999, -3, Number::Normalized()},
                         "9999999999999999");
@@ -1376,7 +1351,7 @@ TEST(NumberTest, to_string)
                     NumberRoundModeGuard const mg(Number::RoundingMode::TowardsZero);
 
                     auto const maxMantissa = Number::maxMantissa();
-                    EXPECT_EQ((maxMantissa), (9'999'999'999'999'999'999ULL));
+                    BEAST_EXPECT(maxMantissa == 9'999'999'999'999'999'999ULL);
                     test(
                         Number{false, maxMantissa, 0, Number::Normalized{}}, "9999999999999999990");
                     test(
@@ -1406,20 +1381,18 @@ TEST(NumberTest, to_string)
                     "-9223372036854775810");
                 break;
             default:
-                EXPECT_TRUE(false);
+                BEAST_EXPECT(false);
         }
     }
-}
 
-TEST(NumberTest, relationals)
-{
-    for (auto const mantissaScale : MantissaRange::getAllScales())
+    void
+    testRelationals()
     {
-        NumberMantissaScaleGuard const sg(mantissaScale);
+        testcase << "test_relationals " << to_string(Number::getMantissaScale());
 
         {
-            auto test = [](auto const& nums) {
-                EXPECT_TRUE(std::ranges::is_sorted(nums));
+            auto test = [this](auto const& nums) {
+                BEAST_EXPECT(std::ranges::is_sorted(nums));
 
                 for (auto iter1 = nums.begin(); iter1 != nums.end(); ++iter1)
                 {
@@ -1435,32 +1408,32 @@ TEST(NumberTest, relationals)
                         // The ==/!= operators use a completely different code path than <, etc.
                         // This helps detect a breakage in one but not the other. It also helps
                         // verify that the values are being ordered correctly.
-                        EXPECT_TRUE(smaller != larger) << str << " (!=)";
-                        EXPECT_FALSE(smaller == larger) << str << " (==)";
+                        BEAST_EXPECTS(smaller != larger, str + " (!=)");
+                        BEAST_EXPECTS(!(smaller == larger), str + " (==)");
 
                         // true results using operator< and derived operators
-                        EXPECT_TRUE(smaller < larger) << str << " (<)";
-                        EXPECT_TRUE(larger > smaller) << str << " (>)";
-                        EXPECT_TRUE(larger >= smaller) << str << " (>=)";
-                        EXPECT_TRUE(smaller <= larger) << str << " (<=)";
+                        BEAST_EXPECTS(smaller < larger, str + " (<)");
+                        BEAST_EXPECTS(larger > smaller, str + " (>)");
+                        BEAST_EXPECTS(larger >= smaller, str + " (>=)");
+                        BEAST_EXPECTS(smaller <= larger, str + " (<=)");
 
                         // false results using operator< and derived operators
-                        EXPECT_FALSE(larger < smaller) << str << " (! <)";
-                        EXPECT_FALSE(smaller > larger) << str << " (! >)";
-                        EXPECT_FALSE(smaller >= larger) << str << " (! >=)";
-                        EXPECT_FALSE(larger <= smaller) << str << " (! <=)";
+                        BEAST_EXPECTS(!(larger < smaller), str + " (! <)");
+                        BEAST_EXPECTS(!(smaller > larger), str + " (! >)");
+                        BEAST_EXPECTS(!(smaller >= larger), str + " (! >=)");
+                        BEAST_EXPECTS(!(larger <= smaller), str + " (! <=)");
                     }
                 }
             };
 
-            auto const intNums = []() {
+            auto const intNums = [this]() {
                 // Inequality test cases are built from a list of sorted integers
                 auto const values =
                     std::to_array<int>({-100, -50, -20, -10, -1, 0, 1, 10, 20, 50, 100});
                 // Check this list is sorted before converting it to Numbers.
                 // That way if any of the other tests fail, we know it's because of code and not the
                 // source data.
-                EXPECT_TRUE(std::ranges::is_sorted(values));
+                BEAST_EXPECT(std::ranges::is_sorted(values));
 
                 std::vector<Number> result;
                 result.reserve(values.size());
@@ -1500,114 +1473,95 @@ TEST(NumberTest, relationals)
             for (auto const& [n, line] : c)
             {
                 auto const str = to_string(n);
-                auto const location =
-                    std::string{" ("} + __FILE__ + ":" + std::to_string(line) + ")";
 
                 // NOLINTBEGIN(misc-redundant-expression) Explicitly testing operators with
                 // equivalent values
-                EXPECT_TRUE(n == n) << str << " ==" << location;
-                EXPECT_FALSE(n != n) << str << " !=" << location;
+                expect(n == n, str + " ==", __FILE__, line);
+                expect(!(n != n), str + " !=", __FILE__, line);
 
-                EXPECT_FALSE(n < n) << str << " <" << location;
-                EXPECT_FALSE(n > n) << str << " >" << location;
-                EXPECT_TRUE(n >= n) << str << " >=" << location;
-                EXPECT_TRUE(n <= n) << str << " <=" << location;
+                expect(!(n < n), str + " < ", __FILE__, line);
+                expect(!(n > n), str + " >", __FILE__, line);
+                expect(n >= n, str + " >=", __FILE__, line);
+                expect(n <= n, str + " <=", __FILE__, line);
                 // NOLINTEND(misc-redundant-expression)
             }
         }
     }
-}
 
-TEST(NumberTest, stream)
-{
-    for (auto const mantissaScale : MantissaRange::getAllScales())
+    void
+    testStream()
     {
-        NumberMantissaScaleGuard const sg(mantissaScale);
-
+        testcase << "test_stream " << to_string(Number::getMantissaScale());
         Number const x{100};
         std::ostringstream os;
         os << x;
-        EXPECT_EQ((os.str()), (to_string(x)));
+        BEAST_EXPECT(os.str() == to_string(x));
     }
-}
 
-TEST(NumberTest, inc_dec)
-{
-    for (auto const mantissaScale : MantissaRange::getAllScales())
+    void
+    testIncDec()
     {
-        NumberMantissaScaleGuard const sg(mantissaScale);
-
+        testcase << "test_inc_dec " << to_string(Number::getMantissaScale());
         Number x{100};
         Number const y = +x;
-        EXPECT_EQ((x), (y));
-        EXPECT_EQ((x++), (y));
-        EXPECT_EQ((x), (Number{101}));
-        EXPECT_EQ((x--), (Number{101}));
-        EXPECT_EQ((x), (y));
+        BEAST_EXPECT(x == y);
+        BEAST_EXPECT(x++ == y);
+        BEAST_EXPECT(x == Number{101});
+        BEAST_EXPECT(x-- == Number{101});
+        BEAST_EXPECT(x == y);
     }
-}
 
-TEST(NumberTest, to_st_amount)
-{
-    for (auto const mantissaScale : MantissaRange::getAllScales())
+    void
+    testToStAmount()
     {
-        NumberMantissaScaleGuard const sg(mantissaScale);
-
         Issue const issue;
         Number const n{7'518'783'80596, -5};
         SaveNumberRoundMode const save{Number::setround(Number::RoundingMode::ToNearest)};
         auto res2 = STAmount{issue, n};
-        EXPECT_EQ((res2), (STAmount{7518784}));
+        BEAST_EXPECT(res2 == STAmount{7518784});
 
         Number::setround(Number::RoundingMode::TowardsZero);
         res2 = STAmount{issue, n};
-        EXPECT_EQ((res2), (STAmount{7518783}));
+        BEAST_EXPECT(res2 == STAmount{7518783});
 
         Number::setround(Number::RoundingMode::Downward);
         res2 = STAmount{issue, n};
-        EXPECT_EQ((res2), (STAmount{7518783}));
+        BEAST_EXPECT(res2 == STAmount{7518783});
 
         Number::setround(Number::RoundingMode::Upward);
         res2 = STAmount{issue, n};
-        EXPECT_EQ((res2), (STAmount{7518784}));
+        BEAST_EXPECT(res2 == STAmount{7518784});
     }
-}
 
-TEST(NumberTest, truncate)
-{
-    for (auto const mantissaScale : MantissaRange::getAllScales())
+    void
+    testTruncate()
     {
-        NumberMantissaScaleGuard const sg(mantissaScale);
+        BEAST_EXPECT(Number(25, +1).truncate() == Number(250, 0));
+        BEAST_EXPECT(Number(25, 0).truncate() == Number(25, 0));
+        BEAST_EXPECT(Number(25, -1).truncate() == Number(2, 0));
+        BEAST_EXPECT(Number(25, -2).truncate() == Number(0, 0));
+        BEAST_EXPECT(Number(99, -2).truncate() == Number(0, 0));
 
-        EXPECT_EQ((Number(25, +1).truncate()), (Number(250, 0)));
-        EXPECT_EQ((Number(25, 0).truncate()), (Number(25, 0)));
-        EXPECT_EQ((Number(25, -1).truncate()), (Number(2, 0)));
-        EXPECT_EQ((Number(25, -2).truncate()), (Number(0, 0)));
-        EXPECT_EQ((Number(99, -2).truncate()), (Number(0, 0)));
+        BEAST_EXPECT(Number(-25, +1).truncate() == Number(-250, 0));
+        BEAST_EXPECT(Number(-25, 0).truncate() == Number(-25, 0));
+        BEAST_EXPECT(Number(-25, -1).truncate() == Number(-2, 0));
+        BEAST_EXPECT(Number(-25, -2).truncate() == Number(0, 0));
+        BEAST_EXPECT(Number(-99, -2).truncate() == Number(0, 0));
 
-        EXPECT_EQ((Number(-25, +1).truncate()), (Number(-250, 0)));
-        EXPECT_EQ((Number(-25, 0).truncate()), (Number(-25, 0)));
-        EXPECT_EQ((Number(-25, -1).truncate()), (Number(-2, 0)));
-        EXPECT_EQ((Number(-25, -2).truncate()), (Number(0, 0)));
-        EXPECT_EQ((Number(-99, -2).truncate()), (Number(0, 0)));
-
-        EXPECT_EQ((Number(0, 0).truncate()), (Number(0, 0)));
-        EXPECT_EQ((Number(0, 30000).truncate()), (Number(0, 0)));
-        EXPECT_EQ((Number(0, -30000).truncate()), (Number(0, 0)));
-        EXPECT_EQ((Number(100, -30000).truncate()), (Number(0, 0)));
-        EXPECT_EQ((Number(100, -30000).truncate()), (Number(0, 0)));
-        EXPECT_EQ((Number(-100, -30000).truncate()), (Number(0, 0)));
-        EXPECT_EQ((Number(-100, -30000).truncate()), (Number(0, 0)));
+        BEAST_EXPECT(Number(0, 0).truncate() == Number(0, 0));
+        BEAST_EXPECT(Number(0, 30000).truncate() == Number(0, 0));
+        BEAST_EXPECT(Number(0, -30000).truncate() == Number(0, 0));
+        BEAST_EXPECT(Number(100, -30000).truncate() == Number(0, 0));
+        BEAST_EXPECT(Number(100, -30000).truncate() == Number(0, 0));
+        BEAST_EXPECT(Number(-100, -30000).truncate() == Number(0, 0));
+        BEAST_EXPECT(Number(-100, -30000).truncate() == Number(0, 0));
     }
-}
 
-TEST(NumberTest, rounding)
-{
-    for (auto const mantissaScale : MantissaRange::getAllScales())
+    void
+    testRounding()
     {
-        NumberMantissaScaleGuard const sg(mantissaScale);
-
         // Test that rounding works as expected.
+        testcase("Rounding");
 
         using NumberRoundings = std::map<Number::RoundingMode, std::int64_t>;
 
@@ -1703,340 +1657,348 @@ TEST(NumberTest, rounding)
             {
                 NumberRoundModeGuard const g{mode};
                 auto const res = static_cast<std::int64_t>(num);
-                EXPECT_EQ((res), (val)) << to_string(num) + " with mode " +
-                        std::to_string(static_cast<int>(mode)) + " expected " +
-                        std::to_string(val) + " got " + std::to_string(res);
+                BEAST_EXPECTS(
+                    res == val,
+                    to_string(num) + " with mode " + std::to_string(static_cast<int>(mode)) +
+                        " expected " + std::to_string(val) + " got " + std::to_string(res));
             }
         }
     }
-}
 
-TEST(NumberTest, int64)
-{
-    for (auto const mantissaScale : MantissaRange::getAllScales())
+    void
+    testInt64()
     {
-        NumberMantissaScaleGuard const sg(mantissaScale);
-
         auto const scale = Number::getMantissaScale();
+        testcase << "std::int64_t " << to_string(scale);
 
         // Control case
-        EXPECT_GT((Number::maxMantissa()), (10));
+        BEAST_EXPECT(Number::maxMantissa() > 10);
         Number const ten{10};
-        EXPECT_LE((ten.exponent()), (0));
+        BEAST_EXPECT(ten.exponent() <= 0);
 
         if (scale == MantissaRange::MantissaScale::Small)
         {
-            EXPECT_GT((std::numeric_limits<std::int64_t>::max()), (kInitialXrp.drops()));
-            EXPECT_LT((Number::maxMantissa()), (kInitialXrp.drops()));
+            BEAST_EXPECT(std::numeric_limits<std::int64_t>::max() > kInitialXrp.drops());
+            BEAST_EXPECT(Number::maxMantissa() < kInitialXrp.drops());
             Number const initalXrp{kInitialXrp};
-            EXPECT_GT((initalXrp.exponent()), (0));
+            BEAST_EXPECT(initalXrp.exponent() > 0);
 
             Number const maxInt64{Number::kMaxRep};
-            EXPECT_GT((maxInt64.exponent()), (0));
+            BEAST_EXPECT(maxInt64.exponent() > 0);
             // 85'070'591'730'234'615'865'843'651'857'942'052'864 - 38 digits
-            EXPECT_EQ((power(maxInt64, 2)), (Number{85'070'591'730'234'62, 22}));
+            BEAST_EXPECT((power(maxInt64, 2) == Number{85'070'591'730'234'62, 22}));
 
             Number const max = Number{false, Number::maxMantissa(), 0, Number::Normalized{}};
-            EXPECT_LE(max.exponent(), 0);
+            BEAST_EXPECT(max.exponent() <= 0);
             // 99'999'999'999'999'980'000'000'000'000'001 - 32 digits
-            EXPECT_EQ(power(max, 2), (Number{99'999'999'999'999'98, 16}));
+            BEAST_EXPECT((power(max, 2) == Number{99'999'999'999'999'98, 16}));
         }
         else
         {
-            EXPECT_GT((std::numeric_limits<std::int64_t>::max()), (kInitialXrp.drops()));
-            EXPECT_GT((Number::maxMantissa()), (kInitialXrp.drops()));
+            BEAST_EXPECT(std::numeric_limits<std::int64_t>::max() > kInitialXrp.drops());
+            BEAST_EXPECT(Number::maxMantissa() > kInitialXrp.drops());
             Number const initalXrp{kInitialXrp};
-            EXPECT_LE((initalXrp.exponent()), (0));
+            BEAST_EXPECT(initalXrp.exponent() <= 0);
 
             Number const maxInt64{Number::kMaxRep};
-            EXPECT_LE((maxInt64.exponent()), (0));
+            BEAST_EXPECT(maxInt64.exponent() <= 0);
             // 85'070'591'730'234'615'847'396'907'784'232'501'249 - 38 digits
-            EXPECT_EQ((power(maxInt64, 2)), (Number{85'070'591'730'234'615'85, 19}));
+            BEAST_EXPECT((power(maxInt64, 2) == Number{85'070'591'730'234'615'85, 19}));
 
             NumberRoundModeGuard const mg(Number::RoundingMode::TowardsZero);
 
             auto const maxMantissa = Number::maxMantissa();
             Number const max = Number{false, maxMantissa, 0, Number::Normalized{}};
-            EXPECT_EQ((max.mantissa()), (maxMantissa / 10));
-            EXPECT_EQ((max.exponent()), (1));
+            BEAST_EXPECT(max.mantissa() == maxMantissa / 10);
+            BEAST_EXPECT(max.exponent() == 1);
             // 99'999'999'999'999'999'800'000'000'000'000'000'100 - also 38
             // digits
-            EXPECT_EQ(
-                (power(max, 2)), (Number{false, (maxMantissa / 10) - 1, 20, Number::Normalized{}}));
+            BEAST_EXPECT(
+                (power(max, 2) == Number{false, (maxMantissa / 10) - 1, 20, Number::Normalized{}}));
         }
     }
-}
 
-TEST(NumberTest, upward_rounding_produces_value_not_below_exact_at_k_max_rep_cusp)
-{
-    for (auto const mantissaScale : MantissaRange::getAllScales())
+    void
+    testUpwardRoundsDown()
     {
-        NumberMantissaScaleGuard const mg{mantissaScale};
-        NumberRoundModeGuard const rg{Number::RoundingMode::Upward};
-
         auto const scale = Number::getMantissaScale();
-
-        constexpr std::int64_t kAValue = 1'000'000'000'000'049'863LL;
-        constexpr std::int64_t kBValue = 9'223'372'036'854'315'903LL;
-
-        Number const a = kAValue;
-        Number const b = kBValue;
-        Number const product = a * b;
-
-        // Exact reference in BigInt.
-        BigInt const exactProduct = BigInt(kAValue) * BigInt(kBValue);
-
-        // What Number actually stored.
-        BigInt storedValue = BigInt(product.mantissa());
-        for (int i = 0; i < product.exponent(); ++i)
-            storedValue *= 10;
-
-        BigInt const signedDifference = storedValue - exactProduct;
-
-        auto const message = [&] {
-            std::ostringstream os;
-            os << "\n"
-               << "  a              = " << fmt(BigInt(kAValue)) << "\n"
-               << "  b              = " << fmt(BigInt(kBValue)) << "\n"
-               << "  exact a*b      = " << fmt(exactProduct) << "\n"
-               << "  stored         = " << fmt(storedValue) << "\n"
-               << "  stored - exact = " << fmt(signedDifference) << "\n"
-               << "  upward         = " << (signedDifference >= 0 ? "held" : "VIOLATED") << "\n"
-               << " stored.mantissa = " << product.mantissa() << "\n"
-               << " stored.exponent = " << product.exponent() << "\n";
-            return os.str();
-        };
-
-        switch (scale)
         {
-            case MantissaRange::MantissaScale::Large:
-                EXPECT_TRUE(signedDifference >= 0) << message();
-                EXPECT_TRUE(signedDifference < pow10<BigInt>(product.exponent())) << message();
-                EXPECT_EQ(product.mantissa(), (std::numeric_limits<std::int64_t>::max() / 10) + 1);
-                EXPECT_EQ(product.exponent(), 19);
-                break;
+            testcase << "upward rounding produces a value below exact at kMaxRep cusp "
+                     << to_string(scale);
 
-            case MantissaRange::MantissaScale::LargeLegacy:
-                EXPECT_TRUE(signedDifference < 0) << message();
-                EXPECT_EQ(
-                    product.mantissa(), (std::numeric_limits<std::int64_t>::max() / 100) * 100);
-                EXPECT_EQ(product.exponent(), 18);
-                break;
+            NumberRoundModeGuard const rg{Number::RoundingMode::Upward};
 
-            case MantissaRange::MantissaScale::Small:
-                // The seemingly weird rounding here is because a & b are both
-                // normalized, and both round up when being converted to Number,
-                // so you're really getting
-                // 1_000_000_000_000_050 * 9_223_372_036_854_316.
-                EXPECT_TRUE(signedDifference >= 0) << message();
-                EXPECT_EQ(
-                    product.mantissa(), (std::numeric_limits<std::int64_t>::max() / 1000) + 3);
-                EXPECT_EQ(product.exponent(), 21);
-                break;
+            constexpr std::int64_t kAValue = 1'000'000'000'000'049'863LL;
+            constexpr std::int64_t kBValue = 9'223'372'036'854'315'903LL;
+
+            Number const a = kAValue;
+            Number const b = kBValue;
+            Number const product = a * b;
+
+            // Exact reference in BigInt.
+            BigInt const exactProduct = BigInt(kAValue) * BigInt(kBValue);
+
+            // What Number actually stored.
+            BigInt storedValue = BigInt(product.mantissa());
+            for (int i = 0; i < product.exponent(); ++i)
+                storedValue *= 10;
+
+            BigInt const signedDifference = storedValue - exactProduct;
+
+            log << "\n"
+                << "  a              = " << fmt(BigInt(kAValue)) << "\n"
+                << "  b              = " << fmt(BigInt(kBValue)) << "\n"
+                << "  exact a*b      = " << fmt(exactProduct) << "\n"
+                << "  stored         = " << fmt(storedValue) << "\n"
+                << "  stored - exact = " << fmt(signedDifference) << "\n"
+                << "  upward         = " << (signedDifference >= 0 ? "held" : "VIOLATED") << "\n"
+                << " stored.mantissa = " << product.mantissa() << "\n"
+                << " stored.exponent = " << product.exponent() << "\n";
+            log.flush();
+
+            switch (scale)
+            {
+                case MantissaRange::MantissaScale::Large:
+                    BEAST_EXPECT(signedDifference >= 0);
+                    BEAST_EXPECT(signedDifference < pow10<BigInt>(product.exponent()));
+                    BEAST_EXPECT(
+                        product.mantissa() == (std::numeric_limits<std::int64_t>::max() / 10) + 1);
+                    BEAST_EXPECT(product.exponent() == 19);
+                    break;
+
+                case MantissaRange::MantissaScale::LargeLegacy:
+                    BEAST_EXPECT(signedDifference < 0);
+                    BEAST_EXPECT(
+                        product.mantissa() ==
+                        (std::numeric_limits<std::int64_t>::max() / 100) * 100);
+                    BEAST_EXPECT(product.exponent() == 18);
+                    break;
+
+                case MantissaRange::MantissaScale::Small:
+                    // The seemingly weird rounding here is because
+                    // a & b are both normalized, and both round up when
+                    // being converted to Number, so you're really
+                    // getting 1_000_000_000_000_050 * 9_223_372_036_854_316
+                    BEAST_EXPECT(signedDifference >= 0);
+                    BEAST_EXPECT(
+                        product.mantissa() ==
+                        (std::numeric_limits<std::int64_t>::max() / 1000) + 3);
+                    BEAST_EXPECT(product.exponent() == 21);
+                    break;
+            }
+        }
+
+        {
+            /* Companion regression for the kMaxRep cusp behavior, but for
+             * `operator/=` on the cusp-fix-ENABLED `Large` scale.
+             *
+             * Before the dropped-remainder fix, `operator/=` with Upward
+             * rounding could return a value STRICTLY LESS than the exact quotient,
+             * violating Upward's directional invariant.
+             *
+             * Mechanism (fix-enabled path):
+             *   1. `operator/=` computes `numerator = nm * 10^17` and
+             *      `zm = numerator / dm` (integer division, truncates remainder).
+             *   2. If `remainder != 0`, the correction block runs:
+             *        zm *= 100000
+             *        correction = (remainder * 100000) / dm  // also truncates
+             *        zm += correction
+             *        ze -= 5
+             *      The truncation in `correction` discards a sub-1/100000 residual.
+             *   3. `normalize`'s shift loop reduces zm to fit, but the discarded
+             *      residual is BELOW the Guard's visibility, so the Guard sees fraction = 0.
+             *   4. Under Upward + positive, `round()` returns -1 (no round-up), and
+             *      the algorithm returns the truncated zm
+             */
+            testcase << "operator/= Upward on Large returns value < truth " << to_string(scale);
+
+            NumberRoundModeGuard const roundGuard{Number::RoundingMode::Upward};
+
+            constexpr std::int64_t aValue = 2LL;
+            constexpr std::int64_t bValue = 1'000'000'000'000'000'007LL;
+            // bValue = 10^18 + 7 (prime, in [minMantissa, kMaxRep]).
+
+            Number const a{aValue, 0};
+            Number const b{bValue, 0};
+            Number const quotient = a / b;
+
+            dec const exact = dec(aValue) / dec(bValue);
+            dec const stored = dec(quotient.mantissa()) * pow10(quotient.exponent());
+            dec const diff = stored - exact;
+
+            log << "\n"
+                << "  a                 = " << aValue << "\n"
+                << "  b                 = " << bValue << "\n"
+                << "  exact a/b         = " << fmt(exact) << "\n"
+                << "  stored a/b        = " << fmt(stored) << "\n"
+                << "  stored - exact    = " << fmt(diff)
+                << "    (negative => Upward gave value BELOW truth)\n"
+                << "  quotient.mantissa = " << quotient.mantissa() << "\n"
+                << "  quotient.exponent = " << quotient.exponent() << "\n";
+            log.flush();
+
+            // Upward invariant: stored >= exact. Bug: stored < exact.
+            switch (scale)
+            {
+                case MantissaRange::MantissaScale::Large:
+                    BEAST_EXPECT(stored >= exact);
+                    BEAST_EXPECT(diff < pow10(quotient.exponent()));
+                    break;
+
+                case MantissaRange::MantissaScale::LargeLegacy:
+                    BEAST_EXPECT(stored < exact);
+                    BEAST_EXPECT(diff >= -pow10(quotient.exponent()));
+                    break;
+
+                case MantissaRange::MantissaScale::Small:
+                    // Small mantissa doesn't have the correction for
+                    // dropped remainders
+                    BEAST_EXPECT(stored < exact);
+                    break;
+            }
+        }
+        {
+            /* Companion test case for Upward positive operator/=: Downward negative
+             */
+            testcase << "operator/= Downward on Large returns value < truth " << to_string(scale);
+
+            NumberRoundModeGuard const roundGuard{Number::RoundingMode::Downward};
+
+            constexpr std::int64_t aValue = -2LL;
+            constexpr std::int64_t bValue = 1'000'000'000'000'000'007LL;
+            // bValue = 10^18 + 7 (prime, in [minMantissa, kMaxRep]).
+
+            Number const a{aValue, 0};
+            Number const b{bValue, 0};
+            Number const quotient = a / b;
+
+            dec const exact = dec(aValue) / dec(bValue);
+            dec const stored = dec(quotient.mantissa()) * pow10(quotient.exponent());
+            dec const diff = stored - exact;
+
+            log << "\n"
+                << "  a                 = " << aValue << "\n"
+                << "  b                 = " << bValue << "\n"
+                << "  exact a/b         = " << fmt(exact) << "\n"
+                << "  stored a/b        = " << fmt(stored) << "\n"
+                << "  stored - exact    = " << fmt(diff)
+                << "    (positive => Downward gave value ABOVE truth)\n"
+                << "  quotient.mantissa = " << quotient.mantissa() << "\n"
+                << "  quotient.exponent = " << quotient.exponent() << "\n";
+            log.flush();
+
+            // invariant: stored <= exact. Bug: stored > exact.
+            switch (scale)
+            {
+                case MantissaRange::MantissaScale::Large:
+                    BEAST_EXPECT(stored <= exact);
+                    BEAST_EXPECT(diff > -pow10(quotient.exponent()));
+                    break;
+
+                case MantissaRange::MantissaScale::LargeLegacy:
+                    BEAST_EXPECT(stored > exact);
+                    BEAST_EXPECT(diff <= pow10(quotient.exponent()));
+                    break;
+
+                case MantissaRange::MantissaScale::Small:
+                    // Small mantissa doesn't have the correction for
+                    // dropped remainders
+                    BEAST_EXPECT(stored < exact);
+                    break;
+            }
+        }
+        {
+            /* Companion test case for Upward positive operator/=: ToNearest
+             *
+             * With ToNearest, if the dropped digits are exactly "5", then the mantissa will be
+             * rounded to even. The numbers below result in a value where the unrounded mantissa
+             * ends in an even digit, and "infinite precision" would drop
+             * "500000000000000000145...", but doNormalize only sees "5". Without the rounding fix,
+             * doNormalize rounds down to the even value. With the rounding fix, doNormalize knows
+             * there are more digits beyond "5", and so rounds _up_ to the odd value.
+             */
+            testcase << "operator/= ToNearest on Large returns value < truth " << to_string(scale);
+
+            NumberRoundModeGuard const roundGuard{Number::RoundingMode::ToNearest};
+
+            constexpr std::int64_t aValue = 1'269'917'268'816'087'809LL;
+            constexpr std::int64_t bValue = 3'458'525'013'821'685'511LL;
+            // bValue = 10^18 + 7 (prime, in [minMantissa, kMaxRep]).
+
+            Number const a{aValue, 0};
+            Number const b{bValue, 0};
+            Number const quotient = a / b;
+
+            dec const exact = dec(aValue) / dec(bValue);
+            dec const stored = dec(quotient.mantissa()) * pow10(quotient.exponent());
+            dec const diff = stored - exact;
+
+            log << "\n"
+                << "  a                 = " << aValue << "\n"
+                << "  b                 = " << bValue << "\n"
+                << "  exact a/b         = " << fmt(exact) << "\n"
+                << "  stored a/b        = " << fmt(stored) << "\n"
+                << "  stored - exact    = " << fmt(diff)
+                << "    (negative => ToNearest gave value BELOW truth)\n"
+                << "  quotient.mantissa = " << quotient.mantissa() << "\n"
+                << "  quotient.exponent = " << quotient.exponent() << "\n";
+            log.flush();
+
+            // invariant: stored >= exact. Bug: stored < exact.
+            switch (scale)
+            {
+                case MantissaRange::MantissaScale::Large:
+                    BEAST_EXPECT(stored >= exact);
+                    BEAST_EXPECT(diff < pow10(quotient.exponent()));
+                    break;
+
+                case MantissaRange::MantissaScale::LargeLegacy:
+                    BEAST_EXPECT(stored < exact);
+                    BEAST_EXPECT(diff >= -pow10(quotient.exponent()));
+                    break;
+
+                case MantissaRange::MantissaScale::Small:
+                    // Small mantissa doesn't have the correction for
+                    // dropped remainders
+                    BEAST_EXPECT(stored < exact);
+                    break;
+            }
         }
     }
-}
 
-/*
- * Companion regression for the kMaxRep cusp behavior, but for `operator/=` on
- * the cusp-fix-ENABLED `Large` scale.
- *
- * Before the dropped-remainder fix, `operator/=` with Upward rounding could
- * return a value STRICTLY LESS than the exact quotient, violating Upward's
- * directional invariant.
- *
- * Mechanism (fix-enabled path):
- *   1. `operator/=` computes `numerator = nm * 10^17` and
- *      `zm = numerator / dm` (integer division, truncates remainder).
- *   2. If `remainder != 0`, the correction block runs:
- *        zm *= 100000
- *        correction = (remainder * 100000) / dm  // also truncates
- *        zm += correction
- *        ze -= 5
- *      The truncation in `correction` discards a sub-1/100000 residual.
- *   3. `normalize`'s shift loop reduces zm to fit, but the discarded residual
- *      is BELOW the Guard's visibility, so the Guard sees fraction = 0.
- *   4. Under Upward + positive, `round()` returns -1 (no round-up), and the
- *      algorithm returns the truncated zm.
- */
-TEST(NumberTest, upward_division_returns_value_not_below_exact_on_large_scale)
-{
-    for (auto const mantissaScale : MantissaRange::getAllScales())
+    void
+    run() override
     {
-        NumberMantissaScaleGuard const mg{mantissaScale};
-        NumberRoundModeGuard const rg{Number::RoundingMode::Upward};
-
-        auto const scale = Number::getMantissaScale();
-
-        constexpr std::int64_t kAValue = 2LL;
-        constexpr std::int64_t kBValue = 1'000'000'000'000'000'007LL;
-        // kBValue = 10^18 + 7 (prime, in [minMantissa, kMaxRep]).
-
-        Number const a{kAValue, 0};
-        Number const b{kBValue, 0};
-        Number const quotient = a / b;
-
-        Dec const exact = Dec(kAValue) / Dec(kBValue);
-        Dec const stored = Dec(quotient.mantissa()) * pow10(quotient.exponent());
-        Dec const diff = stored - exact;
-
-        auto const message = [&] {
-            std::ostringstream os;
-            os << "\n"
-               << "  a                 = " << kAValue << "\n"
-               << "  b                 = " << kBValue << "\n"
-               << "  exact a/b         = " << fmt(exact) << "\n"
-               << "  stored a/b        = " << fmt(stored) << "\n"
-               << "  stored - exact    = " << fmt(diff)
-               << "    (negative => Upward gave value BELOW truth)\n"
-               << "  quotient.mantissa = " << quotient.mantissa() << "\n"
-               << "  quotient.exponent = " << quotient.exponent() << "\n";
-            return os.str();
-        };
-
-        // Upward invariant: stored >= exact. Bug: stored < exact.
-        switch (scale)
+        for (auto const scale : MantissaRange::getAllScales())
         {
-            case MantissaRange::MantissaScale::Large:
-                EXPECT_TRUE(stored >= exact) << message();
-                EXPECT_TRUE(diff < pow10(quotient.exponent())) << message();
-                break;
+            NumberMantissaScaleGuard const sg(scale);
+            testZero();
+            testLimits();
+            testToString();
+            testAdd();
+            testSub();
+            testMul();
+            testDiv();
+            testRoot();
+            testRoot2();
+            testPower1();
+            testPower2();
+            testConversions();
+            testToInteger();
+            testSquelch();
+            testRelationals();
+            testStream();
+            testIncDec();
+            testToStAmount();
+            testTruncate();
+            testRounding();
+            testInt64();
 
-            case MantissaRange::MantissaScale::LargeLegacy:
-                EXPECT_TRUE(stored < exact) << message();
-                EXPECT_TRUE(diff >= -pow10(quotient.exponent())) << message();
-                break;
-
-            case MantissaRange::MantissaScale::Small:
-                // Small mantissa doesn't have the correction for dropped remainders.
-                EXPECT_TRUE(stored < exact) << message();
-                break;
+            testUpwardRoundsDown();
         }
     }
-}
+};
 
-// Companion test case for Upward positive operator/=: Downward negative.
-TEST(NumberTest, downward_division_returns_value_not_above_exact_on_large_scale)
-{
-    for (auto const mantissaScale : MantissaRange::getAllScales())
-    {
-        NumberMantissaScaleGuard const mg{mantissaScale};
-        NumberRoundModeGuard const rg{Number::RoundingMode::Downward};
-
-        auto const scale = Number::getMantissaScale();
-
-        constexpr std::int64_t kAValue = -2LL;
-        constexpr std::int64_t kBValue = 1'000'000'000'000'000'007LL;
-        // kBValue = 10^18 + 7 (prime, in [minMantissa, kMaxRep]).
-
-        Number const a{kAValue, 0};
-        Number const b{kBValue, 0};
-        Number const quotient = a / b;
-
-        Dec const exact = Dec(kAValue) / Dec(kBValue);
-        Dec const stored = Dec(quotient.mantissa()) * pow10(quotient.exponent());
-        Dec const diff = stored - exact;
-
-        auto const message = [&] {
-            std::ostringstream os;
-            os << "\n"
-               << "  a                 = " << kAValue << "\n"
-               << "  b                 = " << kBValue << "\n"
-               << "  exact a/b         = " << fmt(exact) << "\n"
-               << "  stored a/b        = " << fmt(stored) << "\n"
-               << "  stored - exact    = " << fmt(diff)
-               << "    (positive => Downward gave value ABOVE truth)\n"
-               << "  quotient.mantissa = " << quotient.mantissa() << "\n"
-               << "  quotient.exponent = " << quotient.exponent() << "\n";
-            return os.str();
-        };
-
-        // Downward invariant: stored <= exact. Bug: stored > exact.
-        switch (scale)
-        {
-            case MantissaRange::MantissaScale::Large:
-                EXPECT_TRUE(stored <= exact) << message();
-                EXPECT_TRUE(diff > -pow10(quotient.exponent())) << message();
-                break;
-
-            case MantissaRange::MantissaScale::LargeLegacy:
-                EXPECT_TRUE(stored > exact) << message();
-                EXPECT_TRUE(diff <= pow10(quotient.exponent())) << message();
-                break;
-
-            case MantissaRange::MantissaScale::Small:
-                // Small mantissa doesn't have the correction for dropped remainders.
-                EXPECT_TRUE(stored < exact) << message();
-                break;
-        }
-    }
-}
-
-/*
- * Companion test case for Upward positive operator/=: ToNearest.
- *
- * With ToNearest, if the dropped digits are exactly "5", then the mantissa will
- * be rounded to even. The numbers below result in a value where the unrounded
- * mantissa ends in an even digit, and "infinite precision" would drop
- * "500000000000000000145...", but doNormalize only sees "5". Without the
- * rounding fix, doNormalize rounds down to the even value. With the rounding
- * fix, doNormalize knows there are more digits beyond "5", and so rounds _up_
- * to the odd value.
- */
-TEST(NumberTest, to_nearest_division_uses_dropped_digits_on_large_scale)
-{
-    for (auto const mantissaScale : MantissaRange::getAllScales())
-    {
-        NumberMantissaScaleGuard const mg{mantissaScale};
-        NumberRoundModeGuard const rg{Number::RoundingMode::ToNearest};
-
-        auto const scale = Number::getMantissaScale();
-
-        constexpr std::int64_t kAValue = 1'269'917'268'816'087'809LL;
-        constexpr std::int64_t kBValue = 3'458'525'013'821'685'511LL;
-        // kBValue is prime and in [minMantissa, kMaxRep].
-
-        Number const a{kAValue, 0};
-        Number const b{kBValue, 0};
-        Number const quotient = a / b;
-
-        Dec const exact = Dec(kAValue) / Dec(kBValue);
-        Dec const stored = Dec(quotient.mantissa()) * pow10(quotient.exponent());
-        Dec const diff = stored - exact;
-
-        auto const message = [&] {
-            std::ostringstream os;
-            os << "\n"
-               << "  a                 = " << kAValue << "\n"
-               << "  b                 = " << kBValue << "\n"
-               << "  exact a/b         = " << fmt(exact) << "\n"
-               << "  stored a/b        = " << fmt(stored) << "\n"
-               << "  stored - exact    = " << fmt(diff)
-               << "    (negative => ToNearest gave value BELOW truth)\n"
-               << "  quotient.mantissa = " << quotient.mantissa() << "\n"
-               << "  quotient.exponent = " << quotient.exponent() << "\n";
-            return os.str();
-        };
-
-        // ToNearest should account for dropped digits beyond the visible "5".
-        switch (scale)
-        {
-            case MantissaRange::MantissaScale::Large:
-                EXPECT_TRUE(stored >= exact) << message();
-                EXPECT_TRUE(diff < pow10(quotient.exponent())) << message();
-                break;
-
-            case MantissaRange::MantissaScale::LargeLegacy:
-                EXPECT_TRUE(stored < exact) << message();
-                EXPECT_TRUE(diff >= -pow10(quotient.exponent())) << message();
-                break;
-
-            case MantissaRange::MantissaScale::Small:
-                // Small mantissa doesn't have the correction for dropped remainders.
-                EXPECT_TRUE(stored < exact) << message();
-                break;
-        }
-    }
-}
+BEAST_DEFINE_TESTSUITE(Number, basics, xrpl);
 
 }  // namespace xrpl
diff --git a/src/test/basics/StringUtilities_test.cpp b/src/test/basics/StringUtilities_test.cpp
new file mode 100644
index 0000000000..e12bc53857
--- /dev/null
+++ b/src/test/basics/StringUtilities_test.cpp
@@ -0,0 +1,309 @@
+#include <xrpl/basics/Slice.h>
+#include <xrpl/basics/StringUtilities.h>
+#include <xrpl/basics/ToString.h>
+#include <xrpl/beast/unit_test/suite.h>
+
+#include <string>
+
+namespace xrpl {
+
+class StringUtilities_test : public beast::unit_test::Suite
+{
+public:
+    void
+    testUnHexSuccess(std::string const& strIn, std::string const& strExpected)
+    {
+        auto rv = strUnHex(strIn);
+        BEAST_EXPECT(rv);
+
+        // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+        BEAST_EXPECT(makeSlice(*rv) == makeSlice(strExpected));
+    }
+
+    void
+    testUnHexFailure(std::string const& strIn)
+    {
+        auto rv = strUnHex(strIn);
+        BEAST_EXPECT(!rv);
+    }
+
+    void
+    testUnHex()
+    {
+        testcase("strUnHex");
+
+        testUnHexSuccess("526970706c6544", "RippleD");
+        testUnHexSuccess("A", "\n");
+        testUnHexSuccess("0A", "\n");
+        testUnHexSuccess("D0A", "\r\n");
+        testUnHexSuccess("0D0A", "\r\n");
+        testUnHexSuccess("200D0A", " \r\n");
+        testUnHexSuccess("282A2B2C2D2E2F29", "(*+,-./)");
+
+        // Check for things which contain some or only invalid characters
+        testUnHexFailure("123X");
+        testUnHexFailure("V");
+        testUnHexFailure("XRP");
+    }
+
+    void
+    testParseUrl()
+    {
+        testcase("parseUrl");
+
+        // Expected passes.
+        {
+            ParsedUrl pUrl;
+            BEAST_EXPECT(parseUrl(pUrl, "scheme://"));
+            BEAST_EXPECT(pUrl.scheme == "scheme");
+            BEAST_EXPECT(pUrl.username.empty());
+            BEAST_EXPECT(pUrl.password.empty());
+            BEAST_EXPECT(pUrl.domain.empty());
+            BEAST_EXPECT(!pUrl.port);
+            // RFC 3986:
+            // > In general, a URI that uses the generic syntax for authority
+            //   with an empty path should be normalized to a path of "/".
+            // Do we want to normalize paths?
+            BEAST_EXPECT(pUrl.path.empty());
+        }
+
+        {
+            ParsedUrl pUrl;
+            BEAST_EXPECT(parseUrl(pUrl, "scheme:///"));
+            BEAST_EXPECT(pUrl.scheme == "scheme");
+            BEAST_EXPECT(pUrl.username.empty());
+            BEAST_EXPECT(pUrl.password.empty());
+            BEAST_EXPECT(pUrl.domain.empty());
+            BEAST_EXPECT(!pUrl.port);
+            BEAST_EXPECT(pUrl.path == "/");
+        }
+
+        {
+            ParsedUrl pUrl;
+            BEAST_EXPECT(parseUrl(pUrl, "lower://domain"));
+            BEAST_EXPECT(pUrl.scheme == "lower");
+            BEAST_EXPECT(pUrl.username.empty());
+            BEAST_EXPECT(pUrl.password.empty());
+            BEAST_EXPECT(pUrl.domain == "domain");
+            BEAST_EXPECT(!pUrl.port);
+            BEAST_EXPECT(pUrl.path.empty());
+        }
+
+        {
+            ParsedUrl pUrl;
+            BEAST_EXPECT(parseUrl(pUrl, "UPPER://domain:234/"));
+            BEAST_EXPECT(pUrl.scheme == "upper");
+            BEAST_EXPECT(pUrl.username.empty());
+            BEAST_EXPECT(pUrl.password.empty());
+            BEAST_EXPECT(pUrl.domain == "domain");
+            BEAST_EXPECT(*pUrl.port == 234);  // NOLINT(bugprone-unchecked-optional-access)
+            BEAST_EXPECT(pUrl.path == "/");
+        }
+
+        {
+            ParsedUrl pUrl;
+            BEAST_EXPECT(parseUrl(pUrl, "Mixed://domain/path"));
+            BEAST_EXPECT(pUrl.scheme == "mixed");
+            BEAST_EXPECT(pUrl.username.empty());
+            BEAST_EXPECT(pUrl.password.empty());
+            BEAST_EXPECT(pUrl.domain == "domain");
+            BEAST_EXPECT(!pUrl.port);
+            BEAST_EXPECT(pUrl.path == "/path");
+        }
+
+        {
+            ParsedUrl pUrl;
+            BEAST_EXPECT(parseUrl(pUrl, "scheme://[::1]:123/path"));
+            BEAST_EXPECT(pUrl.scheme == "scheme");
+            BEAST_EXPECT(pUrl.username.empty());
+            BEAST_EXPECT(pUrl.password.empty());
+            BEAST_EXPECT(pUrl.domain == "::1");
+            BEAST_EXPECT(*pUrl.port == 123);  // NOLINT(bugprone-unchecked-optional-access)
+            BEAST_EXPECT(pUrl.path == "/path");
+        }
+
+        {
+            ParsedUrl pUrl;
+            BEAST_EXPECT(parseUrl(pUrl, "scheme://user:pass@domain:123/abc:321"));
+            BEAST_EXPECT(pUrl.scheme == "scheme");
+            BEAST_EXPECT(pUrl.username == "user");
+            BEAST_EXPECT(pUrl.password == "pass");
+            BEAST_EXPECT(pUrl.domain == "domain");
+            BEAST_EXPECT(*pUrl.port == 123);  // NOLINT(bugprone-unchecked-optional-access)
+            BEAST_EXPECT(pUrl.path == "/abc:321");
+        }
+
+        {
+            ParsedUrl pUrl;
+            BEAST_EXPECT(parseUrl(pUrl, "scheme://user@domain:123/abc:321"));
+            BEAST_EXPECT(pUrl.scheme == "scheme");
+            BEAST_EXPECT(pUrl.username == "user");
+            BEAST_EXPECT(pUrl.password.empty());
+            BEAST_EXPECT(pUrl.domain == "domain");
+            BEAST_EXPECT(*pUrl.port == 123);  // NOLINT(bugprone-unchecked-optional-access)
+            BEAST_EXPECT(pUrl.path == "/abc:321");
+        }
+
+        {
+            ParsedUrl pUrl;
+            BEAST_EXPECT(parseUrl(pUrl, "scheme://:pass@domain:123/abc:321"));
+            BEAST_EXPECT(pUrl.scheme == "scheme");
+            BEAST_EXPECT(pUrl.username.empty());
+            BEAST_EXPECT(pUrl.password == "pass");
+            BEAST_EXPECT(pUrl.domain == "domain");
+            BEAST_EXPECT(*pUrl.port == 123);  // NOLINT(bugprone-unchecked-optional-access)
+            BEAST_EXPECT(pUrl.path == "/abc:321");
+        }
+
+        {
+            ParsedUrl pUrl;
+            BEAST_EXPECT(parseUrl(pUrl, "scheme://domain:123/abc:321"));
+            BEAST_EXPECT(pUrl.scheme == "scheme");
+            BEAST_EXPECT(pUrl.username.empty());
+            BEAST_EXPECT(pUrl.password.empty());
+            BEAST_EXPECT(pUrl.domain == "domain");
+            BEAST_EXPECT(*pUrl.port == 123);  // NOLINT(bugprone-unchecked-optional-access)
+            BEAST_EXPECT(pUrl.path == "/abc:321");
+        }
+
+        {
+            ParsedUrl pUrl;
+            BEAST_EXPECT(parseUrl(pUrl, "scheme://user:pass@domain/abc:321"));
+            BEAST_EXPECT(pUrl.scheme == "scheme");
+            BEAST_EXPECT(pUrl.username == "user");
+            BEAST_EXPECT(pUrl.password == "pass");
+            BEAST_EXPECT(pUrl.domain == "domain");
+            BEAST_EXPECT(!pUrl.port);
+            BEAST_EXPECT(pUrl.path == "/abc:321");
+        }
+
+        {
+            ParsedUrl pUrl;
+            BEAST_EXPECT(parseUrl(pUrl, "scheme://user@domain/abc:321"));
+            BEAST_EXPECT(pUrl.scheme == "scheme");
+            BEAST_EXPECT(pUrl.username == "user");
+            BEAST_EXPECT(pUrl.password.empty());
+            BEAST_EXPECT(pUrl.domain == "domain");
+            BEAST_EXPECT(!pUrl.port);
+            BEAST_EXPECT(pUrl.path == "/abc:321");
+        }
+
+        {
+            ParsedUrl pUrl;
+            BEAST_EXPECT(parseUrl(pUrl, "scheme://:pass@domain/abc:321"));
+            BEAST_EXPECT(pUrl.scheme == "scheme");
+            BEAST_EXPECT(pUrl.username.empty());
+            BEAST_EXPECT(pUrl.password == "pass");
+            BEAST_EXPECT(pUrl.domain == "domain");
+            BEAST_EXPECT(!pUrl.port);
+            BEAST_EXPECT(pUrl.path == "/abc:321");
+        }
+
+        {
+            ParsedUrl pUrl;
+            BEAST_EXPECT(parseUrl(pUrl, "scheme://domain/abc:321"));
+            BEAST_EXPECT(pUrl.scheme == "scheme");
+            BEAST_EXPECT(pUrl.username.empty());
+            BEAST_EXPECT(pUrl.password.empty());
+            BEAST_EXPECT(pUrl.domain == "domain");
+            BEAST_EXPECT(!pUrl.port);
+            BEAST_EXPECT(pUrl.path == "/abc:321");
+        }
+
+        {
+            ParsedUrl pUrl;
+            BEAST_EXPECT(parseUrl(pUrl, "scheme:///path/to/file"));
+            BEAST_EXPECT(pUrl.scheme == "scheme");
+            BEAST_EXPECT(pUrl.username.empty());
+            BEAST_EXPECT(pUrl.password.empty());
+            BEAST_EXPECT(pUrl.domain.empty());
+            BEAST_EXPECT(!pUrl.port);
+            BEAST_EXPECT(pUrl.path == "/path/to/file");
+        }
+
+        {
+            ParsedUrl pUrl;
+            BEAST_EXPECT(parseUrl(pUrl, "scheme://user:pass@domain/path/with/an@sign"));
+            BEAST_EXPECT(pUrl.scheme == "scheme");
+            BEAST_EXPECT(pUrl.username == "user");
+            BEAST_EXPECT(pUrl.password == "pass");
+            BEAST_EXPECT(pUrl.domain == "domain");
+            BEAST_EXPECT(!pUrl.port);
+            BEAST_EXPECT(pUrl.path == "/path/with/an@sign");
+        }
+
+        {
+            ParsedUrl pUrl;
+            BEAST_EXPECT(parseUrl(pUrl, "scheme://domain/path/with/an@sign"));
+            BEAST_EXPECT(pUrl.scheme == "scheme");
+            BEAST_EXPECT(pUrl.username.empty());
+            BEAST_EXPECT(pUrl.password.empty());
+            BEAST_EXPECT(pUrl.domain == "domain");
+            BEAST_EXPECT(!pUrl.port);
+            BEAST_EXPECT(pUrl.path == "/path/with/an@sign");
+        }
+
+        {
+            ParsedUrl pUrl;
+            BEAST_EXPECT(parseUrl(pUrl, "scheme://:999/"));
+            BEAST_EXPECT(pUrl.scheme == "scheme");
+            BEAST_EXPECT(pUrl.username.empty());
+            BEAST_EXPECT(pUrl.password.empty());
+            BEAST_EXPECT(pUrl.domain == ":999");
+            BEAST_EXPECT(!pUrl.port);
+            BEAST_EXPECT(pUrl.path == "/");
+        }
+
+        {
+            ParsedUrl pUrl;
+            BEAST_EXPECT(parseUrl(pUrl, "http://::1:1234/validators"));
+            BEAST_EXPECT(pUrl.scheme == "http");
+            BEAST_EXPECT(pUrl.username.empty());
+            BEAST_EXPECT(pUrl.password.empty());
+            BEAST_EXPECT(pUrl.domain == "::0.1.18.52");
+            BEAST_EXPECT(!pUrl.port);
+            BEAST_EXPECT(pUrl.path == "/validators");
+        }
+
+        // Expected fails.
+        {
+            ParsedUrl pUrl;
+            BEAST_EXPECT(!parseUrl(pUrl, ""));
+            BEAST_EXPECT(!parseUrl(pUrl, "nonsense"));
+            BEAST_EXPECT(!parseUrl(pUrl, "://"));
+            BEAST_EXPECT(!parseUrl(pUrl, ":///"));
+            BEAST_EXPECT(!parseUrl(pUrl, "scheme://user:pass@domain:65536/abc:321"));
+            BEAST_EXPECT(!parseUrl(pUrl, "UPPER://domain:23498765/"));
+            BEAST_EXPECT(!parseUrl(pUrl, "UPPER://domain:0/"));
+            BEAST_EXPECT(!parseUrl(pUrl, "UPPER://domain:+7/"));
+            BEAST_EXPECT(!parseUrl(pUrl, "UPPER://domain:-7234/"));
+            BEAST_EXPECT(!parseUrl(pUrl, "UPPER://domain:@#$56!/"));
+        }
+
+        {
+            std::string const strUrl("s://" + std::string(8192, ':'));
+            ParsedUrl pUrl;
+            BEAST_EXPECT(!parseUrl(pUrl, strUrl));
+        }
+    }
+
+    void
+    testToString()
+    {
+        testcase("toString");
+        auto result = to_string("hello");
+        BEAST_EXPECT(result == "hello");
+    }
+
+    void
+    run() override
+    {
+        testParseUrl();
+        testUnHex();
+        testToString();
+    }
+};
+
+BEAST_DEFINE_TESTSUITE(StringUtilities, basics, xrpl);
+
+}  // namespace xrpl
diff --git a/src/test/basics/TaggedCache_test.cpp b/src/test/basics/TaggedCache_test.cpp
new file mode 100644
index 0000000000..26564a4de8
--- /dev/null
+++ b/src/test/basics/TaggedCache_test.cpp
@@ -0,0 +1,251 @@
+#include <test/unit_test/SuiteJournal.h>
+
+#include <xrpl/basics/IntrusivePointer.h>
+#include <xrpl/basics/IntrusiveRefCounts.h>
+#include <xrpl/basics/TaggedCache.h>
+#include <xrpl/basics/TaggedCache.ipp>  // IWYU pragma: keep
+#include <xrpl/basics/chrono.h>
+#include <xrpl/beast/unit_test/suite.h>
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/protocol/Protocol.h>
+
+#include <memory>
+#include <utility>
+
+namespace xrpl {
+
+/*
+I guess you can put some items in, make sure they're still there. Let some
+time pass, make sure they're gone. Keep a strong pointer to one of them, make
+sure you can still find it even after time passes. Create two objects with
+the same key, canonicalize them both and make sure you get the same object.
+Put an object in but keep a strong pointer to it, advance the clock a lot,
+then canonicalize a new object with the same key, make sure you get the
+original object.
+*/
+
+class TaggedCache_test : public beast::unit_test::Suite
+{
+public:
+    void
+    run() override
+    {
+        using namespace std::chrono_literals;
+        using beast::Severity;
+        test::SuiteJournal journal("TaggedCache_test", *this);
+
+        TestStopwatch clock;
+        clock.set(0);
+
+        using Key = LedgerIndex;
+        using Value = std::string;
+        using Cache = TaggedCache<Key, Value>;
+
+        Cache c("test", 1, 1s, clock, journal);
+
+        // Insert an item, retrieve it, and age it so it gets purged.
+        {
+            BEAST_EXPECT(c.getCacheSize() == 0);
+            BEAST_EXPECT(c.getTrackSize() == 0);
+            BEAST_EXPECT(!c.insert(1, "one"));
+            BEAST_EXPECT(c.getCacheSize() == 1);
+            BEAST_EXPECT(c.getTrackSize() == 1);
+
+            {
+                std::string s;
+                BEAST_EXPECT(c.retrieve(1, s));
+                BEAST_EXPECT(s == "one");
+            }
+
+            ++clock;
+            c.sweep();
+            BEAST_EXPECT(c.getCacheSize() == 0);
+            BEAST_EXPECT(c.getTrackSize() == 0);
+        }
+
+        // Insert an item, maintain a strong pointer, age it, and
+        // verify that the entry still exists.
+        {
+            BEAST_EXPECT(!c.insert(2, "two"));
+            BEAST_EXPECT(c.getCacheSize() == 1);
+            BEAST_EXPECT(c.getTrackSize() == 1);
+
+            {
+                auto p = c.fetch(2);
+                BEAST_EXPECT(p != nullptr);
+                ++clock;
+                c.sweep();
+                BEAST_EXPECT(c.getCacheSize() == 0);
+                BEAST_EXPECT(c.getTrackSize() == 1);
+            }
+
+            // Make sure its gone now that our reference is gone
+            ++clock;
+            c.sweep();
+            BEAST_EXPECT(c.getCacheSize() == 0);
+            BEAST_EXPECT(c.getTrackSize() == 0);
+        }
+
+        // Insert the same key/value pair and make sure we get the same result
+        {
+            BEAST_EXPECT(!c.insert(3, "three"));
+
+            {
+                auto const p1 = c.fetch(3);
+                auto p2 = std::make_shared<Value>("three");
+                c.canonicalizeReplaceClient(3, p2);
+                BEAST_EXPECT(p1.get() == p2.get());
+            }
+            ++clock;
+            c.sweep();
+            BEAST_EXPECT(c.getCacheSize() == 0);
+            BEAST_EXPECT(c.getTrackSize() == 0);
+        }
+
+        // Put an object in but keep a strong pointer to it, advance the clock a
+        // lot, then canonicalize a new object with the same key, make sure you
+        // get the original object.
+        {
+            // Put an object in
+            BEAST_EXPECT(!c.insert(4, "four"));
+            BEAST_EXPECT(c.getCacheSize() == 1);
+            BEAST_EXPECT(c.getTrackSize() == 1);
+
+            {
+                // Keep a strong pointer to it
+                auto const p1 = c.fetch(4);
+                BEAST_EXPECT(p1 != nullptr);
+                BEAST_EXPECT(c.getCacheSize() == 1);
+                BEAST_EXPECT(c.getTrackSize() == 1);
+                // Advance the clock a lot
+                ++clock;
+                c.sweep();
+                BEAST_EXPECT(c.getCacheSize() == 0);
+                BEAST_EXPECT(c.getTrackSize() == 1);
+                // Canonicalize a new object with the same key
+                auto p2 = std::make_shared<std::string>("four");
+                BEAST_EXPECT(c.canonicalizeReplaceClient(4, p2));
+                BEAST_EXPECT(c.getCacheSize() == 1);
+                BEAST_EXPECT(c.getTrackSize() == 1);
+                // Make sure we get the original object
+                BEAST_EXPECT(p1.get() == p2.get());
+            }
+
+            ++clock;
+            c.sweep();
+            BEAST_EXPECT(c.getCacheSize() == 0);
+            BEAST_EXPECT(c.getTrackSize() == 0);
+        }
+        {
+            BEAST_EXPECT(!c.insert(5, "five"));
+            BEAST_EXPECT(c.getCacheSize() == 1);
+            BEAST_EXPECT(c.size() == 1);
+
+            {
+                auto const p1 = c.fetch(5);
+                BEAST_EXPECT(p1 != nullptr);
+                BEAST_EXPECT(c.getCacheSize() == 1);
+                BEAST_EXPECT(c.size() == 1);
+
+                // Advance the clock a lot
+                ++clock;
+                c.sweep();
+                BEAST_EXPECT(c.getCacheSize() == 0);
+                BEAST_EXPECT(c.size() == 1);
+
+                auto p2 = std::make_shared<std::string>("five_2");
+                BEAST_EXPECT(c.canonicalizeReplaceCache(5, p2));
+                BEAST_EXPECT(c.getCacheSize() == 1);
+                BEAST_EXPECT(c.size() == 1);
+                // Make sure the caller's original pointer is unchanged
+                BEAST_EXPECT(p1.get() != p2.get());
+                BEAST_EXPECT(*p2 == "five_2");
+
+                auto const p3 = c.fetch(5);
+                BEAST_EXPECT(p3 != nullptr);
+                BEAST_EXPECT(p3.get() == p2.get());
+                BEAST_EXPECT(p3.get() != p1.get());
+            }
+
+            ++clock;
+            c.sweep();
+            BEAST_EXPECT(c.getCacheSize() == 0);
+            BEAST_EXPECT(c.size() == 0);
+        }
+
+        {
+            testcase("intrptr");
+
+            struct MyRefCountObject : IntrusiveRefCounts
+            {
+                std::string data;
+
+                // Needed to support weak intrusive pointers
+                virtual void
+                partialDestructor() {};
+
+                MyRefCountObject() = default;
+                explicit MyRefCountObject(std::string data) : data(std::move(data))
+                {
+                }
+
+                bool
+                operator==(std::string const& other) const
+                {
+                    return data == other;
+                }
+            };
+
+            using IntrPtrCache = TaggedCache<
+                Key,
+                MyRefCountObject,
+                /*IsKeyCache*/ false,
+                intr_ptr::SharedWeakUnionPtr<MyRefCountObject>,
+                intr_ptr::SharedPtr<MyRefCountObject>>;
+
+            IntrPtrCache intrPtrCache("IntrPtrTest", 1, 1s, clock, journal);
+
+            intrPtrCache.canonicalizeReplaceCache(1, intr_ptr::makeShared<MyRefCountObject>("one"));
+            BEAST_EXPECT(intrPtrCache.getCacheSize() == 1);
+            BEAST_EXPECT(intrPtrCache.size() == 1);
+
+            {
+                {
+                    intrPtrCache.canonicalizeReplaceCache(
+                        1, intr_ptr::makeShared<MyRefCountObject>("one_replaced"));
+
+                    auto p = intrPtrCache.fetch(1);
+                    BEAST_EXPECT(*p == "one_replaced");
+
+                    // Advance the clock a lot
+                    ++clock;
+                    intrPtrCache.sweep();
+                    BEAST_EXPECT(intrPtrCache.getCacheSize() == 0);
+                    BEAST_EXPECT(intrPtrCache.size() == 1);
+
+                    intrPtrCache.canonicalizeReplaceCache(
+                        1, intr_ptr::makeShared<MyRefCountObject>("one_replaced_2"));
+
+                    auto p2 = intrPtrCache.fetch(1);
+                    BEAST_EXPECT(*p2 == "one_replaced_2");
+
+                    intrPtrCache.del(1, true);
+                }
+
+                intrPtrCache.canonicalizeReplaceCache(
+                    1, intr_ptr::makeShared<MyRefCountObject>("one_replaced_3"));
+                auto p3 = intrPtrCache.fetch(1);
+                BEAST_EXPECT(*p3 == "one_replaced_3");
+            }
+
+            ++clock;
+            intrPtrCache.sweep();
+            BEAST_EXPECT(intrPtrCache.getCacheSize() == 0);
+            BEAST_EXPECT(intrPtrCache.size() == 0);
+        }
+    }
+};
+
+BEAST_DEFINE_TESTSUITE(TaggedCache, basics, xrpl);
+
+}  // namespace xrpl
diff --git a/src/test/basics/Units_test.cpp b/src/test/basics/Units_test.cpp
new file mode 100644
index 0000000000..dc780166c6
--- /dev/null
+++ b/src/test/basics/Units_test.cpp
@@ -0,0 +1,344 @@
+#include <xrpl/beast/unit_test/suite.h>
+#include <xrpl/beast/utility/Zero.h>
+#include <xrpl/json/json_value.h>
+#include <xrpl/protocol/SystemParameters.h>
+#include <xrpl/protocol/Units.h>
+#include <xrpl/protocol/XRPAmount.h>
+
+#include <cstdint>
+#include <limits>
+#include <type_traits>
+
+namespace xrpl::test {
+
+class units_test : public beast::unit_test::Suite
+{
+private:
+    void
+    testTypes()
+    {
+        using FeeLevel32 = FeeLevel<std::uint32_t>;
+
+        {
+            XRPAmount const x{100};
+            BEAST_EXPECT(x.drops() == 100);
+            BEAST_EXPECT((std::is_same_v<decltype(x)::unit_type, unit::dropTag>));
+            auto y = 4u * x;
+            BEAST_EXPECT(y.value() == 400);
+            BEAST_EXPECT((std::is_same_v<decltype(y)::unit_type, unit::dropTag>));
+
+            auto z = 4 * y;
+            BEAST_EXPECT(z.value() == 1600);
+            BEAST_EXPECT((std::is_same_v<decltype(z)::unit_type, unit::dropTag>));
+
+            FeeLevel32 const f{10};
+            FeeLevel32 const baseFee{100};
+
+            auto drops = mulDiv(baseFee, x, f);
+
+            BEAST_EXPECT(drops);
+            BEAST_EXPECT(drops.value() == 1000);  // NOLINT(bugprone-unchecked-optional-access)
+            BEAST_EXPECT((std::is_same_v<
+                          std::remove_reference_t<decltype(*drops)>::unit_type,
+                          unit::dropTag>));
+
+            BEAST_EXPECT((std::is_same_v<std::remove_reference_t<decltype(*drops)>, XRPAmount>));
+        }
+        {
+            XRPAmount const x{100};
+            BEAST_EXPECT(x.value() == 100);
+            BEAST_EXPECT((std::is_same_v<decltype(x)::unit_type, unit::dropTag>));
+            auto y = 4u * x;
+            BEAST_EXPECT(y.value() == 400);
+            BEAST_EXPECT((std::is_same_v<decltype(y)::unit_type, unit::dropTag>));
+
+            FeeLevel64 const f{10};
+            FeeLevel64 const baseFee{100};
+
+            auto drops = mulDiv(baseFee, x, f);
+
+            BEAST_EXPECT(drops);
+            BEAST_EXPECT(drops.value() == 1000);  // NOLINT(bugprone-unchecked-optional-access)
+            BEAST_EXPECT((std::is_same_v<
+                          std::remove_reference_t<decltype(*drops)>::unit_type,
+                          unit::dropTag>));
+            BEAST_EXPECT((std::is_same_v<std::remove_reference_t<decltype(*drops)>, XRPAmount>));
+        }
+        {
+            FeeLevel64 const x{1024};
+            BEAST_EXPECT(x.value() == 1024);
+            BEAST_EXPECT((std::is_same_v<decltype(x)::unit_type, unit::feelevelTag>));
+            std::uint64_t const m = 4;
+            auto y = m * x;
+            BEAST_EXPECT(y.value() == 4096);
+            BEAST_EXPECT((std::is_same_v<decltype(y)::unit_type, unit::feelevelTag>));
+
+            XRPAmount const basefee{10};
+            FeeLevel64 const referencefee{256};
+
+            auto drops = mulDiv(x, basefee, referencefee);
+
+            BEAST_EXPECT(drops);
+            BEAST_EXPECT(drops.value() == 40);  // NOLINT(bugprone-unchecked-optional-access)
+            BEAST_EXPECT((std::is_same_v<
+                          std::remove_reference_t<decltype(*drops)>::unit_type,
+                          unit::dropTag>));
+            BEAST_EXPECT((std::is_same_v<std::remove_reference_t<decltype(*drops)>, XRPAmount>));
+        }
+    }
+
+    void
+    testJson()
+    {
+        // Json value functionality
+        using FeeLevel32 = FeeLevel<std::uint32_t>;
+
+        {
+            FeeLevel32 const x{std::numeric_limits<std::uint32_t>::max()};
+            auto y = x.jsonClipped();
+            BEAST_EXPECT(y.type() == json::ValueType::UInt);
+            BEAST_EXPECT(y == json::Value{x.fee()});
+        }
+
+        {
+            FeeLevel32 const x{std::numeric_limits<std::uint32_t>::min()};
+            auto y = x.jsonClipped();
+            BEAST_EXPECT(y.type() == json::ValueType::UInt);
+            BEAST_EXPECT(y == json::Value{x.fee()});
+        }
+
+        {
+            FeeLevel64 const x{std::numeric_limits<std::uint64_t>::max()};
+            auto y = x.jsonClipped();
+            BEAST_EXPECT(y.type() == json::ValueType::UInt);
+            BEAST_EXPECT(y == json::Value{std::numeric_limits<std::uint32_t>::max()});
+        }
+
+        {
+            FeeLevel64 const x{std::numeric_limits<std::uint64_t>::min()};
+            auto y = x.jsonClipped();
+            BEAST_EXPECT(y.type() == json::ValueType::UInt);
+            BEAST_EXPECT(y == json::Value{0});
+        }
+
+        {
+            FeeLevelDouble const x{std::numeric_limits<double>::max()};
+            auto y = x.jsonClipped();
+            BEAST_EXPECT(y.type() == json::ValueType::Real);
+            BEAST_EXPECT(y == json::Value{std::numeric_limits<double>::max()});
+        }
+
+        {
+            FeeLevelDouble const x{std::numeric_limits<double>::min()};
+            auto y = x.jsonClipped();
+            BEAST_EXPECT(y.type() == json::ValueType::Real);
+            BEAST_EXPECT(y == json::Value{std::numeric_limits<double>::min()});
+        }
+
+        {
+            XRPAmount const x{std::numeric_limits<std::int64_t>::max()};
+            auto y = x.jsonClipped();
+            BEAST_EXPECT(y.type() == json::ValueType::Int);
+            BEAST_EXPECT(y == json::Value{std::numeric_limits<std::int32_t>::max()});
+        }
+
+        {
+            XRPAmount const x{std::numeric_limits<std::int64_t>::min()};
+            auto y = x.jsonClipped();
+            BEAST_EXPECT(y.type() == json::ValueType::Int);
+            BEAST_EXPECT(y == json::Value{std::numeric_limits<std::int32_t>::min()});
+        }
+    }
+
+    void
+    testFunctions()
+    {
+        // Explicitly test every defined function for the ValueUnit class
+        // since some of them are templated, but not used anywhere else.
+        using FeeLevel32 = FeeLevel<std::uint32_t>;
+
+        {
+            auto make = [&](auto x) -> FeeLevel64 { return x; };
+            auto explicitmake = [&](auto x) -> FeeLevel64 { return FeeLevel64{x}; };
+
+            [[maybe_unused]]
+            FeeLevel64 const defaulted{};
+            FeeLevel64 test{0};
+            BEAST_EXPECT(test.fee() == 0);
+
+            test = explicitmake(beast::kZero);
+            BEAST_EXPECT(test.fee() == 0);
+
+            test = beast::kZero;
+            BEAST_EXPECT(test.fee() == 0);
+
+            test = explicitmake(100u);
+            BEAST_EXPECT(test.fee() == 100);
+
+            FeeLevel64 const targetSame{200u};
+            FeeLevel32 const targetOther{300u};
+            test = make(targetSame);
+            BEAST_EXPECT(test.fee() == 200);
+            BEAST_EXPECT(test == targetSame);
+            BEAST_EXPECT(test < FeeLevel64{1000});
+            BEAST_EXPECT(test > FeeLevel64{100});
+            test = make(targetOther);
+            BEAST_EXPECT(test.fee() == 300);
+            BEAST_EXPECT(test == targetOther);
+
+            test = std::uint64_t(200);
+            BEAST_EXPECT(test.fee() == 200);
+            test = std::uint32_t(300);
+            BEAST_EXPECT(test.fee() == 300);
+
+            test = targetSame;
+            BEAST_EXPECT(test.fee() == 200);
+            test = targetOther.fee();
+            BEAST_EXPECT(test.fee() == 300);
+            BEAST_EXPECT(test == targetOther);
+
+            test = targetSame * 2;
+            BEAST_EXPECT(test.fee() == 400);
+            test = 3 * targetSame;
+            BEAST_EXPECT(test.fee() == 600);
+            test = targetSame / 10;
+            BEAST_EXPECT(test.fee() == 20);
+
+            test += targetSame;
+            BEAST_EXPECT(test.fee() == 220);
+
+            test -= targetSame;
+            BEAST_EXPECT(test.fee() == 20);
+
+            test++;
+            BEAST_EXPECT(test.fee() == 21);
+            ++test;
+            BEAST_EXPECT(test.fee() == 22);
+            test--;
+            BEAST_EXPECT(test.fee() == 21);
+            --test;
+            BEAST_EXPECT(test.fee() == 20);
+
+            test *= 5;
+            BEAST_EXPECT(test.fee() == 100);
+            test /= 2;
+            BEAST_EXPECT(test.fee() == 50);
+            test %= 13;
+            BEAST_EXPECT(test.fee() == 11);
+
+            /*
+            // illegal with unsigned
+            test = -test;
+            BEAST_EXPECT(test.fee() == -11);
+            BEAST_EXPECT(test.signum() == -1);
+            BEAST_EXPECT(to_string(test) == "-11");
+            */
+
+            BEAST_EXPECT(test);
+            test = 0;
+            BEAST_EXPECT(!test);
+            BEAST_EXPECT(test.signum() == 0);
+            test = targetSame;
+            BEAST_EXPECT(test.signum() == 1);
+            BEAST_EXPECT(to_string(test) == "200");
+        }
+        {
+            auto make = [&](auto x) -> FeeLevelDouble { return x; };
+            auto explicitmake = [&](auto x) -> FeeLevelDouble { return FeeLevelDouble{x}; };
+
+            [[maybe_unused]]
+            FeeLevelDouble const defaulted{};
+            FeeLevelDouble test{0};
+            BEAST_EXPECT(test.fee() == 0);
+
+            test = explicitmake(beast::kZero);
+            BEAST_EXPECT(test.fee() == 0);
+
+            test = beast::kZero;
+            BEAST_EXPECT(test.fee() == 0);
+
+            test = explicitmake(100.0);
+            BEAST_EXPECT(test.fee() == 100);
+
+            FeeLevelDouble const targetSame{200.0};
+            FeeLevel64 const targetOther{300};
+            test = make(targetSame);
+            BEAST_EXPECT(test.fee() == 200);
+            BEAST_EXPECT(test == targetSame);
+            BEAST_EXPECT(test < FeeLevelDouble{1000.0});
+            BEAST_EXPECT(test > FeeLevelDouble{100.0});
+            test = targetOther.fee();
+            BEAST_EXPECT(test.fee() == 300);
+            BEAST_EXPECT(test == targetOther);
+
+            test = 200.0;
+            BEAST_EXPECT(test.fee() == 200);
+            test = std::uint64_t(300);
+            BEAST_EXPECT(test.fee() == 300);
+
+            test = targetSame;
+            BEAST_EXPECT(test.fee() == 200);
+
+            test = targetSame * 2;
+            BEAST_EXPECT(test.fee() == 400);
+            test = 3 * targetSame;
+            BEAST_EXPECT(test.fee() == 600);
+            test = targetSame / 10;
+            BEAST_EXPECT(test.fee() == 20);
+
+            test += targetSame;
+            BEAST_EXPECT(test.fee() == 220);
+
+            test -= targetSame;
+            BEAST_EXPECT(test.fee() == 20);
+
+            test++;
+            BEAST_EXPECT(test.fee() == 21);
+            ++test;
+            BEAST_EXPECT(test.fee() == 22);
+            test--;
+            BEAST_EXPECT(test.fee() == 21);
+            --test;
+            BEAST_EXPECT(test.fee() == 20);
+
+            test *= 5;
+            BEAST_EXPECT(test.fee() == 100);
+            test /= 2;
+            BEAST_EXPECT(test.fee() == 50);
+            /* illegal with floating
+            test %= 13;
+            BEAST_EXPECT(test.fee() == 11);
+            */
+
+            // legal with signed
+            test = -test;
+            BEAST_EXPECT(test.fee() == -50);
+            BEAST_EXPECT(test.signum() == -1);
+            BEAST_EXPECT(to_string(test) == "-50.000000");
+
+            BEAST_EXPECT(test);
+            test = 0;
+            BEAST_EXPECT(!test);
+            BEAST_EXPECT(test.signum() == 0);
+            test = targetSame;
+            BEAST_EXPECT(test.signum() == 1);
+            BEAST_EXPECT(to_string(test) == "200.000000");
+        }
+    }
+
+public:
+    void
+    run() override
+    {
+        BEAST_EXPECT(kInitialXrp.drops() == 100'000'000'000'000'000);
+        BEAST_EXPECT(kInitialXrp == XRPAmount{100'000'000'000'000'000});
+
+        testTypes();
+        testJson();
+        testFunctions();
+    }
+};
+
+BEAST_DEFINE_TESTSUITE(units, basics, xrpl);
+
+}  // namespace xrpl::test
diff --git a/src/test/basics/XRPAmount_test.cpp b/src/test/basics/XRPAmount_test.cpp
new file mode 100644
index 0000000000..f393003365
--- /dev/null
+++ b/src/test/basics/XRPAmount_test.cpp
@@ -0,0 +1,326 @@
+#include <xrpl/beast/unit_test/suite.h>
+#include <xrpl/beast/utility/Zero.h>
+#include <xrpl/protocol/XRPAmount.h>
+
+#include <cstdint>
+#include <limits>
+
+namespace xrpl {
+
+class XRPAmount_test : public beast::unit_test::Suite
+{
+public:
+    void
+    testSigNum()
+    {
+        testcase("signum");
+
+        for (auto i : {-1, 0, 1})
+        {
+            XRPAmount const x(i);
+
+            if (i < 0)
+            {
+                BEAST_EXPECT(x.signum() < 0);
+            }
+            else if (i > 0)
+            {
+                BEAST_EXPECT(x.signum() > 0);
+            }
+            else
+            {
+                BEAST_EXPECT(x.signum() == 0);
+            }
+        }
+    }
+
+    void
+    testBeastZero()
+    {
+        testcase("beast::Zero Comparisons");
+
+        using beast::kZero;
+
+        for (auto i : {-1, 0, 1})
+        {
+            XRPAmount const x(i);
+
+            BEAST_EXPECT((i == 0) == (x == kZero));
+            BEAST_EXPECT((i != 0) == (x != kZero));
+            BEAST_EXPECT((i < 0) == (x < kZero));
+            BEAST_EXPECT((i > 0) == (x > kZero));
+            BEAST_EXPECT((i <= 0) == (x <= kZero));
+            BEAST_EXPECT((i >= 0) == (x >= kZero));
+
+            BEAST_EXPECT((0 == i) == (kZero == x));
+            BEAST_EXPECT((0 != i) == (kZero != x));
+            BEAST_EXPECT((0 < i) == (kZero < x));
+            BEAST_EXPECT((0 > i) == (kZero > x));
+            BEAST_EXPECT((0 <= i) == (kZero <= x));
+            BEAST_EXPECT((0 >= i) == (kZero >= x));
+        }
+    }
+
+    void
+    testComparisons()
+    {
+        testcase("XRP Comparisons");
+
+        for (auto i : {-1, 0, 1})
+        {
+            XRPAmount const x(i);
+
+            for (auto j : {-1, 0, 1})
+            {
+                XRPAmount const y(j);
+
+                BEAST_EXPECT((i == j) == (x == y));
+                BEAST_EXPECT((i != j) == (x != y));
+                BEAST_EXPECT((i < j) == (x < y));
+                BEAST_EXPECT((i > j) == (x > y));
+                BEAST_EXPECT((i <= j) == (x <= y));
+                BEAST_EXPECT((i >= j) == (x >= y));
+            }
+        }
+    }
+
+    void
+    testAddSub()
+    {
+        testcase("Addition & Subtraction");
+
+        for (auto i : {-1, 0, 1})
+        {
+            XRPAmount const x(i);
+
+            for (auto j : {-1, 0, 1})
+            {
+                XRPAmount const y(j);
+
+                BEAST_EXPECT(XRPAmount(i + j) == (x + y));
+                BEAST_EXPECT(XRPAmount(i - j) == (x - y));
+
+                BEAST_EXPECT((x + y) == (y + x));  // addition is commutative
+            }
+        }
+    }
+
+    void
+    testDecimal()
+    {
+        // Tautology
+        BEAST_EXPECT(kDropsPerXrp.decimalXRP() == 1);
+
+        XRPAmount test{1};
+        BEAST_EXPECT(test.decimalXRP() == 0.000001);
+
+        test = -test;
+        BEAST_EXPECT(test.decimalXRP() == -0.000001);
+
+        test = 100'000'000;
+        BEAST_EXPECT(test.decimalXRP() == 100);
+
+        test = -test;
+        BEAST_EXPECT(test.decimalXRP() == -100);
+    }
+
+    void
+    testFunctions()
+    {
+        // Explicitly test every defined function for the XRPAmount class
+        // since some of them are templated, but not used anywhere else.
+        auto make = [&](auto x) -> XRPAmount { return XRPAmount{x}; };
+
+        XRPAmount const defaulted{};
+        (void)defaulted;
+        XRPAmount test{0};
+        BEAST_EXPECT(test.drops() == 0);
+
+        test = make(beast::kZero);
+        BEAST_EXPECT(test.drops() == 0);
+
+        test = beast::kZero;
+        BEAST_EXPECT(test.drops() == 0);
+
+        test = make(100);
+        BEAST_EXPECT(test.drops() == 100);
+
+        test = make(100u);
+        BEAST_EXPECT(test.drops() == 100);
+
+        XRPAmount const targetSame{200u};
+        test = make(targetSame);
+        BEAST_EXPECT(test.drops() == 200);
+        BEAST_EXPECT(test == targetSame);
+        BEAST_EXPECT(test < XRPAmount{1000});
+        BEAST_EXPECT(test > XRPAmount{100});
+
+        test = std::int64_t(200);
+        BEAST_EXPECT(test.drops() == 200);
+        test = std::uint32_t(300);
+        BEAST_EXPECT(test.drops() == 300);
+
+        test = targetSame;
+        BEAST_EXPECT(test.drops() == 200);
+        auto testOther = test.dropsAs<std::uint32_t>();
+        BEAST_EXPECT(testOther);
+        BEAST_EXPECT(*testOther == 200);  // NOLINT(bugprone-unchecked-optional-access)
+        test = std::numeric_limits<std::uint64_t>::max();
+        testOther = test.dropsAs<std::uint32_t>();
+        BEAST_EXPECT(!testOther);
+        test = -1;
+        testOther = test.dropsAs<std::uint32_t>();
+        BEAST_EXPECT(!testOther);
+
+        test = targetSame * 2;
+        BEAST_EXPECT(test.drops() == 400);
+        test = 3 * targetSame;
+        BEAST_EXPECT(test.drops() == 600);
+        test = 20;
+        BEAST_EXPECT(test.drops() == 20);
+
+        test += targetSame;
+        BEAST_EXPECT(test.drops() == 220);
+
+        test -= targetSame;
+        BEAST_EXPECT(test.drops() == 20);
+
+        test *= 5;
+        BEAST_EXPECT(test.drops() == 100);
+        test = 50;
+        BEAST_EXPECT(test.drops() == 50);
+        test -= 39;
+        BEAST_EXPECT(test.drops() == 11);
+
+        // legal with signed
+        test = -test;
+        BEAST_EXPECT(test.drops() == -11);
+        BEAST_EXPECT(test.signum() == -1);
+        BEAST_EXPECT(to_string(test) == "-11");
+
+        BEAST_EXPECT(test);
+        test = 0;
+        BEAST_EXPECT(!test);
+        BEAST_EXPECT(test.signum() == 0);
+        test = targetSame;
+        BEAST_EXPECT(test.signum() == 1);
+        BEAST_EXPECT(to_string(test) == "200");
+    }
+
+    void
+    testMulRatio()
+    {
+        testcase("mulRatio");
+
+        constexpr auto kMaxUInt32 = std::numeric_limits<std::uint32_t>::max();
+        constexpr auto kMaxXrp = std::numeric_limits<XRPAmount::value_type>::max();
+        constexpr auto kMinXrp = std::numeric_limits<XRPAmount::value_type>::min();
+
+        {
+            // multiply by a number that would overflow then divide by the same
+            // number, and check we didn't lose any value
+            XRPAmount big(kMaxXrp);
+            BEAST_EXPECT(big == mulRatio(big, kMaxUInt32, kMaxUInt32, true));
+            // rounding mode shouldn't matter as the result is exact
+            BEAST_EXPECT(big == mulRatio(big, kMaxUInt32, kMaxUInt32, false));
+
+            // multiply and divide by values that would overflow if done
+            // naively, and check that it gives the correct answer
+            big -= 0xf;  // Subtract a little so it's divisible by 4
+            BEAST_EXPECT(mulRatio(big, 3, 4, false).value() == (big.value() / 4) * 3);
+            BEAST_EXPECT(mulRatio(big, 3, 4, true).value() == (big.value() / 4) * 3);
+            BEAST_EXPECT((big.value() * 3) / 4 != (big.value() / 4) * 3);
+        }
+
+        {
+            // Similar test as above, but for negative values
+            XRPAmount big(kMinXrp);  // NOLINT TODO
+            BEAST_EXPECT(big == mulRatio(big, kMaxUInt32, kMaxUInt32, true));
+            // rounding mode shouldn't matter as the result is exact
+            BEAST_EXPECT(big == mulRatio(big, kMaxUInt32, kMaxUInt32, false));
+
+            // multiply and divide by values that would overflow if done
+            // naively, and check that it gives the correct answer
+            BEAST_EXPECT(mulRatio(big, 3, 4, false).value() == (big.value() / 4) * 3);
+            BEAST_EXPECT(mulRatio(big, 3, 4, true).value() == (big.value() / 4) * 3);
+            BEAST_EXPECT((big.value() * 3) / 4 != (big.value() / 4) * 3);
+        }
+
+        {
+            // small amounts
+            XRPAmount const tiny(1);
+            // Round up should give the smallest allowable number
+            BEAST_EXPECT(tiny == mulRatio(tiny, 1, kMaxUInt32, true));
+            // rounding down should be zero
+            BEAST_EXPECT(beast::kZero == mulRatio(tiny, 1, kMaxUInt32, false));
+            BEAST_EXPECT(beast::kZero == mulRatio(tiny, kMaxUInt32 - 1, kMaxUInt32, false));
+
+            // tiny negative numbers
+            XRPAmount const tinyNeg(-1);
+            // Round up should give zero
+            BEAST_EXPECT(beast::kZero == mulRatio(tinyNeg, 1, kMaxUInt32, true));
+            BEAST_EXPECT(beast::kZero == mulRatio(tinyNeg, kMaxUInt32 - 1, kMaxUInt32, true));
+            // rounding down should be tiny
+            BEAST_EXPECT(tinyNeg == mulRatio(tinyNeg, kMaxUInt32 - 1, kMaxUInt32, false));
+        }
+
+        {  // rounding
+            {
+                XRPAmount const one(1);
+                auto const rup = mulRatio(one, kMaxUInt32 - 1, kMaxUInt32, true);
+                auto const rdown = mulRatio(one, kMaxUInt32 - 1, kMaxUInt32, false);
+                BEAST_EXPECT(rup.drops() - rdown.drops() == 1);
+            }
+
+            {
+                XRPAmount const big(kMaxXrp);
+                auto const rup = mulRatio(big, kMaxUInt32 - 1, kMaxUInt32, true);
+                auto const rdown = mulRatio(big, kMaxUInt32 - 1, kMaxUInt32, false);
+                BEAST_EXPECT(rup.drops() - rdown.drops() == 1);
+            }
+
+            {
+                XRPAmount const negOne(-1);
+                auto const rup = mulRatio(negOne, kMaxUInt32 - 1, kMaxUInt32, true);
+                auto const rdown = mulRatio(negOne, kMaxUInt32 - 1, kMaxUInt32, false);
+                BEAST_EXPECT(rup.drops() - rdown.drops() == 1);
+            }
+        }
+
+        {
+            // division by zero
+            XRPAmount one(1);
+            except([&] { mulRatio(one, 1, 0, true); });
+        }
+
+        {
+            // overflow
+            XRPAmount big(kMaxXrp);
+            except([&] { mulRatio(big, 2, 1, true); });
+        }
+
+        {
+            // underflow
+            XRPAmount const bigNegative(kMinXrp + 10);
+            BEAST_EXPECT(mulRatio(bigNegative, 2, 1, true) == kMinXrp);
+        }
+    }  // namespace xrpl
+
+    //--------------------------------------------------------------------------
+
+    void
+    run() override
+    {
+        testSigNum();
+        testBeastZero();
+        testComparisons();
+        testAddSub();
+        testDecimal();
+        testFunctions();
+        testMulRatio();
+    }
+};
+
+BEAST_DEFINE_TESTSUITE(XRPAmount, basics, xrpl);
+
+}  // namespace xrpl
diff --git a/src/test/basics/base58_test.cpp b/src/test/basics/base58_test.cpp
new file mode 100644
index 0000000000..3c76308813
--- /dev/null
+++ b/src/test/basics/base58_test.cpp
@@ -0,0 +1,439 @@
+#include <xrpl/beast/unit_test/suite.h>
+#include <xrpl/protocol/detail/token_errors.h>
+
+#include <boost/multiprecision/cpp_int.hpp>  // IWYU pragma: keep
+
+#include <algorithm>
+#include <cassert>
+#include <cstdint>
+#include <cstring>
+#include <iomanip>
+#include <iostream>
+#include <limits>
+#include <stdexcept>
+#include <string>
+#include <tuple>
+#include <vector>
+#ifndef _MSC_VER
+
+#include <xrpl/protocol/detail/b58_utils.h>
+#include <xrpl/protocol/tokens.h>
+
+#include <array>
+#include <cstddef>
+#include <random>
+#include <span>
+#include <sstream>
+
+namespace xrpl::test {
+namespace {
+
+[[nodiscard]] inline auto
+randEngine() -> std::mt19937&
+{
+    static std::mt19937 kR = [] {
+        std::random_device rd;
+        return std::mt19937{rd()};
+    }();
+    return kR;
+}
+
+constexpr int kNumTokenTypeIndexes = 9;
+
+[[nodiscard]] inline auto
+tokenTypeAndSize(int i) -> std::tuple<xrpl::TokenType, std::size_t>
+{
+    assert(i < kNumTokenTypeIndexes);
+
+    switch (i)
+    {
+        using enum xrpl::TokenType;
+        case 0:
+            return {None, 20};
+        case 1:
+            return {NodePublic, 32};
+        case 2:
+            return {NodePublic, 33};
+        case 3:
+            return {NodePrivate, 32};
+        case 4:
+            return {AccountID, 20};
+        case 5:
+            return {AccountPublic, 32};
+        case 6:
+            return {AccountPublic, 33};
+        case 7:
+            return {AccountSecret, 32};
+        case 8:
+            return {FamilySeed, 16};
+        default:
+            throw std::invalid_argument(
+                "Invalid token selection passed to tokenTypeAndSize() "
+                "in " __FILE__);
+    }
+}
+
+[[nodiscard]] inline auto
+randomTokenTypeAndSize() -> std::tuple<xrpl::TokenType, std::size_t>
+{
+    using namespace xrpl;
+    auto& rng = randEngine();
+    std::uniform_int_distribution<> d(0, 8);
+    return tokenTypeAndSize(d(rng));
+}
+
+// Return the token type and subspan of `d` to use as test data.
+[[nodiscard]] inline auto
+randomB256TestData(std::span<std::uint8_t> d)
+    -> std::tuple<xrpl::TokenType, std::span<std::uint8_t>>
+{
+    auto& rng = randEngine();
+    std::uniform_int_distribution<std::uint8_t> dist(0, 255);
+    auto [tokType, tokSize] = randomTokenTypeAndSize();
+    std::generate(d.begin(), d.begin() + tokSize, [&] { return dist(rng); });
+    return {tokType, d.subspan(0, tokSize)};
+}
+
+inline void
+printAsChar(std::span<std::uint8_t> a, std::span<std::uint8_t> b)
+{
+    auto asString = [](std::span<std::uint8_t> s) {
+        std::string r;
+        r.resize(s.size());
+        std::ranges::copy(s, r.begin());
+        return r;
+    };
+    auto sa = asString(a);
+    auto sb = asString(b);
+    std::cerr << "\n\n" << sa << "\n" << sb << "\n";
+}
+
+inline void
+printAsInt(std::span<std::uint8_t> a, std::span<std::uint8_t> b)
+{
+    auto asString = [](std::span<std::uint8_t> s) -> std::string {
+        std::stringstream sstr;
+        for (auto i : s)
+        {
+            sstr << std::setw(3) << int(i) << ',';
+        }
+        return sstr.str();
+    };
+    auto sa = asString(a);
+    auto sb = asString(b);
+    std::cerr << "\n\n" << sa << "\n" << sb << "\n";
+}
+
+}  // namespace
+
+namespace multiprecision_utils {
+
+boost::multiprecision::checked_uint512_t
+toBoostMP(std::span<std::uint64_t> in)
+{
+    boost::multiprecision::checked_uint512_t mbp = 0;
+    for (auto i = in.rbegin(); i != in.rend(); ++i)
+    {
+        mbp <<= 64;
+        mbp += *i;
+    }
+    return mbp;
+}
+
+std::vector<std::uint64_t>
+randomBigInt(std::uint8_t minSize = 1, std::uint8_t maxSize = 5)
+{
+    auto eng = randEngine();
+    std::uniform_int_distribution<std::uint8_t> numCoeffDist(minSize, maxSize);
+    std::uniform_int_distribution<std::uint64_t> dist;
+    auto const numCoeff = numCoeffDist(eng);
+    std::vector<std::uint64_t> coeffs;
+    coeffs.reserve(numCoeff);
+    for (int i = 0; i < numCoeff; ++i)
+    {
+        coeffs.push_back(dist(eng));
+    }
+    return coeffs;
+}
+}  // namespace multiprecision_utils
+
+class base58_test : public beast::unit_test::Suite
+{
+    void
+    testMultiprecision()
+    {
+        testcase("b58_multiprecision");
+
+        using namespace boost::multiprecision;
+
+        static constexpr std::size_t kIters = 100000;
+        auto eng = randEngine();
+        std::uniform_int_distribution<std::uint64_t> dist;
+        std::uniform_int_distribution<std::uint64_t> dist1(1);
+        for (int i = 0; i < kIters; ++i)
+        {
+            std::uint64_t const d = dist(eng);
+            if (d == 0u)
+                continue;
+            auto bigInt = multiprecision_utils::randomBigInt();
+            auto const boostBigInt = multiprecision_utils::toBoostMP(
+                std::span<std::uint64_t>(bigInt.data(), bigInt.size()));
+
+            auto const refDiv = boostBigInt / d;
+            auto const refMod = boostBigInt % d;
+
+            auto const mod = b58_fast::detail::inplaceBigintDivRem(
+                std::span<uint64_t>(bigInt.data(), bigInt.size()), d);
+            auto const foundDiv = multiprecision_utils::toBoostMP(bigInt);
+            BEAST_EXPECT(refMod.convert_to<std::uint64_t>() == mod);
+            BEAST_EXPECT(foundDiv == refDiv);
+        }
+        for (int i = 0; i < kIters; ++i)
+        {
+            std::uint64_t const d = dist(eng);
+            auto bigInt = multiprecision_utils::randomBigInt(/*minSize*/ 2);
+            if (bigInt[bigInt.size() - 1] == std::numeric_limits<std::uint64_t>::max())
+            {
+                bigInt[bigInt.size() - 1] -= 1;  // Prevent overflow
+            }
+            auto const boostBigInt = multiprecision_utils::toBoostMP(
+                std::span<std::uint64_t>(bigInt.data(), bigInt.size()));
+
+            auto const refAdd = boostBigInt + d;
+
+            auto const result = b58_fast::detail::inplaceBigintAdd(
+                std::span<uint64_t>(bigInt.data(), bigInt.size()), d);
+            BEAST_EXPECT(result == TokenCodecErrc::Success);
+            auto const foundAdd = multiprecision_utils::toBoostMP(bigInt);
+            BEAST_EXPECT(refAdd == foundAdd);
+        }
+        for (int i = 0; i < kIters; ++i)
+        {
+            std::uint64_t const d = dist1(eng);
+            // Force overflow
+            std::vector<std::uint64_t> bigInt(5, std::numeric_limits<std::uint64_t>::max());
+
+            auto const boostBigInt = multiprecision_utils::toBoostMP(
+                std::span<std::uint64_t>(bigInt.data(), bigInt.size()));
+
+            auto const refAdd = boostBigInt + d;
+
+            auto const result = b58_fast::detail::inplaceBigintAdd(
+                std::span<uint64_t>(bigInt.data(), bigInt.size()), d);
+            BEAST_EXPECT(result == TokenCodecErrc::OverflowAdd);
+            auto const foundAdd = multiprecision_utils::toBoostMP(bigInt);
+            BEAST_EXPECT(refAdd != foundAdd);
+        }
+        for (int i = 0; i < kIters; ++i)
+        {
+            std::uint64_t const d = dist(eng);
+            auto bigInt = multiprecision_utils::randomBigInt(/* minSize */ 2);
+            // inplace mul requires the most significant coeff to be zero to
+            // hold the result.
+            bigInt[bigInt.size() - 1] = 0;
+            auto const boostBigInt = multiprecision_utils::toBoostMP(
+                std::span<std::uint64_t>(bigInt.data(), bigInt.size()));
+
+            auto const refMul = boostBigInt * d;
+
+            auto const result = b58_fast::detail::inplaceBigintMul(
+                std::span<uint64_t>(bigInt.data(), bigInt.size()), d);
+            BEAST_EXPECT(result == TokenCodecErrc::Success);
+            auto const foundMul = multiprecision_utils::toBoostMP(bigInt);
+            BEAST_EXPECT(refMul == foundMul);
+        }
+        for (int i = 0; i < kIters; ++i)
+        {
+            std::uint64_t const d = dist1(eng);
+            // Force overflow
+            std::vector<std::uint64_t> bigInt(5, std::numeric_limits<std::uint64_t>::max());
+            auto const boostBigInt = multiprecision_utils::toBoostMP(
+                std::span<std::uint64_t>(bigInt.data(), bigInt.size()));
+
+            auto const refMul = boostBigInt * d;
+
+            auto const result = b58_fast::detail::inplaceBigintMul(
+                std::span<uint64_t>(bigInt.data(), bigInt.size()), d);
+            BEAST_EXPECT(result == TokenCodecErrc::InputTooLarge);
+            auto const foundMul = multiprecision_utils::toBoostMP(bigInt);
+            BEAST_EXPECT(refMul != foundMul);
+        }
+    }
+
+    void
+    testFastMatchesRef()
+    {
+        testcase("fast_matches_ref");
+        auto testRawEncode = [&](std::span<std::uint8_t> const& b256Data) {
+            std::array<std::uint8_t, 64> b58ResultBuf[2];
+            std::array<std::span<std::uint8_t>, 2> b58Result;
+
+            std::array<std::uint8_t, 64> b256ResultBuf[2];
+            std::array<std::span<std::uint8_t>, 2> b256Result;
+            for (int i = 0; i < 2; ++i)
+            {
+                std::span const outBuf{b58ResultBuf[i]};
+                if (i == 0)
+                {
+                    auto const r = xrpl::b58_fast::detail::b256ToB58Be(b256Data, outBuf);
+                    BEAST_EXPECT(r);
+                    b58Result[i] = r.value();
+                }
+                else
+                {
+                    std::array<std::uint8_t, 128> tmpBuf{};
+                    std::string const s = xrpl::b58_ref::detail::encodeBase58(
+                        b256Data.data(), b256Data.size(), tmpBuf.data(), tmpBuf.size());
+                    BEAST_EXPECT(s.size());
+                    b58Result[i] = outBuf.subspan(0, s.size());
+                    std::ranges::copy(s, b58Result[i].begin());
+                }
+            }
+            if (BEAST_EXPECT(b58Result[0].size() == b58Result[1].size()))
+            {
+                if (!BEAST_EXPECT(
+                        memcmp(b58Result[0].data(), b58Result[1].data(), b58Result[0].size()) == 0))
+                {
+                    printAsChar(b58Result[0], b58Result[1]);
+                }
+            }
+
+            for (int i = 0; i < 2; ++i)
+            {
+                std::span const outBuf{b256ResultBuf[i].data(), b256ResultBuf[i].size()};
+                if (i == 0)
+                {
+                    std::string const in(
+                        b58Result[i].data(), b58Result[i].data() + b58Result[i].size());
+                    auto const r = xrpl::b58_fast::detail::b58ToB256Be(in, outBuf);
+                    BEAST_EXPECT(r);
+                    b256Result[i] = r.value();
+                }
+                else
+                {
+                    std::string const st(b58Result[i].begin(), b58Result[i].end());
+                    std::string const s = xrpl::b58_ref::detail::decodeBase58(st);
+                    BEAST_EXPECT(s.size());
+                    b256Result[i] = outBuf.subspan(0, s.size());
+                    std::ranges::copy(s, b256Result[i].begin());
+                }
+            }
+
+            if (BEAST_EXPECT(b256Result[0].size() == b256Result[1].size()))
+            {
+                if (!BEAST_EXPECT(
+                        memcmp(b256Result[0].data(), b256Result[1].data(), b256Result[0].size()) ==
+                        0))
+                {
+                    printAsInt(b256Result[0], b256Result[1]);
+                }
+            }
+        };
+
+        auto testTokenEncode = [&](xrpl::TokenType const tokType,
+                                   std::span<std::uint8_t> const& b256Data) {
+            std::array<std::uint8_t, 64> b58ResultBuf[2];
+            std::array<std::span<std::uint8_t>, 2> b58Result;
+
+            std::array<std::uint8_t, 64> b256ResultBuf[2];
+            std::array<std::span<std::uint8_t>, 2> b256Result;
+            for (int i = 0; i < 2; ++i)
+            {
+                std::span const outBuf{b58ResultBuf[i].data(), b58ResultBuf[i].size()};
+                if (i == 0)
+                {
+                    auto const r = xrpl::b58_fast::encodeBase58Token(tokType, b256Data, outBuf);
+                    BEAST_EXPECT(r);
+                    b58Result[i] = r.value();
+                }
+                else
+                {
+                    std::string const s =
+                        xrpl::b58_ref::encodeBase58Token(tokType, b256Data.data(), b256Data.size());
+                    BEAST_EXPECT(s.size());
+                    b58Result[i] = outBuf.subspan(0, s.size());
+                    std::ranges::copy(s, b58Result[i].begin());
+                }
+            }
+            if (BEAST_EXPECT(b58Result[0].size() == b58Result[1].size()))
+            {
+                if (!BEAST_EXPECT(
+                        memcmp(b58Result[0].data(), b58Result[1].data(), b58Result[0].size()) == 0))
+                {
+                    printAsChar(b58Result[0], b58Result[1]);
+                }
+            }
+
+            for (int i = 0; i < 2; ++i)
+            {
+                std::span const outBuf{b256ResultBuf[i].data(), b256ResultBuf[i].size()};
+                if (i == 0)
+                {
+                    std::string const in(
+                        b58Result[i].data(), b58Result[i].data() + b58Result[i].size());
+                    auto const r = xrpl::b58_fast::decodeBase58Token(tokType, in, outBuf);
+                    BEAST_EXPECT(r);
+                    b256Result[i] = r.value();
+                }
+                else
+                {
+                    std::string const st(b58Result[i].begin(), b58Result[i].end());
+                    std::string const s = xrpl::b58_ref::decodeBase58Token(st, tokType);
+                    BEAST_EXPECT(s.size());
+                    b256Result[i] = outBuf.subspan(0, s.size());
+                    std::ranges::copy(s, b256Result[i].begin());
+                }
+            }
+
+            if (BEAST_EXPECT(b256Result[0].size() == b256Result[1].size()))
+            {
+                if (!BEAST_EXPECT(
+                        memcmp(b256Result[0].data(), b256Result[1].data(), b256Result[0].size()) ==
+                        0))
+                {
+                    printAsInt(b256Result[0], b256Result[1]);
+                }
+            }
+        };
+
+        auto testIt = [&](xrpl::TokenType const tokType, std::span<std::uint8_t> const& b256Data) {
+            testRawEncode(b256Data);
+            testTokenEncode(tokType, b256Data);
+        };
+
+        // test every token type with data where every byte is the same and the
+        // bytes range from 0-255
+        for (int i = 0; i < kNumTokenTypeIndexes; ++i)
+        {
+            std::array<std::uint8_t, 128> b256DataBuf{};
+            auto const [tokType, tokSize] = tokenTypeAndSize(i);
+            for (int d = 0; d <= 255; ++d)
+            {
+                memset(b256DataBuf.data(), d, tokSize);
+                testIt(tokType, std::span(b256DataBuf.data(), tokSize));
+            }
+        }
+
+        // test with random data
+        static constexpr std::size_t kIters = 100000;
+        for (int i = 0; i < kIters; ++i)
+        {
+            std::array<std::uint8_t, 128> b256DataBuf{};
+            auto const [tokType, b256Data] = randomB256TestData(b256DataBuf);
+            testIt(tokType, b256Data);
+        }
+    }
+
+    void
+    run() override
+    {
+        testMultiprecision();
+        testFastMatchesRef();
+    }
+};
+
+BEAST_DEFINE_TESTSUITE(base58, basics, xrpl);
+
+}  // namespace xrpl::test
+
+#endif  // _MSC_VER
diff --git a/src/test/basics/base_uint_test.cpp b/src/test/basics/base_uint_test.cpp
new file mode 100644
index 0000000000..c6572a0028
--- /dev/null
+++ b/src/test/basics/base_uint_test.cpp
@@ -0,0 +1,376 @@
+#include <xrpl/basics/Blob.h>
+#include <xrpl/basics/base_uint.h>
+#include <xrpl/basics/hardened_hash.h>
+#include <xrpl/beast/unit_test/suite.h>
+#include <xrpl/beast/utility/Zero.h>
+
+#include <boost/endian/detail/order.hpp>
+
+#include <array>
+#include <cassert>
+#include <complex>
+#include <cstddef>
+#include <cstdint>
+#include <iterator>
+#include <stdexcept>
+#include <string_view>
+#include <type_traits>
+#include <unordered_set>
+#include <utility>
+#include <vector>
+
+namespace xrpl::test {
+
+// a non-hashing Hasher that just copies the bytes.
+// Used to test hash_append in base_uint
+template <std::size_t Bits>
+struct Nonhash
+{
+    static constexpr auto kEndian = boost::endian::order::big;
+    static constexpr std::size_t kWidth = Bits / 8;
+
+    std::array<std::uint8_t, kWidth> data;
+
+    Nonhash() = default;
+
+    void
+    operator()(void const* key, std::size_t len) noexcept
+    {
+        assert(len == kWidth);
+        memcpy(data.data(), key, len);
+    }
+
+    explicit
+    operator std::size_t() noexcept
+    {
+        return kWidth;
+    }
+};
+
+struct base_uint_test : beast::unit_test::Suite
+{
+    using test96 = BaseUInt<96>;
+    static_assert(std::is_copy_constructible_v<test96>);
+    static_assert(std::is_copy_assignable_v<test96>);
+
+    void
+    testComparisons()
+    {
+        {
+            static constexpr std::array<std::pair<std::string_view, std::string_view>, 6> kTestArgs{
+                {{"0000000000000000", "0000000000000001"},
+                 {"0000000000000000", "ffffffffffffffff"},
+                 {"1234567812345678", "2345678923456789"},
+                 {"8000000000000000", "8000000000000001"},
+                 {"aaaaaaaaaaaaaaa9", "aaaaaaaaaaaaaaaa"},
+                 {"fffffffffffffffe", "ffffffffffffffff"}}};
+
+            for (auto const& arg : kTestArgs)
+            {
+                xrpl::BaseUInt<64> const u{arg.first}, v{arg.second};
+                BEAST_EXPECT(u < v);
+                BEAST_EXPECT(u <= v);
+                BEAST_EXPECT(u != v);
+                BEAST_EXPECT(!(u == v));
+                BEAST_EXPECT(!(u > v));
+                BEAST_EXPECT(!(u >= v));
+                BEAST_EXPECT(!(v < u));
+                BEAST_EXPECT(!(v <= u));
+                BEAST_EXPECT(v != u);
+                BEAST_EXPECT(!(v == u));
+                BEAST_EXPECT(v > u);
+                BEAST_EXPECT(v >= u);
+                BEAST_EXPECT(u == u);
+                BEAST_EXPECT(v == v);
+            }
+        }
+
+        {
+            static constexpr std::array<std::pair<std::string_view, std::string_view>, 6> kTestArgs{
+                {
+                    {"000000000000000000000000", "000000000000000000000001"},
+                    {"000000000000000000000000", "ffffffffffffffffffffffff"},
+                    {"0123456789ab0123456789ab", "123456789abc123456789abc"},
+                    {"555555555555555555555555", "55555555555a555555555555"},
+                    {"aaaaaaaaaaaaaaa9aaaaaaaa", "aaaaaaaaaaaaaaaaaaaaaaaa"},
+                    {"fffffffffffffffffffffffe", "ffffffffffffffffffffffff"},
+                }};
+
+            for (auto const& arg : kTestArgs)
+            {
+                xrpl::BaseUInt<96> const u{arg.first}, v{arg.second};
+                BEAST_EXPECT(u < v);
+                BEAST_EXPECT(u <= v);
+                BEAST_EXPECT(u != v);
+                BEAST_EXPECT(!(u == v));
+                BEAST_EXPECT(!(u > v));
+                BEAST_EXPECT(!(u >= v));
+                BEAST_EXPECT(!(v < u));
+                BEAST_EXPECT(!(v <= u));
+                BEAST_EXPECT(v != u);
+                BEAST_EXPECT(!(v == u));
+                BEAST_EXPECT(v > u);
+                BEAST_EXPECT(v >= u);
+                BEAST_EXPECT(u == u);
+                BEAST_EXPECT(v == v);
+            }
+        }
+    }
+
+    void
+    testFromRawSizeMismatch()
+    {
+        testcase("base_uint: fromRaw size mismatch");
+
+        // Container larger than the base_uint (16 bytes vs 12 bytes for test96).
+        // Only the first 12 bytes are copied; the extra bytes are ignored.
+        {
+            Blob const tooBig{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
+            test96 const result = test96::fromRaw(tooBig);
+            BEAST_EXPECT(to_string(result) == "0102030405060708090A0B0C");
+        }
+    }
+
+    void
+    run() override
+    {
+        testcase("base_uint: general purpose tests");
+
+#ifdef NDEBUG
+        testFromRawSizeMismatch();
+#endif
+
+        static_assert(!std::is_constructible_v<test96, std::complex<double>>);
+        static_assert(!std::is_assignable_v<test96&, std::complex<double>>);
+
+        testComparisons();
+
+        // used to verify set insertion (hashing required)
+        std::unordered_set<test96, HardenedHash<>> uset;
+
+        Blob const raw{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
+        BEAST_EXPECT(test96::kBytes == raw.size());
+
+        test96 u = test96::fromRaw(raw);
+        uset.insert(u);
+        BEAST_EXPECT(raw.size() == u.size());
+        BEAST_EXPECT(to_string(u) == "0102030405060708090A0B0C");
+        BEAST_EXPECT(toShortString(u) == "01020304...");
+        BEAST_EXPECT(*u.data() == 1);
+        BEAST_EXPECT(u.signum() == 1);
+        BEAST_EXPECT(!!u);
+        BEAST_EXPECT(!u.isZero());
+        BEAST_EXPECT(u.isNonZero());
+        unsigned char t = 0;
+        for (auto& d : u)
+        {
+            BEAST_EXPECT(d == ++t);
+        }
+
+        // Test hash_append by "hashing" with a no-op hasher (h)
+        // and then extracting the bytes that were written during hashing
+        // back into another base_uint (w) for comparison with the original
+        Nonhash<96> h{};
+        hash_append(h, u);
+        test96 const w = test96::fromRaw(std::vector<std::uint8_t>(h.data.begin(), h.data.end()));
+        BEAST_EXPECT(w == u);
+
+        test96 v{~u};
+        uset.insert(v);
+        BEAST_EXPECT(to_string(v) == "FEFDFCFBFAF9F8F7F6F5F4F3");
+        BEAST_EXPECT(toShortString(v) == "FEFDFCFB...");
+        BEAST_EXPECT(*v.data() == 0xfe);
+        BEAST_EXPECT(v.signum() == 1);
+        BEAST_EXPECT(!!v);
+        BEAST_EXPECT(!v.isZero());
+        BEAST_EXPECT(v.isNonZero());
+        t = 0xff;
+        for (auto& d : v)
+        {
+            BEAST_EXPECT(d == --t);
+        }
+
+        BEAST_EXPECT(u < v);
+        BEAST_EXPECT(v > u);
+
+        v = u;
+        BEAST_EXPECT(v == u);
+
+        test96 z{beast::kZero};
+        uset.insert(z);
+        BEAST_EXPECT(to_string(z) == "000000000000000000000000");
+        BEAST_EXPECT(toShortString(z) == "00000000...");
+        BEAST_EXPECT(*z.data() == 0);
+        BEAST_EXPECT(*z.begin() == 0);
+        BEAST_EXPECT(*std::prev(z.end(), 1) == 0);
+        BEAST_EXPECT(z.signum() == 0);
+        BEAST_EXPECT(!z);
+        BEAST_EXPECT(z.isZero());
+        BEAST_EXPECT(!z.isNonZero());
+        for (auto& d : z)
+        {
+            BEAST_EXPECT(d == 0);
+        }
+
+        test96 n{z};
+        n++;
+        BEAST_EXPECT(n == test96(1));
+        n--;
+        BEAST_EXPECT(n == beast::kZero);
+        BEAST_EXPECT(n == z);
+        n--;
+        BEAST_EXPECT(to_string(n) == "FFFFFFFFFFFFFFFFFFFFFFFF");
+        BEAST_EXPECT(toShortString(n) == "FFFFFFFF...");
+        n = beast::kZero;
+        BEAST_EXPECT(n == z);
+
+        test96 zp1{z};
+        zp1++;
+        test96 zm1{z};
+        zm1--;
+        test96 const x{zm1 ^ zp1};
+        uset.insert(x);
+        BEAST_EXPECTS(to_string(x) == "FFFFFFFFFFFFFFFFFFFFFFFE", to_string(x));
+        BEAST_EXPECTS(toShortString(x) == "FFFFFFFF...", toShortString(x));
+
+        BEAST_EXPECT(uset.size() == 4);
+
+        test96 tmp;
+        BEAST_EXPECT(tmp.parseHex(to_string(u)));
+        BEAST_EXPECT(tmp == u);
+        tmp = z;
+
+        // fails with extra char
+        BEAST_EXPECT(!tmp.parseHex("A" + to_string(u)));
+        tmp = z;
+
+        // fails with extra char at end
+        BEAST_EXPECT(!tmp.parseHex(to_string(u) + "A"));
+
+        // fails with a non-hex character at some point in the string:
+        tmp = z;
+
+        for (std::size_t i = 0; i != 24; ++i)
+        {
+            std::string x = to_string(z);
+            x[i] = ('G' + (i % 10));
+            BEAST_EXPECT(!tmp.parseHex(x));
+        }
+
+        // Walking 1s:
+        for (std::size_t i = 0; i != 24; ++i)
+        {
+            std::string s1 = "000000000000000000000000";
+            s1[i] = '1';
+
+            BEAST_EXPECT(tmp.parseHex(s1));
+            BEAST_EXPECT(to_string(tmp) == s1);
+        }
+
+        // Walking 0s:
+        for (std::size_t i = 0; i != 24; ++i)
+        {
+            std::string s1 = "111111111111111111111111";
+            s1[i] = '0';
+
+            BEAST_EXPECT(tmp.parseHex(s1));
+            BEAST_EXPECT(to_string(tmp) == s1);
+        }
+
+        // Constexpr constructors
+        {
+            static_assert(test96{}.signum() == 0);
+            static_assert(test96("0").signum() == 0);
+            static_assert(test96("000000000000000000000000").signum() == 0);
+            static_assert(test96("000000000000000000000001").signum() == 1);
+            static_assert(test96("800000000000000000000000").signum() == 1);
+
+// Everything within the #if should fail during compilation.
+#if 0
+            // Too few characters
+            static_assert(test96("00000000000000000000000").signum() == 0);
+
+            // Too many characters
+            static_assert(test96("0000000000000000000000000").signum() == 0);
+
+            // Non-hex characters
+            static_assert(test96("00000000000000000000000 ").signum() == 1);
+            static_assert(test96("00000000000000000000000/").signum() == 1);
+            static_assert(test96("00000000000000000000000:").signum() == 1);
+            static_assert(test96("00000000000000000000000@").signum() == 1);
+            static_assert(test96("00000000000000000000000G").signum() == 1);
+            static_assert(test96("00000000000000000000000`").signum() == 1);
+            static_assert(test96("00000000000000000000000g").signum() == 1);
+            static_assert(test96("00000000000000000000000~").signum() == 1);
+#endif  // 0
+
+            // Using the constexpr constructor in a non-constexpr context
+            // with an error in the parsing throws an exception.
+            {
+                // Invalid length for string.
+                bool caught = false;
+                try
+                {
+                    // Try to prevent constant evaluation.
+                    std::vector<char> str(23, '7');
+                    std::string_view const sView(str.data(), str.size());
+                    [[maybe_unused]] test96 const t96(sView);
+                }
+                catch (std::invalid_argument const& e)
+                {
+                    BEAST_EXPECT(e.what() == std::string("invalid length for hex string"));
+                    caught = true;
+                }
+                BEAST_EXPECT(caught);
+            }
+            {
+                // Invalid character in string.
+                bool caught = false;
+                try
+                {
+                    // Try to prevent constant evaluation.
+                    std::vector<char> str(23, '7');
+                    str.push_back('G');
+                    std::string_view const sView(str.data(), str.size());
+                    [[maybe_unused]] test96 const t96(sView);
+                }
+                catch (std::range_error const& e)
+                {
+                    BEAST_EXPECT(e.what() == std::string("invalid hex character"));
+                    caught = true;
+                }
+                BEAST_EXPECT(caught);
+            }
+
+            // Verify that constexpr base_uints interpret a string the same
+            // way parseHex() does.
+            struct StrBaseUInt
+            {
+                char const* const str;
+                test96 tst;
+
+                constexpr StrBaseUInt(char const* s) : str(s), tst(s)
+                {
+                }
+            };
+            static constexpr StrBaseUInt kTestCases[] = {
+                "000000000000000000000000",
+                "000000000000000000000001",
+                "fedcba9876543210ABCDEF91",
+                "19FEDCBA0123456789abcdef",
+                "800000000000000000000000",
+                "fFfFfFfFfFfFfFfFfFfFfFfF"};
+
+            for (StrBaseUInt const& t : kTestCases)
+            {
+                test96 t96;
+                BEAST_EXPECT(t96.parseHex(t.str));
+                BEAST_EXPECT(t96 == t.tst);
+            }
+        }
+    }
+};
+
+BEAST_DEFINE_TESTSUITE(base_uint, basics, xrpl);
+
+}  // namespace xrpl::test
diff --git a/src/tests/libxrpl/basics/hardened_hash.cpp b/src/test/basics/hardened_hash_test.cpp
similarity index 84%
rename from src/tests/libxrpl/basics/hardened_hash.cpp
rename to src/test/basics/hardened_hash_test.cpp
index 4f51ce4305..8b10967932 100644
--- a/src/tests/libxrpl/basics/hardened_hash.cpp
+++ b/src/test/basics/hardened_hash_test.cpp
@@ -1,8 +1,6 @@
 #include <xrpl/basics/hardened_hash.h>
-
 #include <xrpl/beast/hash/hash_append.h>
-
-#include <gtest/gtest.h>
+#include <xrpl/beast/unit_test/suite.h>
 
 #include <array>
 #include <cstddef>
@@ -155,20 +153,20 @@ static_assert(sha256_t::kBits == 256, "sha256_t must have 256 bits");
 
 namespace xrpl {
 
-class HardenedHashTest : public ::testing::Test
+class hardened_hash_test : public beast::unit_test::Suite
 {
 public:
     template <class T>
-    static void
+    void
     check()
     {
         T t{};
         HardenedHash<>()(t);
-        SUCCEED();
+        pass();
     }
 
     template <template <class T> class U>
-    static void
+    void
     checkUserType()
     {
         check<U<bool>>();
@@ -193,35 +191,48 @@ public:
     }
 
     template <template <class T> class C>
-    static void
+    void
     checkContainer()
     {
         {
             C<detail::TestUserTypeMember<std::string>> const c;
         }
 
-        SUCCEED();
+        pass();
 
         {
             C<detail::TestUserTypeFree<std::string>> const c;
         }
 
-        SUCCEED();
+        pass();
+    }
+
+    void
+    testUserTypes()
+    {
+        testcase("user types");
+        checkUserType<detail::TestUserTypeMember>();
+        checkUserType<detail::TestUserTypeFree>();
+    }
+
+    void
+    testContainers()
+    {
+        testcase("containers");
+        checkContainer<detail::test_hardened_unordered_set>();
+        checkContainer<detail::test_hardened_unordered_map>();
+        checkContainer<detail::test_hardened_unordered_multiset>();
+        checkContainer<detail::test_hardened_unordered_multimap>();
+    }
+
+    void
+    run() override
+    {
+        testUserTypes();
+        testContainers();
     }
 };
 
-TEST_F(HardenedHashTest, user_types)
-{
-    checkUserType<detail::TestUserTypeMember>();
-    checkUserType<detail::TestUserTypeFree>();
-}
-
-TEST_F(HardenedHashTest, containers)
-{
-    checkContainer<detail::test_hardened_unordered_set>();
-    checkContainer<detail::test_hardened_unordered_map>();
-    checkContainer<detail::test_hardened_unordered_multiset>();
-    checkContainer<detail::test_hardened_unordered_multimap>();
-}
+BEAST_DEFINE_TESTSUITE(hardened_hash, basics, xrpl);
 
 }  // namespace xrpl
diff --git a/src/test/basics/join_test.cpp b/src/test/basics/join_test.cpp
new file mode 100644
index 0000000000..1ee81f786a
--- /dev/null
+++ b/src/test/basics/join_test.cpp
@@ -0,0 +1,83 @@
+#include <test/jtx/Account.h>
+
+#include <xrpl/basics/base_uint.h>
+#include <xrpl/basics/join.h>
+#include <xrpl/beast/unit_test/suite.h>
+
+#include <array>
+#include <cstddef>
+#include <initializer_list>
+#include <sstream>
+#include <string>
+#include <vector>
+
+namespace xrpl::test {
+
+struct join_test : beast::unit_test::Suite
+{
+    void
+    run() override
+    {
+        auto test = [this](auto collectionanddelimiter, std::string expected) {
+            std::stringstream ss;
+            // Put something else in the buffer before and after to ensure that
+            // the << operator returns the stream correctly.
+            ss << "(" << collectionanddelimiter << ")";
+            auto const str = ss.str();
+            BEAST_EXPECT(str.substr(1, str.length() - 2) == expected);
+            BEAST_EXPECT(str.front() == '(');
+            BEAST_EXPECT(str.back() == ')');
+        };
+
+        // C++ array
+        test(CollectionAndDelimiter(std::array<int, 4>{2, -1, 5, 10}, "/"), "2/-1/5/10");
+        // One item C++ array edge case
+        test(CollectionAndDelimiter(std::array<std::string, 1>{"test"}, " & "), "test");
+        // Empty C++ array edge case
+        test(CollectionAndDelimiter(std::array<int, 0>{}, ","), "");
+        {
+            // C-style array
+            char letters[4]{'w', 'a', 's', 'd'};
+            test(CollectionAndDelimiter(letters, std::to_string(0)), "w0a0s0d");
+        }
+        {
+            // Auto sized C-style array
+            std::string words[]{"one", "two", "three", "four"};
+            test(CollectionAndDelimiter(words, "\n"), "one\ntwo\nthree\nfour");
+        }
+        {
+            // One item C-style array edge case
+            std::string words[]{"thing"};
+            test(CollectionAndDelimiter(words, "\n"), "thing");
+        }
+        // Initializer list
+        test(CollectionAndDelimiter(std::initializer_list<size_t>{19, 25}, "+"), "19+25");
+        // vector
+        test(CollectionAndDelimiter(std::vector<int>{0, 42}, std::to_string(99)), "09942");
+        {
+            // vector with one item edge case
+            using namespace jtx;
+            test(
+                CollectionAndDelimiter(std::vector<Account>{Account::kMaster}, "xxx"),
+                Account::kMaster.human());
+        }
+        // empty vector edge case
+        test(CollectionAndDelimiter(std::vector<uint256>{}, ","), "");
+        // C-style string
+        test(CollectionAndDelimiter("string", " "), "s t r i n g");
+        // Empty C-style string edge case
+        test(CollectionAndDelimiter("", "*"), "");
+        // Single char C-style string edge case
+        test(CollectionAndDelimiter("x", "*"), "x");
+        // std::string
+        test(CollectionAndDelimiter(std::string{"string"}, "-"), "s-t-r-i-n-g");
+        // Empty std::string edge case
+        test(CollectionAndDelimiter(std::string{""}, "*"), "");
+        // Single char std::string edge case
+        test(CollectionAndDelimiter(std::string{"y"}, "*"), "y");
+    }
+};  // namespace test
+
+BEAST_DEFINE_TESTSUITE(join, basics, xrpl);
+
+}  // namespace xrpl::test
diff --git a/src/test/beast/LexicalCast_test.cpp b/src/test/beast/LexicalCast_test.cpp
index b1d37daab8..f988aa03cf 100644
--- a/src/test/beast/LexicalCast_test.cpp
+++ b/src/test/beast/LexicalCast_test.cpp
@@ -24,7 +24,7 @@ public:
     testInteger(IntType in)
     {
         std::string s;
-        auto out = static_cast<IntType>(~in);  // Ensure out != in
+        IntType out = static_cast<IntType>(~in);  // Ensure out != in
 
         expect(lexicalCastChecked(s, in));
         expect(lexicalCastChecked(out, s));
@@ -42,7 +42,7 @@ public:
 
             for (int i = 0; i < 1000; ++i)
             {
-                auto const value = nextRandomInt<IntType>(r);
+                IntType const value(nextRandomInt<IntType>(r));
                 testInteger(value);
             }
         }
@@ -229,7 +229,7 @@ public:
 
         while (i <= std::numeric_limits<std::int16_t>::max())
         {
-            auto const j = static_cast<std::int16_t>(i);
+            std::int16_t const j = static_cast<std::int16_t>(i);
 
             auto actual = std::to_string(j);
 
diff --git a/src/test/beast/aged_associative_container_test.cpp b/src/test/beast/aged_associative_container_test.cpp
index 76be44b793..3dbaf74040 100644
--- a/src/test/beast/aged_associative_container_test.cpp
+++ b/src/test/beast/aged_associative_container_test.cpp
@@ -145,7 +145,7 @@ public:
         }
 
         T*
-        allocate(std::size_t n, T const* = nullptr)
+        allocate(std::size_t n, T const* = 0)
         {
             return static_cast<T*>(::operator new(n * sizeof(T)));
         }
@@ -404,27 +404,23 @@ public:
     //--------------------------------------------------------------------------
 
     template <class Container, class Values>
-    void
-    checkMapContents(Container& c, Values const& v)
-        requires(Container::is_map::value && !Container::is_multi::value);
+    std::enable_if_t<Container::is_map::value && !Container::is_multi::value>
+    checkMapContents(Container& c, Values const& v);
 
     template <class Container, class Values>
-    void
+    std::enable_if_t<!(Container::is_map::value && !Container::is_multi::value)>
     checkMapContents(Container, Values const&)
-        requires(!(Container::is_map::value && !Container::is_multi::value))
     {
     }
 
     // unordered
     template <class C, class Values>
-    void
-    checkUnorderedContentsRefRef(C&& c, Values const& v)
-        requires(std::remove_reference_t<C>::is_unordered::value);
+    std::enable_if_t<std::remove_reference_t<C>::is_unordered::value>
+    checkUnorderedContentsRefRef(C&& c, Values const& v);
 
     template <class C, class Values>
-    void
+    std::enable_if_t<!std::remove_reference_t<C>::is_unordered::value>
     checkUnorderedContentsRefRef(C&&, Values const&)
-        requires(!std::remove_reference_t<C>::is_unordered::value)
     {
     }
 
@@ -444,39 +440,33 @@ public:
 
     // ordered
     template <bool IsUnordered, bool IsMulti, bool IsMap>
-    void
-    testConstructEmpty()
-        requires(!IsUnordered);
+    std::enable_if_t<!IsUnordered>
+    testConstructEmpty();
 
     // unordered
     template <bool IsUnordered, bool IsMulti, bool IsMap>
-    void
-    testConstructEmpty()
-        requires IsUnordered;
+    std::enable_if_t<IsUnordered>
+    testConstructEmpty();
 
     // ordered
     template <bool IsUnordered, bool IsMulti, bool IsMap>
-    void
-    testConstructRange()
-        requires(!IsUnordered);
+    std::enable_if_t<!IsUnordered>
+    testConstructRange();
 
     // unordered
     template <bool IsUnordered, bool IsMulti, bool IsMap>
-    void
-    testConstructRange()
-        requires IsUnordered;
+    std::enable_if_t<IsUnordered>
+    testConstructRange();
 
     // ordered
     template <bool IsUnordered, bool IsMulti, bool IsMap>
-    void
-    testConstructInitList()
-        requires(!IsUnordered);
+    std::enable_if_t<!IsUnordered>
+    testConstructInitList();
 
     // unordered
     template <bool IsUnordered, bool IsMulti, bool IsMap>
-    void
-    testConstructInitList()
-        requires IsUnordered;
+    std::enable_if_t<IsUnordered>
+    testConstructInitList();
 
     //--------------------------------------------------------------------------
 
@@ -492,14 +482,12 @@ public:
 
     // Unordered containers don't have reverse iterators
     template <bool IsUnordered, bool IsMulti, bool IsMap>
-    void
-    testReverseIterator()
-        requires(!IsUnordered);
+    std::enable_if_t<!IsUnordered>
+    testReverseIterator();
 
     template <bool IsUnordered, bool IsMulti, bool IsMap>
-    void
+    std::enable_if_t<IsUnordered>
     testReverseIterator()
-        requires IsUnordered
     {
     }
 
@@ -543,14 +531,12 @@ public:
 
     // map, unordered_map
     template <bool IsUnordered, bool IsMulti, bool IsMap>
-    void
-    testArrayCreate()
-        requires(IsMap && !IsMulti);
+    std::enable_if_t<IsMap && !IsMulti>
+    testArrayCreate();
 
     template <bool IsUnordered, bool IsMulti, bool IsMap>
-    void
+    std::enable_if_t<!IsMap || IsMulti>
     testArrayCreate()
-        requires(!IsMap || IsMulti)
     {
     }
 
@@ -589,14 +575,12 @@ public:
 
     // ordered
     template <bool IsUnordered, bool IsMulti, bool IsMap>
-    void
-    testCompare()
-        requires(!IsUnordered);
+    std::enable_if_t<!IsUnordered>
+    testCompare();
 
     template <bool IsUnordered, bool IsMulti, bool IsMap>
-    void
+    std::enable_if_t<IsUnordered>
     testCompare()
-        requires IsUnordered
     {
     }
 
@@ -604,15 +588,13 @@ public:
 
     // ordered
     template <bool IsUnordered, bool IsMulti, bool IsMap>
-    void
-    testObservers()
-        requires(!IsUnordered);
+    std::enable_if_t<!IsUnordered>
+    testObservers();
 
     // unordered
     template <bool IsUnordered, bool IsMulti, bool IsMap>
-    void
-    testObservers()
-        requires IsUnordered;
+    std::enable_if_t<IsUnordered>
+    testObservers();
 
     //--------------------------------------------------------------------------
 
@@ -634,9 +616,8 @@ public:
 // Check contents via at() and operator[]
 // map, unordered_map
 template <class Container, class Values>
-void
+std::enable_if_t<Container::is_map::value && !Container::is_multi::value>
 AgedAssociativeContainerTestBase::checkMapContents(Container& c, Values const& v)
-    requires(Container::is_map::value && !Container::is_multi::value)
 {
     if (v.empty())
     {
@@ -661,9 +642,8 @@ AgedAssociativeContainerTestBase::checkMapContents(Container& c, Values const& v
 
 // unordered
 template <class C, class Values>
-void
+std::enable_if_t<std::remove_reference_t<C>::is_unordered::value>
 AgedAssociativeContainerTestBase::checkUnorderedContentsRefRef(C&& c, Values const& v)
-    requires(std::remove_reference_t<C>::is_unordered::value)
 {
     using Cont = std::remove_reference_t<C>;
     using Traits =
@@ -735,9 +715,8 @@ AgedAssociativeContainerTestBase::checkContents(Cont& c)
 
 // ordered
 template <bool IsUnordered, bool IsMulti, bool IsMap>
-void
+std::enable_if_t<!IsUnordered>
 AgedAssociativeContainerTestBase::testConstructEmpty()
-    requires(!IsUnordered)
 {
     using Traits = TestTraits<IsUnordered, IsMulti, IsMap>;
     using Comp = Traits::Comp;
@@ -772,9 +751,8 @@ AgedAssociativeContainerTestBase::testConstructEmpty()
 
 // unordered
 template <bool IsUnordered, bool IsMulti, bool IsMap>
-void
+std::enable_if_t<IsUnordered>
 AgedAssociativeContainerTestBase::testConstructEmpty()
-    requires IsUnordered
 {
     using Traits = TestTraits<IsUnordered, IsMulti, IsMap>;
     using Hash = Traits::Hash;
@@ -831,9 +809,8 @@ AgedAssociativeContainerTestBase::testConstructEmpty()
 
 // ordered
 template <bool IsUnordered, bool IsMulti, bool IsMap>
-void
+std::enable_if_t<!IsUnordered>
 AgedAssociativeContainerTestBase::testConstructRange()
-    requires(!IsUnordered)
 {
     using Traits = TestTraits<IsUnordered, IsMulti, IsMap>;
     using Comp = Traits::Comp;
@@ -879,9 +856,8 @@ AgedAssociativeContainerTestBase::testConstructRange()
 
 // unordered
 template <bool IsUnordered, bool IsMulti, bool IsMap>
-void
+std::enable_if_t<IsUnordered>
 AgedAssociativeContainerTestBase::testConstructRange()
-    requires IsUnordered
 {
     using Traits = TestTraits<IsUnordered, IsMulti, IsMap>;
     using Hash = Traits::Hash;
@@ -946,9 +922,8 @@ AgedAssociativeContainerTestBase::testConstructRange()
 
 // ordered
 template <bool IsUnordered, bool IsMulti, bool IsMap>
-void
+std::enable_if_t<!IsUnordered>
 AgedAssociativeContainerTestBase::testConstructInitList()
-    requires(!IsUnordered)
 {
     using Traits = TestTraits<IsUnordered, IsMulti, IsMap>;
     typename Traits::ManualClock const clock;
@@ -963,9 +938,8 @@ AgedAssociativeContainerTestBase::testConstructInitList()
 
 // unordered
 template <bool IsUnordered, bool IsMulti, bool IsMap>
-void
+std::enable_if_t<IsUnordered>
 AgedAssociativeContainerTestBase::testConstructInitList()
-    requires IsUnordered
 {
     using Traits = TestTraits<IsUnordered, IsMulti, IsMap>;
     typename Traits::ManualClock const clock;
@@ -1110,9 +1084,8 @@ AgedAssociativeContainerTestBase::testIterator()
 }
 
 template <bool IsUnordered, bool IsMulti, bool IsMap>
-void
+std::enable_if_t<!IsUnordered>
 AgedAssociativeContainerTestBase::testReverseIterator()
-    requires(!IsUnordered)
 {
     using Traits = TestTraits<IsUnordered, IsMulti, IsMap>;
     typename Traits::ManualClock clock;
@@ -1375,9 +1348,8 @@ AgedAssociativeContainerTestBase::testChronological()
 
 // map, unordered_map
 template <bool IsUnordered, bool IsMulti, bool IsMap>
-void
+std::enable_if_t<IsMap && !IsMulti>
 AgedAssociativeContainerTestBase::testArrayCreate()
-    requires(IsMap && !IsMulti)
 {
     using Traits = TestTraits<IsUnordered, IsMulti, IsMap>;
     typename Traits::ManualClock clock;
@@ -1419,7 +1391,7 @@ AgedAssociativeContainerTestBase::reverseFillAgedContainer(Container& c, Values
     // c.clock() returns an abstract_clock, so dynamic_cast to ManualClock.
     // VFALCO NOTE This is sketchy
     using ManualClock = TestTraitsBase::ManualClock;
-    auto& clk = dynamic_cast<ManualClock&>(c.clock());
+    ManualClock& clk(dynamic_cast<ManualClock&>(c.clock()));
     clk.set(0);
 
     Values rev(values);
@@ -1659,9 +1631,8 @@ AgedAssociativeContainerTestBase::testRangeErase()
 
 // ordered
 template <bool IsUnordered, bool IsMulti, bool IsMap>
-void
+std::enable_if_t<!IsUnordered>
 AgedAssociativeContainerTestBase::testCompare()
-    requires(!IsUnordered)
 {
     using Traits = TestTraits<IsUnordered, IsMulti, IsMap>;
     typename Traits::ManualClock clock;
@@ -1691,9 +1662,8 @@ AgedAssociativeContainerTestBase::testCompare()
 
 // ordered
 template <bool IsUnordered, bool IsMulti, bool IsMap>
-void
+std::enable_if_t<!IsUnordered>
 AgedAssociativeContainerTestBase::testObservers()
-    requires(!IsUnordered)
 {
     using Traits = TestTraits<IsUnordered, IsMulti, IsMap>;
     typename Traits::ManualClock clock;
@@ -1710,9 +1680,8 @@ AgedAssociativeContainerTestBase::testObservers()
 
 // unordered
 template <bool IsUnordered, bool IsMulti, bool IsMap>
-void
+std::enable_if_t<IsUnordered>
 AgedAssociativeContainerTestBase::testObservers()
-    requires IsUnordered
 {
     using Traits = TestTraits<IsUnordered, IsMulti, IsMap>;
     typename Traits::ManualClock clock;
diff --git a/src/test/beast/beast_io_latency_probe_test.cpp b/src/test/beast/beast_io_latency_probe_test.cpp
index 807ad81c49..9a93968dab 100644
--- a/src/test/beast/beast_io_latency_probe_test.cpp
+++ b/src/test/beast/beast_io_latency_probe_test.cpp
@@ -8,7 +8,7 @@
 #include <boost/asio/spawn.hpp>
 #include <boost/system/detail/error_code.hpp>
 
-#include <algorithm>  // IWYU pragma: keep
+#include <algorithm>
 #include <chrono>
 #include <condition_variable>  // IWYU pragma: keep
 #include <cstddef>
diff --git a/src/test/core/Config_test.cpp b/src/test/core/Config_test.cpp
index 38c14b8ac5..fdac1e450d 100644
--- a/src/test/core/Config_test.cpp
+++ b/src/test/core/Config_test.cpp
@@ -1136,7 +1136,7 @@ trust-these-validators.gov
     testZeroPort()
     {
         auto const contents = std::regex_replace(
-            detail::configContents("", ""), std::regex(R"(port\s*=\s*\d+)"), "port = 0");
+            detail::configContents("", ""), std::regex("port\\s*=\\s*\\d+"), "port = 0");
 
         try
         {
diff --git a/src/test/csf/Tx.h b/src/test/csf/Tx.h
index 75254f865a..f871909f48 100644
--- a/src/test/csf/Tx.h
+++ b/src/test/csf/Tx.h
@@ -27,10 +27,8 @@ public:
     {
     }
 
-    template <typename T>
-    Tx(T const* t)
-        requires(std::is_same_v<T, Tx>)
-        : id_{t->id_}
+    template <typename T, typename = std::enable_if_t<std::is_same_v<T, Tx>>>
+    Tx(T const* t) : id_{t->id_}
     {
     }
 
diff --git a/src/test/csf/ledgers.h b/src/test/csf/ledgers.h
index 4873519dee..dc5ec5277c 100644
--- a/src/test/csf/ledgers.h
+++ b/src/test/csf/ledgers.h
@@ -3,6 +3,7 @@
 #include <test/csf/Tx.h>
 
 #include <xrpl/basics/chrono.h>
+#include <xrpl/basics/comparators.h>
 #include <xrpl/basics/tagged_integer.h>
 #include <xrpl/json/json_value.h>
 #include <xrpl/ledger/LedgerTiming.h>
@@ -12,7 +13,6 @@
 #include <cassert>
 #include <cstddef>
 #include <cstdint>
-#include <functional>
 #include <optional>
 #include <set>
 #include <string>
@@ -232,8 +232,8 @@ private:
 class LedgerOracle
 {
     using InstanceMap = boost::bimaps::bimap<
-        boost::bimaps::set_of<Ledger::Instance, std::less<>>,
-        boost::bimaps::set_of<Ledger::ID, std::less<>>>;
+        boost::bimaps::set_of<Ledger::Instance, xrpl::less<Ledger::Instance>>,
+        boost::bimaps::set_of<Ledger::ID, xrpl::less<Ledger::ID>>>;
     using InstanceEntry = InstanceMap::value_type;
 
     // Set of all known ledgers; note this is never pruned
diff --git a/src/test/csf/random.h b/src/test/csf/random.h
index aa20c73a10..9fc51f1217 100644
--- a/src/test/csf/random.h
+++ b/src/test/csf/random.h
@@ -135,8 +135,9 @@ class PowerLawDistribution
 public:
     using result_type = double;
 
-    PowerLawDistribution(double xmin, double a) : xmin_{xmin}, a_{a}, inv_(1.0 / (1.0 - a_))
+    PowerLawDistribution(double xmin, double a) : xmin_{xmin}, a_{a}
     {
+        inv_ = 1.0 / (1.0 - a_);
     }
 
     template <class Generator>
diff --git a/src/test/csf/submitters.h b/src/test/csf/submitters.h
index a71c849fb7..546681abe0 100644
--- a/src/test/csf/submitters.h
+++ b/src/test/csf/submitters.h
@@ -61,9 +61,8 @@ class Submitter
     }
 
     template <class T>
-    static SimDuration
+    static std::enable_if_t<std::is_arithmetic_v<T>, SimDuration>
     asDuration(T t)
-        requires(std::is_arithmetic_v<T>)
     {
         return SimDuration{static_cast<SimDuration::rep>(t)};
     }
diff --git a/src/test/jtx/Env_test.cpp b/src/test/jtx/Env_test.cpp
index 47cfb604f4..d82cb86b36 100644
--- a/src/test/jtx/Env_test.cpp
+++ b/src/test/jtx/Env_test.cpp
@@ -110,10 +110,10 @@ public:
         PrettyAmount(0u);  // NOLINT(bugprone-unused-raii)
         PrettyAmount(1u);  // NOLINT(bugprone-unused-raii)
         PrettyAmount(-1);  // NOLINT(bugprone-unused-raii)
-        static_assert(!std::is_trivially_constructible_v<PrettyAmount, char>);
-        static_assert(!std::is_trivially_constructible_v<PrettyAmount, unsigned char>);
-        static_assert(!std::is_trivially_constructible_v<PrettyAmount, short>);
-        static_assert(!std::is_trivially_constructible_v<PrettyAmount, unsigned short>);
+        static_assert(!std::is_trivially_constructible_v<PrettyAmount, char>, "");
+        static_assert(!std::is_trivially_constructible_v<PrettyAmount, unsigned char>, "");
+        static_assert(!std::is_trivially_constructible_v<PrettyAmount, short>, "");
+        static_assert(!std::is_trivially_constructible_v<PrettyAmount, unsigned short>, "");
 
         try
         {
diff --git a/src/test/jtx/TestHelpers.h b/src/test/jtx/TestHelpers.h
index 4c18d7343c..4f27fb61ee 100644
--- a/src/test/jtx/TestHelpers.h
+++ b/src/test/jtx/TestHelpers.h
@@ -413,9 +413,8 @@ void
 stpathAppendOne(STPath& st, Account const& account);
 
 template <class T>
-void
+std::enable_if_t<std::is_constructible_v<Account, T>>
 stpathAppendOne(STPath& st, T const& t)
-    requires(std::is_constructible_v<Account, T>)
 {
     stpathAppendOne(st, Account{t});
 }
diff --git a/src/test/jtx/TrustedPublisherServer.h b/src/test/jtx/TrustedPublisherServer.h
index f5ee8aac3a..008bbe70c3 100644
--- a/src/test/jtx/TrustedPublisherServer.h
+++ b/src/test/jtx/TrustedPublisherServer.h
@@ -188,8 +188,8 @@ public:
 
             for (auto const& val : validators)
             {
-                data += R"({"validation_public_key":")" + strHex(val.masterPublic) +
-                    R"(","manifest":")" + val.manifest + "\"},";
+                data += "{\"validation_public_key\":\"" + strHex(val.masterPublic) +
+                    "\",\"manifest\":\"" + val.manifest + "\"},";
             }
             data.pop_back();
             data += "]}";
@@ -201,8 +201,8 @@ public:
         getList_ = [blob = blob, sig, manifest, version](int interval) {
             // Build the contents of a version 1 format UNL file
             std::stringstream l;
-            l << R"({"blob":")" << blob << "\"" << R"(,"signature":")" << sig << "\""
-              << R"(,"manifest":")" << manifest << "\""
+            l << "{\"blob\":\"" << blob << "\"" << ",\"signature\":\"" << sig << "\""
+              << ",\"manifest\":\"" << manifest << "\""
               << ",\"refresh_interval\": " << interval << ",\"version\":" << version << '}';
             return l.str();
         };
@@ -216,8 +216,8 @@ public:
             // Use the same set of validators for simplicity
             for (auto const& val : validators)
             {
-                data += R"({"validation_public_key":")" + strHex(val.masterPublic) +
-                    R"(","manifest":")" + val.manifest + "\"},";
+                data += "{\"validation_public_key\":\"" + strHex(val.masterPublic) +
+                    "\",\"manifest\":\"" + val.manifest + "\"},";
             }
             data.pop_back();
             data += "]}";
@@ -232,13 +232,13 @@ public:
             std::stringstream l;
             for (auto const& info : blobInfo)
             {
-                l << R"({"blob":")" << info.blob << "\"" << R"(,"signature":")" << info.signature
+                l << "{\"blob\":\"" << info.blob << "\"" << ",\"signature\":\"" << info.signature
                   << "\"},";
             }
             std::string blobs = l.str();
             blobs.pop_back();
             l.str(std::string());
-            l << "{\"blobs_v2\": [ " << blobs << R"(],"manifest":")" << manifest << "\""
+            l << "{\"blobs_v2\": [ " << blobs << "],\"manifest\":\"" << manifest << "\""
               << ",\"refresh_interval\": " << interval << ",\"version\":" << (version + 1) << '}';
             return l.str();
         };
diff --git a/src/test/jtx/amount.h b/src/test/jtx/amount.h
index db7dbd1cc1..ce0234b41a 100644
--- a/src/test/jtx/amount.h
+++ b/src/test/jtx/amount.h
@@ -93,16 +93,19 @@ public:
 
     /** drops */
     template <class T>
-    PrettyAmount(T v)
-        requires(sizeof(T) >= sizeof(int) && std::is_integral_v<T> && std::is_signed_v<T>)
+    PrettyAmount(
+        T v,
+        std::enable_if_t<
+            sizeof(T) >= sizeof(int) && std::is_integral_v<T> && std::is_signed_v<T>>* = nullptr)
         : amount_((v > 0) ? v : -v, v < 0)
     {
     }
 
     /** drops */
     template <class T>
-    PrettyAmount(T v)
-        requires(sizeof(T) >= sizeof(int) && std::is_unsigned_v<T>)
+    PrettyAmount(
+        T v,
+        std::enable_if_t<sizeof(T) >= sizeof(int) && std::is_unsigned_v<T>>* = nullptr)
         : amount_(v)
     {
     }
@@ -279,10 +282,9 @@ struct XrpT
         @param v The number of XRP (not drops)
     */
     /** @{ */
-    template <class T>
+    template <class T, class = std::enable_if_t<std::is_integral_v<T>>>
     PrettyAmount
     operator()(T v) const
-        requires(std::is_integral_v<T>)
     {
         using TOut = std::conditional_t<std::is_signed_v<T>, std::int64_t, std::uint64_t>;
         return {TOut{v} * kJtxDropsPerXrp};
@@ -348,10 +350,9 @@ extern XrpT const XRP;  // NOLINT(readability-identifier-naming)
     Example:
         drops(10)   Returns PrettyAmount of 10 drops
 */
-template <class Integer>
+template <class Integer, class = std::enable_if_t<std::is_integral_v<Integer>>>
 PrettyAmount
 drops(Integer i)
-    requires(std::is_integral_v<Integer>)
 {
     return {i};
 }
@@ -435,10 +436,11 @@ public:
         return asset();
     }
 
-    template <class T>
+    template <
+        class T,
+        class = std::enable_if_t<sizeof(T) >= sizeof(int) && std::is_arithmetic_v<T>>>
     PrettyAmount
     operator()(T v) const
-        requires(sizeof(T) >= sizeof(int) && std::is_arithmetic_v<T>)
     {
         // VFALCO NOTE Should throw if the
         //             representation of v is not exact.
diff --git a/src/test/jtx/impl/WSClient.cpp b/src/test/jtx/impl/WSClient.cpp
index ca322415fb..c00a88f270 100644
--- a/src/test/jtx/impl/WSClient.cpp
+++ b/src/test/jtx/impl/WSClient.cpp
@@ -30,7 +30,6 @@
 
 #include <chrono>
 #include <condition_variable>
-#include <cstddef>
 #include <exception>
 #include <functional>
 #include <iostream>
@@ -173,9 +172,9 @@ public:
                     }));
             ws_.handshake(ep.address().to_string() + ":" + std::to_string(ep.port()), "/");
             ws_.async_read(
-                rb_, boost::asio::bind_executor(strand_, [this](error_code const& ec, std::size_t) {
-                    onReadMsg(ec);
-                }));
+                rb_,
+                boost::asio::bind_executor(
+                    strand_, std::bind(&WSClientImpl::onReadMsg, this, std::placeholders::_1)));
         }
         catch (std::exception&)
         {
@@ -311,9 +310,9 @@ private:
             cv_.notify_all();
         }
         ws_.async_read(
-            rb_, boost::asio::bind_executor(strand_, [this](error_code const& ec, std::size_t) {
-                onReadMsg(ec);
-            }));
+            rb_,
+            boost::asio::bind_executor(
+                strand_, std::bind(&WSClientImpl::onReadMsg, this, std::placeholders::_1)));
     }
 
     // Called when the read op terminates
diff --git a/src/test/jtx/impl/amount.cpp b/src/test/jtx/impl/amount.cpp
index f90102245a..b07703dace 100644
--- a/src/test/jtx/impl/amount.cpp
+++ b/src/test/jtx/impl/amount.cpp
@@ -12,7 +12,7 @@
 #include <cstdint>
 #include <iomanip>
 #include <ios>
-#include <limits>  // IWYU pragma: keep
+#include <limits>
 #include <ostream>
 #include <sstream>
 #include <string>
diff --git a/src/test/jtx/paths.h b/src/test/jtx/paths.h
index b141300a66..1450985687 100644
--- a/src/test/jtx/paths.h
+++ b/src/test/jtx/paths.h
@@ -67,9 +67,8 @@ private:
     appendOne(AccountID const& account);
 
     template <class T>
-    void
+    std::enable_if_t<std::is_constructible_v<Account, T>>
     appendOne(T const& t)
-        requires(std::is_constructible_v<Account, T>)
     {
         appendOne(Account{t});
     }
diff --git a/src/test/nodestore/Basics_test.cpp b/src/test/nodestore/Basics_test.cpp
index 7d77b18630..5565399cc2 100644
--- a/src/test/nodestore/Basics_test.cpp
+++ b/src/test/nodestore/Basics_test.cpp
@@ -40,9 +40,9 @@ public:
 
         auto batch = createPredictableBatch(kNumObjectsToTest, seedValue);
 
-        for (auto const& expected : batch)
+        for (int i = 0; i < batch.size(); ++i)
         {
-            EncodedBlob const encoded(expected);
+            EncodedBlob const encoded(batch[i]);
 
             DecodedBlob decoded(encoded.getKey(), encoded.getData(), encoded.getSize());
 
@@ -52,7 +52,7 @@ public:
             {
                 std::shared_ptr<NodeObject> const object(decoded.createObject());
 
-                BEAST_EXPECT(isSame(expected, object));
+                BEAST_EXPECT(isSame(batch[i], object));
             }
         }
     }
diff --git a/src/test/nodestore/TestBase.h b/src/test/nodestore/TestBase.h
index a1245ec963..1254fc51aa 100644
--- a/src/test/nodestore/TestBase.h
+++ b/src/test/nodestore/TestBase.h
@@ -124,9 +124,9 @@ public:
     static void
     storeBatch(Backend& backend, Batch const& batch)
     {
-        for (auto const& object : batch)
+        for (int i = 0; i < batch.size(); ++i)
         {
-            backend.store(object);
+            backend.store(batch[i]);
         }
     }
 
@@ -137,11 +137,11 @@ public:
         pCopy->clear();
         pCopy->reserve(batch.size());
 
-        for (auto const& expected : batch)
+        for (int i = 0; i < batch.size(); ++i)
         {
             std::shared_ptr<NodeObject> object;
 
-            Status const status = backend.fetch(expected->getHash(), &object);
+            Status const status = backend.fetch(batch[i]->getHash(), &object);
 
             BEAST_EXPECT(status == Status::Ok);
 
@@ -157,11 +157,11 @@ public:
     void
     fetchMissing(Backend& backend, Batch const& batch)
     {
-        for (auto const& expected : batch)
+        for (int i = 0; i < batch.size(); ++i)
         {
             std::shared_ptr<NodeObject> object;
 
-            Status const status = backend.fetch(expected->getHash(), &object);
+            Status const status = backend.fetch(batch[i]->getHash(), &object);
 
             BEAST_EXPECT(status == Status::NotFound);
         }
@@ -171,8 +171,10 @@ public:
     static void
     storeBatch(Database& db, Batch const& batch)
     {
-        for (auto const& object : batch)
+        for (int i = 0; i < batch.size(); ++i)
         {
+            std::shared_ptr<NodeObject> const object(batch[i]);
+
             Blob data(object->getData());
 
             db.store(object->getType(), std::move(data), object->getHash(), db.earliestLedgerSeq());
@@ -186,9 +188,9 @@ public:
         pCopy->clear();
         pCopy->reserve(batch.size());
 
-        for (auto const& expected : batch)
+        for (int i = 0; i < batch.size(); ++i)
         {
-            std::shared_ptr<NodeObject> const object = db.fetchNodeObject(expected->getHash(), 0);
+            std::shared_ptr<NodeObject> const object = db.fetchNodeObject(batch[i]->getHash(), 0);
 
             if (object != nullptr)
                 pCopy->push_back(object);
diff --git a/src/test/nodestore/Timing_test.cpp b/src/test/nodestore/Timing_test.cpp
index 1c296ca44c..e308d0d5ff 100644
--- a/src/test/nodestore/Timing_test.cpp
+++ b/src/test/nodestore/Timing_test.cpp
@@ -564,10 +564,10 @@ public:
                     char p[2];
                     p[0] = rand_(gen_) < 50 ? 0 : 1;
                     p[1] = 1 - p[0];
-                    for (char const op : p)
+                    for (int q = 0; q < 2; ++q)
                     {
                         // NOLINTNEXTLINE(bugprone-switch-missing-default-case)
-                        switch (op)
+                        switch (p[q])
                         {
                             case 0: {
                                 // fetch recent
diff --git a/src/test/overlay/reduce_relay_test.cpp b/src/test/overlay/reduce_relay_test.cpp
index 433595522d..1c9bf1f9c1 100644
--- a/src/test/overlay/reduce_relay_test.cpp
+++ b/src/test/overlay/reduce_relay_test.cpp
@@ -323,11 +323,12 @@ class Validator
     using Links = std::unordered_map<Peer::id_t, LinkSPtr>;
 
 public:
-    Validator() : pkey_(std::get<0>(randomKeyPair(KeyType::Ed25519))), id_(sid++)
+    Validator() : pkey_(std::get<0>(randomKeyPair(KeyType::Ed25519)))
     {
         protocol::TMValidation v;
         v.set_validation("validation");
         message_ = std::make_shared<Message>(v, protocol::mtVALIDATION, pkey_);
+        id_ = sid++;
     }
     Validator(Validator const&) = default;
     Validator(Validator&&) = default;
@@ -456,6 +457,7 @@ public:
     using id_t = Peer::id_t;
     PeerSim(Overlay& overlay, beast::Journal journal) : overlay_(overlay), squelch_(journal)
     {
+        id_ = sid++;
     }
 
     ~PeerSim() override = default;
@@ -510,7 +512,7 @@ public:
 private:
     inline static id_t sid = 0;
     std::string fingerprint_;
-    id_t id_{sid++};
+    id_t id_;
     Overlay& overlay_;
     reduce_relay::Squelch<ManualClock> squelch_;
 };
diff --git a/src/test/overlay/short_read_test.cpp b/src/test/overlay/short_read_test.cpp
index d856231b8d..9af632d65c 100644
--- a/src/test/overlay/short_read_test.cpp
+++ b/src/test/overlay/short_read_test.cpp
@@ -26,6 +26,7 @@
 #include <chrono>
 #include <condition_variable>
 #include <cstddef>
+#include <functional>
 #include <map>
 #include <memory>
 #include <mutex>
@@ -198,7 +199,7 @@ private:
             {
                 if (!strand.running_in_this_thread())
                 {
-                    post(strand, [self = shared_from_this()] { self->close(); });
+                    post(strand, std::bind(&Acceptor::close, shared_from_this()));
                     return;
                 }
                 acceptor.close();
@@ -209,9 +210,9 @@ private:
             {
                 acceptor.async_accept(
                     socket,
-                    bind_executor(strand, [self = shared_from_this()](error_code const& ec) {
-                        self->onAccept(ec);
-                    }));
+                    bind_executor(
+                        strand,
+                        std::bind(&Acceptor::onAccept, shared_from_this(), std::placeholders::_1)));
             }
 
             void
@@ -238,9 +239,9 @@ private:
                 p->run();
                 acceptor.async_accept(
                     socket,
-                    bind_executor(strand, [self = shared_from_this()](error_code const& ec) {
-                        self->onAccept(ec);
-                    }));
+                    bind_executor(
+                        strand,
+                        std::bind(&Acceptor::onAccept, shared_from_this(), std::placeholders::_1)));
             }
         };
 
@@ -270,7 +271,7 @@ private:
             {
                 if (!strand.running_in_this_thread())
                 {
-                    post(strand, [self = shared_from_this()] { self->close(); });
+                    post(strand, std::bind(&Connection::close, shared_from_this()));
                     return;
                 }
                 if (socket.is_open())
@@ -286,12 +287,13 @@ private:
                 timer.expires_after(std::chrono::seconds(3));
                 timer.async_wait(bind_executor(
                     strand,
-                    [self = shared_from_this()](error_code const& ec) { self->onTimer(ec); }));
+                    std::bind(&Connection::onTimer, shared_from_this(), std::placeholders::_1)));
                 stream.async_handshake(
                     stream_type::server,
-                    bind_executor(strand, [self = shared_from_this()](error_code const& ec) {
-                        self->onHandshake(ec);
-                    }));
+                    bind_executor(
+                        strand,
+                        std::bind(
+                            &Connection::onHandshake, shared_from_this(), std::placeholders::_1)));
             }
 
             void
@@ -328,16 +330,21 @@ private:
                     fail("handshake", ec);
                     return;
                 }
+#if 1
                 boost::asio::async_read_until(
                     stream,
                     buf,
                     "\n",
                     bind_executor(
                         strand,
-                        [self = shared_from_this()](
-                            error_code const& ec, std::size_t bytesTransferred) {
-                            self->onRead(ec, bytesTransferred);
-                        }));
+                        std::bind(
+                            &Connection::onRead,
+                            shared_from_this(),
+                            std::placeholders::_1,
+                            std::placeholders::_2)));
+#else
+                close();
+#endif
             }
 
             void
@@ -346,10 +353,10 @@ private:
                 if (ec == boost::asio::error::eof)
                 {
                     server.test_.log << "[server] read: EOF" << std::endl;
-                    stream.async_shutdown(
-                        bind_executor(strand, [self = shared_from_this()](error_code const& ec) {
-                            self->onShutdown(ec);
-                        }));
+                    stream.async_shutdown(bind_executor(
+                        strand,
+                        std::bind(
+                            &Connection::onShutdown, shared_from_this(), std::placeholders::_1)));
                     return;
                 }
                 if (ec)
@@ -366,10 +373,11 @@ private:
                     buf.data(),
                     bind_executor(
                         strand,
-                        [self = shared_from_this()](
-                            error_code const& ec, std::size_t bytesTransferred) {
-                            self->onWrite(ec, bytesTransferred);
-                        }));
+                        std::bind(
+                            &Connection::onWrite,
+                            shared_from_this(),
+                            std::placeholders::_1,
+                            std::placeholders::_2)));
             }
 
             void
@@ -383,7 +391,7 @@ private:
                 }
                 stream.async_shutdown(bind_executor(
                     strand,
-                    [self = shared_from_this()](error_code const& ec) { self->onShutdown(ec); }));
+                    std::bind(&Connection::onShutdown, shared_from_this(), std::placeholders::_1)));
             }
 
             void
@@ -455,7 +463,7 @@ private:
             {
                 if (!strand.running_in_this_thread())
                 {
-                    post(strand, [self = shared_from_this()] { self->close(); });
+                    post(strand, std::bind(&Connection::close, shared_from_this()));
                     return;
                 }
                 if (socket.is_open())
@@ -471,11 +479,13 @@ private:
                 timer.expires_after(std::chrono::seconds(3));
                 timer.async_wait(bind_executor(
                     strand,
-                    [self = shared_from_this()](error_code const& ec) { self->onTimer(ec); }));
+                    std::bind(&Connection::onTimer, shared_from_this(), std::placeholders::_1)));
                 socket.async_connect(
-                    ep, bind_executor(strand, [self = shared_from_this()](error_code const& ec) {
-                        self->onConnect(ec);
-                    }));
+                    ep,
+                    bind_executor(
+                        strand,
+                        std::bind(
+                            &Connection::onConnect, shared_from_this(), std::placeholders::_1)));
             }
 
             void
@@ -514,9 +524,10 @@ private:
                 }
                 stream.async_handshake(
                     stream_type::client,
-                    bind_executor(strand, [self = shared_from_this()](error_code const& ec) {
-                        self->onHandshake(ec);
-                    }));
+                    bind_executor(
+                        strand,
+                        std::bind(
+                            &Connection::onHandshake, shared_from_this(), std::placeholders::_1)));
             }
 
             void
@@ -529,15 +540,23 @@ private:
                 }
                 write(buf, "HELLO\n");
 
+#if 1
                 boost::asio::async_write(
                     stream,
                     buf.data(),
                     bind_executor(
                         strand,
-                        [self = shared_from_this()](
-                            error_code const& ec, std::size_t bytesTransferred) {
-                            self->onWrite(ec, bytesTransferred);
-                        }));
+                        std::bind(
+                            &Connection::onWrite,
+                            shared_from_this(),
+                            std::placeholders::_1,
+                            std::placeholders::_2)));
+#else
+                stream_.async_shutdown(bind_executor(
+                    strand_,
+                    std::bind(
+                        &Connection::on_shutdown, shared_from_this(), std::placeholders::_1)));
+#endif
             }
 
             void
@@ -549,16 +568,24 @@ private:
                     fail("write", ec);
                     return;
                 }
+#if 1
                 boost::asio::async_read_until(
                     stream,
                     buf,
                     "\n",
                     bind_executor(
                         strand,
-                        [self = shared_from_this()](
-                            error_code const& ec, std::size_t bytesTransferred) {
-                            self->onRead(ec, bytesTransferred);
-                        }));
+                        std::bind(
+                            &Connection::onRead,
+                            shared_from_this(),
+                            std::placeholders::_1,
+                            std::placeholders::_2)));
+#else
+                stream_.async_shutdown(bind_executor(
+                    strand_,
+                    std::bind(
+                        &Connection::on_shutdown, shared_from_this(), std::placeholders::_1)));
+#endif
             }
 
             void
@@ -572,7 +599,7 @@ private:
                 buf.commit(bytesTransferred);
                 stream.async_shutdown(bind_executor(
                     strand,
-                    [self = shared_from_this()](error_code const& ec) { self->onShutdown(ec); }));
+                    std::bind(&Connection::onShutdown, shared_from_this(), std::placeholders::_1)));
             }
 
             void
diff --git a/src/test/protocol/Quality_test.cpp b/src/test/protocol/Quality_test.cpp
index e7ffa9f305..df95cea8ef 100644
--- a/src/test/protocol/Quality_test.cpp
+++ b/src/test/protocol/Quality_test.cpp
@@ -22,19 +22,17 @@ public:
 
     template <class Integer>
     static STAmount
-    amount(Integer integer)
-        requires(std::is_signed_v<Integer>)
+    amount(Integer integer, std::enable_if_t<std::is_signed_v<Integer>>* = 0)
     {
-        static_assert(std::is_integral_v<Integer>);
+        static_assert(std::is_integral_v<Integer>, "");
         return STAmount(integer, false);
     }
 
     template <class Integer>
     static STAmount
-    amount(Integer integer)
-        requires(!std::is_signed_v<Integer>)
+    amount(Integer integer, std::enable_if_t<!std::is_signed_v<Integer>>* = 0)
     {
-        static_assert(std::is_integral_v<Integer>);
+        static_assert(std::is_integral_v<Integer>, "");
         if (integer < 0)
             return STAmount(-integer, true);
         return STAmount(integer, false);
diff --git a/src/test/protocol/STObject_test.cpp b/src/test/protocol/STObject_test.cpp
index 8b7db632c5..b823b24962 100644
--- a/src/test/protocol/STObject_test.cpp
+++ b/src/test/protocol/STObject_test.cpp
@@ -356,7 +356,8 @@ public:
         {
             STObject st(sfGeneric);
             auto const v = ~st[~sf1Outer];
-            static_assert(std::is_same_v<std::decay_t<decltype(v)>, std::optional<std::uint32_t>>);
+            static_assert(
+                std::is_same_v<std::decay_t<decltype(v)>, std::optional<std::uint32_t>>, "");
         }
 
         // UDT scalar fields
@@ -430,7 +431,8 @@ public:
             BEAST_EXPECT(cst[~sf]->size() == 2);  // NOLINT(bugprone-unchecked-optional-access)
             BEAST_EXPECT(cst[sf][0] == 1);
             BEAST_EXPECT(cst[sf][1] == 2);
-            static_assert(std::is_same_v<decltype(cst[sfIndexes]), std::vector<uint256> const&>);
+            static_assert(
+                std::is_same_v<decltype(cst[sfIndexes]), std::vector<uint256> const&>, "");
         }
 
         // Default by reference field
diff --git a/src/test/protocol/STTx_test.cpp b/src/test/protocol/STTx_test.cpp
index 45bd2729c4..21518d1406 100644
--- a/src/test/protocol/STTx_test.cpp
+++ b/src/test/protocol/STTx_test.cpp
@@ -1366,7 +1366,6 @@ public:
         {
             fail("Unable to build object from json");
         }
-        // NOLINTNEXTLINE(cppcoreguidelines-slicing)
         else if (STObject(j) != parsed.object)
         {
             log << "ORIG: " << j.getJson(JsonOptions::Values::None) << '\n'
diff --git a/src/test/protocol/SeqProxy_test.cpp b/src/test/protocol/SeqProxy_test.cpp
index 44aab41992..90345ddc22 100644
--- a/src/test/protocol/SeqProxy_test.cpp
+++ b/src/test/protocol/SeqProxy_test.cpp
@@ -81,128 +81,128 @@ struct SeqProxy_test : public beast::unit_test::Suite
         static constexpr SeqProxy kTicBig{kTicket, kUintMax};
 
         // Verify operation of value(), isSeq() and isTicket().
-        static_assert(expectValues(kSeqZero, 0, kSeq));
-        static_assert(expectValues(kSeqSmall, 1, kSeq));
-        static_assert(expectValues(kSeqMiD0, 2, kSeq));
-        static_assert(expectValues(kSeqMiD1, 2, kSeq));
-        static_assert(expectValues(kSeqBig, kUintMax, kSeq));
+        static_assert(expectValues(kSeqZero, 0, kSeq), "");
+        static_assert(expectValues(kSeqSmall, 1, kSeq), "");
+        static_assert(expectValues(kSeqMiD0, 2, kSeq), "");
+        static_assert(expectValues(kSeqMiD1, 2, kSeq), "");
+        static_assert(expectValues(kSeqBig, kUintMax, kSeq), "");
 
-        static_assert(expectValues(kTicZero, 0, kTicket));
-        static_assert(expectValues(kTicSmall, 1, kTicket));
-        static_assert(expectValues(kTicMid0, 2, kTicket));
-        static_assert(expectValues(kTicMid1, 2, kTicket));
-        static_assert(expectValues(kTicBig, kUintMax, kTicket));
+        static_assert(expectValues(kTicZero, 0, kTicket), "");
+        static_assert(expectValues(kTicSmall, 1, kTicket), "");
+        static_assert(expectValues(kTicMid0, 2, kTicket), "");
+        static_assert(expectValues(kTicMid1, 2, kTicket), "");
+        static_assert(expectValues(kTicBig, kUintMax, kTicket), "");
 
         // Verify expected behavior of comparison operators.
-        static_assert(expectEq(kSeqZero, kSeqZero));
-        static_assert(expectLt(kSeqZero, kSeqSmall));
-        static_assert(expectLt(kSeqZero, kSeqMiD0));
-        static_assert(expectLt(kSeqZero, kSeqMiD1));
-        static_assert(expectLt(kSeqZero, kSeqBig));
-        static_assert(expectLt(kSeqZero, kTicZero));
-        static_assert(expectLt(kSeqZero, kTicSmall));
-        static_assert(expectLt(kSeqZero, kTicMid0));
-        static_assert(expectLt(kSeqZero, kTicMid1));
-        static_assert(expectLt(kSeqZero, kTicBig));
+        static_assert(expectEq(kSeqZero, kSeqZero), "");
+        static_assert(expectLt(kSeqZero, kSeqSmall), "");
+        static_assert(expectLt(kSeqZero, kSeqMiD0), "");
+        static_assert(expectLt(kSeqZero, kSeqMiD1), "");
+        static_assert(expectLt(kSeqZero, kSeqBig), "");
+        static_assert(expectLt(kSeqZero, kTicZero), "");
+        static_assert(expectLt(kSeqZero, kTicSmall), "");
+        static_assert(expectLt(kSeqZero, kTicMid0), "");
+        static_assert(expectLt(kSeqZero, kTicMid1), "");
+        static_assert(expectLt(kSeqZero, kTicBig), "");
 
-        static_assert(expectGt(kSeqSmall, kSeqZero));
-        static_assert(expectEq(kSeqSmall, kSeqSmall));
-        static_assert(expectLt(kSeqSmall, kSeqMiD0));
-        static_assert(expectLt(kSeqSmall, kSeqMiD1));
-        static_assert(expectLt(kSeqSmall, kSeqBig));
-        static_assert(expectLt(kSeqSmall, kTicZero));
-        static_assert(expectLt(kSeqSmall, kTicSmall));
-        static_assert(expectLt(kSeqSmall, kTicMid0));
-        static_assert(expectLt(kSeqSmall, kTicMid1));
-        static_assert(expectLt(kSeqSmall, kTicBig));
+        static_assert(expectGt(kSeqSmall, kSeqZero), "");
+        static_assert(expectEq(kSeqSmall, kSeqSmall), "");
+        static_assert(expectLt(kSeqSmall, kSeqMiD0), "");
+        static_assert(expectLt(kSeqSmall, kSeqMiD1), "");
+        static_assert(expectLt(kSeqSmall, kSeqBig), "");
+        static_assert(expectLt(kSeqSmall, kTicZero), "");
+        static_assert(expectLt(kSeqSmall, kTicSmall), "");
+        static_assert(expectLt(kSeqSmall, kTicMid0), "");
+        static_assert(expectLt(kSeqSmall, kTicMid1), "");
+        static_assert(expectLt(kSeqSmall, kTicBig), "");
 
-        static_assert(expectGt(kSeqMiD0, kSeqZero));
-        static_assert(expectGt(kSeqMiD0, kSeqSmall));
-        static_assert(expectEq(kSeqMiD0, kSeqMiD0));
-        static_assert(expectEq(kSeqMiD0, kSeqMiD1));
-        static_assert(expectLt(kSeqMiD0, kSeqBig));
-        static_assert(expectLt(kSeqMiD0, kTicZero));
-        static_assert(expectLt(kSeqMiD0, kTicSmall));
-        static_assert(expectLt(kSeqMiD0, kTicMid0));
-        static_assert(expectLt(kSeqMiD0, kTicMid1));
-        static_assert(expectLt(kSeqMiD0, kTicBig));
+        static_assert(expectGt(kSeqMiD0, kSeqZero), "");
+        static_assert(expectGt(kSeqMiD0, kSeqSmall), "");
+        static_assert(expectEq(kSeqMiD0, kSeqMiD0), "");
+        static_assert(expectEq(kSeqMiD0, kSeqMiD1), "");
+        static_assert(expectLt(kSeqMiD0, kSeqBig), "");
+        static_assert(expectLt(kSeqMiD0, kTicZero), "");
+        static_assert(expectLt(kSeqMiD0, kTicSmall), "");
+        static_assert(expectLt(kSeqMiD0, kTicMid0), "");
+        static_assert(expectLt(kSeqMiD0, kTicMid1), "");
+        static_assert(expectLt(kSeqMiD0, kTicBig), "");
 
-        static_assert(expectGt(kSeqMiD1, kSeqZero));
-        static_assert(expectGt(kSeqMiD1, kSeqSmall));
-        static_assert(expectEq(kSeqMiD1, kSeqMiD0));
-        static_assert(expectEq(kSeqMiD1, kSeqMiD1));
-        static_assert(expectLt(kSeqMiD1, kSeqBig));
-        static_assert(expectLt(kSeqMiD1, kTicZero));
-        static_assert(expectLt(kSeqMiD1, kTicSmall));
-        static_assert(expectLt(kSeqMiD1, kTicMid0));
-        static_assert(expectLt(kSeqMiD1, kTicMid1));
-        static_assert(expectLt(kSeqMiD1, kTicBig));
+        static_assert(expectGt(kSeqMiD1, kSeqZero), "");
+        static_assert(expectGt(kSeqMiD1, kSeqSmall), "");
+        static_assert(expectEq(kSeqMiD1, kSeqMiD0), "");
+        static_assert(expectEq(kSeqMiD1, kSeqMiD1), "");
+        static_assert(expectLt(kSeqMiD1, kSeqBig), "");
+        static_assert(expectLt(kSeqMiD1, kTicZero), "");
+        static_assert(expectLt(kSeqMiD1, kTicSmall), "");
+        static_assert(expectLt(kSeqMiD1, kTicMid0), "");
+        static_assert(expectLt(kSeqMiD1, kTicMid1), "");
+        static_assert(expectLt(kSeqMiD1, kTicBig), "");
 
-        static_assert(expectGt(kSeqBig, kSeqZero));
-        static_assert(expectGt(kSeqBig, kSeqSmall));
-        static_assert(expectGt(kSeqBig, kSeqMiD0));
-        static_assert(expectGt(kSeqBig, kSeqMiD1));
-        static_assert(expectEq(kSeqBig, kSeqBig));
-        static_assert(expectLt(kSeqBig, kTicZero));
-        static_assert(expectLt(kSeqBig, kTicSmall));
-        static_assert(expectLt(kSeqBig, kTicMid0));
-        static_assert(expectLt(kSeqBig, kTicMid1));
-        static_assert(expectLt(kSeqBig, kTicBig));
+        static_assert(expectGt(kSeqBig, kSeqZero), "");
+        static_assert(expectGt(kSeqBig, kSeqSmall), "");
+        static_assert(expectGt(kSeqBig, kSeqMiD0), "");
+        static_assert(expectGt(kSeqBig, kSeqMiD1), "");
+        static_assert(expectEq(kSeqBig, kSeqBig), "");
+        static_assert(expectLt(kSeqBig, kTicZero), "");
+        static_assert(expectLt(kSeqBig, kTicSmall), "");
+        static_assert(expectLt(kSeqBig, kTicMid0), "");
+        static_assert(expectLt(kSeqBig, kTicMid1), "");
+        static_assert(expectLt(kSeqBig, kTicBig), "");
 
-        static_assert(expectGt(kTicZero, kSeqZero));
-        static_assert(expectGt(kTicZero, kSeqSmall));
-        static_assert(expectGt(kTicZero, kSeqMiD0));
-        static_assert(expectGt(kTicZero, kSeqMiD1));
-        static_assert(expectGt(kTicZero, kSeqBig));
-        static_assert(expectEq(kTicZero, kTicZero));
-        static_assert(expectLt(kTicZero, kTicSmall));
-        static_assert(expectLt(kTicZero, kTicMid0));
-        static_assert(expectLt(kTicZero, kTicMid1));
-        static_assert(expectLt(kTicZero, kTicBig));
+        static_assert(expectGt(kTicZero, kSeqZero), "");
+        static_assert(expectGt(kTicZero, kSeqSmall), "");
+        static_assert(expectGt(kTicZero, kSeqMiD0), "");
+        static_assert(expectGt(kTicZero, kSeqMiD1), "");
+        static_assert(expectGt(kTicZero, kSeqBig), "");
+        static_assert(expectEq(kTicZero, kTicZero), "");
+        static_assert(expectLt(kTicZero, kTicSmall), "");
+        static_assert(expectLt(kTicZero, kTicMid0), "");
+        static_assert(expectLt(kTicZero, kTicMid1), "");
+        static_assert(expectLt(kTicZero, kTicBig), "");
 
-        static_assert(expectGt(kTicSmall, kSeqZero));
-        static_assert(expectGt(kTicSmall, kSeqSmall));
-        static_assert(expectGt(kTicSmall, kSeqMiD0));
-        static_assert(expectGt(kTicSmall, kSeqMiD1));
-        static_assert(expectGt(kTicSmall, kSeqBig));
-        static_assert(expectGt(kTicSmall, kTicZero));
-        static_assert(expectEq(kTicSmall, kTicSmall));
-        static_assert(expectLt(kTicSmall, kTicMid0));
-        static_assert(expectLt(kTicSmall, kTicMid1));
-        static_assert(expectLt(kTicSmall, kTicBig));
+        static_assert(expectGt(kTicSmall, kSeqZero), "");
+        static_assert(expectGt(kTicSmall, kSeqSmall), "");
+        static_assert(expectGt(kTicSmall, kSeqMiD0), "");
+        static_assert(expectGt(kTicSmall, kSeqMiD1), "");
+        static_assert(expectGt(kTicSmall, kSeqBig), "");
+        static_assert(expectGt(kTicSmall, kTicZero), "");
+        static_assert(expectEq(kTicSmall, kTicSmall), "");
+        static_assert(expectLt(kTicSmall, kTicMid0), "");
+        static_assert(expectLt(kTicSmall, kTicMid1), "");
+        static_assert(expectLt(kTicSmall, kTicBig), "");
 
-        static_assert(expectGt(kTicMid0, kSeqZero));
-        static_assert(expectGt(kTicMid0, kSeqSmall));
-        static_assert(expectGt(kTicMid0, kSeqMiD0));
-        static_assert(expectGt(kTicMid0, kSeqMiD1));
-        static_assert(expectGt(kTicMid0, kSeqBig));
-        static_assert(expectGt(kTicMid0, kTicZero));
-        static_assert(expectGt(kTicMid0, kTicSmall));
-        static_assert(expectEq(kTicMid0, kTicMid0));
-        static_assert(expectEq(kTicMid0, kTicMid1));
-        static_assert(expectLt(kTicMid0, kTicBig));
+        static_assert(expectGt(kTicMid0, kSeqZero), "");
+        static_assert(expectGt(kTicMid0, kSeqSmall), "");
+        static_assert(expectGt(kTicMid0, kSeqMiD0), "");
+        static_assert(expectGt(kTicMid0, kSeqMiD1), "");
+        static_assert(expectGt(kTicMid0, kSeqBig), "");
+        static_assert(expectGt(kTicMid0, kTicZero), "");
+        static_assert(expectGt(kTicMid0, kTicSmall), "");
+        static_assert(expectEq(kTicMid0, kTicMid0), "");
+        static_assert(expectEq(kTicMid0, kTicMid1), "");
+        static_assert(expectLt(kTicMid0, kTicBig), "");
 
-        static_assert(expectGt(kTicMid1, kSeqZero));
-        static_assert(expectGt(kTicMid1, kSeqSmall));
-        static_assert(expectGt(kTicMid1, kSeqMiD0));
-        static_assert(expectGt(kTicMid1, kSeqMiD1));
-        static_assert(expectGt(kTicMid1, kSeqBig));
-        static_assert(expectGt(kTicMid1, kTicZero));
-        static_assert(expectGt(kTicMid1, kTicSmall));
-        static_assert(expectEq(kTicMid1, kTicMid0));
-        static_assert(expectEq(kTicMid1, kTicMid1));
-        static_assert(expectLt(kTicMid1, kTicBig));
+        static_assert(expectGt(kTicMid1, kSeqZero), "");
+        static_assert(expectGt(kTicMid1, kSeqSmall), "");
+        static_assert(expectGt(kTicMid1, kSeqMiD0), "");
+        static_assert(expectGt(kTicMid1, kSeqMiD1), "");
+        static_assert(expectGt(kTicMid1, kSeqBig), "");
+        static_assert(expectGt(kTicMid1, kTicZero), "");
+        static_assert(expectGt(kTicMid1, kTicSmall), "");
+        static_assert(expectEq(kTicMid1, kTicMid0), "");
+        static_assert(expectEq(kTicMid1, kTicMid1), "");
+        static_assert(expectLt(kTicMid1, kTicBig), "");
 
-        static_assert(expectGt(kTicBig, kSeqZero));
-        static_assert(expectGt(kTicBig, kSeqSmall));
-        static_assert(expectGt(kTicBig, kSeqMiD0));
-        static_assert(expectGt(kTicBig, kSeqMiD1));
-        static_assert(expectGt(kTicBig, kSeqBig));
-        static_assert(expectGt(kTicBig, kTicZero));
-        static_assert(expectGt(kTicBig, kTicSmall));
-        static_assert(expectGt(kTicBig, kTicMid0));
-        static_assert(expectGt(kTicBig, kTicMid1));
-        static_assert(expectEq(kTicBig, kTicBig));
+        static_assert(expectGt(kTicBig, kSeqZero), "");
+        static_assert(expectGt(kTicBig, kSeqSmall), "");
+        static_assert(expectGt(kTicBig, kSeqMiD0), "");
+        static_assert(expectGt(kTicBig, kSeqMiD1), "");
+        static_assert(expectGt(kTicBig, kSeqBig), "");
+        static_assert(expectGt(kTicBig, kTicZero), "");
+        static_assert(expectGt(kTicBig, kTicSmall), "");
+        static_assert(expectGt(kTicBig, kTicMid0), "");
+        static_assert(expectGt(kTicBig, kTicMid1), "");
+        static_assert(expectEq(kTicBig, kTicBig), "");
 
         // Verify streaming.
         BEAST_EXPECT(streamTest(kSeqZero));
diff --git a/src/test/protocol/TER_test.cpp b/src/test/protocol/TER_test.cpp
index 77f12ff2b7..af1cfced0e 100644
--- a/src/test/protocol/TER_test.cpp
+++ b/src/test/protocol/TER_test.cpp
@@ -72,9 +72,8 @@ struct TER_test : public beast::unit_test::Suite
         std::size_t I2,
         template <std::size_t, std::size_t> class Func,
         typename Tup>
-    void
+    std::enable_if_t<I1 != 0>
     testIterate(Tup const& tup, beast::unit_test::Suite& s)
-        requires(I1 != 0)
     {
         Func<I1, I2> const func;
         func(tup, s);
@@ -87,9 +86,8 @@ struct TER_test : public beast::unit_test::Suite
         std::size_t I2,
         template <std::size_t, std::size_t> class Func,
         typename Tup>
-    void
+    std::enable_if_t<I1 == 0 && I2 != 0>
     testIterate(Tup const& tup, beast::unit_test::Suite& s)
-        requires(I1 == 0 && I2 != 0)
     {
         Func<I1, I2> const func;
         func(tup, s);
@@ -102,9 +100,8 @@ struct TER_test : public beast::unit_test::Suite
         std::size_t I2,
         template <std::size_t, std::size_t> class Func,
         typename Tup>
-    void
+    std::enable_if_t<I1 == 0 && I2 == 0>
     testIterate(Tup const& tup, beast::unit_test::Suite& s)
-        requires(I1 == 0 && I2 == 0)
     {
         Func<I1, I2> const func;
         func(tup, s);
diff --git a/src/test/resource/Logic_test.cpp b/src/test/resource/Logic_test.cpp
new file mode 100644
index 0000000000..de4575cb16
--- /dev/null
+++ b/src/test/resource/Logic_test.cpp
@@ -0,0 +1,294 @@
+#include <test/unit_test/SuiteJournal.h>
+
+#include <xrpl/basics/Log.h>
+#include <xrpl/basics/chrono.h>
+#include <xrpl/basics/random.h>
+#include <xrpl/beast/insight/NullCollector.h>
+#include <xrpl/beast/net/IPAddressV4.h>
+#include <xrpl/beast/unit_test/suite.h>
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/resource/Charge.h>
+#include <xrpl/resource/Consumer.h>
+#include <xrpl/resource/Disposition.h>
+#include <xrpl/resource/Gossip.h>
+#include <xrpl/resource/detail/Logic.h>
+#include <xrpl/resource/detail/Tuning.h>
+
+#include <boost/utility/base_from_member.hpp>
+
+#include <chrono>
+#include <cstdint>
+#include <functional>
+#include <string>
+
+namespace xrpl::Resource {
+
+class ResourceManager_test : public beast::unit_test::Suite
+{
+public:
+    class TestLogic : private boost::base_from_member<TestStopwatch>, public Logic
+
+    {
+    private:
+        using clock_type = boost::base_from_member<TestStopwatch>;
+
+    public:
+        explicit TestLogic(beast::Journal journal)
+            : Logic(beast::insight::NullCollector::make(), member, journal)
+        {
+        }
+
+        void
+        advance()
+        {
+            ++member;
+        }
+
+        TestStopwatch&
+        clock()
+        {
+            return member;
+        }
+    };
+
+    //--------------------------------------------------------------------------
+
+    static void
+    createGossip(Gossip& gossip)
+    {
+        std::uint8_t const v(10 + randInt(9));
+        std::uint8_t const n(10 + randInt(9));
+        gossip.items.reserve(n);
+        for (std::uint8_t i = 0; i < n; ++i)
+        {
+            Gossip::Item item;
+            item.balance = 100 + randInt(499);
+            beast::IP::AddressV4::bytes_type const d = {
+                {192, 0, 2, static_cast<std::uint8_t>(v + i)}};
+            item.address = beast::IP::Endpoint{beast::IP::AddressV4{d}};
+            gossip.items.push_back(item);
+        }
+    }
+
+    //--------------------------------------------------------------------------
+
+    void
+    testDrop(beast::Journal j, bool limited)
+    {
+        if (limited)
+        {
+            testcase("Limited warn/drop");
+        }
+        else
+        {
+            testcase("Unlimited warn/drop");
+        }
+
+        TestLogic logic(j);
+
+        Charge const fee(kDropThreshold + 1);
+        beast::IP::Endpoint const addr(beast::IP::Endpoint::fromString("192.0.2.2"));
+
+        std::function<Consumer(beast::IP::Endpoint)> const ep = limited
+            ? std::bind(&TestLogic::newInboundEndpoint, &logic, std::placeholders::_1)
+            : std::bind(&TestLogic::newUnlimitedEndpoint, &logic, std::placeholders::_1);
+
+        {
+            Consumer c(ep(addr));
+
+            // Create load until we get a warning
+            int n = 10000;
+
+            while (--n >= 0)
+            {
+                if (n == 0)
+                {
+                    if (limited)
+                    {
+                        fail("Loop count exceeded without warning");
+                    }
+                    else
+                    {
+                        pass();
+                    }
+                    return;
+                }
+
+                if (c.charge(fee) == Disposition::Warn)
+                {
+                    if (limited)
+                    {
+                        pass();
+                    }
+                    else
+                    {
+                        fail("Should loop forever with no warning");
+                    }
+                    break;
+                }
+                ++logic.clock();
+            }
+
+            // Create load until we get dropped
+            while (--n >= 0)
+            {
+                if (n == 0)
+                {
+                    if (limited)
+                    {
+                        fail("Loop count exceeded without dropping");
+                    }
+                    else
+                    {
+                        pass();
+                    }
+                    return;
+                }
+
+                if (c.charge(fee) == Disposition::Drop)
+                {
+                    // Disconnect abusive Consumer
+                    BEAST_EXPECT(c.disconnect(j) == limited);
+                    break;
+                }
+                ++logic.clock();
+            }
+        }
+
+        // Make sure the consumer is on the blacklist for a while.
+        {
+            Consumer const c(logic.newInboundEndpoint(addr));
+            logic.periodicActivity();
+            if (c.disposition() != Disposition::Drop)
+            {
+                if (limited)
+                {
+                    fail("Dropped consumer not put on blacklist");
+                }
+                else
+                {
+                    pass();
+                }
+                return;
+            }
+        }
+
+        // Makes sure the Consumer is eventually removed from blacklist
+        bool readmitted = false;
+        {
+            using namespace std::chrono_literals;
+            // Give Consumer time to become readmitted.  Should never
+            // exceed expiration time.
+            auto n = kSecondsUntilExpiration + 1s;
+            while (--n > 0s)
+            {
+                ++logic.clock();
+                logic.periodicActivity();
+                Consumer const c(logic.newInboundEndpoint(addr));
+                if (c.disposition() != Disposition::Drop)
+                {
+                    readmitted = true;
+                    break;
+                }
+            }
+        }
+        if (!readmitted)
+        {
+            fail("Dropped Consumer left on blacklist too long");
+            return;
+        }
+        pass();
+    }
+
+    void
+    testImports(beast::Journal j)
+    {
+        testcase("Imports");
+
+        TestLogic logic(j);
+
+        Gossip g[5];
+
+        for (int i = 0; i < 5; ++i)
+            createGossip(g[i]);
+
+        for (int i = 0; i < 5; ++i)
+            logic.importConsumers(std::to_string(i), g[i]);
+
+        pass();
+    }
+
+    void
+    testImport(beast::Journal j)
+    {
+        testcase("Import");
+
+        TestLogic logic(j);
+
+        Gossip g;
+        Gossip::Item item;
+        item.balance = 100;
+        beast::IP::AddressV4::bytes_type const d = {{192, 0, 2, 1}};
+        item.address = beast::IP::Endpoint{beast::IP::AddressV4{d}};
+        g.items.push_back(item);
+
+        logic.importConsumers("g", g);
+
+        pass();
+    }
+
+    void
+    testCharges(beast::Journal j)
+    {
+        testcase("Charge");
+
+        TestLogic logic(j);
+
+        {
+            beast::IP::Endpoint const address(beast::IP::Endpoint::fromString("192.0.2.1"));
+            Consumer c(logic.newInboundEndpoint(address));
+            Charge const fee(1000);
+            JLOG(j.info()) << "Charging " << c.toString() << " " << fee << " per second";
+            c.charge(fee);
+            for (int i = 0; i < 128; ++i)
+            {
+                JLOG(j.info()) << "Time= " << logic.clock().now().time_since_epoch().count()
+                               << ", Balance = " << c.balance();
+                logic.advance();
+            }
+        }
+
+        {
+            beast::IP::Endpoint const address(beast::IP::Endpoint::fromString("192.0.2.2"));
+            Consumer c(logic.newInboundEndpoint(address));
+            Charge const fee(1000);
+            JLOG(j.info()) << "Charging " << c.toString() << " " << fee << " per second";
+            for (int i = 0; i < 128; ++i)
+            {
+                c.charge(fee);
+                JLOG(j.info()) << "Time= " << logic.clock().now().time_since_epoch().count()
+                               << ", Balance = " << c.balance();
+                logic.advance();
+            }
+        }
+
+        pass();
+    }
+
+    void
+    run() override
+    {
+        using beast::Severity;
+        test::SuiteJournal journal("ResourceManager_test", *this);
+
+        testDrop(journal, true);
+        testDrop(journal, false);
+        testCharges(journal);
+        testImports(journal);
+        testImport(journal);
+    }
+};
+
+BEAST_DEFINE_TESTSUITE(ResourceManager, resource, xrpl);
+
+}  // namespace xrpl::Resource
diff --git a/src/test/rpc/AccountInfo_test.cpp b/src/test/rpc/AccountInfo_test.cpp
index 61a11d0b93..d061be1f0e 100644
--- a/src/test/rpc/AccountInfo_test.cpp
+++ b/src/test/rpc/AccountInfo_test.cpp
@@ -234,7 +234,7 @@ public:
         withSigners[jss::account] = alice.human();
         withSigners[jss::signer_lists] = true;
 
-        auto const withSignersAsString = std::string("{ ") + R"("api_version": 2, "account": ")" +
+        auto const withSignersAsString = std::string("{ ") + "\"api_version\": 2, \"account\": \"" +
             alice.human() + "\", " + "\"signer_lists\": asdfggh }";
 
         // Alice has no SignerList yet.
diff --git a/src/test/rpc/AccountTx_test.cpp b/src/test/rpc/AccountTx_test.cpp
index a7f37d39b9..6495e5dc93 100644
--- a/src/test/rpc/AccountTx_test.cpp
+++ b/src/test/rpc/AccountTx_test.cpp
@@ -42,6 +42,7 @@
 #include <chrono>
 #include <cstddef>
 #include <cstdint>
+#include <functional>
 #include <initializer_list>
 #include <iterator>
 #include <memory>
@@ -969,7 +970,7 @@ public:
     void
     run() override
     {
-        forAllApiVersions([this](unsigned apiVersion) { testParameters(apiVersion); });
+        forAllApiVersions(std::bind_front(&AccountTx_test::testParameters, this));
         testContents();
         testAccountDelete();
         testMPT();
diff --git a/src/test/rpc/DepositAuthorized_test.cpp b/src/test/rpc/DepositAuthorized_test.cpp
index 6d6b54d70a..e6720602c9 100644
--- a/src/test/rpc/DepositAuthorized_test.cpp
+++ b/src/test/rpc/DepositAuthorized_test.cpp
@@ -8,7 +8,7 @@
 
 #include <xrpl/beast/unit_test/suite.h>
 #include <xrpl/json/json_value.h>
-#include <xrpl/protocol/Protocol.h>  // IWYU pragma: keep
+#include <xrpl/protocol/Protocol.h>
 #include <xrpl/protocol/SField.h>
 #include <xrpl/protocol/TxFlags.h>
 #include <xrpl/protocol/jss.h>
diff --git a/src/test/rpc/GetAggregatePrice_test.cpp b/src/test/rpc/GetAggregatePrice_test.cpp
index 3e0bfa1fd3..214bd12183 100644
--- a/src/test/rpc/GetAggregatePrice_test.cpp
+++ b/src/test/rpc/GetAggregatePrice_test.cpp
@@ -7,7 +7,6 @@
 
 #include <xrpl/basics/Number.h>
 #include <xrpl/basics/base_uint.h>
-#include <xrpl/basics/random.h>
 #include <xrpl/beast/unit_test/suite.h>
 #include <xrpl/beast/utility/Journal.h>
 #include <xrpl/core/ServiceRegistry.h>
@@ -17,7 +16,7 @@
 #include <xrpl/protocol/SField.h>
 #include <xrpl/protocol/jss.h>
 
-#include <cstdint>
+#include <cstdlib>
 #include <memory>
 #include <optional>
 #include <string>
@@ -174,7 +173,7 @@ public:
                 Oracle const oracle(
                     env,
                     {.owner = owner,
-                     .documentID = randInt<std::uint32_t>(),
+                     .documentID = rand(),
                      .series = {{"XRP", "USD", 740 + i, 1}, {"XRP", "EUR", 740, 1}},
                      .fee = baseFee});
                 oracles.emplace_back(owner, oracle.documentID());
@@ -298,13 +297,13 @@ public:
 
             OraclesData oracles;
             prep(env, oracles);
-            for (auto& oracleData : oracles)
+            for (int i = 0; i < oracles.size(); ++i)
             {
                 Oracle oracle(
                     env,
-                    {.owner = oracleData.first,
+                    {.owner = oracles[i].first,
                      // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
-                     .documentID = asUInt(*oracleData.second),
+                     .documentID = asUInt(*oracles[i].second),
                      .fee = baseFee},
                     false);
                 // push XRP/USD by two ledgers, so this price
diff --git a/src/test/rpc/JSONRPC_test.cpp b/src/test/rpc/JSONRPC_test.cpp
index e18974e7e7..7f6b123533 100644
--- a/src/test/rpc/JSONRPC_test.cpp
+++ b/src/test/rpc/JSONRPC_test.cpp
@@ -2238,7 +2238,7 @@ public:
 
         {
             json::Value req;
-            json::Reader().parse(R"({ "fee_mult_max" : 1, "tx_json" : { } } )", req);
+            json::Reader().parse("{ \"fee_mult_max\" : 1, \"tx_json\" : { } } ", req);
             json::Value const result = checkFee(
                 req,
                 Role::ADMIN,
@@ -2275,7 +2275,7 @@ public:
 
         {
             json::Value req;
-            json::Reader().parse(R"({ "fee_mult_max" : 0, "tx_json" : { } } )", req);
+            json::Reader().parse("{ \"fee_mult_max\" : 0, \"tx_json\" : { } } ", req);
             json::Value const result = checkFee(
                 req,
                 Role::ADMIN,
diff --git a/src/test/rpc/LedgerEntry_test.cpp b/src/test/rpc/LedgerEntry_test.cpp
index 875712b060..ce588fe1d6 100644
--- a/src/test/rpc/LedgerEntry_test.cpp
+++ b/src/test/rpc/LedgerEntry_test.cpp
@@ -2974,32 +2974,29 @@ class LedgerEntry_XChain_test : public beast::unit_test::Suite,
             BEAST_EXPECT(
                 attest[json::Value::UInt(0)].isMember(sfXChainCreateAccountProofSig.jsonName));
             json::Value a[kNumAttest];
-            for (auto& attestation : a)
+            for (size_t i = 0; i < kNumAttest; ++i)
             {
-                attestation = attest[json::Value::UInt(0)][sfXChainCreateAccountProofSig.jsonName];
+                a[i] = attest[json::Value::UInt(0)][sfXChainCreateAccountProofSig.jsonName];
                 BEAST_EXPECT(
-                    attestation.isMember(jss::Amount) &&
-                    attestation[jss::Amount].asInt() == 1000 * kDropPerXrp);
+                    a[i].isMember(jss::Amount) && a[i][jss::Amount].asInt() == 1000 * kDropPerXrp);
                 BEAST_EXPECT(
-                    attestation.isMember(jss::Destination) &&
-                    attestation[jss::Destination] == scCarol.human());
+                    a[i].isMember(jss::Destination) && a[i][jss::Destination] == scCarol.human());
                 BEAST_EXPECT(
-                    attestation.isMember(sfAttestationSignerAccount.jsonName) &&
+                    a[i].isMember(sfAttestationSignerAccount.jsonName) &&
                     std::ranges::any_of(signers, [&](Signer const& s) {
-                        return attestation[sfAttestationSignerAccount.jsonName] ==
-                            s.account.human();
+                        return a[i][sfAttestationSignerAccount.jsonName] == s.account.human();
                     }));
                 BEAST_EXPECT(
-                    attestation.isMember(sfAttestationRewardAccount.jsonName) &&
+                    a[i].isMember(sfAttestationRewardAccount.jsonName) &&
                     std::ranges::any_of(payee, [&](Account const& account) {
-                        return attestation[sfAttestationRewardAccount.jsonName] == account.human();
+                        return a[i][sfAttestationRewardAccount.jsonName] == account.human();
                     }));
                 BEAST_EXPECT(
-                    attestation.isMember(sfWasLockingChainSend.jsonName) &&
-                    attestation[sfWasLockingChainSend.jsonName] == 1);
+                    a[i].isMember(sfWasLockingChainSend.jsonName) &&
+                    a[i][sfWasLockingChainSend.jsonName] == 1);
                 BEAST_EXPECT(
-                    attestation.isMember(sfSignatureReward.jsonName) &&
-                    attestation[sfSignatureReward.jsonName].asInt() == 1 * kDropPerXrp);
+                    a[i].isMember(sfSignatureReward.jsonName) &&
+                    a[i][sfSignatureReward.jsonName].asInt() == 1 * kDropPerXrp);
             }
         }
 
diff --git a/src/test/rpc/LedgerRequest_test.cpp b/src/test/rpc/LedgerRequest_test.cpp
index 93feee9497..4759256b96 100644
--- a/src/test/rpc/LedgerRequest_test.cpp
+++ b/src/test/rpc/LedgerRequest_test.cpp
@@ -11,6 +11,7 @@
 #include <xrpl/protocol/ErrorCodes.h>
 #include <xrpl/protocol/jss.h>
 
+#include <functional>
 #include <memory>
 #include <string>
 #include <utility>
@@ -349,7 +350,7 @@ public:
     {
         testLedgerRequest();
         testEvolution();
-        forAllApiVersions([this](unsigned apiVersion) { testBadInput(apiVersion); });
+        forAllApiVersions(std::bind_front(&LedgerRequest_test::testBadInput, this));
         testMoreThan256Closed();
         testNonAdmin();
     }
diff --git a/src/test/rpc/RPCCall_test.cpp b/src/test/rpc/RPCCall_test.cpp
index 4b5ab1f230..cd3cd3cb41 100644
--- a/src/test/rpc/RPCCall_test.cpp
+++ b/src/test/rpc/RPCCall_test.cpp
@@ -14,6 +14,7 @@
 
 #include <cstdint>
 #include <cstring>
+#include <functional>
 #include <initializer_list>
 #include <memory>
 #include <string>
@@ -5926,7 +5927,7 @@ public:
     void
     run() override
     {
-        forAllApiVersions([this](unsigned apiVersion) { testRPCCall(apiVersion); });
+        forAllApiVersions(std::bind_front(&RPCCall_test::testRPCCall, this));
     }
 };
 
diff --git a/src/test/rpc/ServerDefinitions_test.cpp b/src/test/rpc/ServerDefinitions_test.cpp
index bf345e6fdf..bac1b4f7a5 100644
--- a/src/test/rpc/ServerDefinitions_test.cpp
+++ b/src/test/rpc/ServerDefinitions_test.cpp
@@ -433,7 +433,7 @@ public:
                 Env env(*this);
                 auto const firstResult = env.rpc("server_definitions");
                 auto const hash = firstResult[jss::result][jss::hash].asString();
-                auto const hashParam = std::string("{ ") + R"("hash": ")" + hash + "\"}";
+                auto const hashParam = std::string("{ ") + "\"hash\": \"" + hash + "\"}";
 
                 auto const result = env.rpc("json", "server_definitions", hashParam);
                 BEAST_EXPECT(!result[jss::result].isMember(jss::error));
@@ -456,7 +456,7 @@ public:
                 std::string const hash =
                     "54296160385A27154BFA70A239DD8E8FD4CC2DB7BA32D970BA3A5B132CF749"
                     "D1";
-                auto const hashParam = std::string("{ ") + R"("hash": ")" + hash + "\"}";
+                auto const hashParam = std::string("{ ") + "\"hash\": \"" + hash + "\"}";
 
                 auto const result = env.rpc("json", "server_definitions", hashParam);
                 BEAST_EXPECT(!result[jss::result].isMember(jss::error));
diff --git a/src/test/rpc/TransactionEntry_test.cpp b/src/test/rpc/TransactionEntry_test.cpp
index 38a95e84f8..8724e2974d 100644
--- a/src/test/rpc/TransactionEntry_test.cpp
+++ b/src/test/rpc/TransactionEntry_test.cpp
@@ -17,6 +17,7 @@
 #include <xrpl/protocol/ErrorCodes.h>
 #include <xrpl/protocol/jss.h>
 
+#include <functional>
 #include <memory>
 #include <stdexcept>
 #include <string>
@@ -352,7 +353,7 @@ public:
     run() override
     {
         testBadInput();
-        forAllApiVersions([this](unsigned apiVersion) { testRequest(apiVersion); });
+        forAllApiVersions(std::bind_front(&TransactionEntry_test::testRequest, this));
     }
 };
 
diff --git a/src/test/rpc/Transaction_test.cpp b/src/test/rpc/Transaction_test.cpp
index c3bf707ec4..8c50736b85 100644
--- a/src/test/rpc/Transaction_test.cpp
+++ b/src/test/rpc/Transaction_test.cpp
@@ -31,6 +31,7 @@
 #include <cctype>
 #include <cstddef>
 #include <cstdint>
+#include <functional>
 #include <memory>
 #include <optional>
 #include <string>
@@ -885,7 +886,7 @@ public:
     run() override
     {
         using namespace test::jtx;
-        forAllApiVersions([this](unsigned apiVersion) { testBinaryRequest(apiVersion); });
+        forAllApiVersions(std::bind_front(&Transaction_test::testBinaryRequest, this));
 
         FeatureBitset const all{testableAmendments()};
         testWithFeats(all);
@@ -898,8 +899,7 @@ public:
         testRangeCTIDRequest(features);
         testCTIDValidation(features);
         testRPCsForCTID(features);
-        forAllApiVersions(
-            [this, features](unsigned apiVersion) { testRequest(features, apiVersion); });
+        forAllApiVersions(std::bind_front(&Transaction_test::testRequest, this, features));
     }
 };
 
diff --git a/src/test/rpc/Version_test.cpp b/src/test/rpc/Version_test.cpp
index 71830c2219..20740bfe53 100644
--- a/src/test/rpc/Version_test.cpp
+++ b/src/test/rpc/Version_test.cpp
@@ -76,7 +76,7 @@ class Version_test : public beast::unit_test::Suite
                 "}");
         BEAST_EXPECT(badVersion(re));
 
-        re = env.rpc("json", "version", R"({"api_version": "a"})");
+        re = env.rpc("json", "version", "{\"api_version\": \"a\"}");
         BEAST_EXPECT(badVersion(re));
     }
 
diff --git a/src/test/shamap/FetchPack_test.cpp b/src/test/shamap/FetchPack_test.cpp
new file mode 100644
index 0000000000..b2fc185b31
--- /dev/null
+++ b/src/test/shamap/FetchPack_test.cpp
@@ -0,0 +1,169 @@
+#include <test/shamap/common.h>
+#include <test/unit_test/SuiteJournal.h>
+
+#include <xrpl/basics/Blob.h>
+#include <xrpl/basics/Log.h>
+#include <xrpl/basics/SHAMapHash.h>
+#include <xrpl/basics/Slice.h>
+#include <xrpl/basics/UnorderedContainers.h>
+#include <xrpl/basics/contract.h>
+#include <xrpl/basics/random.h>
+#include <xrpl/beast/unit_test/suite.h>
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/beast/xor_shift_engine.h>
+#include <xrpl/protocol/Serializer.h>
+#include <xrpl/protocol/digest.h>
+#include <xrpl/shamap/SHAMap.h>
+#include <xrpl/shamap/SHAMapItem.h>
+#include <xrpl/shamap/SHAMapMissingNode.h>
+#include <xrpl/shamap/SHAMapSyncFilter.h>
+#include <xrpl/shamap/SHAMapTreeNode.h>
+
+#include <boost/smart_ptr/intrusive_ptr.hpp>
+
+#include <cassert>
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <optional>
+#include <stdexcept>
+
+namespace xrpl::tests {
+
+class FetchPack_test : public beast::unit_test::Suite
+{
+public:
+    static constexpr auto kTableItems = 100;
+    static constexpr auto kTableItemsExtra = 20;
+
+    using Map = hash_map<SHAMapHash, Blob>;
+    using Table = SHAMap;
+    using Item = SHAMapItem;
+
+    struct Handler
+    {
+        void
+        operator()(std::uint32_t refNum) const
+        {
+            Throw<std::runtime_error>("missing node");
+        }
+    };
+
+    struct TestFilter : SHAMapSyncFilter
+    {
+        TestFilter(Map& map, beast::Journal journal) : map(map), journal(journal)
+        {
+        }
+
+        void
+        gotNode(
+            bool fromFilter,
+            SHAMapHash const& nodeHash,
+            std::uint32_t ledgerSeq,
+            Blob&& nodeData,  // NOLINT(cppcoreguidelines-rvalue-reference-param-not-moved)
+            SHAMapNodeType type) const override
+        {
+        }
+
+        [[nodiscard]] std::optional<Blob>
+        getNode(SHAMapHash const& nodeHash) const override
+        {
+            Map::iterator const it = map.find(nodeHash);
+            if (it == map.end())
+            {
+                JLOG(journal.fatal()) << "Test filter missing node";
+                return std::nullopt;
+            }
+            return it->second;
+        }
+
+        Map& map;
+        beast::Journal journal;
+    };
+
+    static boost::intrusive_ptr<Item>
+    makeRandomItemMember(beast::xor_shift_engine& r)
+    {
+        Serializer s;
+        for (int d = 0; d < 3; ++d)
+            s.add32(xrpl::randInt<std::uint32_t>(r));
+        return makeShamapitem(s.getSHA512Half(), s.slice());
+    }
+
+    static void
+    addRandomItems(std::size_t n, Table& t, beast::xor_shift_engine& r)
+    {
+        while ((n--) != 0u)
+        {
+            auto const result(t.addItem(SHAMapNodeType::TnAccountState, makeRandomItemMember(r)));
+            assert(result);
+            (void)result;
+        }
+    }
+
+    void
+    onFetch(Map& map, SHAMapHash const& hash, Blob const& blob)
+    {
+        BEAST_EXPECT(sha512Half(makeSlice(blob)) == hash.asUInt256());
+        map.emplace(hash, blob);
+    }
+
+    void
+    run() override
+    {
+        using beast::Severity;
+        test::SuiteJournal journal("FetchPack_test", *this);
+
+        TestNodeFamily f(journal);
+        std::shared_ptr<Table> const t1(std::make_shared<Table>(SHAMapType::FREE, f));
+
+        pass();
+
+        //         beast::Random r;
+        //         add_random_items_ (tableItems, *t1, r);
+        //         std::shared_ptr <Table> t2 (t1->snapShot (true));
+        //
+        //         add_random_items_ (tableItemsExtra, *t1, r);
+        //         add_random_items_ (tableItemsExtra, *t2, r);
+
+        // turn t1 into t2
+        //         Map map;
+        //         t2->getFetchPack (t1.get(), true, 1000000, std::bind (
+        //             &FetchPack_test::on_fetch, this, std::ref (map),
+        //             std::placeholders::_1, std::placeholders::_2));
+        //         t1->getFetchPack (nullptr, true, 1000000, std::bind (
+        //             &FetchPack_test::on_fetch, this, std::ref (map),
+        //             std::placeholders::_1, std::placeholders::_2));
+
+        // try to rebuild t2 from the fetch pack
+        //         std::shared_ptr <Table> t3;
+        //         try
+        //         {
+        //             TestFilter filter (map, beast::Journal());
+        //
+        //             t3 = std::make_shared <Table> (SHAMapType::FREE,
+        //             t2->getHash (),
+        //                 fullBelowCache);
+        //
+        //             BEAST_EXPECT(t3->fetchRoot (t2->getHash (), &filter),
+        //             "unable to get root");
+        //
+        //             // everything should be in the pack, no hashes should be
+        //             needed std::vector <uint256> hashes =
+        //             t3->getNeededHashes(1, &filter);
+        //             BEAST_EXPECT(hashes.empty(), "missing hashes");
+        //
+        //             BEAST_EXPECT(t3->getHash () == t2->getHash (), "root
+        //             hashes do not match"); BEAST_EXPECT(t3->deepCompare
+        //             (*t2), "failed compare");
+        //         }
+        //         catch (std::exception const&)
+        //         {
+        //             fail ("unhandled exception");
+        //         }
+    }
+};
+
+BEAST_DEFINE_TESTSUITE(FetchPack, shamap, xrpl);
+
+}  // namespace xrpl::tests
diff --git a/src/test/shamap/SHAMapSync_test.cpp b/src/test/shamap/SHAMapSync_test.cpp
new file mode 100644
index 0000000000..9e9a490977
--- /dev/null
+++ b/src/test/shamap/SHAMapSync_test.cpp
@@ -0,0 +1,178 @@
+#include <test/shamap/common.h>
+#include <test/unit_test/SuiteJournal.h>
+
+#include <xrpl/basics/Blob.h>
+#include <xrpl/basics/SHAMapHash.h>
+#include <xrpl/basics/Slice.h>
+#include <xrpl/basics/base_uint.h>
+#include <xrpl/basics/random.h>
+#include <xrpl/beast/unit_test/suite.h>
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/beast/xor_shift_engine.h>
+#include <xrpl/protocol/Serializer.h>
+#include <xrpl/shamap/SHAMap.h>
+#include <xrpl/shamap/SHAMapItem.h>
+#include <xrpl/shamap/SHAMapMissingNode.h>
+#include <xrpl/shamap/SHAMapTreeNode.h>
+
+#include <boost/smart_ptr/intrusive_ptr.hpp>
+
+#include <chrono>
+#include <cstddef>
+#include <cstdint>
+#include <list>
+#include <ostream>
+#include <utility>
+#include <vector>
+
+namespace xrpl::tests {
+
+class SHAMapSync_test : public beast::unit_test::Suite
+{
+public:
+    beast::xor_shift_engine eng;
+
+    boost::intrusive_ptr<SHAMapItem>
+    makeRandomAS()
+    {
+        Serializer s;
+
+        for (int d = 0; d < 3; ++d)
+            s.add32(randInt<std::uint32_t>(eng));
+        return makeShamapitem(s.getSHA512Half(), s.slice());
+    }
+
+    bool
+    confuseMap(SHAMap& map, int count)
+    {
+        // add a bunch of random states to a map, then remove them
+        // map should be the same
+        SHAMapHash const beforeHash = map.getHash();
+
+        std::list<uint256> items;
+
+        for (int i = 0; i < count; ++i)
+        {
+            auto item = makeRandomAS();
+            items.push_back(item->key());
+
+            if (!map.addItem(SHAMapNodeType::TnAccountState, item))
+            {
+                log << "Unable to add item to map\n";
+                return false;
+            }
+        }
+
+        for (auto const& item : items)
+        {
+            if (!map.delItem(item))
+            {
+                log << "Unable to remove item from map\n";
+                return false;
+            }
+        }
+
+        if (beforeHash != map.getHash())
+        {
+            log << "Hashes do not match " << beforeHash << " " << map.getHash() << std::endl;
+            return false;
+        }
+
+        return true;
+    }
+
+    void
+    run() override
+    {
+        using beast::Severity;
+        test::SuiteJournal journal("SHAMapSync_test", *this);
+
+        TestNodeFamily f(journal), f2(journal);
+        SHAMap source(SHAMapType::FREE, f);
+        SHAMap destination(SHAMapType::FREE, f2);
+
+        int const items = 10000;
+        for (int i = 0; i < items; ++i)
+        {
+            source.addItem(SHAMapNodeType::TnAccountState, makeRandomAS());
+            if (i % 100 == 0)
+                source.invariants();
+        }
+
+        source.invariants();
+        BEAST_EXPECT(confuseMap(source, 500));
+        source.invariants();
+
+        source.setImmutable();
+
+        int count = 0;
+        source.visitLeaves([&count](auto const& item) { ++count; });
+        BEAST_EXPECT(count == items);
+
+        std::vector<SHAMapMissingNode> missingNodes;
+        source.walkMap(missingNodes, 2048);
+        BEAST_EXPECT(missingNodes.empty());
+
+        destination.setSynching();
+
+        {
+            std::vector<std::pair<SHAMapNodeID, Blob>> a;
+
+            BEAST_EXPECT(source.getNodeFat(SHAMapNodeID(), a, randBool(eng), randInt(eng, 2)));
+
+            unexpected(a.empty(), "NodeSize");
+
+            BEAST_EXPECT(destination.addRootNode(source.getHash(), makeSlice(a[0].second), nullptr)
+                             .isGood());
+        }
+
+        do
+        {
+            f.clock().advance(std::chrono::seconds(1));
+
+            // get the list of nodes we know we need
+            auto nodesMissing = destination.getMissingNodes(2048, nullptr);
+
+            if (nodesMissing.empty())
+                break;
+
+            // get as many nodes as possible based on this information
+            std::vector<std::pair<SHAMapNodeID, Blob>> b;
+
+            for (auto& it : nodesMissing)
+            {
+                // Don't use BEAST_EXPECT here b/c it will be called a
+                // non-deterministic number of times and the number of tests run
+                // should be deterministic
+                if (!source.getNodeFat(it.first, b, randBool(eng), randInt(eng, 2)))
+                    fail("", __FILE__, __LINE__);
+            }
+
+            // Don't use BEAST_EXPECT here b/c it will be called a
+            // non-deterministic number of times and the number of tests run
+            // should be deterministic
+            if (b.empty())
+                fail("", __FILE__, __LINE__);
+
+            for (std::size_t i = 0; i < b.size(); ++i)
+            {
+                // Don't use BEAST_EXPECT here b/c it will be called a
+                // non-deterministic number of times and the number of tests run
+                // should be deterministic
+                if (!destination.addKnownNode(b[i].first, makeSlice(b[i].second), nullptr)
+                         .isUseful())
+                    fail("", __FILE__, __LINE__);
+            }
+        } while (true);
+
+        destination.clearSynching();
+
+        BEAST_EXPECT(source.deepCompare(destination));
+
+        destination.invariants();
+    }
+};
+
+BEAST_DEFINE_TESTSUITE(SHAMapSync, shamap, xrpl);
+
+}  // namespace xrpl::tests
diff --git a/src/test/shamap/SHAMap_test.cpp b/src/test/shamap/SHAMap_test.cpp
new file mode 100644
index 0000000000..ab7e01e3af
--- /dev/null
+++ b/src/test/shamap/SHAMap_test.cpp
@@ -0,0 +1,427 @@
+#include <test/shamap/common.h>
+#include <test/unit_test/SuiteJournal.h>
+
+#include <xrpl/basics/Blob.h>
+#include <xrpl/basics/Buffer.h>
+#include <xrpl/basics/SHAMapHash.h>
+#include <xrpl/basics/base_uint.h>
+#include <xrpl/beast/unit_test/suite.h>
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/beast/utility/Zero.h>
+#include <xrpl/shamap/SHAMap.h>
+#include <xrpl/shamap/SHAMapInnerNode.h>
+#include <xrpl/shamap/SHAMapItem.h>
+#include <xrpl/shamap/SHAMapLeafNode.h>
+#include <xrpl/shamap/SHAMapMissingNode.h>
+#include <xrpl/shamap/SHAMapTreeNode.h>
+
+#include <algorithm>
+#include <array>
+#include <cstdint>
+#include <memory>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+namespace xrpl::tests {
+
+#ifndef __INTELLISENSE__
+static_assert(std::is_nothrow_destructible<SHAMap>{}, "");
+static_assert(!std::is_default_constructible<SHAMap>{}, "");
+static_assert(!std::is_copy_constructible<SHAMap>{}, "");
+static_assert(!std::is_copy_assignable<SHAMap>{}, "");
+static_assert(!std::is_move_constructible<SHAMap>{}, "");
+static_assert(!std::is_move_assignable<SHAMap>{}, "");
+
+static_assert(std::is_nothrow_destructible<SHAMap::ConstIterator>{}, "");
+static_assert(std::is_copy_constructible<SHAMap::ConstIterator>{}, "");
+static_assert(std::is_copy_assignable<SHAMap::ConstIterator>{}, "");
+static_assert(std::is_move_constructible<SHAMap::ConstIterator>{}, "");
+static_assert(std::is_move_assignable<SHAMap::ConstIterator>{}, "");
+
+static_assert(std::is_nothrow_destructible<SHAMapItem>{}, "");
+static_assert(!std::is_default_constructible<SHAMapItem>{}, "");
+static_assert(!std::is_copy_constructible<SHAMapItem>{}, "");
+
+static_assert(std::is_nothrow_destructible<SHAMapNodeID>{}, "");
+static_assert(std::is_default_constructible<SHAMapNodeID>{}, "");
+static_assert(std::is_copy_constructible<SHAMapNodeID>{}, "");
+static_assert(std::is_copy_assignable<SHAMapNodeID>{}, "");
+static_assert(std::is_move_constructible<SHAMapNodeID>{}, "");
+static_assert(std::is_move_assignable<SHAMapNodeID>{}, "");
+
+static_assert(std::is_nothrow_destructible<SHAMapHash>{}, "");
+static_assert(std::is_default_constructible<SHAMapHash>{}, "");
+static_assert(std::is_copy_constructible<SHAMapHash>{}, "");
+static_assert(std::is_copy_assignable<SHAMapHash>{}, "");
+static_assert(std::is_move_constructible<SHAMapHash>{}, "");
+static_assert(std::is_move_assignable<SHAMapHash>{}, "");
+
+static_assert(std::is_nothrow_destructible<SHAMapTreeNode>{}, "");
+static_assert(!std::is_default_constructible<SHAMapTreeNode>{}, "");
+static_assert(!std::is_copy_constructible<SHAMapTreeNode>{}, "");
+static_assert(!std::is_copy_assignable<SHAMapTreeNode>{}, "");
+static_assert(!std::is_move_constructible<SHAMapTreeNode>{}, "");
+static_assert(!std::is_move_assignable<SHAMapTreeNode>{}, "");
+
+static_assert(std::is_nothrow_destructible<SHAMapInnerNode>{}, "");
+static_assert(!std::is_default_constructible<SHAMapInnerNode>{}, "");
+static_assert(!std::is_copy_constructible<SHAMapInnerNode>{}, "");
+static_assert(!std::is_copy_assignable<SHAMapInnerNode>{}, "");
+static_assert(!std::is_move_constructible<SHAMapInnerNode>{}, "");
+static_assert(!std::is_move_assignable<SHAMapInnerNode>{}, "");
+
+static_assert(std::is_nothrow_destructible<SHAMapLeafNode>{}, "");
+static_assert(!std::is_default_constructible<SHAMapLeafNode>{}, "");
+static_assert(!std::is_copy_constructible<SHAMapLeafNode>{}, "");
+static_assert(!std::is_copy_assignable<SHAMapLeafNode>{}, "");
+static_assert(!std::is_move_constructible<SHAMapLeafNode>{}, "");
+static_assert(!std::is_move_assignable<SHAMapLeafNode>{}, "");
+#endif
+
+inline bool
+operator==(SHAMapItem const& a, SHAMapItem const& b)
+{
+    return a.key() == b.key();
+}
+inline bool
+operator!=(SHAMapItem const& a, SHAMapItem const& b)
+{
+    return a.key() != b.key();
+}
+inline bool
+operator==(SHAMapItem const& a, uint256 const& b)
+{
+    return a.key() == b;
+}
+inline bool
+operator!=(SHAMapItem const& a, uint256 const& b)
+{
+    return a.key() != b;
+}
+
+class SHAMap_test : public beast::unit_test::Suite
+{
+public:
+    static Buffer
+    intToVuc(int v)
+    {
+        Buffer vuc(32);
+        std::fill_n(vuc.data(), vuc.size(), static_cast<std::uint8_t>(v));
+        return vuc;
+    }
+
+    void
+    run() override
+    {
+        using beast::Severity;
+        test::SuiteJournal journal("SHAMap_test", *this);
+
+        run(true, journal);
+        run(false, journal);
+    }
+
+    void
+    run(bool backed, beast::Journal const& journal)
+    {
+        if (backed)
+        {
+            testcase("add/traverse backed");
+        }
+        else
+        {
+            testcase("add/traverse unbacked");
+        }
+
+        tests::TestNodeFamily f(journal);
+
+        // h3 and h4 differ only in the leaf, same terminal node (level 19)
+        constexpr uint256 kH1("092891fe4ef6cee585fdc6fda0e09eb4d386363158ec3321b8123e5a772c6ca7");
+        constexpr uint256 kH2("436ccbac3347baa1f1e53baeef1f43334da88f1f6d70d963b833afd6dfa289fe");
+        constexpr uint256 kH3("b92891fe4ef6cee585fdc6fda1e09eb4d386363158ec3321b8123e5a772c6ca8");
+        constexpr uint256 kH4("b92891fe4ef6cee585fdc6fda2e09eb4d386363158ec3321b8123e5a772c6ca8");
+        constexpr uint256 kH5("a92891fe4ef6cee585fdc6fda0e09eb4d386363158ec3321b8123e5a772c6ca7");
+
+        SHAMap sMap(SHAMapType::FREE, f);
+        sMap.invariants();
+        if (!backed)
+            sMap.setUnbacked();
+
+        auto i1 = makeShamapitem(kH1, intToVuc(1));
+        auto i2 = makeShamapitem(kH2, intToVuc(2));
+        auto i3 = makeShamapitem(kH3, intToVuc(3));
+        auto i4 = makeShamapitem(kH4, intToVuc(4));
+        auto i5 = makeShamapitem(kH5, intToVuc(5));
+
+        unexpected(!sMap.addItem(SHAMapNodeType::TnTransactionNm, makeShamapitem(*i2)), "no add");
+        sMap.invariants();
+        unexpected(!sMap.addItem(SHAMapNodeType::TnTransactionNm, makeShamapitem(*i1)), "no add");
+        sMap.invariants();
+
+        auto i = sMap.begin();
+        auto e = sMap.end();
+        unexpected(i == e || (*i != *i1), "bad traverse");
+        ++i;
+        unexpected(i == e || (*i != *i2), "bad traverse");
+        ++i;
+        unexpected(i != e, "bad traverse");
+        sMap.addItem(SHAMapNodeType::TnTransactionNm, makeShamapitem(*i4));
+        sMap.invariants();
+        sMap.delItem(i2->key());
+        sMap.invariants();
+        sMap.addItem(SHAMapNodeType::TnTransactionNm, makeShamapitem(*i3));
+        sMap.invariants();
+        i = sMap.begin();
+        e = sMap.end();
+        unexpected(i == e || (*i != *i1), "bad traverse");
+        ++i;
+        unexpected(i == e || (*i != *i3), "bad traverse");
+        ++i;
+        unexpected(i == e || (*i != *i4), "bad traverse");
+        ++i;
+        unexpected(i != e, "bad traverse");
+
+        if (backed)
+        {
+            testcase("snapshot backed");
+        }
+        else
+        {
+            testcase("snapshot unbacked");
+        }
+
+        SHAMapHash const mapHash = sMap.getHash();
+        std::shared_ptr<SHAMap> const map2 = sMap.snapShot(false);
+        map2->invariants();
+        unexpected(sMap.getHash() != mapHash, "bad snapshot");
+        unexpected(map2->getHash() != mapHash, "bad snapshot");
+
+        SHAMap::Delta delta;
+        BEAST_EXPECT(sMap.compare(*map2, delta, 100));
+        BEAST_EXPECT(delta.empty());
+
+        unexpected(!sMap.delItem(sMap.begin()->key()), "bad mod");
+        sMap.invariants();
+        unexpected(sMap.getHash() == mapHash, "bad snapshot");
+        unexpected(map2->getHash() != mapHash, "bad snapshot");
+
+        BEAST_EXPECT(sMap.compare(*map2, delta, 100));
+        BEAST_EXPECT(delta.size() == 1);
+        BEAST_EXPECT(delta.begin()->first == kH1);
+        BEAST_EXPECT(delta.begin()->second.first == nullptr);
+        BEAST_EXPECT(delta.begin()->second.second->key() == kH1);
+
+        sMap.dump();
+
+        if (backed)
+        {
+            testcase("build/tear backed");
+        }
+        else
+        {
+            testcase("build/tear unbacked");
+        }
+        {
+            static constexpr std::array keys{
+                uint256(
+                    "b92891fe4ef6cee585fdc6fda1e09eb4d386363158ec3321b8123e"
+                    "5a772c6ca8"),
+                uint256(
+                    "b92881fe4ef6cee585fdc6fda1e09eb4d386363158ec3321b8123e"
+                    "5a772c6ca8"),
+                uint256(
+                    "b92691fe4ef6cee585fdc6fda1e09eb4d386363158ec3321b8123e"
+                    "5a772c6ca8"),
+                uint256(
+                    "b92791fe4ef6cee585fdc6fda1e09eb4d386363158ec3321b8123e"
+                    "5a772c6ca8"),
+                uint256(
+                    "b91891fe4ef6cee585fdc6fda1e09eb4d386363158ec3321b8123e"
+                    "5a772c6ca8"),
+                uint256(
+                    "b99891fe4ef6cee585fdc6fda1e09eb4d386363158ec3321b8123e"
+                    "5a772c6ca8"),
+                uint256(
+                    "f22891fe4ef6cee585fdc6fda1e09eb4d386363158ec3321b8123e"
+                    "5a772c6ca8"),
+                uint256(
+                    "292891fe4ef6cee585fdc6fda1e09eb4d386363158ec3321b8123e"
+                    "5a772c6ca8")};
+
+            static constexpr std::array kHashes{
+                uint256(
+                    "B7387CFEA0465759ADC718E8C42B52D2309D179B326E239EB5075C"
+                    "64B6281F7F"),
+                uint256(
+                    "FBC195A9592A54AB44010274163CB6BA95F497EC5BA0A883184546"
+                    "7FB2ECE266"),
+                uint256(
+                    "4E7D2684B65DFD48937FFB775E20175C43AF0C94066F7D5679F51A"
+                    "E756795B75"),
+                uint256(
+                    "7A2F312EB203695FFD164E038E281839EEF06A1B99BFC263F3CECC"
+                    "6C74F93E07"),
+                uint256(
+                    "395A6691A372387A703FB0F2C6D2C405DAF307D0817F8F0E207596"
+                    "462B0E3A3E"),
+                uint256(
+                    "D044C0A696DE3169CC70AE216A1564D69DE96582865796142CE7D9"
+                    "8A84D9DDE4"),
+                uint256(
+                    "76DCC77C4027309B5A91AD164083264D70B77B5E43E08AEDA5EBF9"
+                    "4361143615"),
+                uint256(
+                    "DF4220E93ADC6F5569063A01B4DC79F8DB9553B6A3222ADE23DEA0"
+                    "2BBE7230E5")};
+
+            SHAMap map(SHAMapType::FREE, f);
+            if (!backed)
+                map.setUnbacked();
+
+            BEAST_EXPECT(map.getHash() == beast::kZero);
+            for (int k = 0; k < keys.size(); ++k)
+            {
+                BEAST_EXPECT(map.addItem(
+                    SHAMapNodeType::TnTransactionNm, makeShamapitem(keys[k], intToVuc(k))));
+                BEAST_EXPECT(map.getHash().asUInt256() == kHashes[k]);
+                map.invariants();
+            }
+            for (int k = keys.size() - 1; k >= 0; --k)
+            {
+                BEAST_EXPECT(map.getHash().asUInt256() == kHashes[k]);
+                BEAST_EXPECT(map.delItem(keys[k]));
+                map.invariants();
+            }
+            BEAST_EXPECT(map.getHash() == beast::kZero);
+        }
+
+        if (backed)
+        {
+            testcase("iterate backed");
+        }
+        else
+        {
+            testcase("iterate unbacked");
+        }
+
+        {
+            static constexpr std::array keys{
+                uint256(
+                    "f22891fe4ef6cee585fdc6fda1e09eb4d386363158ec3321b8123e"
+                    "5a772c6ca8"),
+                uint256(
+                    "b99891fe4ef6cee585fdc6fda1e09eb4d386363158ec3321b8123e"
+                    "5a772c6ca8"),
+                uint256(
+                    "b92891fe4ef6cee585fdc6fda1e09eb4d386363158ec3321b8123e"
+                    "5a772c6ca8"),
+                uint256(
+                    "b92881fe4ef6cee585fdc6fda1e09eb4d386363158ec3321b8123e"
+                    "5a772c6ca8"),
+                uint256(
+                    "b92791fe4ef6cee585fdc6fda1e09eb4d386363158ec3321b8123e"
+                    "5a772c6ca8"),
+                uint256(
+                    "b92691fe4ef6cee585fdc6fda1e09eb4d386363158ec3321b8123e"
+                    "5a772c6ca8"),
+                uint256(
+                    "b91891fe4ef6cee585fdc6fda1e09eb4d386363158ec3321b8123e"
+                    "5a772c6ca8"),
+                uint256(
+                    "292891fe4ef6cee585fdc6fda1e09eb4d386363158ec3321b8123e"
+                    "5a772c6ca8")};
+
+            tests::TestNodeFamily tf{journal};
+            SHAMap map{SHAMapType::FREE, tf};
+            if (!backed)
+                map.setUnbacked();
+            for (auto const& k : keys)
+            {
+                map.addItem(SHAMapNodeType::TnTransactionNm, makeShamapitem(k, intToVuc(0)));
+                map.invariants();
+            }
+
+            int h = 7;
+            for (auto const& k : map)
+            {
+                BEAST_EXPECT(k.key() == keys[h]);
+                --h;
+            }
+        }
+    }
+};
+
+class SHAMapPathProof_test : public beast::unit_test::Suite
+{
+    void
+    run() override
+    {
+        test::SuiteJournal journal("SHAMapPathProof_test", *this);
+
+        tests::TestNodeFamily tf{journal};
+        SHAMap map{SHAMapType::FREE, tf};
+        map.setUnbacked();
+
+        uint256 key;
+        uint256 rootHash;
+        std::vector<Blob> goodPath;
+
+        for (unsigned char c = 1; c < 100; ++c)
+        {
+            uint256 k(c);
+            map.addItem(
+                SHAMapNodeType::TnAccountState, makeShamapitem(k, Slice{k.data(), k.size()}));
+            map.invariants();
+
+            auto root = map.getHash().asUInt256();
+            auto path = map.getProofPath(k);
+            BEAST_EXPECT(path);
+            if (!path)
+                break;
+            BEAST_EXPECT(map.verifyProofPath(root, k, *path));
+            if (c == 1)
+            {
+                // extra node
+                path->insert(path->begin(), path->front());
+                BEAST_EXPECT(!map.verifyProofPath(root, k, *path));
+                // wrong key
+                uint256 const wrongKey(c + 1);
+                BEAST_EXPECT(!map.getProofPath(wrongKey));
+            }
+            if (c == 99)
+            {
+                key = k;
+                rootHash = root;
+                goodPath = std::move(*path);
+            }
+        }
+
+        // still good
+        BEAST_EXPECT(map.verifyProofPath(rootHash, key, goodPath));
+        // empty path
+        std::vector<Blob> badPath;
+        BEAST_EXPECT(!map.verifyProofPath(rootHash, key, badPath));
+        // too long
+        badPath = goodPath;
+        badPath.push_back(goodPath.back());
+        BEAST_EXPECT(!map.verifyProofPath(rootHash, key, badPath));
+        // bad node
+        badPath.clear();
+        badPath.emplace_back(100, 100);
+        BEAST_EXPECT(!map.verifyProofPath(rootHash, key, badPath));
+        // bad node type
+        badPath.clear();
+        badPath.push_back(goodPath.front());
+        badPath.front().back()--;  // change node type
+        BEAST_EXPECT(!map.verifyProofPath(rootHash, key, badPath));
+        // all inner
+        badPath.clear();
+        badPath = goodPath;
+        badPath.erase(badPath.begin());
+        BEAST_EXPECT(!map.verifyProofPath(rootHash, key, badPath));
+    }
+};
+
+BEAST_DEFINE_TESTSUITE(SHAMap, shamap, xrpl);
+BEAST_DEFINE_TESTSUITE(SHAMapPathProof, shamap, xrpl);
+}  // namespace xrpl::tests
diff --git a/src/tests/libxrpl/shamap/common.h b/src/test/shamap/common.h
similarity index 89%
rename from src/tests/libxrpl/shamap/common.h
rename to src/test/shamap/common.h
index 5b44f2b251..9bef10d851 100644
--- a/src/tests/libxrpl/shamap/common.h
+++ b/src/test/shamap/common.h
@@ -4,6 +4,7 @@
 #include <xrpl/basics/base_uint.h>
 #include <xrpl/basics/chrono.h>
 #include <xrpl/basics/contract.h>
+#include <xrpl/beast/clock/manual_clock.h>
 #include <xrpl/beast/utility/Journal.h>
 #include <xrpl/config/BasicConfig.h>
 #include <xrpl/config/Constants.h>
@@ -91,17 +92,13 @@ public:
     }
 
     void
-    missingNodeAcquireBySeq(
-        [[maybe_unused]] std::uint32_t refNum,
-        [[maybe_unused]] uint256 const& nodeHash) override
+    missingNodeAcquireBySeq(std::uint32_t refNum, uint256 const& nodeHash) override
     {
         Throw<std::runtime_error>("missing node");
     }
 
     void
-    missingNodeAcquireByHash(
-        [[maybe_unused]] uint256 const& refHash,
-        [[maybe_unused]] std::uint32_t refNum) override
+    missingNodeAcquireByHash(uint256 const& refHash, std::uint32_t refNum) override
     {
         Throw<std::runtime_error>("missing node");
     }
@@ -113,7 +110,7 @@ public:
         (*tnCache_).reset();
     }
 
-    TestStopwatch&
+    beast::ManualClock<std::chrono::steady_clock>
     clock()
     {
         return clock_;
diff --git a/src/tests/libxrpl/CMakeLists.txt b/src/tests/libxrpl/CMakeLists.txt
index cafe72eff9..df483a36d8 100644
--- a/src/tests/libxrpl/CMakeLists.txt
+++ b/src/tests/libxrpl/CMakeLists.txt
@@ -29,8 +29,6 @@ set(test_modules
     basics
     crypto
     json
-    resource
-    shamap
     tx
     protocol_autogen
 )
diff --git a/src/tests/libxrpl/basics/Buffer.cpp b/src/tests/libxrpl/basics/Buffer.cpp
deleted file mode 100644
index 5b34585fcf..0000000000
--- a/src/tests/libxrpl/basics/Buffer.cpp
+++ /dev/null
@@ -1,260 +0,0 @@
-#include <xrpl/basics/Buffer.h>
-
-#include <xrpl/basics/Slice.h>
-
-#include <gtest/gtest.h>
-
-#include <cstddef>
-#include <cstdint>
-#include <cstring>
-#include <type_traits>
-#include <utility>
-
-namespace xrpl::test {
-
-struct BufferTest : public ::testing::Test
-{
-    static bool
-    sane(Buffer const& b)
-    {
-        if (b.empty())
-            return b.data() == nullptr;
-
-        return b.data() != nullptr;
-    }
-};
-
-TEST_F(BufferTest, buffer)
-{
-    std::uint8_t const data[] = {0xa8, 0xa1, 0x38, 0x45, 0x23, 0xec, 0xe4, 0x23, 0x71, 0x6d, 0x2a,
-                                 0x18, 0xb4, 0x70, 0xcb, 0xf5, 0xac, 0x2d, 0x89, 0x4d, 0x19, 0x9c,
-                                 0xf0, 0x2c, 0x15, 0xd1, 0xf9, 0x9b, 0x66, 0xd2, 0x30, 0xd3};
-
-    Buffer const b0;
-    EXPECT_TRUE(sane(b0));
-    EXPECT_TRUE(b0.empty());
-
-    Buffer b1{0};
-    EXPECT_TRUE(sane(b1));
-    EXPECT_TRUE(b1.empty());
-    std::memcpy(b1.alloc(16), data, 16);
-    EXPECT_TRUE(sane(b1));
-    EXPECT_FALSE(b1.empty());
-    EXPECT_EQ(b1.size(), 16);
-
-    Buffer b2{b1.size()};
-    EXPECT_TRUE(sane(b2));
-    EXPECT_FALSE(b2.empty());
-    EXPECT_EQ(b2.size(), b1.size());
-    std::memcpy(b2.data(), data + 16, 16);
-
-    Buffer b3{data, sizeof(data)};
-    EXPECT_TRUE(sane(b3));
-    EXPECT_FALSE(b3.empty());
-    EXPECT_EQ(b3.size(), sizeof(data));
-    EXPECT_EQ(std::memcmp(b3.data(), data, b3.size()), 0);
-
-    // Check equality and inequality comparisons.
-    // For code readability, we want to use general
-    // EXPECT_TRUE instead of specific EXPECT_EQ etc.
-    EXPECT_TRUE(b0 == b0);
-    EXPECT_TRUE(b0 != b1);
-    EXPECT_TRUE(b1 == b1);
-    EXPECT_TRUE(b1 != b2);
-    EXPECT_TRUE(b2 != b3);
-
-    // Check copy constructors and copy assignments:
-    {
-        Buffer x{b0};
-        EXPECT_EQ(x, b0);
-        EXPECT_TRUE(sane(x));
-        Buffer y{b1};
-        EXPECT_EQ(y, b1);
-        EXPECT_TRUE(sane(y));
-        x = b2;
-        EXPECT_EQ(x, b2);
-        EXPECT_TRUE(sane(x));
-        x = y;
-        EXPECT_EQ(x, y);
-        EXPECT_TRUE(sane(x));
-        y = b3;
-        EXPECT_EQ(y, b3);
-        EXPECT_TRUE(sane(y));
-        x = b0;
-        EXPECT_EQ(x, b0);
-        EXPECT_TRUE(sane(x));
-#if defined(__clang__)
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wself-assign-overloaded"
-#endif
-
-        x = x;
-        EXPECT_EQ(x, b0);
-        EXPECT_TRUE(sane(x));
-        y = y;
-        EXPECT_EQ(y, b3);
-        EXPECT_TRUE(sane(y));
-
-#if defined(__clang__)
-#pragma clang diagnostic pop
-#endif
-    }
-
-    // Check move constructor & move assignments:
-    {
-        static_assert(std::is_nothrow_move_constructible_v<Buffer>);
-        static_assert(std::is_nothrow_move_assignable_v<Buffer>);
-
-        {  // Move-construct from empty buf
-            Buffer x;
-            Buffer const y{std::move(x)};
-            EXPECT_TRUE(sane(x));    // NOLINT(bugprone-use-after-move)
-            EXPECT_TRUE(x.empty());  // NOLINT(bugprone-use-after-move)
-            EXPECT_TRUE(sane(y));
-            EXPECT_TRUE(y.empty());
-            EXPECT_EQ(x, y);  // NOLINT(bugprone-use-after-move)
-        }
-
-        {  // Move-construct from non-empty buf
-            Buffer x{b1};
-            Buffer const y{std::move(x)};
-            EXPECT_TRUE(sane(x));    // NOLINT(bugprone-use-after-move)
-            EXPECT_TRUE(x.empty());  // NOLINT(bugprone-use-after-move)
-            EXPECT_TRUE(sane(y));
-            EXPECT_EQ(y, b1);
-        }
-
-        {  // Move assign empty buf to empty buf
-            Buffer x;
-            Buffer y;
-
-            x = std::move(y);
-            EXPECT_TRUE(sane(x));
-            EXPECT_TRUE(x.empty());
-            EXPECT_TRUE(sane(y));    // NOLINT(bugprone-use-after-move)
-            EXPECT_TRUE(y.empty());  // NOLINT(bugprone-use-after-move)
-        }
-
-        {  // Move assign non-empty buf to empty buf
-            Buffer x;
-            Buffer y{b1};
-
-            x = std::move(y);
-            EXPECT_TRUE(sane(x));
-            EXPECT_EQ(x, b1);
-            EXPECT_TRUE(sane(y));    // NOLINT(bugprone-use-after-move)
-            EXPECT_TRUE(y.empty());  // NOLINT(bugprone-use-after-move)
-        }
-
-        {  // Move assign empty buf to non-empty buf
-            Buffer x{b1};
-            Buffer y;
-
-            x = std::move(y);
-            EXPECT_TRUE(sane(x));
-            EXPECT_TRUE(x.empty());
-            EXPECT_TRUE(sane(y));    // NOLINT(bugprone-use-after-move)
-            EXPECT_TRUE(y.empty());  // NOLINT(bugprone-use-after-move)
-        }
-
-        {  // Move assign non-empty buf to non-empty buf
-            Buffer x{b1};
-            Buffer y{b2};
-            Buffer z{b3};
-
-            x = std::move(y);
-            EXPECT_TRUE(sane(x));
-            EXPECT_FALSE(x.empty());
-            EXPECT_TRUE(sane(y));    // NOLINT(bugprone-use-after-move)
-            EXPECT_TRUE(y.empty());  // NOLINT(bugprone-use-after-move)
-
-            x = std::move(z);
-            EXPECT_TRUE(sane(x));
-            EXPECT_FALSE(x.empty());
-            EXPECT_TRUE(sane(z));    // NOLINT(bugprone-use-after-move)
-            EXPECT_TRUE(z.empty());  // NOLINT(bugprone-use-after-move)
-        }
-    }
-
-    {
-        Buffer w{static_cast<Slice>(b0)};
-        EXPECT_TRUE(sane(w));
-        EXPECT_EQ(w, b0);
-
-        Buffer x{static_cast<Slice>(b1)};
-        EXPECT_TRUE(sane(x));
-        EXPECT_EQ(x, b1);
-
-        Buffer y{static_cast<Slice>(b2)};
-        EXPECT_TRUE(sane(y));
-        EXPECT_EQ(y, b2);
-
-        Buffer z{static_cast<Slice>(b3)};
-        EXPECT_TRUE(sane(z));
-        EXPECT_EQ(z, b3);
-
-        // Assign empty slice to empty buffer
-        w = static_cast<Slice>(b0);
-        EXPECT_TRUE(sane(w));
-        EXPECT_EQ(w, b0);
-
-        // Assign non-empty slice to empty buffer
-        w = static_cast<Slice>(b1);
-        EXPECT_TRUE(sane(w));
-        EXPECT_EQ(w, b1);
-
-        // Assign non-empty slice to non-empty buffer
-        x = static_cast<Slice>(b2);
-        EXPECT_TRUE(sane(x));
-        EXPECT_EQ(x, b2);
-
-        // Assign non-empty slice to non-empty buffer
-        y = static_cast<Slice>(z);
-        EXPECT_TRUE(sane(y));
-        EXPECT_EQ(y, z);
-
-        // Assign empty slice to non-empty buffer:
-        z = static_cast<Slice>(b0);
-        EXPECT_TRUE(sane(z));
-        EXPECT_EQ(z, b0);
-    }
-
-    {
-        auto test = [](Buffer const& b, std::size_t i) {
-            Buffer x{b};
-
-            // Try to allocate some number of bytes, possibly
-            // zero (which means clear) and sanity check
-            x(i);
-            EXPECT_TRUE(sane(x));
-            EXPECT_EQ(x.size(), i);
-            EXPECT_EQ((x.data() == nullptr), (i == 0));
-
-            // Try to allocate some more data (always non-zero)
-            x(i + 1);
-            EXPECT_TRUE(sane(x));
-            EXPECT_EQ(x.size(), i + 1);
-            EXPECT_NE(x.data(), nullptr);
-
-            // Try to clear:
-            x.clear();
-            EXPECT_TRUE(sane(x));
-            EXPECT_TRUE(x.empty());
-            EXPECT_EQ(x.data(), nullptr);
-
-            // Try to clear again:
-            x.clear();
-            EXPECT_TRUE(sane(x));
-            EXPECT_TRUE(x.empty());
-            EXPECT_EQ(x.data(), nullptr);
-        };
-
-        for (std::size_t i = 0; i < 16; ++i)
-        {
-            test(b0, i);
-            test(b1, i);
-        }
-    }
-}
-
-}  // namespace xrpl::test
diff --git a/src/tests/libxrpl/basics/FileUtilities.cpp b/src/tests/libxrpl/basics/FileUtilities.cpp
deleted file mode 100644
index cd24abd696..0000000000
--- a/src/tests/libxrpl/basics/FileUtilities.cpp
+++ /dev/null
@@ -1,94 +0,0 @@
-#include <xrpl/basics/FileUtilities.h>
-
-#include <xrpl/basics/ByteUtilities.h>
-
-#include <boost/filesystem/operations.hpp>
-#include <boost/filesystem/path.hpp>
-#include <boost/system/detail/errc.hpp>
-#include <boost/system/detail/error_code.hpp>
-
-#include <gtest/gtest.h>
-
-#include <fstream>
-#include <stdexcept>
-#include <string>
-
-namespace xrpl {
-
-namespace {
-
-class TempFile
-{
-public:
-    explicit TempFile(boost::filesystem::path file, std::string const& contents)
-        : dir_(
-              boost::filesystem::temp_directory_path() /
-              boost::filesystem::unique_path("xrpl-file-utilities-%%%%-%%%%-%%%%"))
-        , file_(dir_ / file)
-    {
-        boost::filesystem::create_directory(dir_);
-
-        std::ofstream output(file_.string());
-        if (!output)
-            throw std::runtime_error("Unable to create temporary test file");
-
-        output << contents;
-    }
-
-    ~TempFile()
-    {
-        boost::system::error_code ec;
-        boost::filesystem::remove(file_, ec);
-        boost::filesystem::remove(dir_, ec);
-    }
-
-    [[nodiscard]] boost::filesystem::path const&
-    file() const
-    {
-        return file_;
-    }
-
-private:
-    boost::filesystem::path dir_;
-    boost::filesystem::path file_;
-};
-
-}  // namespace
-
-TEST(FileUtilitiesTest, get_file_contents)
-{
-    using namespace boost::system;
-
-    constexpr char const* kExpectedContents = "This file is very short. That's all we need.";
-
-    TempFile const file("test_file", "This is temporary text that should get overwritten");
-
-    error_code ec;
-    auto const path = file.file();
-
-    writeFileContents(ec, path, kExpectedContents);
-    EXPECT_FALSE(ec);
-
-    {
-        // Test with no max
-        auto const good = getFileContents(ec, path);
-        EXPECT_FALSE(ec);
-        EXPECT_EQ(good, kExpectedContents);
-    }
-
-    {
-        // Test with large max
-        auto const good = getFileContents(ec, path, kilobytes(1));
-        EXPECT_FALSE(ec);
-        EXPECT_EQ(good, kExpectedContents);
-    }
-
-    {
-        // Test with small max
-        auto const bad = getFileContents(ec, path, 16);
-        EXPECT_TRUE(ec && ec.value() == boost::system::errc::file_too_large);
-        EXPECT_TRUE(bad.empty());
-    }
-}
-
-}  // namespace xrpl
diff --git a/src/tests/libxrpl/basics/IOUAmount.cpp b/src/tests/libxrpl/basics/IOUAmount.cpp
deleted file mode 100644
index 46d6d7c5e1..0000000000
--- a/src/tests/libxrpl/basics/IOUAmount.cpp
+++ /dev/null
@@ -1,243 +0,0 @@
-#include <xrpl/protocol/IOUAmount.h>
-
-#include <xrpl/basics/Number.h>
-#include <xrpl/beast/utility/Zero.h>
-
-#include <gtest/gtest.h>
-
-#include <cstdint>
-#include <limits>
-#include <sstream>
-#include <string>
-
-namespace xrpl {
-
-TEST(IOUAmountTest, zero)
-{
-    IOUAmount const z(0, 0);
-
-    EXPECT_EQ(z.mantissa(), 0);
-    EXPECT_EQ(z.exponent(), -100);
-    EXPECT_FALSE(z);
-    EXPECT_EQ(z.signum(), 0);
-    EXPECT_EQ(z, beast::kZero);
-
-    EXPECT_EQ((z + z), z);
-    EXPECT_EQ((z - z), z);
-    EXPECT_EQ(z, -z);
-
-    IOUAmount const zz(beast::kZero);
-    EXPECT_EQ(z, zz);
-
-    // https://github.com/XRPLF/rippled/issues/5170
-    IOUAmount const zzz{};
-    EXPECT_EQ(zzz, beast::kZero);
-    // EXPECT_EQ(zzz, zz);
-}
-
-TEST(IOUAmountTest, sig_num)
-{
-    IOUAmount const neg(-1, 0);
-    EXPECT_LT(neg.signum(), 0);
-
-    IOUAmount const zer(0, 0);
-    EXPECT_EQ(zer.signum(), 0);
-
-    IOUAmount const pos(1, 0);
-    EXPECT_GT(pos.signum(), 0);
-}
-
-TEST(IOUAmountTest, beast_zero)
-{
-    using beast::kZero;
-
-    {
-        IOUAmount const z(kZero);
-        EXPECT_TRUE(z == kZero);
-        EXPECT_TRUE(z >= kZero);
-        EXPECT_TRUE(z <= kZero);
-        EXPECT_FALSE(z != kZero);
-        EXPECT_FALSE(z > kZero);
-        EXPECT_FALSE(z < kZero);
-    }
-
-    {
-        IOUAmount const neg(-2, 0);
-        EXPECT_TRUE(neg < kZero);
-        EXPECT_TRUE(neg <= kZero);
-        EXPECT_TRUE(neg != kZero);
-        EXPECT_FALSE(neg == kZero);
-    }
-
-    {
-        IOUAmount const pos(2, 0);
-        EXPECT_TRUE(pos > kZero);
-        EXPECT_TRUE(pos >= kZero);
-        EXPECT_TRUE(pos != kZero);
-        EXPECT_FALSE(pos == kZero);
-    }
-}
-
-TEST(IOUAmountTest, comparisons)
-{
-    IOUAmount const n(-2, 0);
-    IOUAmount const z(0, 0);
-    IOUAmount const p(2, 0);
-    // For code readability, we want to use general
-    // EXPECT_TRUE instead of specific EXPECT_EQ etc.
-    EXPECT_TRUE(z == z);
-    EXPECT_TRUE(z >= z);
-    EXPECT_TRUE(z <= z);
-    EXPECT_TRUE(z == -z);
-    // NOLINTBEGIN(misc-redundant-expression)
-    EXPECT_FALSE(z > z);
-    EXPECT_FALSE(z < z);
-    EXPECT_FALSE(z != z);
-    // NOLINTEND(misc-redundant-expression)
-    EXPECT_FALSE(z != -z);
-
-    EXPECT_TRUE(n < z);
-    EXPECT_TRUE(n <= z);
-    EXPECT_TRUE(n != z);
-    EXPECT_FALSE(n > z);
-    EXPECT_FALSE(n >= z);
-    EXPECT_FALSE(n == z);
-
-    EXPECT_TRUE(p > z);
-    EXPECT_TRUE(p >= z);
-    EXPECT_TRUE(p != z);
-    EXPECT_FALSE(p < z);
-    EXPECT_FALSE(p <= z);
-    EXPECT_FALSE(p == z);
-
-    EXPECT_TRUE(n < p);
-    EXPECT_TRUE(n <= p);
-    EXPECT_TRUE(n != p);
-    EXPECT_FALSE(n > p);
-    EXPECT_FALSE(n >= p);
-    EXPECT_FALSE(n == p);
-
-    EXPECT_TRUE(p > n);
-    EXPECT_TRUE(p >= n);
-    EXPECT_TRUE(p != n);
-    EXPECT_FALSE(p < n);
-    EXPECT_FALSE(p <= n);
-    EXPECT_FALSE(p == n);
-
-    EXPECT_TRUE(p > -p);
-    EXPECT_TRUE(p >= -p);
-    EXPECT_TRUE(p != -p);
-
-    EXPECT_TRUE(n < -n);
-    EXPECT_TRUE(n <= -n);
-    EXPECT_TRUE(n != -n);
-}
-
-TEST(IOUAmountTest, to_string)
-{
-    auto test = [](IOUAmount const& n, std::string const& expected) {
-        auto const result = to_string(n);
-        std::stringstream ss;
-        ss << "to_string(" << result << "). Expected: " << expected;
-        EXPECT_EQ(result, expected) << ss.str();
-    };
-
-    for (auto const mantissaSize : MantissaRange::getAllScales())
-    {
-        NumberMantissaScaleGuard const mg(mantissaSize);
-
-        test(IOUAmount(-2, 0), "-2");
-        test(IOUAmount(0, 0), "0");
-        test(IOUAmount(2, 0), "2");
-        test(IOUAmount(25, -3), "0.025");
-        test(IOUAmount(-25, -3), "-0.025");
-        test(IOUAmount(25, 1), "250");
-        test(IOUAmount(-25, 1), "-250");
-        test(IOUAmount(2, 20), "2e20");
-        test(IOUAmount(-2, -20), "-2e-20");
-    }
-}
-
-TEST(IOUAmountTest, mul_ratio)
-{
-    /* The range for the mantissa when normalized */
-    constexpr std::int64_t kMinMantissa = 1000000000000000ull;
-    constexpr std::int64_t kMaxMantissa = 9999999999999999ull;
-    // log(2,maxMantissa) ~ 53.15
-    /* The range for the exponent when normalized */
-    constexpr int kMinExponent = -96;
-    constexpr int kMaxExponent = 80;
-    constexpr auto kMaxUInt = std::numeric_limits<std::uint32_t>::max();
-
-    {
-        // multiply by a number that would overflow the mantissa, then
-        // divide by the same number, and check we didn't lose any value
-        IOUAmount const bigMan(kMaxMantissa, 0);
-        EXPECT_EQ(bigMan, mulRatio(bigMan, kMaxUInt, kMaxUInt, true));
-        // rounding mode shouldn't matter as the result is exact
-        EXPECT_EQ(bigMan, mulRatio(bigMan, kMaxUInt, kMaxUInt, false));
-    }
-    {
-        // Similar test as above, but for negative values
-        IOUAmount const bigMan(-kMaxMantissa, 0);
-        EXPECT_EQ(bigMan, mulRatio(bigMan, kMaxUInt, kMaxUInt, true));
-        // rounding mode shouldn't matter as the result is exact
-        EXPECT_EQ(bigMan, mulRatio(bigMan, kMaxUInt, kMaxUInt, false));
-    }
-
-    {
-        // small amounts
-        IOUAmount const tiny(kMinMantissa, kMinExponent);
-        // Round up should give the smallest allowable number
-        EXPECT_EQ(tiny, mulRatio(tiny, 1, kMaxUInt, true));
-        EXPECT_EQ(tiny, mulRatio(tiny, kMaxUInt - 1, kMaxUInt, true));
-        // rounding down should be zero
-        EXPECT_EQ(beast::kZero, mulRatio(tiny, 1, kMaxUInt, false));
-        EXPECT_EQ(beast::kZero, mulRatio(tiny, kMaxUInt - 1, kMaxUInt, false));
-
-        // tiny negative numbers
-        IOUAmount const tinyNeg(-kMinMantissa, kMinExponent);
-        // Round up should give zero
-        EXPECT_EQ(beast::kZero, mulRatio(tinyNeg, 1, kMaxUInt, true));
-        EXPECT_EQ(beast::kZero, mulRatio(tinyNeg, kMaxUInt - 1, kMaxUInt, true));
-        // rounding down should be tiny
-        EXPECT_EQ(tinyNeg, mulRatio(tinyNeg, 1, kMaxUInt, false));
-        EXPECT_EQ(tinyNeg, mulRatio(tinyNeg, kMaxUInt - 1, kMaxUInt, false));
-    }
-
-    {  // rounding
-        {
-            IOUAmount const one(1, 0);
-            auto const rup = mulRatio(one, kMaxUInt - 1, kMaxUInt, true);
-            auto const rdown = mulRatio(one, kMaxUInt - 1, kMaxUInt, false);
-            EXPECT_EQ(rup.mantissa() - rdown.mantissa(), 1);
-        }
-        {
-            IOUAmount const big(kMaxMantissa, kMaxExponent);
-            auto const rup = mulRatio(big, kMaxUInt - 1, kMaxUInt, true);
-            auto const rdown = mulRatio(big, kMaxUInt - 1, kMaxUInt, false);
-            EXPECT_EQ(rup.mantissa() - rdown.mantissa(), 1);
-        }
-
-        {
-            IOUAmount const negOne(-1, 0);
-            auto const rup = mulRatio(negOne, kMaxUInt - 1, kMaxUInt, true);
-            auto const rdown = mulRatio(negOne, kMaxUInt - 1, kMaxUInt, false);
-            EXPECT_EQ(rup.mantissa() - rdown.mantissa(), 1);
-        }
-    }
-
-    {
-        // division by zero
-        IOUAmount const one(1, 0);
-        EXPECT_ANY_THROW({ mulRatio(one, 1, 0, true); });
-    }
-
-    {
-        // overflow
-        IOUAmount const big(kMaxMantissa, kMaxExponent);
-        EXPECT_ANY_THROW({ mulRatio(big, 2, 0, true); });
-    }
-}
-
-}  // namespace xrpl
diff --git a/src/tests/libxrpl/basics/IntrusiveShared.cpp b/src/tests/libxrpl/basics/IntrusiveShared.cpp
deleted file mode 100644
index e798cd1ccc..0000000000
--- a/src/tests/libxrpl/basics/IntrusiveShared.cpp
+++ /dev/null
@@ -1,844 +0,0 @@
-#include <xrpl/basics/IntrusivePointer.h>    // IWYU pragma: keep
-#include <xrpl/basics/IntrusivePointer.ipp>  // IWYU pragma: keep
-#include <xrpl/basics/IntrusiveRefCounts.h>
-
-#include <gtest/gtest.h>
-
-#include <algorithm>
-#include <array>
-#include <atomic>
-#include <chrono>  // IWYU pragma: keep
-#include <condition_variable>
-#include <cstddef>
-#include <cstdint>
-#include <functional>
-#include <latch>
-#include <mutex>
-#include <optional>
-#include <random>
-#include <stdexcept>
-#include <thread>
-#include <utility>
-#include <variant>
-#include <vector>
-
-namespace xrpl::tests {
-
-/*
- * Experimentally, we discovered that using std::barrier performs extremely
- * poorly (~1 hour vs ~1 minute to run the test suite) in certain macOS
- * environments. To unblock our macOS CI pipeline, we replaced std::barrier with a
- * custom mutex-based barrier (Barrier) that significantly improves performance
- * without compromising correctness. For future reference, if we ever consider
- * reintroducing std::barrier, the following configuration is known to exhibit the
- * problem:
- *
- *     Model Name: Mac mini
- *     Model Identifier: Mac14,3
- *     Model Number: Z16K000R4LL/A
- *     Chip: Apple M2
- *     Total Number of Cores: 8 (4 performance and 4 efficiency)
- *     Memory: 24 GB
- *     System Firmware Version: 11881.41.5
- *     OS Loader Version: 11881.1.1
- *     Apple clang version 16.0.0 (clang-1600.0.26.3)
- *     Target: arm64-apple-darwin24.0.0
- *     Thread model: posix
- *
- */
-struct Barrier
-{
-    std::mutex mtx;
-    std::condition_variable cv;
-    int count;
-    int const initial;
-    std::size_t generation{0};
-
-    explicit Barrier(int n) : count(n), initial(n)
-    {
-    }
-
-    void
-    arriveAndWait()
-    {
-        std::unique_lock lock(mtx);
-        auto const currentGeneration = generation;
-        if (--count == 0)
-        {
-            ++generation;
-            count = initial;
-            cv.notify_all();
-        }
-        else
-        {
-            cv.wait(lock, [&] { return generation != currentGeneration; });
-        }
-    }
-};
-
-namespace {
-enum class TrackedState : std::uint8_t {
-    Uninitialized,
-    Alive,
-    PartiallyDeletedStarted,
-    PartiallyDeleted,
-    DeletedStarted,
-    Deleted
-};
-
-class TIBase : public IntrusiveRefCounts
-{
-public:
-    static constexpr std::size_t kMaxStates = 128;
-    static std::array<std::atomic<TrackedState>, kMaxStates> state;
-    static std::atomic<std::size_t> nextId;
-    static TrackedState
-    getState(std::size_t id)
-    {
-        if (id >= state.size())
-            throw std::out_of_range("TIBase state id out of range");
-
-        return state[id].load(std::memory_order_acquire);
-    }
-    static void
-    resetStates(bool resetCallback)
-    {
-        for (std::size_t i = 0; i < kMaxStates; ++i)
-        {
-            state[i].store(TrackedState::Uninitialized, std::memory_order_release);
-        }
-        nextId.store(0, std::memory_order_release);
-        if (resetCallback)
-            TIBase::tracingCallback = [](TrackedState, std::optional<TrackedState>) {};
-    }
-
-    struct ResetStatesGuard
-    {
-        bool resetCallback{false};
-
-        ResetStatesGuard(bool resetCallback) : resetCallback{resetCallback}
-        {
-            TIBase::resetStates(resetCallback);
-        }
-        ~ResetStatesGuard()
-        {
-            TIBase::resetStates(resetCallback);
-        }
-    };
-
-    TIBase() : id{checkoutID()}
-    {
-        state[id].store(TrackedState::Alive, std::memory_order_relaxed);
-    }
-    ~TIBase() override
-    {
-        using enum TrackedState;
-
-        tracingCallback(state[id].load(std::memory_order_relaxed), DeletedStarted);
-
-        // Use relaxed memory order to try to avoid atomic operations from
-        // adding additional memory synchronizations that may hide threading
-        // errors in the underlying shared pointer class.
-        state[id].store(DeletedStarted, std::memory_order_relaxed);
-
-        tracingCallback(DeletedStarted, Deleted);
-
-        state[id].store(TrackedState::Deleted, std::memory_order_relaxed);
-
-        tracingCallback(TrackedState::Deleted, std::nullopt);
-    }
-
-    void
-    partialDestructor() const
-    {
-        using enum TrackedState;
-
-        tracingCallback(state[id].load(std::memory_order_relaxed), PartiallyDeletedStarted);
-
-        state[id].store(PartiallyDeletedStarted, std::memory_order_relaxed);
-
-        tracingCallback(PartiallyDeletedStarted, PartiallyDeleted);
-
-        state[id].store(PartiallyDeleted, std::memory_order_relaxed);
-
-        tracingCallback(PartiallyDeleted, std::nullopt);
-    }
-
-    static std::function<void(TrackedState, std::optional<TrackedState>)> tracingCallback;
-
-    std::size_t const id;
-
-private:
-    static std::size_t
-    checkoutID()
-    {
-        auto const id = nextId.fetch_add(1, std::memory_order_acq_rel);
-        if (id >= state.size())
-            throw std::out_of_range("TIBase state capacity exceeded");
-
-        return id;
-    }
-};
-
-std::array<std::atomic<TrackedState>, TIBase::kMaxStates> TIBase::state;
-std::atomic<std::size_t> TIBase::nextId{0};
-
-std::function<void(TrackedState, std::optional<TrackedState>)> TIBase::tracingCallback =
-    [](TrackedState, std::optional<TrackedState>) {};
-
-}  // namespace
-
-TEST(IntrusiveSharedTest, basics)
-{
-    {
-        TIBase::ResetStatesGuard const rsg{true};
-
-        TIBase const b;
-        EXPECT_EQ(b.useCount(), 1);
-        b.addWeakRef();
-        EXPECT_EQ(b.useCount(), 1);
-        auto s = b.releaseStrongRef();
-        EXPECT_EQ(s, ReleaseStrongRefAction::PartialDestroy);
-        EXPECT_EQ(b.useCount(), 0);
-        TIBase const* pb = &b;
-        partialDestructorFinished(&pb);
-        EXPECT_FALSE(pb);
-        auto w = b.releaseWeakRef();
-        EXPECT_EQ(w, ReleaseWeakRefAction::Destroy);
-    }
-
-    std::vector<SharedIntrusive<TIBase>> strong;
-    std::vector<WeakIntrusive<TIBase>> weak;
-    {
-        TIBase::ResetStatesGuard const rsg{true};
-
-        using enum TrackedState;
-        auto b = makeSharedIntrusive<TIBase>();
-        auto id = b->id;
-        EXPECT_EQ(TIBase::getState(id), Alive);
-        EXPECT_EQ(b->useCount(), 1);
-        for (int i = 0; i < 10; ++i)
-        {
-            strong.push_back(b);
-        }
-        b.reset();
-        EXPECT_EQ(TIBase::getState(id), Alive);
-        strong.resize(strong.size() - 1);
-        EXPECT_EQ(TIBase::getState(id), Alive);
-        strong.clear();
-        EXPECT_EQ(TIBase::getState(id), Deleted);
-
-        b = makeSharedIntrusive<TIBase>();
-        id = b->id;
-        EXPECT_EQ(TIBase::getState(id), Alive);
-        EXPECT_EQ(b->useCount(), 1);
-        for (int i = 0; i < 10; ++i)
-        {
-            weak.emplace_back(b);
-            EXPECT_EQ(b->useCount(), 1);
-        }
-        EXPECT_EQ(TIBase::getState(id), Alive);
-        weak.resize(weak.size() - 1);
-        EXPECT_EQ(TIBase::getState(id), Alive);
-        b.reset();
-        EXPECT_EQ(TIBase::getState(id), PartiallyDeleted);
-        while (!weak.empty())
-        {
-            weak.resize(weak.size() - 1);
-            if (!weak.empty())
-            {
-                EXPECT_EQ(TIBase::getState(id), PartiallyDeleted);
-            }
-        }
-        EXPECT_EQ(TIBase::getState(id), Deleted);
-    }
-    {
-        TIBase::ResetStatesGuard const rsg{true};
-
-        using enum TrackedState;
-        auto b = makeSharedIntrusive<TIBase>();
-        auto id = b->id;
-        EXPECT_EQ(TIBase::getState(id), Alive);
-        WeakIntrusive<TIBase> w{b};
-        EXPECT_EQ(TIBase::getState(id), Alive);
-        auto s = w.lock();
-        EXPECT_TRUE(s && s->useCount() == 2);
-        b.reset();
-        EXPECT_TRUE(TIBase::getState(id) == Alive);
-        EXPECT_TRUE(s && s->useCount() == 1);
-        s.reset();
-        EXPECT_EQ(TIBase::getState(id), PartiallyDeleted);
-        EXPECT_TRUE(w.expired());
-        s = w.lock();
-        // Cannot convert a weak pointer to a strong pointer if object is
-        // already partially deleted
-        EXPECT_FALSE(s);
-        w.reset();
-        EXPECT_EQ(TIBase::getState(id), Deleted);
-    }
-    {
-        TIBase::ResetStatesGuard const rsg{true};
-
-        using enum TrackedState;
-        using swu = SharedWeakUnion<TIBase>;
-        swu b = makeSharedIntrusive<TIBase>();
-        EXPECT_TRUE(b.isStrong() && b.useCount() == 1);
-        auto id = b.get()->id;
-        EXPECT_EQ(TIBase::getState(id), Alive);
-        swu w = b;
-        EXPECT_TRUE(TIBase::getState(id) == Alive);
-        EXPECT_TRUE(w.isStrong() && b.useCount() == 2);
-        w.convertToWeak();
-        EXPECT_TRUE(w.isWeak() && b.useCount() == 1);
-        swu s = w;
-        EXPECT_TRUE(s.isWeak() && b.useCount() == 1);
-        s.convertToStrong();
-        EXPECT_TRUE(s.isStrong() && b.useCount() == 2);
-        b.reset();
-        EXPECT_EQ(TIBase::getState(id), Alive);
-        EXPECT_EQ(s.useCount(), 1);
-        EXPECT_FALSE(w.expired());
-        s.reset();
-        EXPECT_EQ(TIBase::getState(id), PartiallyDeleted);
-        EXPECT_TRUE(w.expired());
-        w.convertToStrong();
-        // Cannot convert a weak pointer to a strong pointer if object is
-        // already partially deleted
-        EXPECT_TRUE(w.isWeak());
-        w.reset();
-        EXPECT_EQ(TIBase::getState(id), Deleted);
-    }
-    {
-        // Testing SharedWeakUnion assignment operator
-
-        TIBase::ResetStatesGuard const rsg{true};
-
-        auto strong1 = makeSharedIntrusive<TIBase>();
-        auto strong2 = makeSharedIntrusive<TIBase>();
-
-        auto id1 = strong1->id;
-        auto id2 = strong2->id;
-
-        EXPECT_NE(id1, id2);
-
-        SharedWeakUnion<TIBase> union1 = strong1;
-        SharedWeakUnion<TIBase> union2 = strong2;
-
-        EXPECT_TRUE(union1.isStrong());
-        EXPECT_TRUE(union2.isStrong());
-        EXPECT_EQ(union1.get(), strong1.get());
-        EXPECT_EQ(union2.get(), strong2.get());
-
-        // 1) Normal assignment: explicitly calls SharedWeakUnion assignment
-        union1 = union2;
-        EXPECT_TRUE(union1.isStrong());
-        EXPECT_TRUE(union2.isStrong());
-        EXPECT_EQ(union1.get(), union2.get());
-        EXPECT_EQ(TIBase::getState(id1), TrackedState::Alive);
-        EXPECT_EQ(TIBase::getState(id2), TrackedState::Alive);
-
-        // 2) Test self-assignment
-        EXPECT_TRUE(union1.isStrong());
-        EXPECT_EQ(TIBase::getState(id1), TrackedState::Alive);
-        int const initialRefCount = strong1->useCount();
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wself-assign-overloaded"
-        union1 = union1;  // Self-assignment
-#pragma clang diagnostic pop
-        EXPECT_TRUE(union1.isStrong());
-        EXPECT_EQ(TIBase::getState(id1), TrackedState::Alive);
-        EXPECT_EQ(strong1->useCount(), initialRefCount);
-
-        // 3) Test assignment from null union pointer
-        union1 = SharedWeakUnion<TIBase>();
-        EXPECT_EQ(union1.get(), nullptr);
-
-        // 4) Test assignment to expired union pointer
-        strong2.reset();
-        union2.reset();
-        union1 = union2;
-        EXPECT_EQ(union1.get(), nullptr);
-        EXPECT_EQ(TIBase::getState(id2), TrackedState::Deleted);
-    }
-}
-
-TEST(IntrusiveSharedTest, partial_delete)
-{
-    // This test creates two threads. One with a strong pointer and one
-    // with a weak pointer. The strong pointer is reset while the weak
-    // pointer still holds a reference, triggering a partial delete.
-    // While the partial delete function runs (a sleep is inserted) the
-    // weak pointer is reset. The destructor should wait to run until
-    // after the partial delete function has completed running.
-
-    using enum TrackedState;
-
-    TIBase::ResetStatesGuard const rsg{true};
-
-    auto strong = makeSharedIntrusive<TIBase>();
-    WeakIntrusive<TIBase> weak{strong};
-    std::atomic<bool> destructorRan{false};
-    std::atomic<bool> partialDeleteRan{false};
-    std::latch partialDeleteStartedSyncPoint{2};
-    strong->tracingCallback = [&](TrackedState cur, std::optional<TrackedState> next) {
-        using enum TrackedState;
-        if (next == DeletedStarted)
-        {
-            // strong goes out of scope while weak is still in scope
-            // This checks that partialDelete has run to completion
-            // before the destructor is called. A sleep is inserted
-            // inside the partial delete to make sure the destructor is
-            // given an opportunity to run during partial delete.
-            EXPECT_EQ(cur, PartiallyDeleted);
-        }
-        if (next == PartiallyDeletedStarted)
-        {
-            partialDeleteStartedSyncPoint.arrive_and_wait();
-            using namespace std::chrono_literals;
-            // Sleep and let the weak pointer go out of scope,
-            // potentially triggering a destructor while partial delete
-            // is running. The test is to make sure that doesn't happen.
-            std::this_thread::sleep_for(800ms);
-        }
-        if (next == PartiallyDeleted)
-        {
-            EXPECT_FALSE(partialDeleteRan.exchange(true) || destructorRan.load());
-        }
-        if (next == Deleted)
-        {
-            EXPECT_FALSE(destructorRan.exchange(true));
-        }
-    };
-    std::thread t1{[&] {
-        partialDeleteStartedSyncPoint.arrive_and_wait();
-        weak.reset();  // Trigger a full delete as soon as the partial
-                       // delete starts
-    }};
-    std::thread t2{[&] {
-        strong.reset();  // Trigger a partial delete
-    }};
-    t1.join();
-    t2.join();
-
-    EXPECT_TRUE(destructorRan.load() && partialDeleteRan.load());
-}
-
-TEST(IntrusiveSharedTest, destructor)
-{
-    // This test creates two threads. One with a strong pointer and one
-    // with a weak pointer. The weak pointer is reset while the strong
-    // pointer still holds a reference. Then the strong pointer is
-    // reset. Only the destructor should run. The partial destructor
-    // should not be called. Since the weak reset runs to completion
-    // before the strong pointer is reset, threading doesn't add much to
-    // this test, but there is no harm in keeping it.
-
-    using enum TrackedState;
-
-    TIBase::ResetStatesGuard const rsg{true};
-
-    auto strong = makeSharedIntrusive<TIBase>();
-    WeakIntrusive<TIBase> weak{strong};
-    std::atomic<bool> destructorRan{false};
-    std::atomic<bool> partialDeleteRan{false};
-    std::latch weakResetSyncPoint{2};
-    strong->tracingCallback = [&](TrackedState cur, std::optional<TrackedState> next) {
-        using enum TrackedState;
-        if (next == PartiallyDeleted)
-        {
-            EXPECT_FALSE(partialDeleteRan.exchange(true) || destructorRan.load());
-        }
-        if (next == Deleted)
-        {
-            EXPECT_FALSE(destructorRan.exchange(true));
-        }
-    };
-    std::thread t1{[&] {
-        weak.reset();
-        weakResetSyncPoint.arrive_and_wait();
-    }};
-    std::thread t2{[&] {
-        weakResetSyncPoint.arrive_and_wait();
-        strong.reset();  // Trigger a partial delete
-    }};
-    t1.join();
-    t2.join();
-
-    EXPECT_TRUE(destructorRan.load() && !partialDeleteRan.load());
-}
-
-TEST(IntrusiveSharedTest, multithreaded_clear_mixed_variant)
-{
-    // This test creates and destroys many strong and weak pointers in a
-    // loop. There is a random mix of strong and weak pointers stored in
-    // a vector (held as a variant). Both threads clear all the pointers
-    // and check that the invariants hold.
-
-    using enum TrackedState;
-    TIBase::ResetStatesGuard const rsg{true};
-
-    std::atomic<int> destructionState{0};
-    // returns destructorRan and partialDestructorRan (in that order)
-    auto getDestructorState = [&]() -> std::pair<bool, bool> {
-        int const s = destructionState.load(std::memory_order_relaxed);
-        return {(s & 1) != 0, (s & 2) != 0};
-    };
-    auto setDestructorRan = [&]() -> void {
-        destructionState.fetch_or(1, std::memory_order_acq_rel);
-    };
-    auto setPartialDeleteRan = [&]() -> void {
-        destructionState.fetch_or(2, std::memory_order_acq_rel);
-    };
-    auto tracingCallback = [&](TrackedState cur, std::optional<TrackedState> next) {
-        using enum TrackedState;
-        auto [destructorRan, partialDeleteRan] = getDestructorState();
-        if (next == PartiallyDeleted)
-        {
-            EXPECT_FALSE(partialDeleteRan || destructorRan);
-            setPartialDeleteRan();
-        }
-        if (next == Deleted)
-        {
-            EXPECT_FALSE(destructorRan);
-            setDestructorRan();
-        }
-    };
-    auto createVecOfPointers = [&](auto const& toClone, std::default_random_engine& eng)
-        -> std::vector<std::variant<SharedIntrusive<TIBase>, WeakIntrusive<TIBase>>> {
-        std::vector<std::variant<SharedIntrusive<TIBase>, WeakIntrusive<TIBase>>> result;
-        std::uniform_int_distribution<> toCreateDist(4, 64);
-        std::uniform_int_distribution<> isStrongDist(0, 1);
-        auto numToCreate = toCreateDist(eng);
-        result.reserve(numToCreate);
-        for (int i = 0; i < numToCreate; ++i)
-        {
-            if (isStrongDist(eng))
-            {
-                result.emplace_back(SharedIntrusive<TIBase>(toClone));
-            }
-            else
-            {
-                result.emplace_back(WeakIntrusive<TIBase>(toClone));
-            }
-        }
-        return result;
-    };
-    constexpr int kLoopIters = 2 * 1024;
-    constexpr int kNumThreads = 16;
-    std::vector<SharedIntrusive<TIBase>> toClone;
-    Barrier loopStartSyncPoint{kNumThreads};
-    Barrier postCreateToCloneSyncPoint{kNumThreads};
-    Barrier postCreateVecOfPointersSyncPoint{kNumThreads};
-    auto engines = [&]() -> std::vector<std::default_random_engine> {
-        std::random_device rd;
-        std::vector<std::default_random_engine> result;
-        result.reserve(kNumThreads);
-        for (int i = 0; i < kNumThreads; ++i)
-            result.emplace_back(rd());
-        return result;
-    }();
-
-    // cloneAndDestroy clones the strong pointer into a vector of mixed
-    // strong and weak pointers and destroys them all at once.
-    // threadId==0 is special.
-    auto cloneAndDestroy = [&](int threadId) {
-        for (int i = 0; i < kLoopIters; ++i)
-        {
-            // ------ Sync Point ------
-            loopStartSyncPoint.arriveAndWait();
-
-            // only thread 0 should reset the state
-            std::optional<TIBase::ResetStatesGuard> rsg;
-            if (threadId == 0)
-            {
-                // Thread 0 is the genesis thread. It creates the strong
-                // pointers to be cloned by the other threads. This
-                // thread will also check that the destructor ran and
-                // clear the temporary variables.
-
-                rsg.emplace(false);
-                auto [destructorRan, partialDeleteRan] = getDestructorState();
-                EXPECT_TRUE(i == 0 || destructorRan);
-                destructionState.store(0, std::memory_order_release);
-
-                toClone.clear();
-                toClone.resize(kNumThreads);
-                auto strong = makeSharedIntrusive<TIBase>();
-                strong->tracingCallback = tracingCallback;
-                std::ranges::fill(toClone, strong);
-            }
-
-            // ------ Sync Point ------
-            postCreateToCloneSyncPoint.arriveAndWait();
-
-            auto v = createVecOfPointers(toClone[threadId], engines[threadId]);
-            toClone[threadId].reset();
-
-            // ------ Sync Point ------
-            postCreateVecOfPointersSyncPoint.arriveAndWait();
-
-            v.clear();
-        }
-    };
-    std::vector<std::thread> threads;
-    threads.reserve(kNumThreads);
-    for (int i = 0; i < kNumThreads; ++i)
-    {
-        threads.emplace_back(cloneAndDestroy, i);
-    }
-    for (int i = 0; i < kNumThreads; ++i)
-    {
-        threads[i].join();
-    }
-}
-
-TEST(IntrusiveSharedTest, multithreaded_clear_mixed_union)
-{
-    // This test creates and destroys many SharedWeak pointers in a
-    // loop. All the pointers start as strong and a loop randomly
-    // convert them between strong and weak pointers. Both threads clear
-    // all the pointers and check that the invariants hold.
-    //
-    // Note: This test also differs from the test above in that the pointers
-    // randomly change from strong to weak and from weak to strong in a
-    // loop. This can't be done in the variant test above because variant is
-    // not thread safe while the SharedWeakUnion is thread safe.
-
-    using enum TrackedState;
-
-    TIBase::ResetStatesGuard const rsg{true};
-
-    std::atomic<int> destructionState{0};
-    // returns destructorRan and partialDestructorRan (in that order)
-    auto getDestructorState = [&]() -> std::pair<bool, bool> {
-        int const s = destructionState.load(std::memory_order_relaxed);
-        return {(s & 1) != 0, (s & 2) != 0};
-    };
-    auto setDestructorRan = [&]() -> void {
-        destructionState.fetch_or(1, std::memory_order_acq_rel);
-    };
-    auto setPartialDeleteRan = [&]() -> void {
-        destructionState.fetch_or(2, std::memory_order_acq_rel);
-    };
-    auto tracingCallback = [&](TrackedState cur, std::optional<TrackedState> next) {
-        using enum TrackedState;
-        auto [destructorRan, partialDeleteRan] = getDestructorState();
-        if (next == PartiallyDeleted)
-        {
-            EXPECT_FALSE(partialDeleteRan || destructorRan);
-            setPartialDeleteRan();
-        }
-        if (next == Deleted)
-        {
-            EXPECT_FALSE(destructorRan);
-            setDestructorRan();
-        }
-    };
-    auto createVecOfPointers =
-        [&](auto const& toClone,
-            std::default_random_engine& eng) -> std::vector<SharedWeakUnion<TIBase>> {
-        std::vector<SharedWeakUnion<TIBase>> result;
-        std::uniform_int_distribution<> toCreateDist(4, 64);
-        auto numToCreate = toCreateDist(eng);
-        result.reserve(numToCreate);
-        for (int i = 0; i < numToCreate; ++i)
-            result.emplace_back(SharedIntrusive<TIBase>(toClone));
-        return result;
-    };
-    constexpr int kLoopIters = 2 * 1024;
-    constexpr int kFlipPointersLoopIters = 256;
-    constexpr int kNumThreads = 16;
-    std::vector<SharedIntrusive<TIBase>> toClone;
-    Barrier loopStartSyncPoint{kNumThreads};
-    Barrier postCreateToCloneSyncPoint{kNumThreads};
-    Barrier postCreateVecOfPointersSyncPoint{kNumThreads};
-    Barrier postFlipPointersLoopSyncPoint{kNumThreads};
-    auto engines = [&]() -> std::vector<std::default_random_engine> {
-        std::random_device rd;
-        std::vector<std::default_random_engine> result;
-        result.reserve(kNumThreads);
-        for (int i = 0; i < kNumThreads; ++i)
-            result.emplace_back(rd());
-        return result;
-    }();
-
-    // cloneAndDestroy clones the strong pointer into a vector of
-    // mixed strong and weak pointers, runs a loop that randomly
-    // changes strong pointers to weak pointers,  and destroys them
-    // all at once.
-    auto cloneAndDestroy = [&](int threadId) {
-        for (int i = 0; i < kLoopIters; ++i)
-        {
-            // ------ Sync Point ------
-            loopStartSyncPoint.arriveAndWait();
-
-            // only thread 0 should reset the state
-            std::optional<TIBase::ResetStatesGuard> rsg;
-            if (threadId == 0)
-            {
-                // threadId 0 is the genesis thread. It creates the
-                // strong point to be cloned by the other threads. This
-                // thread will also check that the destructor ran and
-                // clear the temporary variables.
-                rsg.emplace(false);
-                auto [destructorRan, partialDeleteRan] = getDestructorState();
-                EXPECT_TRUE(i == 0 || destructorRan);
-                destructionState.store(0, std::memory_order_release);
-
-                toClone.clear();
-                toClone.resize(kNumThreads);
-                auto strong = makeSharedIntrusive<TIBase>();
-                strong->tracingCallback = tracingCallback;
-                std::ranges::fill(toClone, strong);
-            }
-
-            // ------ Sync Point ------
-            postCreateToCloneSyncPoint.arriveAndWait();
-
-            auto v = createVecOfPointers(toClone[threadId], engines[threadId]);
-            toClone[threadId].reset();
-
-            // ------ Sync Point ------
-            postCreateVecOfPointersSyncPoint.arriveAndWait();
-
-            std::uniform_int_distribution<> isStrongDist(0, 1);
-            for (int f = 0; f < kFlipPointersLoopIters; ++f)
-            {
-                for (auto& p : v)
-                {
-                    if (isStrongDist(engines[threadId]))
-                    {
-                        p.convertToStrong();
-                    }
-                    else
-                    {
-                        p.convertToWeak();
-                    }
-                }
-            }
-
-            // ------ Sync Point ------
-            postFlipPointersLoopSyncPoint.arriveAndWait();
-
-            v.clear();
-        }
-    };
-    std::vector<std::thread> threads;
-    threads.reserve(kNumThreads);
-    for (int i = 0; i < kNumThreads; ++i)
-    {
-        threads.emplace_back(cloneAndDestroy, i);
-    }
-    for (int i = 0; i < kNumThreads; ++i)
-    {
-        threads[i].join();
-    }
-}
-
-TEST(IntrusiveSharedTest, multithreaded_locking_weak)
-{
-    // This test creates a single shared atomic pointer that multiple thread
-    // create weak pointers from. The threads then lock the weak pointers.
-    // Both threads clear all the pointers and check that the invariants
-    // hold.
-
-    using enum TrackedState;
-
-    TIBase::ResetStatesGuard const rsg{true};
-
-    std::atomic<int> destructionState{0};
-    // returns destructorRan and partialDestructorRan (in that order)
-    auto getDestructorState = [&]() -> std::pair<bool, bool> {
-        int const s = destructionState.load(std::memory_order_relaxed);
-        return {(s & 1) != 0, (s & 2) != 0};
-    };
-    auto setDestructorRan = [&]() -> void {
-        destructionState.fetch_or(1, std::memory_order_acq_rel);
-    };
-    auto setPartialDeleteRan = [&]() -> void {
-        destructionState.fetch_or(2, std::memory_order_acq_rel);
-    };
-    auto tracingCallback = [&](TrackedState cur, std::optional<TrackedState> next) {
-        using enum TrackedState;
-        auto [destructorRan, partialDeleteRan] = getDestructorState();
-        if (next == PartiallyDeleted)
-        {
-            EXPECT_FALSE(partialDeleteRan || destructorRan);
-            setPartialDeleteRan();
-        }
-        if (next == Deleted)
-        {
-            EXPECT_FALSE(destructorRan);
-            setDestructorRan();
-        }
-    };
-
-    constexpr int kLoopIters = 2 * 1024;
-    constexpr int kLockWeakLoopIters = 256;
-    constexpr int kNumThreads = 16;
-    std::vector<SharedIntrusive<TIBase>> toLock;
-    Barrier loopStartSyncPoint{kNumThreads};
-    Barrier postCreateToLockSyncPoint{kNumThreads};
-    Barrier postLockWeakLoopSyncPoint{kNumThreads};
-
-    // lockAndDestroy creates weak pointers from the strong pointer
-    // and runs a loop that locks the weak pointer. At the end of the loop
-    // all the pointers are destroyed all at once.
-    auto lockAndDestroy = [&](int threadId) {
-        for (int i = 0; i < kLoopIters; ++i)
-        {
-            // ------ Sync Point ------
-            loopStartSyncPoint.arriveAndWait();
-
-            // only thread 0 should reset the state
-            std::optional<TIBase::ResetStatesGuard> rsg;
-            if (threadId == 0)
-            {
-                // threadId 0 is the genesis thread. It creates the
-                // strong point to be locked by the other threads. This
-                // thread will also check that the destructor ran and
-                // clear the temporary variables.
-                rsg.emplace(false);
-                auto [destructorRan, partialDeleteRan] = getDestructorState();
-                EXPECT_TRUE(i == 0 || destructorRan);
-                destructionState.store(0, std::memory_order_release);
-
-                toLock.clear();
-                toLock.resize(kNumThreads);
-                auto strong = makeSharedIntrusive<TIBase>();
-                strong->tracingCallback = tracingCallback;
-                std::ranges::fill(toLock, strong);
-            }
-
-            // ------ Sync Point ------
-            postCreateToLockSyncPoint.arriveAndWait();
-
-            // Multiple threads all create a weak pointer from the same
-            // strong pointer
-            WeakIntrusive const weak{toLock[threadId]};
-            for (int wi = 0; wi < kLockWeakLoopIters; ++wi)
-            {
-                EXPECT_FALSE(weak.expired());
-                auto strong = weak.lock();
-                EXPECT_TRUE(strong);
-            }
-
-            // ------ Sync Point ------
-            postLockWeakLoopSyncPoint.arriveAndWait();
-
-            toLock[threadId].reset();
-        }
-    };
-    std::vector<std::thread> threads;
-    threads.reserve(kNumThreads);
-    for (int i = 0; i < kNumThreads; ++i)
-    {
-        threads.emplace_back(lockAndDestroy, i);
-    }
-    for (int i = 0; i < kNumThreads; ++i)
-    {
-        threads[i].join();
-    }
-}
-
-}  // namespace xrpl::tests
diff --git a/src/tests/libxrpl/basics/KeyCache.cpp b/src/tests/libxrpl/basics/KeyCache.cpp
deleted file mode 100644
index 061264b11d..0000000000
--- a/src/tests/libxrpl/basics/KeyCache.cpp
+++ /dev/null
@@ -1,81 +0,0 @@
-#include <xrpl/basics/TaggedCache.h>
-#include <xrpl/basics/TaggedCache.ipp>  // IWYU pragma: keep
-#include <xrpl/basics/chrono.h>
-#include <xrpl/beast/utility/Journal.h>
-#include <xrpl/protocol/Protocol.h>
-
-#include <gtest/gtest.h>
-#include <helpers/TestSink.h>
-
-#include <string>
-
-namespace xrpl {
-
-class KeyCacheTest : public ::testing::Test
-{
-public:
-};
-
-TEST_F(KeyCacheTest, key_cache)
-{
-    using namespace std::chrono_literals;
-    TestStopwatch clock;
-    clock.set(0);
-
-    using Key = std::string;
-    using Cache = TaggedCache<Key, int, true>;
-
-    beast::Journal const j{TestSink::instance()};
-
-    // Insert an item, retrieve it, and age it so it gets purged.
-    {
-        Cache c("test", LedgerIndex(1), 2s, clock, j);
-
-        EXPECT_EQ(c.size(), 0);
-        EXPECT_TRUE(c.insert("one"));
-        EXPECT_FALSE(c.insert("one"));
-        EXPECT_EQ(c.size(), 1);
-        EXPECT_TRUE(c.touchIfExists("one"));
-        ++clock;
-        c.sweep();
-        EXPECT_EQ(c.size(), 1);
-        ++clock;
-        c.sweep();
-        EXPECT_EQ(c.size(), 0);
-        EXPECT_FALSE(c.touchIfExists("one"));
-    }
-
-    // Insert two items, have one expire
-    {
-        Cache c("test", LedgerIndex(2), 2s, clock, j);
-
-        EXPECT_TRUE(c.insert("one"));
-        EXPECT_EQ(c.size(), 1);
-        EXPECT_TRUE(c.insert("two"));
-        EXPECT_EQ(c.size(), 2);
-        ++clock;
-        c.sweep();
-        EXPECT_EQ(c.size(), 2);
-        EXPECT_TRUE(c.touchIfExists("two"));
-        ++clock;
-        c.sweep();
-        EXPECT_EQ(c.size(), 1);
-    }
-
-    // Insert three items (1 over limit), sweep
-    {
-        Cache c("test", LedgerIndex(2), 3s, clock, j);
-
-        EXPECT_TRUE(c.insert("one"));
-        ++clock;
-        EXPECT_TRUE(c.insert("two"));
-        ++clock;
-        EXPECT_TRUE(c.insert("three"));
-        ++clock;
-        EXPECT_EQ(c.size(), 3);
-        c.sweep();
-        EXPECT_LT(c.size(), 3);
-    }
-}
-
-}  // namespace xrpl
diff --git a/src/tests/libxrpl/basics/StringUtilities.cpp b/src/tests/libxrpl/basics/StringUtilities.cpp
deleted file mode 100644
index a10711abdb..0000000000
--- a/src/tests/libxrpl/basics/StringUtilities.cpp
+++ /dev/null
@@ -1,293 +0,0 @@
-#include <xrpl/basics/StringUtilities.h>
-
-#include <xrpl/basics/Slice.h>
-#include <xrpl/basics/ToString.h>
-
-#include <gtest/gtest.h>
-
-#include <string>
-
-namespace xrpl {
-
-class StringUtilitiesTest : public ::testing::Test
-{
-public:
-    static void
-    testUnHexSuccess(std::string const& strIn, std::string const& strExpected)
-    {
-        auto rv = strUnHex(strIn);
-        EXPECT_TRUE(rv);
-
-        // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
-        EXPECT_EQ(makeSlice(*rv), makeSlice(strExpected));
-    }
-
-    static void
-    testUnHexFailure(std::string const& strIn)
-    {
-        auto rv = strUnHex(strIn);
-        EXPECT_FALSE(rv);
-    }
-};
-
-TEST_F(StringUtilitiesTest, un_hex)
-{
-    testUnHexSuccess("526970706c6544", "RippleD");
-    testUnHexSuccess("A", "\n");
-    testUnHexSuccess("0A", "\n");
-    testUnHexSuccess("D0A", "\r\n");
-    testUnHexSuccess("0D0A", "\r\n");
-    testUnHexSuccess("200D0A", " \r\n");
-    testUnHexSuccess("282A2B2C2D2E2F29", "(*+,-./)");
-
-    // Check for things which contain some or only invalid characters
-    testUnHexFailure("123X");
-    testUnHexFailure("V");
-    testUnHexFailure("XRP");
-}
-
-TEST_F(StringUtilitiesTest, parse_url)
-{
-    // Expected passes.
-    {
-        ParsedUrl pUrl;
-        EXPECT_TRUE(parseUrl(pUrl, "scheme://"));
-        EXPECT_EQ(pUrl.scheme, "scheme");
-        EXPECT_TRUE(pUrl.username.empty());
-        EXPECT_TRUE(pUrl.password.empty());
-        EXPECT_TRUE(pUrl.domain.empty());
-        EXPECT_FALSE(pUrl.port);
-        // RFC 3986:
-        // > In general, a URI that uses the generic syntax for authority
-        //   with an empty path should be normalized to a path of "/".
-        // Do we want to normalize paths?
-        EXPECT_TRUE(pUrl.path.empty());
-    }
-
-    {
-        ParsedUrl pUrl;
-        EXPECT_TRUE(parseUrl(pUrl, "scheme:///"));
-        EXPECT_EQ(pUrl.scheme, "scheme");
-        EXPECT_TRUE(pUrl.username.empty());
-        EXPECT_TRUE(pUrl.password.empty());
-        EXPECT_TRUE(pUrl.domain.empty());
-        EXPECT_FALSE(pUrl.port);
-        EXPECT_EQ(pUrl.path, "/");
-    }
-
-    {
-        ParsedUrl pUrl;
-        EXPECT_TRUE(parseUrl(pUrl, "lower://domain"));
-        EXPECT_EQ(pUrl.scheme, "lower");
-        EXPECT_TRUE(pUrl.username.empty());
-        EXPECT_TRUE(pUrl.password.empty());
-        EXPECT_EQ(pUrl.domain, "domain");
-        EXPECT_FALSE(pUrl.port);
-        EXPECT_TRUE(pUrl.path.empty());
-    }
-
-    {
-        ParsedUrl pUrl;
-        EXPECT_TRUE(parseUrl(pUrl, "UPPER://domain:234/"));
-        EXPECT_EQ(pUrl.scheme, "upper");
-        EXPECT_TRUE(pUrl.username.empty());
-        EXPECT_TRUE(pUrl.password.empty());
-        EXPECT_EQ(pUrl.domain, "domain");
-        EXPECT_EQ(*pUrl.port, 234);  // NOLINT(bugprone-unchecked-optional-access)
-        EXPECT_EQ(pUrl.path, "/");
-    }
-
-    {
-        ParsedUrl pUrl;
-        EXPECT_TRUE(parseUrl(pUrl, "Mixed://domain/path"));
-        EXPECT_EQ(pUrl.scheme, "mixed");
-        EXPECT_TRUE(pUrl.username.empty());
-        EXPECT_TRUE(pUrl.password.empty());
-        EXPECT_EQ(pUrl.domain, "domain");
-        EXPECT_FALSE(pUrl.port);
-        EXPECT_EQ(pUrl.path, "/path");
-    }
-
-    {
-        ParsedUrl pUrl;
-        EXPECT_TRUE(parseUrl(pUrl, "scheme://[::1]:123/path"));
-        EXPECT_EQ(pUrl.scheme, "scheme");
-        EXPECT_TRUE(pUrl.username.empty());
-        EXPECT_TRUE(pUrl.password.empty());
-        EXPECT_EQ(pUrl.domain, "::1");
-        EXPECT_EQ(*pUrl.port, 123);  // NOLINT(bugprone-unchecked-optional-access)
-        EXPECT_EQ(pUrl.path, "/path");
-    }
-
-    {
-        ParsedUrl pUrl;
-        EXPECT_TRUE(parseUrl(pUrl, "scheme://user:pass@domain:123/abc:321"));
-        EXPECT_EQ(pUrl.scheme, "scheme");
-        EXPECT_EQ(pUrl.username, "user");
-        EXPECT_EQ(pUrl.password, "pass");
-        EXPECT_EQ(pUrl.domain, "domain");
-        EXPECT_EQ(*pUrl.port, 123);  // NOLINT(bugprone-unchecked-optional-access)
-        EXPECT_EQ(pUrl.path, "/abc:321");
-    }
-
-    {
-        ParsedUrl pUrl;
-        EXPECT_TRUE(parseUrl(pUrl, "scheme://user@domain:123/abc:321"));
-        EXPECT_EQ(pUrl.scheme, "scheme");
-        EXPECT_EQ(pUrl.username, "user");
-        EXPECT_TRUE(pUrl.password.empty());
-        EXPECT_EQ(pUrl.domain, "domain");
-        EXPECT_EQ(*pUrl.port, 123);  // NOLINT(bugprone-unchecked-optional-access)
-        EXPECT_EQ(pUrl.path, "/abc:321");
-    }
-
-    {
-        ParsedUrl pUrl;
-        EXPECT_TRUE(parseUrl(pUrl, "scheme://:pass@domain:123/abc:321"));
-        EXPECT_EQ(pUrl.scheme, "scheme");
-        EXPECT_TRUE(pUrl.username.empty());
-        EXPECT_EQ(pUrl.password, "pass");
-        EXPECT_EQ(pUrl.domain, "domain");
-        EXPECT_EQ(*pUrl.port, 123);  // NOLINT(bugprone-unchecked-optional-access)
-        EXPECT_EQ(pUrl.path, "/abc:321");
-    }
-
-    {
-        ParsedUrl pUrl;
-        EXPECT_TRUE(parseUrl(pUrl, "scheme://domain:123/abc:321"));
-        EXPECT_EQ(pUrl.scheme, "scheme");
-        EXPECT_TRUE(pUrl.username.empty());
-        EXPECT_TRUE(pUrl.password.empty());
-        EXPECT_EQ(pUrl.domain, "domain");
-        EXPECT_EQ(*pUrl.port, 123);  // NOLINT(bugprone-unchecked-optional-access)
-        EXPECT_EQ(pUrl.path, "/abc:321");
-    }
-
-    {
-        ParsedUrl pUrl;
-        EXPECT_TRUE(parseUrl(pUrl, "scheme://user:pass@domain/abc:321"));
-        EXPECT_EQ(pUrl.scheme, "scheme");
-        EXPECT_EQ(pUrl.username, "user");
-        EXPECT_EQ(pUrl.password, "pass");
-        EXPECT_EQ(pUrl.domain, "domain");
-        EXPECT_FALSE(pUrl.port);
-        EXPECT_EQ(pUrl.path, "/abc:321");
-    }
-
-    {
-        ParsedUrl pUrl;
-        EXPECT_TRUE(parseUrl(pUrl, "scheme://user@domain/abc:321"));
-        EXPECT_EQ(pUrl.scheme, "scheme");
-        EXPECT_EQ(pUrl.username, "user");
-        EXPECT_TRUE(pUrl.password.empty());
-        EXPECT_EQ(pUrl.domain, "domain");
-        EXPECT_FALSE(pUrl.port);
-        EXPECT_EQ(pUrl.path, "/abc:321");
-    }
-
-    {
-        ParsedUrl pUrl;
-        EXPECT_TRUE(parseUrl(pUrl, "scheme://:pass@domain/abc:321"));
-        EXPECT_EQ(pUrl.scheme, "scheme");
-        EXPECT_TRUE(pUrl.username.empty());
-        EXPECT_EQ(pUrl.password, "pass");
-        EXPECT_EQ(pUrl.domain, "domain");
-        EXPECT_FALSE(pUrl.port);
-        EXPECT_EQ(pUrl.path, "/abc:321");
-    }
-
-    {
-        ParsedUrl pUrl;
-        EXPECT_TRUE(parseUrl(pUrl, "scheme://domain/abc:321"));
-        EXPECT_EQ(pUrl.scheme, "scheme");
-        EXPECT_TRUE(pUrl.username.empty());
-        EXPECT_TRUE(pUrl.password.empty());
-        EXPECT_EQ(pUrl.domain, "domain");
-        EXPECT_FALSE(pUrl.port);
-        EXPECT_EQ(pUrl.path, "/abc:321");
-    }
-
-    {
-        ParsedUrl pUrl;
-        EXPECT_TRUE(parseUrl(pUrl, "scheme:///path/to/file"));
-        EXPECT_EQ(pUrl.scheme, "scheme");
-        EXPECT_TRUE(pUrl.username.empty());
-        EXPECT_TRUE(pUrl.password.empty());
-        EXPECT_TRUE(pUrl.domain.empty());
-        EXPECT_FALSE(pUrl.port);
-        EXPECT_EQ(pUrl.path, "/path/to/file");
-    }
-
-    {
-        ParsedUrl pUrl;
-        EXPECT_TRUE(parseUrl(pUrl, "scheme://user:pass@domain/path/with/an@sign"));
-        EXPECT_EQ(pUrl.scheme, "scheme");
-        EXPECT_EQ(pUrl.username, "user");
-        EXPECT_EQ(pUrl.password, "pass");
-        EXPECT_EQ(pUrl.domain, "domain");
-        EXPECT_FALSE(pUrl.port);
-        EXPECT_EQ(pUrl.path, "/path/with/an@sign");
-    }
-
-    {
-        ParsedUrl pUrl;
-        EXPECT_TRUE(parseUrl(pUrl, "scheme://domain/path/with/an@sign"));
-        EXPECT_EQ(pUrl.scheme, "scheme");
-        EXPECT_TRUE(pUrl.username.empty());
-        EXPECT_TRUE(pUrl.password.empty());
-        EXPECT_EQ(pUrl.domain, "domain");
-        EXPECT_FALSE(pUrl.port);
-        EXPECT_EQ(pUrl.path, "/path/with/an@sign");
-    }
-
-    {
-        ParsedUrl pUrl;
-        EXPECT_TRUE(parseUrl(pUrl, "scheme://:999/"));
-        EXPECT_EQ(pUrl.scheme, "scheme");
-        EXPECT_TRUE(pUrl.username.empty());
-        EXPECT_TRUE(pUrl.password.empty());
-        EXPECT_EQ(pUrl.domain, ":999");
-        EXPECT_FALSE(pUrl.port);
-        EXPECT_EQ(pUrl.path, "/");
-    }
-
-    {
-        ParsedUrl pUrl;
-        EXPECT_TRUE(parseUrl(pUrl, "http://::1:1234/validators"));
-        EXPECT_EQ(pUrl.scheme, "http");
-        EXPECT_TRUE(pUrl.username.empty());
-        EXPECT_TRUE(pUrl.password.empty());
-        EXPECT_EQ(pUrl.domain, "::0.1.18.52");
-        EXPECT_FALSE(pUrl.port);
-        EXPECT_EQ(pUrl.path, "/validators");
-    }
-
-    // Expected fails.
-    {
-        ParsedUrl pUrl;
-        EXPECT_FALSE(parseUrl(pUrl, ""));
-        EXPECT_FALSE(parseUrl(pUrl, "nonsense"));
-        EXPECT_FALSE(parseUrl(pUrl, "://"));
-        EXPECT_FALSE(parseUrl(pUrl, ":///"));
-        EXPECT_FALSE(parseUrl(pUrl, "scheme://user:pass@domain:65536/abc:321"));
-        EXPECT_FALSE(parseUrl(pUrl, "UPPER://domain:23498765/"));
-        EXPECT_FALSE(parseUrl(pUrl, "UPPER://domain:0/"));
-        EXPECT_FALSE(parseUrl(pUrl, "UPPER://domain:+7/"));
-        EXPECT_FALSE(parseUrl(pUrl, "UPPER://domain:-7234/"));
-        EXPECT_FALSE(parseUrl(pUrl, "UPPER://domain:@#$56!/"));
-    }
-
-    {
-        std::string const strUrl("s://" + std::string(8192, ':'));
-        ParsedUrl pUrl;
-        EXPECT_FALSE(parseUrl(pUrl, strUrl));
-    }
-}
-
-TEST_F(StringUtilitiesTest, to_string)
-{
-    auto result = to_string("hello");
-    EXPECT_EQ(result, "hello");
-}
-
-}  // namespace xrpl
diff --git a/src/tests/libxrpl/basics/TaggedCache.cpp b/src/tests/libxrpl/basics/TaggedCache.cpp
deleted file mode 100644
index c8ccc415ad..0000000000
--- a/src/tests/libxrpl/basics/TaggedCache.cpp
+++ /dev/null
@@ -1,246 +0,0 @@
-#include <xrpl/basics/TaggedCache.h>
-
-#include <xrpl/basics/IntrusivePointer.h>
-#include <xrpl/basics/IntrusiveRefCounts.h>
-#include <xrpl/basics/TaggedCache.ipp>  // IWYU pragma: keep
-#include <xrpl/basics/chrono.h>
-#include <xrpl/beast/utility/Journal.h>
-#include <xrpl/protocol/Protocol.h>
-
-#include <gtest/gtest.h>
-#include <helpers/TestSink.h>
-
-#include <memory>
-#include <string>
-#include <utility>
-
-namespace xrpl {
-
-/*
-I guess you can put some items in, make sure they're still there. Let some
-time pass, make sure they're gone. Keep a strong pointer to one of them, make
-sure you can still find it even after time passes. Create two objects with
-the same key, canonicalize them both and make sure you get the same object.
-Put an object in but keep a strong pointer to it, advance the clock a lot,
-then canonicalize a new object with the same key, make sure you get the
-original object.
-*/
-
-TEST(TaggedCacheTest, tagged_cache)
-{
-    using namespace std::chrono_literals;
-    beast::Journal const journal{TestSink::instance()};
-
-    TestStopwatch clock;
-    clock.set(0);
-
-    using Key = LedgerIndex;
-    using Value = std::string;
-    using Cache = TaggedCache<Key, Value>;
-
-    Cache c("test", 1, 1s, clock, journal);
-
-    // Insert an item, retrieve it, and age it so it gets purged.
-    {
-        EXPECT_EQ(c.getCacheSize(), 0);
-        EXPECT_EQ(c.getTrackSize(), 0);
-        EXPECT_FALSE(c.insert(1, "one"));
-        EXPECT_EQ(c.getCacheSize(), 1);
-        EXPECT_EQ(c.getTrackSize(), 1);
-
-        {
-            std::string s;
-            EXPECT_TRUE(c.retrieve(1, s));
-            EXPECT_EQ(s, "one");
-        }
-
-        ++clock;
-        c.sweep();
-        EXPECT_EQ(c.getCacheSize(), 0);
-        EXPECT_EQ(c.getTrackSize(), 0);
-    }
-
-    // Insert an item, maintain a strong pointer, age it, and
-    // verify that the entry still exists.
-    {
-        EXPECT_FALSE(c.insert(2, "two"));
-        EXPECT_EQ(c.getCacheSize(), 1);
-        EXPECT_EQ(c.getTrackSize(), 1);
-
-        {
-            auto p = c.fetch(2);
-            EXPECT_NE(p, nullptr);
-            ++clock;
-            c.sweep();
-            EXPECT_EQ(c.getCacheSize(), 0);
-            EXPECT_EQ(c.getTrackSize(), 1);
-        }
-
-        // Make sure its gone now that our reference is gone
-        ++clock;
-        c.sweep();
-        EXPECT_EQ(c.getCacheSize(), 0);
-        EXPECT_EQ(c.getTrackSize(), 0);
-    }
-
-    // Insert the same key/value pair and make sure we get the same result
-    {
-        EXPECT_FALSE(c.insert(3, "three"));
-
-        {
-            auto const p1 = c.fetch(3);
-            auto p2 = std::make_shared<Value>("three");
-            c.canonicalizeReplaceClient(3, p2);
-            EXPECT_EQ(p1.get(), p2.get());
-        }
-        ++clock;
-        c.sweep();
-        EXPECT_EQ(c.getCacheSize(), 0);
-        EXPECT_EQ(c.getTrackSize(), 0);
-    }
-
-    // Put an object in but keep a strong pointer to it, advance the clock a
-    // lot, then canonicalize a new object with the same key, make sure you
-    // get the original object.
-    {
-        // Put an object in
-        EXPECT_FALSE(c.insert(4, "four"));
-        EXPECT_EQ(c.getCacheSize(), 1);
-        EXPECT_EQ(c.getTrackSize(), 1);
-
-        {
-            // Keep a strong pointer to it
-            auto const p1 = c.fetch(4);
-            EXPECT_NE(p1, nullptr);
-            EXPECT_EQ(c.getCacheSize(), 1);
-            EXPECT_EQ(c.getTrackSize(), 1);
-            // Advance the clock a lot
-            ++clock;
-            c.sweep();
-            EXPECT_EQ(c.getCacheSize(), 0);
-            EXPECT_EQ(c.getTrackSize(), 1);
-            // Canonicalize a new object with the same key
-            auto p2 = std::make_shared<std::string>("four");
-            EXPECT_TRUE(c.canonicalizeReplaceClient(4, p2));
-            EXPECT_EQ(c.getCacheSize(), 1);
-            EXPECT_EQ(c.getTrackSize(), 1);
-            // Make sure we get the original object
-            EXPECT_EQ(p1.get(), p2.get());
-        }
-
-        ++clock;
-        c.sweep();
-        EXPECT_EQ(c.getCacheSize(), 0);
-        EXPECT_EQ(c.getTrackSize(), 0);
-    }
-
-    {
-        EXPECT_FALSE(c.insert(5, "five"));
-        EXPECT_EQ(c.getCacheSize(), 1);
-        EXPECT_EQ(c.size(), 1);
-
-        {
-            auto const p1 = c.fetch(5);
-            EXPECT_NE(p1, nullptr);
-            EXPECT_EQ(c.getCacheSize(), 1);
-            EXPECT_EQ(c.size(), 1);
-
-            // Advance the clock a lot
-            ++clock;
-            c.sweep();
-            EXPECT_EQ(c.getCacheSize(), 0);
-            EXPECT_EQ(c.size(), 1);
-
-            auto p2 = std::make_shared<std::string>("five_2");
-            EXPECT_TRUE(c.canonicalizeReplaceCache(5, p2));
-            EXPECT_EQ(c.getCacheSize(), 1);
-            EXPECT_EQ(c.size(), 1);
-            // Make sure the caller's original pointer is unchanged
-            EXPECT_NE(p1.get(), p2.get());
-            EXPECT_EQ(*p2, "five_2");
-
-            auto const p3 = c.fetch(5);
-            EXPECT_NE(p3, nullptr);
-            EXPECT_EQ(p3.get(), p2.get());
-            EXPECT_NE(p3.get(), p1.get());
-        }
-
-        ++clock;
-        c.sweep();
-        EXPECT_EQ(c.getCacheSize(), 0);
-        EXPECT_EQ(c.size(), 0);
-    }
-
-    {
-        struct MyRefCountObject : IntrusiveRefCounts
-        {
-            std::string data;
-
-            // Needed to support weak intrusive pointers
-            virtual void
-            partialDestructor()
-            {
-            }
-
-            MyRefCountObject() = default;
-            explicit MyRefCountObject(std::string data) : data(std::move(data))
-            {
-            }
-
-            bool
-            operator==(std::string const& other) const
-            {
-                return data == other;
-            }
-        };
-
-        using IntrPtrCache = TaggedCache<
-            Key,
-            MyRefCountObject,
-            /*IsKeyCache*/ false,
-            intr_ptr::SharedWeakUnionPtr<MyRefCountObject>,
-            intr_ptr::SharedPtr<MyRefCountObject>>;
-
-        IntrPtrCache intrPtrCache("IntrPtrTest", 1, 1s, clock, journal);
-
-        intrPtrCache.canonicalizeReplaceCache(1, intr_ptr::makeShared<MyRefCountObject>("one"));
-        EXPECT_EQ(intrPtrCache.getCacheSize(), 1);
-        EXPECT_EQ(intrPtrCache.size(), 1);
-
-        {
-            {
-                intrPtrCache.canonicalizeReplaceCache(
-                    1, intr_ptr::makeShared<MyRefCountObject>("one_replaced"));
-
-                auto p = intrPtrCache.fetch(1);
-                EXPECT_EQ(*p, "one_replaced");
-
-                // Advance the clock a lot
-                ++clock;
-                intrPtrCache.sweep();
-                EXPECT_EQ(intrPtrCache.getCacheSize(), 0);
-                EXPECT_EQ(intrPtrCache.size(), 1);
-
-                intrPtrCache.canonicalizeReplaceCache(
-                    1, intr_ptr::makeShared<MyRefCountObject>("one_replaced_2"));
-
-                auto p2 = intrPtrCache.fetch(1);
-                EXPECT_EQ(*p2, "one_replaced_2");
-
-                intrPtrCache.del(1, true);
-            }
-
-            intrPtrCache.canonicalizeReplaceCache(
-                1, intr_ptr::makeShared<MyRefCountObject>("one_replaced_3"));
-            auto p3 = intrPtrCache.fetch(1);
-            EXPECT_EQ(*p3, "one_replaced_3");
-        }
-
-        ++clock;
-        intrPtrCache.sweep();
-        EXPECT_EQ(intrPtrCache.getCacheSize(), 0);
-        EXPECT_EQ(intrPtrCache.size(), 0);
-    }
-}
-
-}  // namespace xrpl
diff --git a/src/tests/libxrpl/basics/Units.cpp b/src/tests/libxrpl/basics/Units.cpp
deleted file mode 100644
index 1cf7024fe0..0000000000
--- a/src/tests/libxrpl/basics/Units.cpp
+++ /dev/null
@@ -1,328 +0,0 @@
-#include <xrpl/protocol/Units.h>
-
-#include <xrpl/beast/utility/Zero.h>
-#include <xrpl/json/json_value.h>
-#include <xrpl/protocol/SystemParameters.h>
-#include <xrpl/protocol/XRPAmount.h>
-
-#include <gtest/gtest.h>
-
-#include <cstdint>
-#include <limits>
-#include <type_traits>
-
-namespace xrpl::test {
-
-TEST(UnitsTest, types)
-{
-    using FeeLevel32 = FeeLevel<std::uint32_t>;
-
-    {
-        XRPAmount const x{100};
-        EXPECT_EQ(x.drops(), 100);
-        EXPECT_TRUE((std::is_same_v<decltype(x)::unit_type, unit::dropTag>));
-        auto y = 4u * x;
-        EXPECT_EQ(y.value(), 400);
-        EXPECT_TRUE((std::is_same_v<decltype(y)::unit_type, unit::dropTag>));
-
-        auto z = 4 * y;
-        EXPECT_EQ(z.value(), 1600);
-        EXPECT_TRUE((std::is_same_v<decltype(z)::unit_type, unit::dropTag>));
-
-        FeeLevel32 const f{10};
-        FeeLevel32 const baseFee{100};
-
-        auto drops = mulDiv(baseFee, x, f);
-
-        EXPECT_TRUE(drops);
-        EXPECT_EQ(drops.value(), 1000);  // NOLINT(bugprone-unchecked-optional-access)
-        EXPECT_TRUE(
-            (std::is_same_v<std::remove_reference_t<decltype(*drops)>::unit_type, unit::dropTag>));
-
-        EXPECT_TRUE((std::is_same_v<std::remove_reference_t<decltype(*drops)>, XRPAmount>));
-    }
-    {
-        XRPAmount const x{100};
-        EXPECT_EQ(x.value(), 100);
-        EXPECT_TRUE((std::is_same_v<decltype(x)::unit_type, unit::dropTag>));
-        auto y = 4u * x;
-        EXPECT_EQ(y.value(), 400);
-        EXPECT_TRUE((std::is_same_v<decltype(y)::unit_type, unit::dropTag>));
-
-        FeeLevel64 const f{10};
-        FeeLevel64 const baseFee{100};
-
-        auto drops = mulDiv(baseFee, x, f);
-
-        EXPECT_TRUE(drops);
-        EXPECT_EQ(drops.value(), 1000);  // NOLINT(bugprone-unchecked-optional-access)
-        EXPECT_TRUE(
-            (std::is_same_v<std::remove_reference_t<decltype(*drops)>::unit_type, unit::dropTag>));
-        EXPECT_TRUE((std::is_same_v<std::remove_reference_t<decltype(*drops)>, XRPAmount>));
-    }
-    {
-        FeeLevel64 const x{1024};
-        EXPECT_EQ(x.value(), 1024);
-        EXPECT_TRUE((std::is_same_v<decltype(x)::unit_type, unit::feelevelTag>));
-        std::uint64_t const m = 4;
-        auto y = m * x;
-        EXPECT_EQ(y.value(), 4096);
-        EXPECT_TRUE((std::is_same_v<decltype(y)::unit_type, unit::feelevelTag>));
-
-        XRPAmount const basefee{10};
-        FeeLevel64 const referencefee{256};
-
-        auto drops = mulDiv(x, basefee, referencefee);
-
-        EXPECT_TRUE(drops);
-        EXPECT_EQ(drops.value(), 40);  // NOLINT(bugprone-unchecked-optional-access)
-        EXPECT_TRUE(
-            (std::is_same_v<std::remove_reference_t<decltype(*drops)>::unit_type, unit::dropTag>));
-        EXPECT_TRUE((std::is_same_v<std::remove_reference_t<decltype(*drops)>, XRPAmount>));
-    }
-}
-
-TEST(UnitsTest, json)
-{
-    // Json value functionality
-    using FeeLevel32 = FeeLevel<std::uint32_t>;
-
-    {
-        FeeLevel32 const x{std::numeric_limits<std::uint32_t>::max()};
-        auto y = x.jsonClipped();
-        EXPECT_EQ(y.type(), json::ValueType::UInt);
-        EXPECT_EQ(y, json::Value{x.fee()});
-    }
-
-    {
-        FeeLevel32 const x{std::numeric_limits<std::uint32_t>::min()};
-        auto y = x.jsonClipped();
-        EXPECT_EQ(y.type(), json::ValueType::UInt);
-        EXPECT_EQ(y, json::Value{x.fee()});
-    }
-
-    {
-        FeeLevel64 const x{std::numeric_limits<std::uint64_t>::max()};
-        auto y = x.jsonClipped();
-        EXPECT_EQ(y.type(), json::ValueType::UInt);
-        EXPECT_EQ(y, json::Value{std::numeric_limits<std::uint32_t>::max()});
-    }
-
-    {
-        FeeLevel64 const x{std::numeric_limits<std::uint64_t>::min()};
-        auto y = x.jsonClipped();
-        EXPECT_EQ(y.type(), json::ValueType::UInt);
-        EXPECT_EQ(y, json::Value{0});
-    }
-
-    {
-        FeeLevelDouble const x{std::numeric_limits<double>::max()};
-        auto y = x.jsonClipped();
-        EXPECT_EQ(y.type(), json::ValueType::Real);
-        EXPECT_EQ(y, json::Value{std::numeric_limits<double>::max()});
-    }
-
-    {
-        FeeLevelDouble const x{std::numeric_limits<double>::min()};
-        auto y = x.jsonClipped();
-        EXPECT_EQ(y.type(), json::ValueType::Real);
-        EXPECT_EQ(y, json::Value{std::numeric_limits<double>::min()});
-    }
-
-    {
-        XRPAmount const x{std::numeric_limits<std::int64_t>::max()};
-        auto y = x.jsonClipped();
-        EXPECT_EQ(y.type(), json::ValueType::Int);
-        EXPECT_EQ(y, json::Value{std::numeric_limits<std::int32_t>::max()});
-    }
-
-    {
-        XRPAmount const x{std::numeric_limits<std::int64_t>::min()};
-        auto y = x.jsonClipped();
-        EXPECT_EQ(y.type(), json::ValueType::Int);
-        EXPECT_EQ(y, json::Value{std::numeric_limits<std::int32_t>::min()});
-    }
-}
-
-TEST(UnitsTest, functions)
-{
-    // Explicitly test every defined function for the ValueUnit class
-    // since some of them are templated, but not used anywhere else.
-    using FeeLevel32 = FeeLevel<std::uint32_t>;
-
-    {
-        auto make = [&](auto x) -> FeeLevel64 { return x; };
-        auto explicitmake = [&](auto x) -> FeeLevel64 { return FeeLevel64{x}; };
-
-        [[maybe_unused]]
-        FeeLevel64 const defaulted{};
-        FeeLevel64 test{0};
-        EXPECT_EQ(test.fee(), 0);
-
-        test = explicitmake(beast::kZero);
-        EXPECT_EQ(test.fee(), 0);
-
-        test = beast::kZero;
-        EXPECT_EQ(test.fee(), 0);
-
-        test = explicitmake(100u);
-        EXPECT_EQ(test.fee(), 100);
-
-        FeeLevel64 const targetSame{200u};
-        FeeLevel32 const targetOther{300u};
-        test = make(targetSame);
-        EXPECT_EQ(test.fee(), 200);
-        EXPECT_EQ(test, targetSame);
-        EXPECT_TRUE(test < FeeLevel64{1000});
-        EXPECT_TRUE(test > FeeLevel64{100});
-        test = make(targetOther);
-        EXPECT_EQ(test.fee(), 300);
-        EXPECT_EQ(test, targetOther);
-
-        test = std::uint64_t(200);
-        EXPECT_EQ(test.fee(), 200);
-        test = std::uint32_t(300);
-        EXPECT_EQ(test.fee(), 300);
-
-        test = targetSame;
-        EXPECT_EQ(test.fee(), 200);
-        test = targetOther.fee();
-        EXPECT_EQ(test.fee(), 300);
-        EXPECT_EQ(test, targetOther);
-
-        test = targetSame * 2;
-        EXPECT_EQ(test.fee(), 400);
-        test = 3 * targetSame;
-        EXPECT_EQ(test.fee(), 600);
-        test = targetSame / 10;
-        EXPECT_EQ(test.fee(), 20);
-
-        test += targetSame;
-        EXPECT_EQ(test.fee(), 220);
-
-        test -= targetSame;
-        EXPECT_EQ(test.fee(), 20);
-
-        test++;
-        EXPECT_EQ(test.fee(), 21);
-        ++test;
-        EXPECT_EQ(test.fee(), 22);
-        test--;
-        EXPECT_EQ(test.fee(), 21);
-        --test;
-        EXPECT_EQ(test.fee(), 20);
-
-        test *= 5;
-        EXPECT_EQ(test.fee(), 100);
-        test /= 2;
-        EXPECT_EQ(test.fee(), 50);
-        test %= 13;
-        EXPECT_EQ(test.fee(), 11);
-
-        /*
-        // illegal with unsigned
-        test = -test;
-        EXPECT_EQ(test.fee(), -11);
-        EXPECT_EQ(test.signum(), -1);
-        EXPECT_EQ(to_string(test), "-11");
-        */
-
-        EXPECT_TRUE(test);
-        test = 0;
-        EXPECT_FALSE(test);
-        EXPECT_EQ(test.signum(), 0);
-        test = targetSame;
-        EXPECT_EQ(test.signum(), 1);
-        EXPECT_EQ(to_string(test), "200");
-    }
-    {
-        auto make = [&](auto x) -> FeeLevelDouble { return x; };
-        auto explicitmake = [&](auto x) -> FeeLevelDouble { return FeeLevelDouble{x}; };
-
-        [[maybe_unused]]
-        FeeLevelDouble const defaulted{};
-        FeeLevelDouble test{0};
-        EXPECT_EQ(test.fee(), 0);
-
-        test = explicitmake(beast::kZero);
-        EXPECT_EQ(test.fee(), 0);
-
-        test = beast::kZero;
-        EXPECT_EQ(test.fee(), 0);
-
-        test = explicitmake(100.0);
-        EXPECT_EQ(test.fee(), 100);
-
-        FeeLevelDouble const targetSame{200.0};
-        FeeLevel64 const targetOther{300};
-        test = make(targetSame);
-        EXPECT_EQ(test.fee(), 200);
-        EXPECT_EQ(test, targetSame);
-        EXPECT_TRUE(test < FeeLevelDouble{1000.0});
-        EXPECT_TRUE(test > FeeLevelDouble{100.0});
-        test = targetOther.fee();
-        EXPECT_EQ(test.fee(), 300);
-        EXPECT_EQ(test, targetOther);
-
-        test = 200.0;
-        EXPECT_EQ(test.fee(), 200);
-        test = std::uint64_t(300);
-        EXPECT_EQ(test.fee(), 300);
-
-        test = targetSame;
-        EXPECT_EQ(test.fee(), 200);
-
-        test = targetSame * 2;
-        EXPECT_EQ(test.fee(), 400);
-        test = 3 * targetSame;
-        EXPECT_EQ(test.fee(), 600);
-        test = targetSame / 10;
-        EXPECT_EQ(test.fee(), 20);
-
-        test += targetSame;
-        EXPECT_EQ(test.fee(), 220);
-
-        test -= targetSame;
-        EXPECT_EQ(test.fee(), 20);
-
-        test++;
-        EXPECT_EQ(test.fee(), 21);
-        ++test;
-        EXPECT_EQ(test.fee(), 22);
-        test--;
-        EXPECT_EQ(test.fee(), 21);
-        --test;
-        EXPECT_EQ(test.fee(), 20);
-
-        test *= 5;
-        EXPECT_EQ(test.fee(), 100);
-        test /= 2;
-        EXPECT_EQ(test.fee(), 50);
-        /* illegal with floating
-        test %= 13;
-        EXPECT_EQ(test.fee(), 11);
-        */
-
-        // legal with signed
-        test = -test;
-        EXPECT_EQ(test.fee(), -50);
-        EXPECT_EQ(test.signum(), -1);
-        EXPECT_EQ(to_string(test), "-50.000000");
-
-        EXPECT_TRUE(test);
-        test = 0;
-        EXPECT_FALSE(test);
-        EXPECT_EQ(test.signum(), 0);
-        test = targetSame;
-        EXPECT_EQ(test.signum(), 1);
-        EXPECT_EQ(to_string(test), "200.000000");
-    }
-}
-
-TEST(UnitsTest, initial_xrp)
-{
-    EXPECT_EQ(kInitialXrp.drops(), 100'000'000'000'000'000);
-    EXPECT_EQ(kInitialXrp, XRPAmount{100'000'000'000'000'000});
-}
-
-}  // namespace xrpl::test
diff --git a/src/tests/libxrpl/basics/XRPAmount.cpp b/src/tests/libxrpl/basics/XRPAmount.cpp
deleted file mode 100644
index 243afbd1a0..0000000000
--- a/src/tests/libxrpl/basics/XRPAmount.cpp
+++ /dev/null
@@ -1,295 +0,0 @@
-#include <xrpl/protocol/XRPAmount.h>
-
-#include <xrpl/beast/utility/Zero.h>
-
-#include <gtest/gtest.h>
-
-#include <cstdint>
-#include <limits>
-
-namespace xrpl {
-
-TEST(XRPAmountTest, sig_num)
-{
-    for (auto i : {-1, 0, 1})
-    {
-        XRPAmount const x(i);
-
-        if (i < 0)
-        {
-            EXPECT_TRUE(x.signum() < 0);
-        }
-        else if (i > 0)
-        {
-            EXPECT_TRUE(x.signum() > 0);
-        }
-        else
-        {
-            EXPECT_EQ(x.signum(), 0);
-        }
-    }
-}
-
-TEST(XRPAmountTest, beast_zero)
-{
-    using beast::kZero;
-
-    for (auto i : {-1, 0, 1})
-    {
-        XRPAmount const x(i);
-
-        EXPECT_TRUE((i == 0) == (x == kZero));
-        EXPECT_TRUE((i != 0) == (x != kZero));
-        EXPECT_TRUE((i < 0) == (x < kZero));
-        EXPECT_TRUE((i > 0) == (x > kZero));
-        EXPECT_TRUE((i <= 0) == (x <= kZero));
-        EXPECT_TRUE((i >= 0) == (x >= kZero));
-
-        EXPECT_TRUE((0 == i) == (kZero == x));
-        EXPECT_TRUE((0 != i) == (kZero != x));
-        EXPECT_TRUE((0 < i) == (kZero < x));
-        EXPECT_TRUE((0 > i) == (kZero > x));
-        EXPECT_TRUE((0 <= i) == (kZero <= x));
-        EXPECT_TRUE((0 >= i) == (kZero >= x));
-    }
-}
-
-TEST(XRPAmountTest, comparisons)
-{
-    for (auto i : {-1, 0, 1})
-    {
-        XRPAmount const x(i);
-
-        for (auto j : {-1, 0, 1})
-        {
-            XRPAmount const y(j);
-
-            EXPECT_EQ((i == j), (x == y));
-            EXPECT_EQ((i != j), (x != y));
-            EXPECT_EQ((i < j), (x < y));
-            EXPECT_EQ((i > j), (x > y));
-            EXPECT_EQ((i <= j), (x <= y));
-            EXPECT_EQ((i >= j), (x >= y));
-        }
-    }
-}
-
-TEST(XRPAmountTest, add_sub)
-{
-    for (auto i : {-1, 0, 1})
-    {
-        XRPAmount const x(i);
-
-        for (auto j : {-1, 0, 1})
-        {
-            XRPAmount const y(j);
-
-            EXPECT_EQ(XRPAmount(i + j), (x + y));
-            EXPECT_EQ(XRPAmount(i - j), (x - y));
-
-            EXPECT_EQ((x + y), (y + x));  // addition is commutative
-        }
-    }
-}
-
-TEST(XRPAmountTest, decimal)
-{
-    // Tautology
-    EXPECT_EQ(kDropsPerXrp.decimalXRP(), 1);
-
-    XRPAmount test{1};
-    EXPECT_EQ(test.decimalXRP(), 0.000001);
-
-    test = -test;
-    EXPECT_EQ(test.decimalXRP(), -0.000001);
-
-    test = 100'000'000;
-    EXPECT_EQ(test.decimalXRP(), 100);
-
-    test = -test;
-    EXPECT_EQ(test.decimalXRP(), -100);
-}
-
-TEST(XRPAmountTest, functions)
-{
-    // Explicitly test every defined function for the XRPAmount class
-    // since some of them are templated, but not used anywhere else.
-    auto make = [&](auto x) -> XRPAmount { return XRPAmount{x}; };
-
-    XRPAmount const defaulted{};
-    (void)defaulted;
-    XRPAmount test{0};
-    EXPECT_EQ(test.drops(), 0);
-
-    test = make(beast::kZero);
-    EXPECT_EQ(test.drops(), 0);
-
-    test = beast::kZero;
-    EXPECT_EQ(test.drops(), 0);
-
-    test = make(100);
-    EXPECT_EQ(test.drops(), 100);
-
-    test = make(100u);
-    EXPECT_EQ(test.drops(), 100);
-
-    XRPAmount const targetSame{200u};
-    test = make(targetSame);
-    EXPECT_EQ(test.drops(), 200);
-    EXPECT_EQ(test, targetSame);
-    EXPECT_TRUE(test < XRPAmount{1000});
-    EXPECT_TRUE(test > XRPAmount{100});
-
-    test = std::int64_t(200);
-    EXPECT_EQ(test.drops(), 200);
-    test = std::uint32_t(300);
-    EXPECT_EQ(test.drops(), 300);
-
-    test = targetSame;
-    EXPECT_EQ(test.drops(), 200);
-    auto testOther = test.dropsAs<std::uint32_t>();
-    EXPECT_TRUE(testOther);
-    EXPECT_EQ(*testOther, 200);  // NOLINT(bugprone-unchecked-optional-access)
-    test = std::numeric_limits<std::uint64_t>::max();
-    testOther = test.dropsAs<std::uint32_t>();
-    EXPECT_FALSE(testOther);
-    test = -1;
-    testOther = test.dropsAs<std::uint32_t>();
-    EXPECT_FALSE(testOther);
-
-    test = targetSame * 2;
-    EXPECT_EQ(test.drops(), 400);
-    test = 3 * targetSame;
-    EXPECT_EQ(test.drops(), 600);
-    test = 20;
-    EXPECT_EQ(test.drops(), 20);
-
-    test += targetSame;
-    EXPECT_EQ(test.drops(), 220);
-
-    test -= targetSame;
-    EXPECT_EQ(test.drops(), 20);
-
-    test *= 5;
-    EXPECT_EQ(test.drops(), 100);
-    test = 50;
-    EXPECT_EQ(test.drops(), 50);
-    test -= 39;
-    EXPECT_EQ(test.drops(), 11);
-
-    // legal with signed
-    test = -test;
-    EXPECT_EQ(test.drops(), -11);
-    EXPECT_EQ(test.signum(), -1);
-    EXPECT_EQ(to_string(test), "-11");
-
-    EXPECT_TRUE(test);
-    test = 0;
-    EXPECT_FALSE(test);
-    EXPECT_EQ(test.signum(), 0);
-    test = targetSame;
-    EXPECT_EQ(test.signum(), 1);
-    EXPECT_EQ(to_string(test), "200");
-}
-
-TEST(XRPAmountTest, mul_ratio)
-{
-    constexpr auto kMaxUInt32 = std::numeric_limits<std::uint32_t>::max();
-    constexpr auto kMaxXrp = std::numeric_limits<XRPAmount::value_type>::max();
-    constexpr auto kMinXrp = std::numeric_limits<XRPAmount::value_type>::min();
-
-    {
-        // multiply by a number that would overflow then divide by the same
-        // number, and check we didn't lose any value
-        XRPAmount big(kMaxXrp);
-        EXPECT_EQ(big, mulRatio(big, kMaxUInt32, kMaxUInt32, true));
-        // rounding mode shouldn't matter as the result is exact
-        EXPECT_EQ(big, mulRatio(big, kMaxUInt32, kMaxUInt32, false));
-
-        // multiply and divide by values that would overflow if done
-        // naively, and check that it gives the correct answer
-        big -= 0xf;  // Subtract a little so it's divisible by 4
-        EXPECT_EQ(mulRatio(big, 3, 4, false).value(), (big.value() / 4) * 3);
-        EXPECT_EQ(mulRatio(big, 3, 4, true).value(), (big.value() / 4) * 3);
-        EXPECT_EQ(big.value() % 4, 0);
-        EXPECT_GT(big.value(), kMaxXrp / 3);
-        EXPECT_LE(big.value() / 4, kMaxXrp / 3);
-    }
-
-    {
-        // Similar test as above, but for negative values
-        XRPAmount big(kMinXrp);  // NOLINT TODO
-        EXPECT_EQ(big, mulRatio(big, kMaxUInt32, kMaxUInt32, true));
-        // rounding mode shouldn't matter as the result is exact
-        EXPECT_EQ(big, mulRatio(big, kMaxUInt32, kMaxUInt32, false));
-
-        // multiply and divide by values that would overflow if done
-        // naively, and check that it gives the correct answer
-        EXPECT_EQ(mulRatio(big, 3, 4, false).value(), (big.value() / 4) * 3);
-        EXPECT_EQ(mulRatio(big, 3, 4, true).value(), (big.value() / 4) * 3);
-        EXPECT_EQ(big.value() % 4, 0);
-        EXPECT_LT(big.value(), kMinXrp / 3);
-        EXPECT_GE(big.value() / 4, kMinXrp / 3);
-    }
-
-    {
-        // small amounts
-        XRPAmount const tiny(1);
-        // Round up should give the smallest allowable number
-        EXPECT_EQ(tiny, mulRatio(tiny, 1, kMaxUInt32, true));
-        // rounding down should be zero
-        EXPECT_EQ(beast::kZero, mulRatio(tiny, 1, kMaxUInt32, false));
-        EXPECT_EQ(beast::kZero, mulRatio(tiny, kMaxUInt32 - 1, kMaxUInt32, false));
-
-        // tiny negative numbers
-        XRPAmount const tinyNeg(-1);
-        // Round up should give zero
-        EXPECT_EQ(beast::kZero, mulRatio(tinyNeg, 1, kMaxUInt32, true));
-        EXPECT_EQ(beast::kZero, mulRatio(tinyNeg, kMaxUInt32 - 1, kMaxUInt32, true));
-        // rounding down should be tiny
-        EXPECT_EQ(tinyNeg, mulRatio(tinyNeg, kMaxUInt32 - 1, kMaxUInt32, false));
-    }
-
-    {  // rounding
-        {
-            XRPAmount const one(1);
-            auto const rup = mulRatio(one, kMaxUInt32 - 1, kMaxUInt32, true);
-            auto const rdown = mulRatio(one, kMaxUInt32 - 1, kMaxUInt32, false);
-            EXPECT_EQ(rup.drops() - rdown.drops(), 1);
-        }
-
-        {
-            XRPAmount const big(kMaxXrp);
-            auto const rup = mulRatio(big, kMaxUInt32 - 1, kMaxUInt32, true);
-            auto const rdown = mulRatio(big, kMaxUInt32 - 1, kMaxUInt32, false);
-            EXPECT_EQ(rup.drops() - rdown.drops(), 1);
-        }
-
-        {
-            XRPAmount const negOne(-1);
-            auto const rup = mulRatio(negOne, kMaxUInt32 - 1, kMaxUInt32, true);
-            auto const rdown = mulRatio(negOne, kMaxUInt32 - 1, kMaxUInt32, false);
-            EXPECT_EQ(rup.drops() - rdown.drops(), 1);
-        }
-    }
-
-    {
-        // division by zero
-        XRPAmount const one(1);
-        EXPECT_ANY_THROW({ mulRatio(one, 1, 0, true); });
-    }
-
-    {
-        // overflow
-        XRPAmount const big(kMaxXrp);
-        EXPECT_ANY_THROW({ mulRatio(big, 2, 1, true); });
-    }
-
-    {
-        // underflow
-        XRPAmount const bigNegative(kMinXrp + 10);
-        EXPECT_EQ(mulRatio(bigNegative, 2, 1, true), kMinXrp);
-    }
-}
-
-}  // namespace xrpl
diff --git a/src/tests/libxrpl/basics/base58.cpp b/src/tests/libxrpl/basics/base58.cpp
deleted file mode 100644
index d452453f76..0000000000
--- a/src/tests/libxrpl/basics/base58.cpp
+++ /dev/null
@@ -1,438 +0,0 @@
-#include <xrpl/protocol/detail/token_errors.h>
-
-#include <boost/multiprecision/cpp_int.hpp>  // IWYU pragma: keep
-
-#include <gtest/gtest.h>
-
-#include <algorithm>
-#include <cassert>
-#include <cstdint>
-#include <cstring>
-#include <iomanip>
-#include <iostream>
-#include <limits>
-#include <ranges>
-#include <stdexcept>
-#include <string>
-#include <tuple>
-#include <vector>
-#ifndef _MSC_VER
-
-#include <xrpl/protocol/detail/b58_utils.h>
-#include <xrpl/protocol/tokens.h>
-
-#include <array>
-#include <cstddef>
-#include <random>
-#include <span>
-#include <sstream>
-
-namespace xrpl::test {
-namespace {
-
-[[nodiscard]] inline auto
-randEngine() -> std::mt19937&
-{
-    static std::mt19937 kR = [] {
-        std::random_device rd;
-        return std::mt19937{rd()};
-    }();
-    return kR;
-}
-
-constexpr int kNumTokenTypeIndexes = 9;
-
-[[nodiscard]] inline auto
-tokenTypeAndSize(int i) -> std::tuple<xrpl::TokenType, std::size_t>
-{
-    assert(i < kNumTokenTypeIndexes);
-
-    switch (i)
-    {
-        using enum xrpl::TokenType;
-        case 0:
-            return {None, 20};
-        case 1:
-            return {NodePublic, 32};
-        case 2:
-            return {NodePublic, 33};
-        case 3:
-            return {NodePrivate, 32};
-        case 4:
-            return {AccountID, 20};
-        case 5:
-            return {AccountPublic, 32};
-        case 6:
-            return {AccountPublic, 33};
-        case 7:
-            return {AccountSecret, 32};
-        case 8:
-            return {FamilySeed, 16};
-        default:
-            throw std::invalid_argument(
-                "Invalid token selection passed to tokenTypeAndSize() "
-                "in " __FILE__);
-    }
-}
-
-[[nodiscard]] inline auto
-randomTokenTypeAndSize() -> std::tuple<xrpl::TokenType, std::size_t>
-{
-    using namespace xrpl;
-    auto& rng = randEngine();
-    std::uniform_int_distribution<> d(0, 8);
-    return tokenTypeAndSize(d(rng));
-}
-
-// Return the token type and subspan of `d` to use as test data.
-[[nodiscard]] inline auto
-randomB256TestData(std::span<std::uint8_t> d)
-    -> std::tuple<xrpl::TokenType, std::span<std::uint8_t>>
-{
-    auto& rng = randEngine();
-    std::uniform_int_distribution<std::uint8_t> dist(0, 255);
-    auto [tokType, tokSize] = randomTokenTypeAndSize();
-    std::generate(d.begin(), d.begin() + tokSize, [&] { return dist(rng); });
-    return {tokType, d.subspan(0, tokSize)};
-}
-
-inline void
-printAsChar(std::span<std::uint8_t> a, std::span<std::uint8_t> b)
-{
-    auto asString = [](std::span<std::uint8_t> s) {
-        std::string r;
-        r.resize(s.size());
-        std::ranges::copy(s, r.begin());
-        return r;
-    };
-    auto sa = asString(a);
-    auto sb = asString(b);
-    std::cerr << "\n\n" << sa << "\n" << sb << "\n";
-}
-
-inline void
-printAsInt(std::span<std::uint8_t> a, std::span<std::uint8_t> b)
-{
-    auto asString = [](std::span<std::uint8_t> s) -> std::string {
-        std::stringstream sstr;
-        for (auto i : s)
-        {
-            sstr << std::setw(3) << int(i) << ',';
-        }
-        return sstr.str();
-    };
-    auto sa = asString(a);
-    auto sb = asString(b);
-    std::cerr << "\n\n" << sa << "\n" << sb << "\n";
-}
-
-}  // namespace
-
-namespace multiprecision_utils {
-
-boost::multiprecision::checked_uint512_t
-toBoostMP(std::span<std::uint64_t> in)
-{
-    boost::multiprecision::checked_uint512_t mbp = 0;
-    for (auto const& i : std::views::reverse(in))
-    {
-        mbp <<= 64;
-        mbp += i;
-    }
-    return mbp;
-}
-
-std::vector<std::uint64_t>
-randomBigInt(std::uint8_t minSize = 1, std::uint8_t maxSize = 5)
-{
-    auto eng = randEngine();
-    std::uniform_int_distribution<std::uint8_t> numCoeffDist(minSize, maxSize);
-    std::uniform_int_distribution<std::uint64_t> dist;
-    auto const numCoeff = numCoeffDist(eng);
-    std::vector<std::uint64_t> coeffs;
-    coeffs.reserve(numCoeff);
-    for (int i = 0; i < numCoeff; ++i)
-    {
-        coeffs.push_back(dist(eng));
-    }
-    return coeffs;
-}
-}  // namespace multiprecision_utils
-
-TEST(Base58Test, multiprecision)
-{
-    using namespace boost::multiprecision;
-
-    constexpr std::size_t kIters = 100000;
-    auto eng = randEngine();
-    std::uniform_int_distribution<std::uint64_t> dist;
-    std::uniform_int_distribution<std::uint64_t> dist1(1);
-    for (int i = 0; i < kIters; ++i)
-    {
-        std::uint64_t const d = dist(eng);
-        if (d == 0u)
-            continue;
-        auto bigInt = multiprecision_utils::randomBigInt();
-        auto const boostBigInt =
-            multiprecision_utils::toBoostMP(std::span<std::uint64_t>(bigInt.data(), bigInt.size()));
-
-        auto const refDiv = boostBigInt / d;
-        auto const refMod = boostBigInt % d;
-
-        auto const mod = b58_fast::detail::inplaceBigintDivRem(
-            std::span<uint64_t>(bigInt.data(), bigInt.size()), d);
-        auto const foundDiv = multiprecision_utils::toBoostMP(bigInt);
-        EXPECT_EQ(refMod.convert_to<std::uint64_t>(), mod);
-        EXPECT_EQ(foundDiv, refDiv);
-    }
-    for (int i = 0; i < kIters; ++i)
-    {
-        std::uint64_t const d = dist(eng);
-        auto bigInt = multiprecision_utils::randomBigInt(/*minSize*/ 2);
-        if (bigInt[bigInt.size() - 1] == std::numeric_limits<std::uint64_t>::max())
-        {
-            bigInt[bigInt.size() - 1] -= 1;  // Prevent overflow
-        }
-        auto const boostBigInt =
-            multiprecision_utils::toBoostMP(std::span<std::uint64_t>(bigInt.data(), bigInt.size()));
-
-        auto const refAdd = boostBigInt + d;
-
-        auto const result = b58_fast::detail::inplaceBigintAdd(
-            std::span<uint64_t>(bigInt.data(), bigInt.size()), d);
-        EXPECT_EQ(result, TokenCodecErrc::Success);
-        auto const foundAdd = multiprecision_utils::toBoostMP(bigInt);
-        EXPECT_EQ(refAdd, foundAdd);
-    }
-    for (int i = 0; i < kIters; ++i)
-    {
-        std::uint64_t const d = dist1(eng);
-        // Force overflow
-        std::vector<std::uint64_t> bigInt(5, std::numeric_limits<std::uint64_t>::max());
-
-        auto const boostBigInt =
-            multiprecision_utils::toBoostMP(std::span<std::uint64_t>(bigInt.data(), bigInt.size()));
-
-        auto const refAdd = boostBigInt + d;
-
-        auto const result = b58_fast::detail::inplaceBigintAdd(
-            std::span<uint64_t>(bigInt.data(), bigInt.size()), d);
-        EXPECT_EQ(result, TokenCodecErrc::OverflowAdd);
-        auto const foundAdd = multiprecision_utils::toBoostMP(bigInt);
-        EXPECT_NE(refAdd, foundAdd);
-    }
-    for (int i = 0; i < kIters; ++i)
-    {
-        std::uint64_t const d = dist(eng);
-        auto bigInt = multiprecision_utils::randomBigInt(/* minSize */ 2);
-        // inplace mul requires the most significant coeff to be zero to
-        // hold the result.
-        bigInt[bigInt.size() - 1] = 0;
-        auto const boostBigInt =
-            multiprecision_utils::toBoostMP(std::span<std::uint64_t>(bigInt.data(), bigInt.size()));
-
-        auto const refMul = boostBigInt * d;
-
-        auto const result = b58_fast::detail::inplaceBigintMul(
-            std::span<uint64_t>(bigInt.data(), bigInt.size()), d);
-        EXPECT_EQ(result, TokenCodecErrc::Success);
-        auto const foundMul = multiprecision_utils::toBoostMP(bigInt);
-        EXPECT_EQ(refMul, foundMul);
-    }
-    for (int i = 0; i < kIters; ++i)
-    {
-        std::uint64_t const d = dist1(eng);
-        // Force overflow
-        std::vector<std::uint64_t> bigInt(5, std::numeric_limits<std::uint64_t>::max());
-        auto const boostBigInt =
-            multiprecision_utils::toBoostMP(std::span<std::uint64_t>(bigInt.data(), bigInt.size()));
-
-        auto const refMul = boostBigInt * d;
-
-        auto const result = b58_fast::detail::inplaceBigintMul(
-            std::span<uint64_t>(bigInt.data(), bigInt.size()), d);
-        EXPECT_EQ(result, TokenCodecErrc::InputTooLarge);
-        auto const foundMul = multiprecision_utils::toBoostMP(bigInt);
-        EXPECT_NE(refMul, foundMul);
-    }
-}
-
-TEST(Base58Test, fast_matches_ref)
-{
-    auto testRawEncode = [&](std::span<std::uint8_t> const& b256Data) {
-        std::array<std::uint8_t, 64> b58ResultBuf[2];
-        std::array<std::span<std::uint8_t>, 2> b58Result;
-
-        std::array<std::uint8_t, 64> b256ResultBuf[2];
-        std::array<std::span<std::uint8_t>, 2> b256Result;
-        for (int i = 0; i < 2; ++i)
-        {
-            std::span const outBuf{b58ResultBuf[i]};
-            if (i == 0)
-            {
-                auto const r = xrpl::b58_fast::detail::b256ToB58Be(b256Data, outBuf);
-                EXPECT_TRUE(r);
-                b58Result[i] = r.value();
-            }
-            else
-            {
-                std::array<std::uint8_t, 128> tmpBuf{};
-                std::string const s = xrpl::b58_ref::detail::encodeBase58(
-                    b256Data.data(), b256Data.size(), tmpBuf.data(), tmpBuf.size());
-                EXPECT_TRUE(s.size());
-                b58Result[i] = outBuf.subspan(0, s.size());
-                std::ranges::copy(s, b58Result[i].begin());
-            }
-        }
-        auto const rawB58SameSize = b58Result[0].size() == b58Result[1].size();
-        EXPECT_TRUE(rawB58SameSize);
-        if (rawB58SameSize)
-        {
-            auto const rawB58SameData =
-                memcmp(b58Result[0].data(), b58Result[1].data(), b58Result[0].size()) == 0;
-            EXPECT_TRUE(rawB58SameData);
-            if (!rawB58SameData)
-            {
-                printAsChar(b58Result[0], b58Result[1]);
-            }
-        }
-
-        for (int i = 0; i < 2; ++i)
-        {
-            std::span const outBuf{b256ResultBuf[i].data(), b256ResultBuf[i].size()};
-            if (i == 0)
-            {
-                std::string const in(
-                    b58Result[i].data(), b58Result[i].data() + b58Result[i].size());
-                auto const r = xrpl::b58_fast::detail::b58ToB256Be(in, outBuf);
-                EXPECT_TRUE(r);
-                b256Result[i] = r.value();
-            }
-            else
-            {
-                std::string const st(b58Result[i].begin(), b58Result[i].end());
-                std::string const s = xrpl::b58_ref::detail::decodeBase58(st);
-                EXPECT_TRUE(s.size());
-                b256Result[i] = outBuf.subspan(0, s.size());
-                std::ranges::copy(s, b256Result[i].begin());
-            }
-        }
-
-        auto const rawB256SameSize = b256Result[0].size() == b256Result[1].size();
-        EXPECT_TRUE(rawB256SameSize);
-        if (rawB256SameSize)
-        {
-            auto const rawB256SameData =
-                memcmp(b256Result[0].data(), b256Result[1].data(), b256Result[0].size()) == 0;
-            EXPECT_TRUE(rawB256SameData);
-            if (!rawB256SameData)
-            {
-                printAsInt(b256Result[0], b256Result[1]);
-            }
-        }
-    };
-
-    auto testTokenEncode = [&](xrpl::TokenType const tokType,
-                               std::span<std::uint8_t> const& b256Data) {
-        std::array<std::uint8_t, 64> b58ResultBuf[2];
-        std::array<std::span<std::uint8_t>, 2> b58Result;
-
-        std::array<std::uint8_t, 64> b256ResultBuf[2];
-        std::array<std::span<std::uint8_t>, 2> b256Result;
-        for (int i = 0; i < 2; ++i)
-        {
-            std::span const outBuf{b58ResultBuf[i].data(), b58ResultBuf[i].size()};
-            if (i == 0)
-            {
-                auto const r = xrpl::b58_fast::encodeBase58Token(tokType, b256Data, outBuf);
-                EXPECT_TRUE(r);
-                b58Result[i] = r.value();
-            }
-            else
-            {
-                std::string const s =
-                    xrpl::b58_ref::encodeBase58Token(tokType, b256Data.data(), b256Data.size());
-                EXPECT_TRUE(s.size());
-                b58Result[i] = outBuf.subspan(0, s.size());
-                std::ranges::copy(s, b58Result[i].begin());
-            }
-        }
-        auto const tokenB58SameSize = b58Result[0].size() == b58Result[1].size();
-        EXPECT_TRUE(tokenB58SameSize);
-        if (tokenB58SameSize)
-        {
-            auto const tokenB58SameData =
-                memcmp(b58Result[0].data(), b58Result[1].data(), b58Result[0].size()) == 0;
-            EXPECT_TRUE(tokenB58SameData);
-            if (!tokenB58SameData)
-            {
-                printAsChar(b58Result[0], b58Result[1]);
-            }
-        }
-
-        for (int i = 0; i < 2; ++i)
-        {
-            std::span const outBuf{b256ResultBuf[i].data(), b256ResultBuf[i].size()};
-            if (i == 0)
-            {
-                std::string const in(
-                    b58Result[i].data(), b58Result[i].data() + b58Result[i].size());
-                auto const r = xrpl::b58_fast::decodeBase58Token(tokType, in, outBuf);
-                EXPECT_TRUE(r);
-                b256Result[i] = r.value();
-            }
-            else
-            {
-                std::string const st(b58Result[i].begin(), b58Result[i].end());
-                std::string const s = xrpl::b58_ref::decodeBase58Token(st, tokType);
-                EXPECT_TRUE(s.size());
-                b256Result[i] = outBuf.subspan(0, s.size());
-                std::ranges::copy(s, b256Result[i].begin());
-            }
-        }
-
-        auto const tokenB256SameSize = b256Result[0].size() == b256Result[1].size();
-        EXPECT_TRUE(tokenB256SameSize);
-        if (tokenB256SameSize)
-        {
-            auto const tokenB256SameData =
-                memcmp(b256Result[0].data(), b256Result[1].data(), b256Result[0].size()) == 0;
-            EXPECT_TRUE(tokenB256SameData);
-            if (!tokenB256SameData)
-            {
-                printAsInt(b256Result[0], b256Result[1]);
-            }
-        }
-    };
-
-    auto testIt = [&](xrpl::TokenType const tokType, std::span<std::uint8_t> const& b256Data) {
-        testRawEncode(b256Data);
-        testTokenEncode(tokType, b256Data);
-    };
-
-    // test every token type with data where every byte is the same and the
-    // bytes range from 0-255
-    for (int i = 0; i < kNumTokenTypeIndexes; ++i)
-    {
-        std::array<std::uint8_t, 128> b256DataBuf{};
-        auto const [tokType, tokSize] = tokenTypeAndSize(i);
-        for (int d = 0; d <= 255; ++d)
-        {
-            memset(b256DataBuf.data(), d, tokSize);
-            testIt(tokType, std::span(b256DataBuf.data(), tokSize));
-        }
-    }
-
-    // test with random data
-    constexpr std::size_t kIters = 100000;
-    for (int i = 0; i < kIters; ++i)
-    {
-        std::array<std::uint8_t, 128> b256DataBuf{};
-        auto const [tokType, b256Data] = randomB256TestData(b256DataBuf);
-        testIt(tokType, b256Data);
-    }
-}
-
-}  // namespace xrpl::test
-
-#endif  // _MSC_VER
diff --git a/src/tests/libxrpl/basics/base_uint_test.cpp b/src/tests/libxrpl/basics/base_uint_test.cpp
deleted file mode 100644
index 365b43930c..0000000000
--- a/src/tests/libxrpl/basics/base_uint_test.cpp
+++ /dev/null
@@ -1,360 +0,0 @@
-#include <xrpl/basics/Blob.h>
-#include <xrpl/basics/base_uint.h>
-#include <xrpl/basics/hardened_hash.h>
-#include <xrpl/beast/utility/Zero.h>
-
-#include <boost/endian/detail/order.hpp>
-
-#include <gtest/gtest.h>
-
-#include <array>
-#include <cassert>
-#include <complex>
-#include <cstddef>
-#include <cstdint>
-#include <iterator>
-#include <stdexcept>
-#include <string>
-#include <string_view>
-#include <type_traits>
-#include <unordered_set>
-#include <utility>
-#include <vector>
-
-namespace xrpl::test {
-
-// a non-hashing Hasher that just copies the bytes.
-// Used to test hash_append in base_uint
-template <std::size_t Bits>
-struct Nonhash
-{
-    static constexpr auto const kEndian = boost::endian::order::big;
-    static constexpr std::size_t kWidth = Bits / 8;
-
-    std::array<std::uint8_t, kWidth> data;
-
-    Nonhash() = default;
-
-    void
-    operator()(void const* key, std::size_t len) noexcept
-    {
-        assert(len == kWidth);
-        memcpy(data.data(), key, len);
-    }
-
-    explicit
-    operator std::size_t() noexcept
-    {
-        return kWidth;
-    }
-};
-
-struct BaseUintTest : public ::testing::Test
-{
-    using BaseUInt96 = BaseUInt<96>;
-    static_assert(std::is_copy_constructible_v<BaseUInt96>);
-    static_assert(std::is_copy_assignable_v<BaseUInt96>);
-
-    static void
-    testComparisons()
-    {
-        {
-            static constexpr std::array<std::pair<std::string_view, std::string_view>, 6> kTestArgs{
-                {{"0000000000000000", "0000000000000001"},
-                 {"0000000000000000", "ffffffffffffffff"},
-                 {"1234567812345678", "2345678923456789"},
-                 {"8000000000000000", "8000000000000001"},
-                 {"aaaaaaaaaaaaaaa9", "aaaaaaaaaaaaaaaa"},
-                 {"fffffffffffffffe", "ffffffffffffffff"}}};
-
-            for (auto const& arg : kTestArgs)
-            {
-                xrpl::BaseUInt<64> const u{arg.first}, v{arg.second};
-                // For code readability, we want to use general boolean
-                // expectations instead of specific EXPECT_LT etc.
-                EXPECT_TRUE(u < v);
-                EXPECT_TRUE(u <= v);
-                EXPECT_TRUE(u != v);
-                EXPECT_FALSE(u == v);
-                EXPECT_FALSE(u > v);
-                EXPECT_FALSE(u >= v);
-                EXPECT_FALSE(v < u);
-                EXPECT_FALSE(v <= u);
-                EXPECT_TRUE(v != u);
-                EXPECT_FALSE(v == u);
-                EXPECT_TRUE(v > u);
-                EXPECT_TRUE(v >= u);
-                EXPECT_TRUE(u == u);
-                EXPECT_TRUE(v == v);
-            }
-        }
-
-        {
-            static constexpr std::array<std::pair<std::string_view, std::string_view>, 6> kTestArgs{
-                {
-                    {"000000000000000000000000", "000000000000000000000001"},
-                    {"000000000000000000000000", "ffffffffffffffffffffffff"},
-                    {"0123456789ab0123456789ab", "123456789abc123456789abc"},
-                    {"555555555555555555555555", "55555555555a555555555555"},
-                    {"aaaaaaaaaaaaaaa9aaaaaaaa", "aaaaaaaaaaaaaaaaaaaaaaaa"},
-                    {"fffffffffffffffffffffffe", "ffffffffffffffffffffffff"},
-                }};
-
-            for (auto const& arg : kTestArgs)
-            {
-                xrpl::BaseUInt<96> const u{arg.first}, v{arg.second};
-                EXPECT_TRUE(u < v);
-                EXPECT_TRUE(u <= v);
-                EXPECT_TRUE(u != v);
-                EXPECT_FALSE(u == v);
-                EXPECT_FALSE(u > v);
-                EXPECT_FALSE(u >= v);
-                EXPECT_FALSE(v < u);
-                EXPECT_FALSE(v <= u);
-                EXPECT_TRUE(v != u);
-                EXPECT_FALSE(v == u);
-                EXPECT_TRUE(v > u);
-                EXPECT_TRUE(v >= u);
-                EXPECT_TRUE(u == u);
-                EXPECT_TRUE(v == v);
-            }
-        }
-    }
-};
-
-TEST_F(BaseUintTest, base_uint)
-{
-    static_assert(!std::is_constructible_v<BaseUInt96, std::complex<double>>);
-    static_assert(!std::is_assignable_v<BaseUInt96&, std::complex<double>>);
-
-    testComparisons();
-
-    // used to verify set insertion (hashing required)
-    std::unordered_set<BaseUInt96, HardenedHash<>> uset;
-
-    Blob const raw{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
-    EXPECT_EQ(BaseUInt96::kBytes, raw.size());
-
-    BaseUInt96 u = BaseUInt96::fromRaw(raw);
-    uset.insert(u);
-    EXPECT_EQ(raw.size(), u.size());
-    EXPECT_EQ(to_string(u), "0102030405060708090A0B0C");
-    EXPECT_EQ(toShortString(u), "01020304...");
-    EXPECT_EQ(*u.data(), 1);
-    EXPECT_EQ(u.signum(), 1);
-    EXPECT_FALSE(!u);
-    EXPECT_FALSE(u.isZero());
-    EXPECT_TRUE(u.isNonZero());
-    unsigned char t = 0;
-    for (auto& d : u)
-    {
-        EXPECT_EQ(d, ++t);
-    }
-
-    // Test hash_append by "hashing" with a no-op hasher (h)
-    // and then extracting the bytes that were written during hashing
-    // back into another base_uint (w) for comparison with the original
-    Nonhash<96> h{};
-    hash_append(h, u);
-    BaseUInt96 const w =
-        BaseUInt96::fromRaw(std::vector<std::uint8_t>(h.data.begin(), h.data.end()));
-    EXPECT_EQ(w, u);
-
-    BaseUInt96 v{~u};
-    uset.insert(v);
-    EXPECT_EQ(to_string(v), "FEFDFCFBFAF9F8F7F6F5F4F3");
-    EXPECT_EQ(toShortString(v), "FEFDFCFB...");
-    EXPECT_EQ(*v.data(), 0xfe);
-    EXPECT_EQ(v.signum(), 1);
-    EXPECT_FALSE(!v);
-    EXPECT_FALSE(v.isZero());
-    EXPECT_TRUE(v.isNonZero());
-
-    t = 0xff;
-    for (auto& d : v)
-    {
-        EXPECT_EQ(d, --t);
-    }
-
-    EXPECT_LT(u, v);
-    EXPECT_GT(v, u);
-
-    v = u;
-    EXPECT_EQ(v, u);
-
-    BaseUInt96 z{beast::kZero};
-    uset.insert(z);
-    EXPECT_EQ(to_string(z), "000000000000000000000000");
-    EXPECT_EQ(toShortString(z), "00000000...");
-    EXPECT_EQ(*z.data(), 0);
-    EXPECT_EQ(*z.begin(), 0);
-    EXPECT_EQ(*std::prev(z.end(), 1), 0);
-    EXPECT_EQ(z.signum(), 0);
-    EXPECT_TRUE(!z);
-    EXPECT_TRUE(z.isZero());
-    EXPECT_FALSE(z.isNonZero());
-    for (auto& d : z)
-    {
-        EXPECT_EQ(d, 0);
-    }
-
-    BaseUInt96 n{z};
-    n++;
-    EXPECT_EQ(n, BaseUInt96(1));
-    n--;
-    EXPECT_EQ(n, beast::kZero);
-    EXPECT_EQ(n, z);
-    n--;
-    EXPECT_EQ(to_string(n), "FFFFFFFFFFFFFFFFFFFFFFFF");
-    EXPECT_EQ(toShortString(n), "FFFFFFFF...");
-    n = beast::kZero;
-    EXPECT_EQ(n, z);
-
-    BaseUInt96 zp1{z};
-    zp1++;
-    BaseUInt96 zm1{z};
-    zm1--;
-    BaseUInt96 const x{zm1 ^ zp1};
-    uset.insert(x);
-    EXPECT_EQ(to_string(x), "FFFFFFFFFFFFFFFFFFFFFFFE") << to_string(x);
-    EXPECT_EQ(toShortString(x), "FFFFFFFF...") << toShortString(x);
-
-    EXPECT_EQ(uset.size(), 4);
-
-    BaseUInt96 tmp;
-    EXPECT_TRUE(tmp.parseHex(to_string(u)));
-    EXPECT_EQ(tmp, u);
-    tmp = z;
-
-    // fails with extra char
-    EXPECT_FALSE(tmp.parseHex("A" + to_string(u)));
-    tmp = z;
-
-    // fails with extra char at end
-    EXPECT_FALSE(tmp.parseHex(to_string(u) + "A"));
-
-    // fails with a non-hex character at some point in the string:
-    tmp = z;
-
-    for (std::size_t i = 0; i != 24; ++i)
-    {
-        std::string x = to_string(z);
-        x[i] = ('G' + (i % 10));
-        EXPECT_FALSE(tmp.parseHex(x));
-    }
-
-    // Walking 1s:
-    for (std::size_t i = 0; i != 24; ++i)
-    {
-        std::string s1 = "000000000000000000000000";
-        s1[i] = '1';
-
-        EXPECT_TRUE(tmp.parseHex(s1));
-        EXPECT_EQ(to_string(tmp), s1);
-    }
-
-    // Walking 0s:
-    for (std::size_t i = 0; i != 24; ++i)
-    {
-        std::string s1 = "111111111111111111111111";
-        s1[i] = '0';
-
-        EXPECT_TRUE(tmp.parseHex(s1));
-        EXPECT_EQ(to_string(tmp), s1);
-    }
-
-    // Constexpr constructors
-    {
-        static_assert(BaseUInt96{}.signum() == 0);
-        static_assert(BaseUInt96("0").signum() == 0);
-        static_assert(BaseUInt96("000000000000000000000000").signum() == 0);
-        static_assert(BaseUInt96("000000000000000000000001").signum() == 1);
-        static_assert(BaseUInt96("800000000000000000000000").signum() == 1);
-
-// Everything within the #if should fail during compilation.
-#if 0
-            // Too few characters
-            static_assert(BaseUInt96("00000000000000000000000").signum() == 0);
-
-            // Too many characters
-            static_assert(BaseUInt96("0000000000000000000000000").signum() == 0);
-
-            // Non-hex characters
-            static_assert(BaseUInt96("00000000000000000000000 ").signum() == 1);
-            static_assert(BaseUInt96("00000000000000000000000/").signum() == 1);
-            static_assert(BaseUInt96("00000000000000000000000:").signum() == 1);
-            static_assert(BaseUInt96("00000000000000000000000@").signum() == 1);
-            static_assert(BaseUInt96("00000000000000000000000G").signum() == 1);
-            static_assert(BaseUInt96("00000000000000000000000`").signum() == 1);
-            static_assert(BaseUInt96("00000000000000000000000g").signum() == 1);
-            static_assert(BaseUInt96("00000000000000000000000~").signum() == 1);
-#endif  // 0
-
-        // Using the constexpr constructor in a non-constexpr context
-        // with an error in the parsing throws an exception.
-        {
-            // Invalid length for string.
-            bool caught = false;
-            try
-            {
-                // Try to prevent constant evaluation.
-                std::vector<char> str(23, '7');
-                std::string_view const sView(str.data(), str.size());
-                [[maybe_unused]] BaseUInt96 const t96(sView);
-            }
-            catch (std::invalid_argument const& e)
-            {
-                EXPECT_EQ(e.what(), std::string("invalid length for hex string"));
-                caught = true;
-            }
-            EXPECT_TRUE(caught);
-        }
-        {
-            // Invalid character in string.
-            bool caught = false;
-            try
-            {
-                // Try to prevent constant evaluation.
-                std::vector<char> str(23, '7');
-                str.push_back('G');
-                std::string_view const sView(str.data(), str.size());
-                [[maybe_unused]] BaseUInt96 const t96(sView);
-            }
-            catch (std::range_error const& e)
-            {
-                EXPECT_EQ(e.what(), std::string("invalid hex character"));
-                caught = true;
-            }
-            EXPECT_TRUE(caught);
-        }
-
-        // Verify that constexpr base_uints interpret a string the same
-        // way parseHex() does.
-        struct StrBaseUInt
-        {
-            char const* const str;
-            BaseUInt96 tst;
-
-            constexpr StrBaseUInt(char const* s) : str(s), tst(s)
-            {
-            }
-        };
-        constexpr StrBaseUInt kTestCases[] = {
-            "000000000000000000000000",
-            "000000000000000000000001",
-            "fedcba9876543210ABCDEF91",
-            "19FEDCBA0123456789abcdef",
-            "800000000000000000000000",
-            "fFfFfFfFfFfFfFfFfFfFfFfF",
-        };
-
-        for (StrBaseUInt const& t : kTestCases)
-        {
-            BaseUInt96 t96;
-            EXPECT_TRUE(t96.parseHex(t.str));
-            EXPECT_EQ(t96, t.tst);
-        }
-    }
-}
-
-}  // namespace xrpl::test
diff --git a/src/tests/libxrpl/basics/join.cpp b/src/tests/libxrpl/basics/join.cpp
deleted file mode 100644
index 66c832678b..0000000000
--- a/src/tests/libxrpl/basics/join.cpp
+++ /dev/null
@@ -1,80 +0,0 @@
-#include <xrpl/basics/join.h>
-
-#include <xrpl/basics/base_uint.h>
-
-#include <gtest/gtest.h>
-
-#include <array>
-#include <cstddef>
-#include <initializer_list>
-#include <sstream>
-#include <string>
-#include <vector>
-
-namespace xrpl::test {
-
-struct JoinTest : public ::testing::Test
-{
-};
-
-TEST_F(JoinTest, join)
-{
-    auto test = [](auto collectionanddelimiter, std::string expected) {
-        std::stringstream ss;
-        // Put something else in the buffer before and after to ensure that
-        // the << operator returns the stream correctly.
-        ss << "(" << collectionanddelimiter << ")";
-        auto const str = ss.str();
-        EXPECT_EQ(str.substr(1, str.length() - 2), expected);
-        EXPECT_EQ(str.front(), '(');
-        EXPECT_EQ(str.back(), ')');
-    };
-
-    // C++ array
-    test(CollectionAndDelimiter(std::array<int, 4>{2, -1, 5, 10}, "/"), "2/-1/5/10");
-    // One item C++ array edge case
-    test(CollectionAndDelimiter(std::array<std::string, 1>{"test"}, " & "), "test");
-    // Empty C++ array edge case
-    test(CollectionAndDelimiter(std::array<int, 0>{}, ","), "");
-    {
-        // C-style array
-        char letters[4]{'w', 'a', 's', 'd'};
-        test(CollectionAndDelimiter(letters, std::to_string(0)), "w0a0s0d");
-    }
-    {
-        // Auto sized C-style array
-        std::string words[]{"one", "two", "three", "four"};
-        test(CollectionAndDelimiter(words, "\n"), "one\ntwo\nthree\nfour");
-    }
-    {
-        // One item C-style array edge case
-        std::string words[]{"thing"};
-        test(CollectionAndDelimiter(words, "\n"), "thing");
-    }
-    // Initializer list
-    test(CollectionAndDelimiter(std::initializer_list<size_t>{19, 25}, "+"), "19+25");
-    // vector
-    test(CollectionAndDelimiter(std::vector<int>{0, 42}, std::to_string(99)), "09942");
-    // vector with one item edge case
-    test(CollectionAndDelimiter(std::vector<std::string>{"master"}, "xxx"), "master");
-    // vector with one non-trivial streamable item edge case
-    test(
-        CollectionAndDelimiter(std::vector<uint256>{uint256{1}}, "xxx"),
-        "0000000000000000000000000000000000000000000000000000000000000001");
-    // empty vector edge case
-    test(CollectionAndDelimiter(std::vector<uint256>{}, ","), "");
-    // C-style string
-    test(CollectionAndDelimiter("string", " "), "s t r i n g");
-    // Empty C-style string edge case
-    test(CollectionAndDelimiter("", "*"), "");
-    // Single char C-style string edge case
-    test(CollectionAndDelimiter("x", "*"), "x");
-    // std::string
-    test(CollectionAndDelimiter(std::string{"string"}, "-"), "s-t-r-i-n-g");
-    // Empty std::string edge case
-    test(CollectionAndDelimiter(std::string{""}, "*"), "");
-    // Single char std::string edge case
-    test(CollectionAndDelimiter(std::string{"y"}, "*"), "y");
-}
-
-}  // namespace xrpl::test
diff --git a/src/tests/libxrpl/helpers/TxTest.cpp b/src/tests/libxrpl/helpers/TxTest.cpp
index 4b4f407eeb..86e36b8abf 100644
--- a/src/tests/libxrpl/helpers/TxTest.cpp
+++ b/src/tests/libxrpl/helpers/TxTest.cpp
@@ -80,9 +80,7 @@ TxTest::TxTest(std::optional<FeatureBitset> features)
         std::vector<uint256>{featureSet_.begin(), featureSet_.end()},
         registry_.getNodeFamily());
 
-    // Initialize time from the genesis ledger.  closedLedger_ is created above
-    // in the body, so this cannot be a member initializer.
-    // NOLINTNEXTLINE(cppcoreguidelines-prefer-member-initializer)
+    // Initialize time from the genesis ledger
     now_ = closedLedger_->header().closeTime;
 
     // Create an open view on top of the genesis ledger
diff --git a/src/tests/libxrpl/json/Value.cpp b/src/tests/libxrpl/json/Value.cpp
index a1cd8160d7..03f565dffb 100644
--- a/src/tests/libxrpl/json/Value.cpp
+++ b/src/tests/libxrpl/json/Value.cpp
@@ -838,7 +838,7 @@ TEST(json_value, compact)
 {
     json::Value j;
     json::Reader r;
-    char const* s(R"({"array":[{"12":23},{},null,false,0.5]})");
+    char const* s("{\"array\":[{\"12\":23},{},null,false,0.5]}");
 
     auto countLines = [](std::string const& str) {
         return 1 + std::count_if(str.begin(), str.end(), [](char c) { return c == '\n'; });
diff --git a/src/tests/libxrpl/resource/Logic.cpp b/src/tests/libxrpl/resource/Logic.cpp
deleted file mode 100644
index 1f935ebf4b..0000000000
--- a/src/tests/libxrpl/resource/Logic.cpp
+++ /dev/null
@@ -1,241 +0,0 @@
-#include <xrpl/resource/detail/Logic.h>
-
-#include <xrpl/basics/Log.h>
-#include <xrpl/basics/chrono.h>
-#include <xrpl/basics/random.h>
-#include <xrpl/beast/insight/NullCollector.h>
-#include <xrpl/beast/net/IPAddressV4.h>
-#include <xrpl/beast/utility/Journal.h>
-#include <xrpl/resource/Charge.h>
-#include <xrpl/resource/Consumer.h>
-#include <xrpl/resource/Disposition.h>
-#include <xrpl/resource/Gossip.h>
-#include <xrpl/resource/detail/Tuning.h>
-
-#include <boost/utility/base_from_member.hpp>
-
-#include <gtest/gtest.h>
-#include <helpers/TestSink.h>
-
-#include <chrono>
-#include <cstdint>
-#include <string>
-
-namespace xrpl::Resource {
-
-class ResourceManagerTest : public ::testing::Test
-{
-protected:
-    beast::Journal const j_{TestSink::instance()};
-
-    class TestLogic : private boost::base_from_member<TestStopwatch>, public Logic
-    {
-    private:
-        using clock_type = boost::base_from_member<TestStopwatch>;
-
-    public:
-        explicit TestLogic(beast::Journal journal)
-            : Logic(beast::insight::NullCollector::make(), member, journal)
-        {
-        }
-
-        void
-        advance()
-        {
-            ++member;
-        }
-
-        TestStopwatch&
-        clock()
-        {
-            return member;
-        }
-    };
-
-    //--------------------------------------------------------------------------
-
-    static void
-    populateGossip(Gossip& gossip)
-    {
-        std::uint8_t const v(10 + randInt(9));
-        std::uint8_t const n(10 + randInt(9));
-        gossip.items.reserve(n);
-        for (std::uint8_t i = 0; i < n; ++i)
-        {
-            Gossip::Item item;
-            item.balance = 100 + randInt(499);
-            beast::IP::AddressV4::bytes_type const d = {{
-                192,
-                0,
-                2,
-                static_cast<std::uint8_t>(v + i),
-            }};
-            item.address = beast::IP::Endpoint{beast::IP::AddressV4{d}};
-            gossip.items.push_back(item);
-        }
-    }
-};
-
-TEST_F(ResourceManagerTest, limited_warn_drop)
-{
-    TestLogic logic{j_};
-
-    Charge const fee{kDropThreshold + 1};
-    beast::IP::Endpoint const addr{beast::IP::Endpoint::fromString("192.0.2.2")};
-
-    {
-        Consumer c{logic.newInboundEndpoint(addr)};
-
-        // Create load until we get a warning
-        int n = 10000;
-        bool warned = false;
-
-        while (--n >= 0)
-        {
-            if (c.charge(fee) == Disposition::Warn)
-            {
-                warned = true;
-                break;
-            }
-            ++logic.clock();
-        }
-
-        ASSERT_TRUE(warned) << "Loop count exceeded without warning";
-
-        // Create load until we get dropped
-        bool dropped = false;
-        while (--n >= 0)
-        {
-            if (c.charge(fee) == Disposition::Drop)
-            {
-                dropped = true;
-                // Disconnect abusive Consumer
-                EXPECT_TRUE(c.disconnect(j_));
-                break;
-            }
-            ++logic.clock();
-        }
-
-        ASSERT_TRUE(dropped) << "Loop count exceeded without dropping";
-    }
-
-    // Make sure the consumer is on the blacklist for a while.
-    {
-        Consumer const c{logic.newInboundEndpoint(addr)};
-        logic.periodicActivity();
-        EXPECT_EQ(c.disposition(), Disposition::Drop) << "Dropped consumer not put on blacklist";
-    }
-
-    // Makes sure the Consumer is eventually removed from blacklist
-    bool readmitted = false;
-    {
-        using namespace std::chrono_literals;
-        // Give Consumer time to become readmitted.  Should never
-        // exceed expiration time.
-        auto n = kSecondsUntilExpiration + 1s;
-        while (--n > 0s)
-        {
-            ++logic.clock();
-            logic.periodicActivity();
-            Consumer const c{logic.newInboundEndpoint(addr)};
-            if (c.disposition() != Disposition::Drop)
-            {
-                readmitted = true;
-                break;
-            }
-        }
-    }
-    EXPECT_TRUE(readmitted) << "Dropped Consumer left on blacklist too long";
-}
-
-TEST_F(ResourceManagerTest, unlimited_warn_drop)
-{
-    TestLogic logic{j_};
-
-    Charge const fee{kDropThreshold + 1};
-    beast::IP::Endpoint const addr{beast::IP::Endpoint::fromString("192.0.2.2")};
-    Consumer c{logic.newUnlimitedEndpoint(addr)};
-
-    // Create load until we get a warning
-    int n = 10000;
-    bool warned = false;
-
-    while (--n >= 0)
-    {
-        if (c.charge(fee) == Disposition::Warn)
-        {
-            warned = true;
-            break;
-        }
-        ++logic.clock();
-    }
-
-    EXPECT_FALSE(warned) << "Should loop forever with no warning";
-}
-
-TEST_F(ResourceManagerTest, charges)
-{
-    TestLogic logic{j_};
-
-    {
-        beast::IP::Endpoint const address{beast::IP::Endpoint::fromString("192.0.2.1")};
-        Consumer c{logic.newInboundEndpoint(address)};
-        Charge const fee{1000};
-        JLOG(j_.info()) << "Charging " << c.toString() << " " << fee << " per second";
-        c.charge(fee);
-        for (int i = 0; i < 128; ++i)
-        {
-            JLOG(j_.info()) << "Time= " << logic.clock().now().time_since_epoch().count()
-                            << ", Balance = " << c.balance();
-            logic.advance();
-        }
-    }
-
-    {
-        beast::IP::Endpoint const address{beast::IP::Endpoint::fromString("192.0.2.2")};
-        Consumer c{logic.newInboundEndpoint(address)};
-        Charge const fee{1000};
-        JLOG(j_.info()) << "Charging " << c.toString() << " " << fee << " per second";
-        for (int i = 0; i < 128; ++i)
-        {
-            c.charge(fee);
-            JLOG(j_.info()) << "Time= " << logic.clock().now().time_since_epoch().count()
-                            << ", Balance = " << c.balance();
-            logic.advance();
-        }
-    }
-}
-
-TEST_F(ResourceManagerTest, imports)
-{
-    TestLogic logic{j_};
-
-    Gossip g[5];
-
-    for (auto& i : g)
-        populateGossip(i);
-
-    for (int i = 0; i < 5; ++i)
-        logic.importConsumers(std::to_string(i), g[i]);
-}
-
-TEST_F(ResourceManagerTest, import)
-{
-    TestLogic logic{j_};
-
-    Gossip g;
-    Gossip::Item item;
-    item.balance = 100;
-    beast::IP::AddressV4::bytes_type const d = {{
-        192,
-        0,
-        2,
-        1,
-    }};
-    item.address = beast::IP::Endpoint{beast::IP::AddressV4{d}};
-    g.items.push_back(item);
-
-    logic.importConsumers("g", g);
-}
-
-}  // namespace xrpl::Resource
diff --git a/src/tests/libxrpl/shamap/FetchPack.cpp b/src/tests/libxrpl/shamap/FetchPack.cpp
deleted file mode 100644
index 05854d482f..0000000000
--- a/src/tests/libxrpl/shamap/FetchPack.cpp
+++ /dev/null
@@ -1,22 +0,0 @@
-#include <xrpl/beast/utility/Journal.h>
-#include <xrpl/shamap/SHAMap.h>
-#include <xrpl/shamap/SHAMapMissingNode.h>
-
-#include <gtest/gtest.h>
-#include <helpers/TestSink.h>
-#include <shamap/common.h>
-
-#include <memory>
-
-namespace xrpl::tests {
-
-TEST(FetchPackTest, construct_table)
-{
-    beast::Journal const j{TestSink::instance()};
-    TestNodeFamily f{j};
-    std::shared_ptr<SHAMap> const t1{std::make_shared<SHAMap>(SHAMapType::FREE, f)};
-
-    EXPECT_NE(t1, nullptr);
-}
-
-}  // namespace xrpl::tests
diff --git a/src/tests/libxrpl/shamap/SHAMap.cpp b/src/tests/libxrpl/shamap/SHAMap.cpp
deleted file mode 100644
index 238c34bf9c..0000000000
--- a/src/tests/libxrpl/shamap/SHAMap.cpp
+++ /dev/null
@@ -1,349 +0,0 @@
-#include <xrpl/shamap/SHAMap.h>
-
-#include <xrpl/basics/Blob.h>
-#include <xrpl/basics/Buffer.h>
-#include <xrpl/basics/SHAMapHash.h>
-#include <xrpl/basics/base_uint.h>
-#include <xrpl/beast/utility/Journal.h>
-#include <xrpl/beast/utility/Zero.h>
-#include <xrpl/shamap/SHAMapInnerNode.h>
-#include <xrpl/shamap/SHAMapItem.h>
-#include <xrpl/shamap/SHAMapLeafNode.h>
-#include <xrpl/shamap/SHAMapMissingNode.h>
-#include <xrpl/shamap/SHAMapTreeNode.h>
-
-#include <gtest/gtest.h>
-#include <helpers/TestSink.h>
-#include <shamap/common.h>
-
-#include <algorithm>
-#include <array>
-#include <cstddef>
-#include <cstdint>
-#include <memory>
-#include <string>
-#include <string_view>
-#include <type_traits>
-#include <utility>
-#include <vector>
-
-namespace xrpl::tests {
-
-#ifndef __INTELLISENSE__
-static_assert(std::is_nothrow_destructible<SHAMap>{});
-static_assert(!std::is_default_constructible<SHAMap>{});
-static_assert(!std::is_copy_constructible<SHAMap>{});
-static_assert(!std::is_copy_assignable<SHAMap>{});
-static_assert(!std::is_move_constructible<SHAMap>{});
-static_assert(!std::is_move_assignable<SHAMap>{});
-
-static_assert(std::is_nothrow_destructible<SHAMap::ConstIterator>{});
-static_assert(std::is_copy_constructible<SHAMap::ConstIterator>{});
-static_assert(std::is_copy_assignable<SHAMap::ConstIterator>{});
-static_assert(std::is_move_constructible<SHAMap::ConstIterator>{});
-static_assert(std::is_move_assignable<SHAMap::ConstIterator>{});
-
-static_assert(std::is_nothrow_destructible<SHAMapItem>{});
-static_assert(!std::is_default_constructible<SHAMapItem>{});
-static_assert(!std::is_copy_constructible<SHAMapItem>{});
-
-static_assert(std::is_nothrow_destructible<SHAMapNodeID>{});
-static_assert(std::is_default_constructible<SHAMapNodeID>{});
-static_assert(std::is_copy_constructible<SHAMapNodeID>{});
-static_assert(std::is_copy_assignable<SHAMapNodeID>{});
-static_assert(std::is_move_constructible<SHAMapNodeID>{});
-static_assert(std::is_move_assignable<SHAMapNodeID>{});
-
-static_assert(std::is_nothrow_destructible<SHAMapHash>{});
-static_assert(std::is_default_constructible<SHAMapHash>{});
-static_assert(std::is_copy_constructible<SHAMapHash>{});
-static_assert(std::is_copy_assignable<SHAMapHash>{});
-static_assert(std::is_move_constructible<SHAMapHash>{});
-static_assert(std::is_move_assignable<SHAMapHash>{});
-
-static_assert(std::is_nothrow_destructible<SHAMapTreeNode>{});
-static_assert(!std::is_default_constructible<SHAMapTreeNode>{});
-static_assert(!std::is_copy_constructible<SHAMapTreeNode>{});
-static_assert(!std::is_copy_assignable<SHAMapTreeNode>{});
-static_assert(!std::is_move_constructible<SHAMapTreeNode>{});
-static_assert(!std::is_move_assignable<SHAMapTreeNode>{});
-
-static_assert(std::is_nothrow_destructible<SHAMapInnerNode>{});
-static_assert(!std::is_default_constructible<SHAMapInnerNode>{});
-static_assert(!std::is_copy_constructible<SHAMapInnerNode>{});
-static_assert(!std::is_copy_assignable<SHAMapInnerNode>{});
-static_assert(!std::is_move_constructible<SHAMapInnerNode>{});
-static_assert(!std::is_move_assignable<SHAMapInnerNode>{});
-
-static_assert(std::is_nothrow_destructible<SHAMapLeafNode>{});
-static_assert(!std::is_default_constructible<SHAMapLeafNode>{});
-static_assert(!std::is_copy_constructible<SHAMapLeafNode>{});
-static_assert(!std::is_copy_assignable<SHAMapLeafNode>{});
-static_assert(!std::is_move_constructible<SHAMapLeafNode>{});
-static_assert(!std::is_move_assignable<SHAMapLeafNode>{});
-#endif
-
-inline bool
-operator!=(SHAMapItem const& a, SHAMapItem const& b)
-{
-    return a.key() != b.key();
-}
-
-struct SHAMapBackingMode
-{
-    bool backed;
-    std::string_view testName;
-};
-
-constexpr SHAMapBackingMode kBackedMode{.backed = true, .testName = "backed"};
-constexpr SHAMapBackingMode kUnbackedMode{.backed = false, .testName = "unbacked"};
-
-std::string
-shamapBackingModeName(::testing::TestParamInfo<SHAMapBackingMode> const& info)
-{
-    return std::string{info.param.testName};
-}
-
-class SHAMapTest : public ::testing::TestWithParam<SHAMapBackingMode>
-{
-protected:
-    beast::Journal const j_{TestSink::instance()};
-
-    static Buffer
-    intToVuc(std::uint8_t v)
-    {
-        Buffer vuc{32};
-        std::fill_n(vuc.data(), vuc.size(), v);
-        return vuc;
-    }
-};
-
-TEST_P(SHAMapTest, add_traverse_snapshot_build_tear_and_iterate)
-{
-    auto const testMode = GetParam();
-    tests::TestNodeFamily f{j_};
-
-    // kH3 and kH4 differ only in the leaf, same terminal node (level 19)
-    constexpr uint256 kH1("092891fe4ef6cee585fdc6fda0e09eb4d386363158ec3321b8123e5a772c6ca7");
-    constexpr uint256 kH2("436ccbac3347baa1f1e53baeef1f43334da88f1f6d70d963b833afd6dfa289fe");
-    constexpr uint256 kH3("b92891fe4ef6cee585fdc6fda1e09eb4d386363158ec3321b8123e5a772c6ca8");
-    constexpr uint256 kH4("b92891fe4ef6cee585fdc6fda2e09eb4d386363158ec3321b8123e5a772c6ca8");
-
-    SHAMap sMap{SHAMapType::FREE, f};
-    sMap.invariants();
-    if (!testMode.backed)
-        sMap.setUnbacked();
-
-    auto i1 = makeShamapitem(kH1, intToVuc(1));
-    auto i2 = makeShamapitem(kH2, intToVuc(2));
-    auto i3 = makeShamapitem(kH3, intToVuc(3));
-    auto i4 = makeShamapitem(kH4, intToVuc(4));
-
-    EXPECT_TRUE(sMap.addItem(SHAMapNodeType::TnTransactionNm, makeShamapitem(*i2))) << "no add";
-    sMap.invariants();
-    EXPECT_TRUE(sMap.addItem(SHAMapNodeType::TnTransactionNm, makeShamapitem(*i1))) << "no add";
-    sMap.invariants();
-
-    auto i = sMap.begin();
-    auto e = sMap.end();
-    EXPECT_FALSE(i == e || (*i != *i1)) << "bad traverse";
-    ++i;
-    EXPECT_FALSE(i == e || (*i != *i2)) << "bad traverse";
-    ++i;
-    EXPECT_EQ(i, e) << "bad traverse";
-    sMap.addItem(SHAMapNodeType::TnTransactionNm, makeShamapitem(*i4));
-    sMap.invariants();
-    sMap.delItem(i2->key());
-    sMap.invariants();
-    sMap.addItem(SHAMapNodeType::TnTransactionNm, makeShamapitem(*i3));
-    sMap.invariants();
-    i = sMap.begin();
-    e = sMap.end();
-    EXPECT_FALSE(i == e || (*i != *i1)) << "bad traverse";
-    ++i;
-    EXPECT_FALSE(i == e || (*i != *i3)) << "bad traverse";
-    ++i;
-    EXPECT_FALSE(i == e || (*i != *i4)) << "bad traverse";
-    ++i;
-    EXPECT_EQ(i, e) << "bad traverse";
-
-    SHAMapHash const mapHash = sMap.getHash();
-    std::shared_ptr<SHAMap> const map2 = sMap.snapShot(false);
-    map2->invariants();
-    EXPECT_EQ(sMap.getHash(), mapHash) << "bad snapshot";
-    EXPECT_EQ(map2->getHash(), mapHash) << "bad snapshot";
-
-    SHAMap::Delta delta;
-    ASSERT_TRUE(sMap.compare(*map2, delta, 100));
-    EXPECT_TRUE(delta.empty());
-
-    EXPECT_TRUE(sMap.delItem(sMap.begin()->key())) << "bad mod";
-    sMap.invariants();
-    EXPECT_NE(sMap.getHash(), mapHash) << "bad snapshot";
-    EXPECT_EQ(map2->getHash(), mapHash) << "bad snapshot";
-
-    ASSERT_TRUE(sMap.compare(*map2, delta, 100));
-    ASSERT_EQ(delta.size(), 1);
-    EXPECT_EQ(delta.begin()->first, kH1);
-    EXPECT_EQ(delta.begin()->second.first, nullptr);
-    ASSERT_NE(delta.begin()->second.second, nullptr);
-    EXPECT_EQ(delta.begin()->second.second->key(), kH1);
-
-    sMap.dump();
-    {
-        constexpr std::array kKeys{
-            uint256{"b92891fe4ef6cee585fdc6fda1e09eb4d386363158ec3321b8123e5a772c6ca8"},
-            uint256{"b92881fe4ef6cee585fdc6fda1e09eb4d386363158ec3321b8123e5a772c6ca8"},
-            uint256{"b92691fe4ef6cee585fdc6fda1e09eb4d386363158ec3321b8123e5a772c6ca8"},
-            uint256{"b92791fe4ef6cee585fdc6fda1e09eb4d386363158ec3321b8123e5a772c6ca8"},
-            uint256{"b91891fe4ef6cee585fdc6fda1e09eb4d386363158ec3321b8123e5a772c6ca8"},
-            uint256{"b99891fe4ef6cee585fdc6fda1e09eb4d386363158ec3321b8123e5a772c6ca8"},
-            uint256{"f22891fe4ef6cee585fdc6fda1e09eb4d386363158ec3321b8123e5a772c6ca8"},
-            uint256{"292891fe4ef6cee585fdc6fda1e09eb4d386363158ec3321b8123e5a772c6ca8"},
-        };
-
-        constexpr std::array kHashes{
-            uint256{"B7387CFEA0465759ADC718E8C42B52D2309D179B326E239EB5075C64B6281F7F"},
-            uint256{"FBC195A9592A54AB44010274163CB6BA95F497EC5BA0A8831845467FB2ECE266"},
-            uint256{"4E7D2684B65DFD48937FFB775E20175C43AF0C94066F7D5679F51AE756795B75"},
-            uint256{"7A2F312EB203695FFD164E038E281839EEF06A1B99BFC263F3CECC6C74F93E07"},
-            uint256{"395A6691A372387A703FB0F2C6D2C405DAF307D0817F8F0E207596462B0E3A3E"},
-            uint256{"D044C0A696DE3169CC70AE216A1564D69DE96582865796142CE7D98A84D9DDE4"},
-            uint256{"76DCC77C4027309B5A91AD164083264D70B77B5E43E08AEDA5EBF94361143615"},
-            uint256{"DF4220E93ADC6F5569063A01B4DC79F8DB9553B6A3222ADE23DEA02BBE7230E5"},
-        };
-
-        SHAMap map{SHAMapType::FREE, f};
-        if (!testMode.backed)
-            map.setUnbacked();
-
-        EXPECT_EQ(map.getHash(), beast::kZero);
-        for (std::size_t k = 0; k < kKeys.size(); ++k)
-        {
-            EXPECT_TRUE(map.addItem(
-                SHAMapNodeType::TnTransactionNm,
-                makeShamapitem(kKeys[k], intToVuc(static_cast<std::uint8_t>(k)))));
-            EXPECT_EQ(map.getHash().asUInt256(), kHashes[k]);
-            map.invariants();
-        }
-        for (std::size_t k = kKeys.size(); k-- > 0;)
-        {
-            EXPECT_EQ(map.getHash().asUInt256(), kHashes[k]);
-            EXPECT_TRUE(map.delItem(kKeys[k]));
-            map.invariants();
-        }
-        EXPECT_EQ(map.getHash(), beast::kZero);
-    }
-
-    {
-        constexpr std::array kKeys{
-            uint256{"f22891fe4ef6cee585fdc6fda1e09eb4d386363158ec3321b8123e5a772c6ca8"},
-            uint256{"b99891fe4ef6cee585fdc6fda1e09eb4d386363158ec3321b8123e5a772c6ca8"},
-            uint256{"b92891fe4ef6cee585fdc6fda1e09eb4d386363158ec3321b8123e5a772c6ca8"},
-            uint256{"b92881fe4ef6cee585fdc6fda1e09eb4d386363158ec3321b8123e5a772c6ca8"},
-            uint256{"b92791fe4ef6cee585fdc6fda1e09eb4d386363158ec3321b8123e5a772c6ca8"},
-            uint256{"b92691fe4ef6cee585fdc6fda1e09eb4d386363158ec3321b8123e5a772c6ca8"},
-            uint256{"b91891fe4ef6cee585fdc6fda1e09eb4d386363158ec3321b8123e5a772c6ca8"},
-            uint256{"292891fe4ef6cee585fdc6fda1e09eb4d386363158ec3321b8123e5a772c6ca8"},
-        };
-
-        tests::TestNodeFamily tf{j_};
-        SHAMap map{SHAMapType::FREE, tf};
-        if (!testMode.backed)
-            map.setUnbacked();
-        for (auto const& k : kKeys)
-        {
-            map.addItem(SHAMapNodeType::TnTransactionNm, makeShamapitem(k, intToVuc(0)));
-            map.invariants();
-        }
-
-        int h = 7;
-        for (auto const& k : map)
-        {
-            EXPECT_EQ(k.key(), kKeys[h]);
-            --h;
-        }
-    }
-}
-
-INSTANTIATE_TEST_SUITE_P(
-    BackingMode,
-    SHAMapTest,
-    ::testing::Values(kBackedMode, kUnbackedMode),
-    shamapBackingModeName);
-
-class SHAMapPathProof : public ::testing::Test
-{
-protected:
-    beast::Journal const j_{TestSink::instance()};
-};
-
-TEST_F(SHAMapPathProof, verify_proof_path)
-{
-    tests::TestNodeFamily tf{j_};
-    SHAMap map{SHAMapType::FREE, tf};
-    map.setUnbacked();
-
-    uint256 key;
-    uint256 rootHash;
-    std::vector<Blob> goodPath;
-
-    for (unsigned char c = 1; c < 100; ++c)
-    {
-        uint256 k(c);
-        map.addItem(SHAMapNodeType::TnAccountState, makeShamapitem(k, Slice{k.data(), k.size()}));
-        map.invariants();
-
-        auto root = map.getHash().asUInt256();
-        auto path = map.getProofPath(k);
-        if (!path)
-        {
-            ADD_FAILURE() << "Missing proof path";
-            return;
-        }
-        auto& proofPath = *path;
-
-        EXPECT_TRUE(map.verifyProofPath(root, k, proofPath));
-        if (c == 1)
-        {
-            // extra node
-            proofPath.insert(proofPath.begin(), proofPath.front());
-            EXPECT_FALSE(map.verifyProofPath(root, k, proofPath));
-            // wrong key
-            uint256 const wrongKey(c + 1);
-            EXPECT_FALSE(map.getProofPath(wrongKey));
-        }
-        if (c == 99)
-        {
-            key = k;
-            rootHash = root;
-            goodPath = std::move(proofPath);
-        }
-    }
-
-    // still good
-    EXPECT_TRUE(map.verifyProofPath(rootHash, key, goodPath));
-    // empty path
-    std::vector<Blob> badPath;
-    EXPECT_FALSE(map.verifyProofPath(rootHash, key, badPath));
-    // too long
-    badPath = goodPath;
-    badPath.push_back(goodPath.back());
-    EXPECT_FALSE(map.verifyProofPath(rootHash, key, badPath));
-    // bad node
-    badPath.clear();
-    badPath.emplace_back(100, 100);
-    EXPECT_FALSE(map.verifyProofPath(rootHash, key, badPath));
-    // bad node type
-    badPath.clear();
-    badPath.push_back(goodPath.front());
-    badPath.front().back()--;  // change node type
-    EXPECT_FALSE(map.verifyProofPath(rootHash, key, badPath));
-    // all inner
-    badPath.clear();
-    badPath = goodPath;
-    badPath.erase(badPath.begin());
-    EXPECT_FALSE(map.verifyProofPath(rootHash, key, badPath));
-}
-
-}  // namespace xrpl::tests
diff --git a/src/tests/libxrpl/shamap/SHAMapSync.cpp b/src/tests/libxrpl/shamap/SHAMapSync.cpp
deleted file mode 100644
index 5cefbae8a1..0000000000
--- a/src/tests/libxrpl/shamap/SHAMapSync.cpp
+++ /dev/null
@@ -1,170 +0,0 @@
-#include <xrpl/basics/Blob.h>
-#include <xrpl/basics/SHAMapHash.h>
-#include <xrpl/basics/Slice.h>
-#include <xrpl/basics/base_uint.h>
-#include <xrpl/basics/random.h>
-#include <xrpl/beast/utility/Journal.h>
-#include <xrpl/beast/xor_shift_engine.h>
-#include <xrpl/protocol/Serializer.h>
-#include <xrpl/shamap/SHAMap.h>
-#include <xrpl/shamap/SHAMapItem.h>
-#include <xrpl/shamap/SHAMapMissingNode.h>
-#include <xrpl/shamap/SHAMapTreeNode.h>
-
-#include <boost/smart_ptr/intrusive_ptr.hpp>
-
-#include <gtest/gtest.h>
-#include <helpers/TestSink.h>
-#include <shamap/common.h>
-
-#include <chrono>
-#include <cstdint>
-#include <list>
-#include <utility>
-#include <vector>
-
-namespace xrpl::tests {
-
-class SHAMapSyncTest : public ::testing::Test
-{
-protected:
-    beast::Journal const j_{TestSink::instance()};
-    beast::xor_shift_engine eng_;
-
-    boost::intrusive_ptr<SHAMapItem>
-    makeRandomAS()
-    {
-        Serializer s;
-
-        for (int d = 0; d < 3; ++d)
-            s.add32(randInt<std::uint32_t>(eng_));
-        return makeShamapitem(s.getSHA512Half(), s.slice());
-    }
-
-    bool
-    confuseMap(SHAMap& map, int count)
-    {
-        // add a bunch of random states to a map, then remove them
-        // map should be the same
-        SHAMapHash const beforeHash = map.getHash();
-
-        std::list<uint256> items;
-
-        for (int i = 0; i < count; ++i)
-        {
-            auto item = makeRandomAS();
-            items.push_back(item->key());
-
-            if (!map.addItem(SHAMapNodeType::TnAccountState, item))
-            {
-                ADD_FAILURE() << "Unable to add item to map";
-                return false;
-            }
-        }
-
-        for (auto const& item : items)
-        {
-            if (!map.delItem(item))
-            {
-                ADD_FAILURE() << "Unable to remove item from map";
-                return false;
-            }
-        }
-
-        if (beforeHash != map.getHash())
-        {
-            ADD_FAILURE() << "Hashes do not match " << beforeHash << " " << map.getHash();
-            return false;
-        }
-
-        return true;
-    }
-};
-
-TEST_F(SHAMapSyncTest, sync)
-{
-    TestNodeFamily f{j_}, f2{j_};
-    SHAMap source{SHAMapType::FREE, f};
-    SHAMap destination{SHAMapType::FREE, f2};
-
-    int const items = 10000;
-    for (int i = 0; i < items; ++i)
-    {
-        source.addItem(SHAMapNodeType::TnAccountState, makeRandomAS());
-        if (i % 100 == 0)
-            source.invariants();
-    }
-
-    source.invariants();
-    ASSERT_TRUE(confuseMap(source, 500));
-    source.invariants();
-
-    source.setImmutable();
-
-    int count = 0;
-    source.visitLeaves([&count]([[maybe_unused]] auto const& item) { ++count; });
-    EXPECT_EQ(count, items);
-
-    std::vector<SHAMapMissingNode> missingNodes;
-    source.walkMap(missingNodes, 2048);
-    EXPECT_TRUE(missingNodes.empty());
-
-    destination.setSynching();
-
-    {
-        std::vector<std::pair<SHAMapNodeID, Blob>> a;
-
-        ASSERT_TRUE(source.getNodeFat(SHAMapNodeID(), a, randBool(eng_), randInt(eng_, 2)));
-
-        ASSERT_FALSE(a.empty()) << "NodeSize";
-
-        ASSERT_TRUE(
-            destination.addRootNode(source.getHash(), makeSlice(a[0].second), nullptr).isGood());
-    }
-
-    do
-    {
-        f.clock().advance(std::chrono::seconds(1));
-
-        // get the list of nodes we know we need
-        auto nodesMissing = destination.getMissingNodes(2048, nullptr);
-
-        if (nodesMissing.empty())
-            break;
-
-        // get as many nodes as possible based on this information
-        std::vector<std::pair<SHAMapNodeID, Blob>> b;
-
-        for (auto& it : nodesMissing)
-        {
-            // Keep failures fatal here because this loop is data-dependent.
-            // non-deterministic number of times and the number of tests run
-            // should be deterministic
-            if (!source.getNodeFat(it.first, b, randBool(eng_), randInt(eng_, 2)))
-                FAIL() << "Unable to fetch node";
-        }
-
-        // Keep failures fatal here because this loop is data-dependent.
-        // non-deterministic number of times and the number of tests run
-        // should be deterministic
-        if (b.empty())
-            FAIL() << "No nodes returned";
-
-        for (auto const& i : b)
-        {
-            // Keep failures fatal here because this loop is data-dependent.
-            // non-deterministic number of times and the number of tests run
-            // should be deterministic
-            if (!destination.addKnownNode(i.first, makeSlice(i.second), nullptr).isUseful())
-                FAIL() << "Known node was not useful";
-        }
-    } while (true);
-
-    destination.clearSynching();
-
-    EXPECT_TRUE(source.deepCompare(destination));
-
-    destination.invariants();
-}
-
-}  // namespace xrpl::tests
diff --git a/src/xrpld/app/consensus/RCLConsensus.cpp b/src/xrpld/app/consensus/RCLConsensus.cpp
index 2abc881adc..a7c2b26c04 100644
--- a/src/xrpld/app/consensus/RCLConsensus.cpp
+++ b/src/xrpld/app/consensus/RCLConsensus.cpp
@@ -690,7 +690,7 @@ RCLConsensus::Adaptor::doAccept(
 
         JLOG(j_.info()) << "We closed at " << closeTime.time_since_epoch().count();
         using usec64_t = std::chrono::duration<std::uint64_t>;
-        auto closeTotal = std::chrono::duration_cast<usec64_t>(closeTime.time_since_epoch());
+        usec64_t closeTotal = std::chrono::duration_cast<usec64_t>(closeTime.time_since_epoch());
         int closeCount = 1;
 
         for (auto const& [t, v] : rawCloseTimes.peers)
diff --git a/src/xrpld/app/ledger/TransactionMaster.h b/src/xrpld/app/ledger/TransactionMaster.h
index 6d81911510..5dcad09f51 100644
--- a/src/xrpld/app/ledger/TransactionMaster.h
+++ b/src/xrpld/app/ledger/TransactionMaster.h
@@ -68,7 +68,7 @@ public:
     canonicalize(std::shared_ptr<Transaction>* pTransaction);
 
     void
-    sweep();
+    sweep(void);
 
     TaggedCache<uint256, Transaction>&
     getCache();
diff --git a/src/xrpld/app/ledger/detail/BuildLedger.cpp b/src/xrpld/app/ledger/detail/BuildLedger.cpp
index d11e0610ba..038a7be4b7 100644
--- a/src/xrpld/app/ledger/detail/BuildLedger.cpp
+++ b/src/xrpld/app/ledger/detail/BuildLedger.cpp
@@ -13,10 +13,10 @@
 #include <xrpl/ledger/Ledger.h>
 #include <xrpl/ledger/OpenView.h>
 #include <xrpl/nodestore/NodeObject.h>
-#include <xrpl/protocol/Indexes.h>  // IWYU pragma: keep
+#include <xrpl/protocol/Indexes.h>
 #include <xrpl/protocol/LedgerHeader.h>
 #include <xrpl/protocol/Protocol.h>
-#include <xrpl/protocol/SystemParameters.h>  // IWYU pragma: keep
+#include <xrpl/protocol/SystemParameters.h>
 #include <xrpl/protocol/TxFlags.h>
 #include <xrpl/tx/apply.h>
 
diff --git a/src/xrpld/app/ledger/detail/InboundLedger.cpp b/src/xrpld/app/ledger/detail/InboundLedger.cpp
index 4d34f60374..4affffd1c1 100644
--- a/src/xrpld/app/ledger/detail/InboundLedger.cpp
+++ b/src/xrpld/app/ledger/detail/InboundLedger.cpp
@@ -21,11 +21,11 @@
 #include <xrpl/nodestore/Database.h>
 #include <xrpl/nodestore/NodeObject.h>
 #include <xrpl/protocol/HashPrefix.h>
-#include <xrpl/protocol/Indexes.h>  // IWYU pragma: keep
+#include <xrpl/protocol/Indexes.h>
 #include <xrpl/protocol/LedgerHeader.h>
 #include <xrpl/protocol/Rules.h>
 #include <xrpl/protocol/Serializer.h>
-#include <xrpl/protocol/SystemParameters.h>  // IWYU pragma: keep
+#include <xrpl/protocol/SystemParameters.h>
 #include <xrpl/protocol/jss.h>
 #include <xrpl/resource/Fees.h>
 #include <xrpl/shamap/SHAMapNodeID.h>
diff --git a/src/xrpld/app/ledger/detail/InboundLedgers.cpp b/src/xrpld/app/ledger/detail/InboundLedgers.cpp
index 07daa7560e..95e3e46f73 100644
--- a/src/xrpld/app/ledger/detail/InboundLedgers.cpp
+++ b/src/xrpld/app/ledger/detail/InboundLedgers.cpp
@@ -378,7 +378,7 @@ public:
 
         {
             ScopedLockType const sl(lock_);
-            auto it = ledgers_.begin();
+            MapType::iterator it(ledgers_.begin());
             total = ledgers_.size();
 
             stuffToSweep.reserve(total);
diff --git a/src/xrpld/app/ledger/detail/LedgerMaster.cpp b/src/xrpld/app/ledger/detail/LedgerMaster.cpp
index bab0dca827..3fcac03ed5 100644
--- a/src/xrpld/app/ledger/detail/LedgerMaster.cpp
+++ b/src/xrpld/app/ledger/detail/LedgerMaster.cpp
@@ -137,7 +137,7 @@ LedgerMaster::LedgerMaster(
           std::chrono::seconds{45},
           stopwatch,
           app_.getJournal("TaggedCache"))
-    , stats_([this] { collectMetrics(); }, collector)
+    , stats_(std::bind(&LedgerMaster::collectMetrics, this), collector)
 {
 }
 
diff --git a/src/xrpld/app/ledger/detail/LedgerPersistence.cpp b/src/xrpld/app/ledger/detail/LedgerPersistence.cpp
index 6baf64e923..3561b66951 100644
--- a/src/xrpld/app/ledger/detail/LedgerPersistence.cpp
+++ b/src/xrpld/app/ledger/detail/LedgerPersistence.cpp
@@ -8,9 +8,9 @@
 #include <xrpl/core/JobQueue.h>
 #include <xrpl/core/ServiceRegistry.h>
 #include <xrpl/ledger/PendingSaves.h>
-#include <xrpl/protocol/Indexes.h>  // IWYU pragma: keep
+#include <xrpl/protocol/Indexes.h>
 #include <xrpl/protocol/Rules.h>
-#include <xrpl/protocol/SystemParameters.h>  // IWYU pragma: keep
+#include <xrpl/protocol/SystemParameters.h>
 #include <xrpl/rdb/RelationalDatabase.h>
 
 #include <cstdint>
diff --git a/src/xrpld/app/ledger/detail/OpenLedger.cpp b/src/xrpld/app/ledger/detail/OpenLedger.cpp
index 4d8a37cdf1..60599c80d3 100644
--- a/src/xrpld/app/ledger/detail/OpenLedger.cpp
+++ b/src/xrpld/app/ledger/detail/OpenLedger.cpp
@@ -14,7 +14,7 @@
 #include <xrpl/ledger/OpenView.h>
 #include <xrpl/ledger/ReadView.h>
 #include <xrpl/protocol/Rules.h>
-#include <xrpl/protocol/SField.h>  // IWYU pragma: keep
+#include <xrpl/protocol/SField.h>
 #include <xrpl/protocol/STObject.h>
 #include <xrpl/protocol/STTx.h>
 #include <xrpl/protocol/Serializer.h>
diff --git a/src/xrpld/app/ledger/detail/TransactionMaster.cpp b/src/xrpld/app/ledger/detail/TransactionMaster.cpp
index ac2aa1aabe..129681b906 100644
--- a/src/xrpld/app/ledger/detail/TransactionMaster.cpp
+++ b/src/xrpld/app/ledger/detail/TransactionMaster.cpp
@@ -152,7 +152,7 @@ TransactionMaster::canonicalize(std::shared_ptr<Transaction>* pTransaction)
 }
 
 void
-TransactionMaster::sweep()
+TransactionMaster::sweep(void)
 {
     cache_.sweep();
 }
diff --git a/src/xrpld/app/main/Application.cpp b/src/xrpld/app/main/Application.cpp
index d329475874..b99c98afa1 100644
--- a/src/xrpld/app/main/Application.cpp
+++ b/src/xrpld/app/main/Application.cpp
@@ -79,11 +79,11 @@
 #include <xrpl/protocol/ApiVersion.h>
 #include <xrpl/protocol/BuildInfo.h>
 #include <xrpl/protocol/Feature.h>
-#include <xrpl/protocol/Indexes.h>  // IWYU pragma: keep
+#include <xrpl/protocol/Indexes.h>
 #include <xrpl/protocol/Protocol.h>
 #include <xrpl/protocol/STParsedJSON.h>
 #include <xrpl/protocol/Serializer.h>
-#include <xrpl/protocol/SystemParameters.h>  // IWYU pragma: keep
+#include <xrpl/protocol/SystemParameters.h>
 #include <xrpl/protocol/jss.h>
 #include <xrpl/rdb/DatabaseCon.h>
 #include <xrpl/resource/Charge.h>
@@ -2178,7 +2178,7 @@ fixConfigPorts(Config& config, Endpoints const& endpoints)
         auto const optPort = section.get(Keys::kPort);
         if (optPort)
         {
-            auto const port = beast::lexicalCast<std::uint16_t>(*optPort);
+            std::uint16_t const port = beast::lexicalCast<std::uint16_t>(*optPort);
             if (port == 0u)
                 section.set(Keys::kPort, std::to_string(ep.port()));
         }
diff --git a/src/xrpld/app/misc/FeeVoteImpl.cpp b/src/xrpld/app/misc/FeeVoteImpl.cpp
index 76a4d8f186..363c17f4fa 100644
--- a/src/xrpld/app/misc/FeeVoteImpl.cpp
+++ b/src/xrpld/app/misc/FeeVoteImpl.cpp
@@ -8,7 +8,7 @@
 #include <xrpl/ledger/ReadView.h>
 #include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/Fees.h>
-#include <xrpl/protocol/Protocol.h>  // IWYU pragma: keep
+#include <xrpl/protocol/Protocol.h>
 #include <xrpl/protocol/SField.h>
 #include <xrpl/protocol/STAccount.h>  // IWYU pragma: keep
 #include <xrpl/protocol/STTx.h>
diff --git a/src/xrpld/app/misc/NetworkOPs.cpp b/src/xrpld/app/misc/NetworkOPs.cpp
index 4d40247a29..82445f3625 100644
--- a/src/xrpld/app/misc/NetworkOPs.cpp
+++ b/src/xrpld/app/misc/NetworkOPs.cpp
@@ -330,7 +330,7 @@ public:
         , jobQueue_(jobQueue)
         , standalone_(standalone)
         , minPeerCount_(startValid ? 0 : minPeerCount)
-        , stats_([this] { collectMetrics(); }, collector)
+        , stats_(std::bind(&NetworkOPsImp::collectMetrics, this), collector)
     {
     }
 
@@ -4392,7 +4392,7 @@ NetworkOPsImp::findRpcSub(std::string const& strUrl)
 {
     std::scoped_lock const sl(subLock_);
 
-    auto const it = rpcSubMap_.find(strUrl);
+    subRpcMapType::iterator const it = rpcSubMap_.find(strUrl);
 
     if (it != rpcSubMap_.end())
         return it->second;
@@ -4827,7 +4827,7 @@ NetworkOPsImp::StateAccounting::json(json::Value& obj) const
     counters[static_cast<std::size_t>(mode)].dur += current;
 
     obj[jss::state_accounting] = json::ValueType::Object;
-    for (auto i = static_cast<std::size_t>(OperatingMode::DISCONNECTED);
+    for (std::size_t i = static_cast<std::size_t>(OperatingMode::DISCONNECTED);
          i <= static_cast<std::size_t>(OperatingMode::FULL);
          ++i)
     {
diff --git a/src/xrpld/app/misc/SHAMapStoreImp.cpp b/src/xrpld/app/misc/SHAMapStoreImp.cpp
index 0e0099cdbf..0389130f7a 100644
--- a/src/xrpld/app/misc/SHAMapStoreImp.cpp
+++ b/src/xrpld/app/misc/SHAMapStoreImp.cpp
@@ -331,9 +331,11 @@ SHAMapStoreImp::run()
             try
             {
                 validatedLedger->stateMap().snapShot(false)->visitNodes(
-                    [this, &nodeCount](SHAMapTreeNode const& node) {
-                        return copyNode(nodeCount, node);
-                    });
+                    std::bind(
+                        &SHAMapStoreImp::copyNode,
+                        this,
+                        std::ref(nodeCount),
+                        std::placeholders::_1));
             }
             catch (SHAMapMissingNode const& e)
             {
diff --git a/src/xrpld/app/misc/detail/AmendmentTable.cpp b/src/xrpld/app/misc/detail/AmendmentTable.cpp
index 694268752e..4f331b0781 100644
--- a/src/xrpld/app/misc/detail/AmendmentTable.cpp
+++ b/src/xrpld/app/misc/detail/AmendmentTable.cpp
@@ -643,7 +643,6 @@ AmendmentState*
 AmendmentTableImpl::get(uint256 const& amendmentHash, std::scoped_lock<std::mutex> const& lock)
 {
     // Forward to the const version of get.
-    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-const-cast)
     return const_cast<AmendmentState*>(std::as_const(*this).get(amendmentHash, lock));
 }
 
diff --git a/src/xrpld/app/misc/detail/Transaction.cpp b/src/xrpld/app/misc/detail/Transaction.cpp
index e29181bfe9..2c55c474eb 100644
--- a/src/xrpld/app/misc/detail/Transaction.cpp
+++ b/src/xrpld/app/misc/detail/Transaction.cpp
@@ -103,7 +103,7 @@ Transaction::transactionFromSQL(
     Blob const& rawTxn,
     Application& app)
 {
-    auto const inLedger = rangeCheckedCast<std::uint32_t>(ledgerSeq.value_or(0));
+    std::uint32_t const inLedger = rangeCheckedCast<std::uint32_t>(ledgerSeq.value_or(0));
 
     SerialIter it(makeSlice(rawTxn));
     auto txn = std::make_shared<STTx const>(it);
diff --git a/src/xrpld/app/misc/detail/TxQ.cpp b/src/xrpld/app/misc/detail/TxQ.cpp
index 2092b4ec27..513ea233c8 100644
--- a/src/xrpld/app/misc/detail/TxQ.cpp
+++ b/src/xrpld/app/misc/detail/TxQ.cpp
@@ -229,11 +229,11 @@ static_assert(sumOfFirstSquares(1).second == 1);
 static_assert(sumOfFirstSquares(2).first);
 static_assert(sumOfFirstSquares(2).second == 5);
 
-static_assert(sumOfFirstSquares(0x1FFFFF).first);
-static_assert(sumOfFirstSquares(0x1FFFFF).second == 0x2AAAA8AAAAB00000ul);
+static_assert(sumOfFirstSquares(0x1FFFFF).first, "");
+static_assert(sumOfFirstSquares(0x1FFFFF).second == 0x2AAAA8AAAAB00000ul, "");
 
-static_assert(!sumOfFirstSquares(0x200000).first);
-static_assert(sumOfFirstSquares(0x200000).second == std::numeric_limits<std::uint64_t>::max());
+static_assert(!sumOfFirstSquares(0x200000).first, "");
+static_assert(sumOfFirstSquares(0x200000).second == std::numeric_limits<std::uint64_t>::max(), "");
 
 }  // namespace detail
 
@@ -792,7 +792,7 @@ TxQ::apply(
     std::scoped_lock const lock(mutex_);
 
     // accountIter is not const because it may be updated further down.
-    auto accountIter = byAccount_.find(account);
+    AccountMap::iterator accountIter = byAccount_.find(account);
     bool const accountIsInQueue = accountIter != byAccount_.end();
 
     // _If_ the account is in the queue, then ignore any sequence-based
@@ -821,7 +821,7 @@ TxQ::apply(
 
         // Find the first transaction in the queue that we might apply.
         TxQAccount::TxMap& acctTxs = accountIter->second.transactions;
-        auto const firstIter = acctTxs.lower_bound(acctSeqProx);
+        TxQAccount::TxMap::iterator const firstIter = acctTxs.lower_bound(acctSeqProx);
 
         if (firstIter == acctTxs.end())
         {
@@ -1000,7 +1000,7 @@ TxQ::apply(
 
             // Find the entry in the queue that precedes the new
             // transaction, if one does.
-            auto const prevIter = txQAcct.getPrevTx(txSeqProx);
+            TxQAccount::TxMap::const_iterator const prevIter = txQAcct.getPrevTx(txSeqProx);
 
             // Does the new transaction go to the front of the queue?
             // This can happen if:
@@ -1619,7 +1619,7 @@ TxQ::nextQueuableSeqImpl(SLE::const_ref sleAccount, std::scoped_lock<std::mutex>
     // Ignore any sequence-based queued transactions that slipped into the
     // ledger while we were not watching.  This does actually happen in the
     // wild, but it's uncommon.
-    auto txIter = acctTxs.lower_bound(acctSeqProx);
+    TxQAccount::TxMap::const_iterator txIter = acctTxs.lower_bound(acctSeqProx);
 
     if (txIter == acctTxs.end() || !txIter->first.isSeq() || txIter->first != acctSeqProx)
     {
@@ -1704,7 +1704,7 @@ TxQ::tryDirectApply(
             // queue then remove the replaced transaction.
             std::scoped_lock const lock(mutex_);
 
-            auto const accountIter = byAccount_.find(account);
+            AccountMap::iterator const accountIter = byAccount_.find(account);
             if (accountIter != byAccount_.end())
             {
                 TxQAccount& txQAcct = accountIter->second;
diff --git a/src/xrpld/app/misc/detail/WorkBase.h b/src/xrpld/app/misc/detail/WorkBase.h
index 73e5081036..5f5fdd28b7 100644
--- a/src/xrpld/app/misc/detail/WorkBase.h
+++ b/src/xrpld/app/misc/detail/WorkBase.h
@@ -12,7 +12,6 @@
 #include <boost/beast/http/read.hpp>
 #include <boost/beast/http/write.hpp>
 
-#include <cstddef>
 #include <functional>
 #include <string>
 #include <utility>
@@ -139,9 +138,9 @@ WorkBase<Impl>::run()
     if (!strand_.running_in_this_thread())
     {
         return boost::asio::post(
-            ios_, boost::asio::bind_executor(strand_, [self = impl().shared_from_this()] {
-                self->run();
-            }));
+            ios_,
+            boost::asio::bind_executor(
+                strand_, std::bind(&WorkBase::run, impl().shared_from_this())));
     }
 
     resolver_.async_resolve(
@@ -149,9 +148,11 @@ WorkBase<Impl>::run()
         port_,
         boost::asio::bind_executor(
             strand_,
-            [self = impl().shared_from_this()](error_code const& ec, results_type results) {
-                self->onResolve(ec, results);
-            }));
+            std::bind(
+                &WorkBase::onResolve,
+                impl().shared_from_this(),
+                std::placeholders::_1,
+                std::placeholders::_2)));
 }
 
 template <class Impl>
@@ -164,7 +165,7 @@ WorkBase<Impl>::cancel()
             ios_,
 
             boost::asio::bind_executor(
-                strand_, [self = impl().shared_from_this()] { self->cancel(); }));
+                strand_, std::bind(&WorkBase::cancel, impl().shared_from_this())));
     }
 
     error_code ec;
@@ -195,12 +196,11 @@ WorkBase<Impl>::onResolve(error_code const& ec, results_type results)
         results,
         boost::asio::bind_executor(
             strand_,
-            [self = impl().shared_from_this()](
-                error_code const& ec, endpoint_type const& endpoint) {
-                // Call the base-class overload explicitly: the derived Impl
-                // hides it with its own single-argument onConnect(ec).
-                self->WorkBase::onConnect(ec, endpoint);
-            }));
+            std::bind(
+                &WorkBase::onConnect,
+                impl().shared_from_this(),
+                std::placeholders::_1,
+                std::placeholders::_2)));
 }
 
 template <class Impl>
@@ -229,9 +229,8 @@ WorkBase<Impl>::onStart()
         impl().stream(),
         req_,
         boost::asio::bind_executor(
-            strand_, [self = impl().shared_from_this()](error_code const& ec, std::size_t) {
-                self->onRequest(ec);
-            }));
+            strand_,
+            std::bind(&WorkBase::onRequest, impl().shared_from_this(), std::placeholders::_1)));
 }
 
 template <class Impl>
@@ -246,9 +245,8 @@ WorkBase<Impl>::onRequest(error_code const& ec)
         readBuf_,
         res_,
         boost::asio::bind_executor(
-            strand_, [self = impl().shared_from_this()](error_code const& ec, std::size_t) {
-                self->onResponse(ec);
-            }));
+            strand_,
+            std::bind(&WorkBase::onResponse, impl().shared_from_this(), std::placeholders::_1)));
 }
 
 template <class Impl>
diff --git a/src/xrpld/app/misc/detail/WorkFile.h b/src/xrpld/app/misc/detail/WorkFile.h
index eb42d14db4..2fc7ab952d 100644
--- a/src/xrpld/app/misc/detail/WorkFile.h
+++ b/src/xrpld/app/misc/detail/WorkFile.h
@@ -63,9 +63,9 @@ WorkFile::run()
 {
     if (!strand_.running_in_this_thread())
     {
-        boost::asio::post(ios_, boost::asio::bind_executor(strand_, [self = shared_from_this()] {
-                              self->run();
-                          }));
+        boost::asio::post(
+            ios_,
+            boost::asio::bind_executor(strand_, std::bind(&WorkFile::run, shared_from_this())));
         return;
     }
 
diff --git a/src/xrpld/app/misc/detail/WorkSSL.cpp b/src/xrpld/app/misc/detail/WorkSSL.cpp
index e8d24b55d6..e1b864e81f 100644
--- a/src/xrpld/app/misc/detail/WorkSSL.cpp
+++ b/src/xrpld/app/misc/detail/WorkSSL.cpp
@@ -12,6 +12,7 @@
 #include <boost/asio/ssl/stream_base.hpp>
 #include <boost/format/free_funcs.hpp>
 
+#include <functional>
 #include <stdexcept>
 #include <string>
 
@@ -54,7 +55,7 @@ WorkSSL::onConnect(error_code const& ec)
     stream_.async_handshake(
         boost::asio::ssl::stream_base::client,
         boost::asio::bind_executor(
-            strand_, [self = shared_from_this()](error_code const& ec) { self->onHandshake(ec); }));
+            strand_, std::bind(&WorkSSL::onHandshake, shared_from_this(), std::placeholders::_1)));
 }
 
 void
diff --git a/src/xrpld/app/rdb/backend/detail/Node.cpp b/src/xrpld/app/rdb/backend/detail/Node.cpp
index f8dc4a6981..6e92a0de60 100644
--- a/src/xrpld/app/rdb/backend/detail/Node.cpp
+++ b/src/xrpld/app/rdb/backend/detail/Node.cpp
@@ -1273,7 +1273,7 @@ getTransaction(
         if (!ledgerSeq)
             return std::pair{std::move(txn), nullptr};
 
-        auto const inLedger = rangeCheckedCast<std::uint32_t>(ledgerSeq.value());
+        std::uint32_t const inLedger = rangeCheckedCast<std::uint32_t>(ledgerSeq.value());
 
         auto txMeta = std::make_shared<TxMeta>(id, inLedger, rawMeta);
 
diff --git a/src/xrpld/app/rdb/backend/detail/SQLiteDatabase.cpp b/src/xrpld/app/rdb/backend/detail/SQLiteDatabase.cpp
index 338a3a33df..fd1298516f 100644
--- a/src/xrpld/app/rdb/backend/detail/SQLiteDatabase.cpp
+++ b/src/xrpld/app/rdb/backend/detail/SQLiteDatabase.cpp
@@ -421,9 +421,8 @@ SQLiteDatabase::oldestAccountTxPage(AccountTxPageOptions const& options)
         return {};
 
     static std::uint32_t const kPageLength(200);
-    auto onUnsavedLedger = [&app = registry_.get().getApp()](std::uint32_t seq) {
-        saveLedgerAsync(app, seq);
-    };
+    auto onUnsavedLedger =
+        std::bind(saveLedgerAsync, std::ref(registry_.get().getApp()), std::placeholders::_1);
     AccountTxs ret;
     auto onTransaction = [&ret, &app = registry_.get().getApp()](
                              std::uint32_t ledgerIndex,
@@ -452,9 +451,8 @@ SQLiteDatabase::newestAccountTxPage(AccountTxPageOptions const& options)
         return {};
 
     static std::uint32_t const kPageLength(200);
-    auto onUnsavedLedger = [&app = registry_.get().getApp()](std::uint32_t seq) {
-        saveLedgerAsync(app, seq);
-    };
+    auto onUnsavedLedger =
+        std::bind(saveLedgerAsync, std::ref(registry_.get().getApp()), std::placeholders::_1);
     AccountTxs ret;
     auto onTransaction = [&ret, &app = registry_.get().getApp()](
                              std::uint32_t ledgerIndex,
@@ -483,9 +481,8 @@ SQLiteDatabase::oldestAccountTxPageB(AccountTxPageOptions const& options)
         return {};
 
     static std::uint32_t const kPageLength(500);
-    auto onUnsavedLedger = [&app = registry_.get().getApp()](std::uint32_t seq) {
-        saveLedgerAsync(app, seq);
-    };
+    auto onUnsavedLedger =
+        std::bind(saveLedgerAsync, std::ref(registry_.get().getApp()), std::placeholders::_1);
     MetaTxsList ret;
     auto onTransaction =
         [&ret](
@@ -512,9 +509,8 @@ SQLiteDatabase::newestAccountTxPageB(AccountTxPageOptions const& options)
         return {};
 
     static std::uint32_t const kPageLength(500);
-    auto onUnsavedLedger = [&app = registry_.get().getApp()](std::uint32_t seq) {
-        saveLedgerAsync(app, seq);
-    };
+    auto onUnsavedLedger =
+        std::bind(saveLedgerAsync, std::ref(registry_.get().getApp()), std::placeholders::_1);
     MetaTxsList ret;
     auto onTransaction =
         [&ret](
diff --git a/src/xrpld/app/rdb/detail/PeerFinder.cpp b/src/xrpld/app/rdb/detail/PeerFinder.cpp
index abdcd1c61a..c40e3e42c6 100644
--- a/src/xrpld/app/rdb/detail/PeerFinder.cpp
+++ b/src/xrpld/app/rdb/detail/PeerFinder.cpp
@@ -147,10 +147,10 @@ updatePeerFinderDB(soci::session& session, int currentSchemaVersion, beast::Jour
             s.reserve(list.size());
             valence.reserve(list.size());
 
-            for (auto const& entry : list)
+            for (auto iter(list.cbegin()); iter != list.cend(); ++iter)
             {
-                s.emplace_back(to_string(entry.endpoint));
-                valence.emplace_back(entry.valence);
+                s.emplace_back(to_string(iter->endpoint));
+                valence.emplace_back(iter->valence);
             }
 
             session << "INSERT INTO PeerFinder_BootstrapCache_Next ( "
diff --git a/src/xrpld/core/detail/Config.cpp b/src/xrpld/core/detail/Config.cpp
index 0706163ab1..523cde743a 100644
--- a/src/xrpld/core/detail/Config.cpp
+++ b/src/xrpld/core/detail/Config.cpp
@@ -98,7 +98,7 @@ getMemorySize()
     std::int64_t ram = 0;
     size_t size = sizeof(ram);
 
-    if (sysctl(mib, 2, &ram, &size, nullptr, 0) == 0)
+    if (sysctl(mib, 2, &ram, &size, NULL, 0) == 0)
         return static_cast<std::uint64_t>(ram);
 
     return 0;
@@ -917,7 +917,7 @@ Config::loadFromString(std::string const& fileContents)
     if (getSingleSection(secConfig, Sections::kAmendmentMajorityTime, strTemp, j_))
     {
         using namespace std::chrono;
-        boost::regex const re(R"(^\s*(\d+)\s*(minutes|hours|days|weeks)\s*(\s+.*)?$)");
+        boost::regex const re("^\\s*(\\d+)\\s*(minutes|hours|days|weeks)\\s*(\\s+.*)?$");
         boost::smatch match;
         if (!boost::regex_match(strTemp, match, re))
         {
@@ -926,7 +926,7 @@ Config::loadFromString(std::string const& fileContents)
                 ", must be: [0-9]+ [minutes|hours|days|weeks]");
         }
 
-        auto const duration = beast::lexicalCastThrow<std::uint32_t>(match[1].str());
+        std::uint32_t const duration = beast::lexicalCastThrow<std::uint32_t>(match[1].str());
 
         if (boost::iequals(match[2], "minutes"))
         {
diff --git a/src/xrpld/overlay/detail/ConnectAttempt.cpp b/src/xrpld/overlay/detail/ConnectAttempt.cpp
index 064b4ecd3e..295f4f5497 100644
--- a/src/xrpld/overlay/detail/ConnectAttempt.cpp
+++ b/src/xrpld/overlay/detail/ConnectAttempt.cpp
@@ -35,8 +35,8 @@
 #include <boost/system/system_error.hpp>
 
 #include <chrono>
-#include <cstddef>
 #include <exception>
+#include <functional>
 #include <memory>
 #include <optional>
 #include <string>
@@ -86,7 +86,7 @@ ConnectAttempt::stop()
 {
     if (!strand_.running_in_this_thread())
     {
-        boost::asio::post(strand_, [self = shared_from_this()] { self->stop(); });
+        boost::asio::post(strand_, std::bind(&ConnectAttempt::stop, shared_from_this()));
         return;
     }
     if (socket_.is_open())
@@ -104,7 +104,8 @@ ConnectAttempt::run()
     stream_.next_layer().async_connect(
         remoteEndpoint_,
         boost::asio::bind_executor(
-            strand_, [self = shared_from_this()](error_code const& ec) { self->onConnect(ec); }));
+            strand_,
+            std::bind(&ConnectAttempt::onConnect, shared_from_this(), std::placeholders::_1)));
 }
 
 //------------------------------------------------------------------------------
@@ -159,7 +160,8 @@ ConnectAttempt::setTimer()
 
     timer_.async_wait(
         boost::asio::bind_executor(
-            strand_, [self = shared_from_this()](error_code const& ec) { self->onTimer(ec); }));
+            strand_,
+            std::bind(&ConnectAttempt::onTimer, shared_from_this(), std::placeholders::_1)));
 }
 
 void
@@ -226,7 +228,8 @@ ConnectAttempt::onConnect(error_code ec)
     stream_.async_handshake(
         boost::asio::ssl::stream_base::client,
         boost::asio::bind_executor(
-            strand_, [self = shared_from_this()](error_code const& ec) { self->onHandshake(ec); }));
+            strand_,
+            std::bind(&ConnectAttempt::onHandshake, shared_from_this(), std::placeholders::_1)));
 }
 
 void
@@ -287,7 +290,7 @@ ConnectAttempt::onHandshake(error_code ec)
         req_,
         boost::asio::bind_executor(
             strand_,
-            [self = shared_from_this()](error_code const& ec, std::size_t) { self->onWrite(ec); }));
+            std::bind(&ConnectAttempt::onWrite, shared_from_this(), std::placeholders::_1)));
 }
 
 void
@@ -313,7 +316,7 @@ ConnectAttempt::onWrite(error_code ec)
         response_,
         boost::asio::bind_executor(
             strand_,
-            [self = shared_from_this()](error_code const& ec, std::size_t) { self->onRead(ec); }));
+            std::bind(&ConnectAttempt::onRead, shared_from_this(), std::placeholders::_1)));
 }
 
 void
@@ -336,7 +339,8 @@ ConnectAttempt::onRead(error_code ec)
             stream_.async_shutdown(
                 boost::asio::bind_executor(
                     strand_,
-                    [self = shared_from_this()](error_code const& ec) { self->onShutdown(ec); }));
+                    std::bind(
+                        &ConnectAttempt::onShutdown, shared_from_this(), std::placeholders::_1)));
             return;
         }
 
diff --git a/src/xrpld/overlay/detail/OverlayImpl.cpp b/src/xrpld/overlay/detail/OverlayImpl.cpp
index b7af3b6ace..89c7dfe5eb 100644
--- a/src/xrpld/overlay/detail/OverlayImpl.cpp
+++ b/src/xrpld/overlay/detail/OverlayImpl.cpp
@@ -133,7 +133,7 @@ OverlayImpl::Timer::asyncWait()
     timer.async_wait(
         boost::asio::bind_executor(
             overlay_.strand_,
-            [self = shared_from_this()](error_code const& ec) { self->onTimer(ec); }));
+            std::bind(&Timer::onTimer, shared_from_this(), std::placeholders::_1)));
 }
 
 void
@@ -190,7 +190,7 @@ OverlayImpl::OverlayImpl(
     , nextId_(1)
     , slots_(app, *this, app.config())
     , stats_(
-          [this] { collectMetrics(); },
+          std::bind(&OverlayImpl::collectMetrics, this),
           collector,
           [counts = traffic_.getCounts(), collector]() {
               std::unordered_map<TrafficCount::Category, TrafficGauges> ret;
@@ -593,7 +593,7 @@ OverlayImpl::start()
 void
 OverlayImpl::stop()
 {
-    boost::asio::dispatch(strand_, [this] { stopChildren(); });
+    boost::asio::dispatch(strand_, std::bind(&OverlayImpl::stopChildren, this));
     {
         std::unique_lock<decltype(mutex_)> lock(mutex_);
         cond_.wait(lock, [this] { return list_.empty(); });
@@ -1490,7 +1490,7 @@ OverlayImpl::deletePeer(Peer::id_t id)
 {
     if (!strand_.running_in_this_thread())
     {
-        post(strand_, [this, id] { deletePeer(id); });
+        post(strand_, std::bind(&OverlayImpl::deletePeer, this, id));
         return;
     }
 
@@ -1502,7 +1502,7 @@ OverlayImpl::deleteIdlePeers()
 {
     if (!strand_.running_in_this_thread())
     {
-        post(strand_, [this] { deleteIdlePeers(); });
+        post(strand_, std::bind(&OverlayImpl::deleteIdlePeers, this));
         return;
     }
 
diff --git a/src/xrpld/overlay/detail/OverlayImpl.h b/src/xrpld/overlay/detail/OverlayImpl.h
index 83d5a81a89..7db32c0d23 100644
--- a/src/xrpld/overlay/detail/OverlayImpl.h
+++ b/src/xrpld/overlay/detail/OverlayImpl.h
@@ -427,7 +427,7 @@ public:
     addTxMetrics(Args... args)
     {
         if (!strand_.running_in_this_thread())
-            return post(strand_, [this, args...] { addTxMetrics(args...); });
+            return post(strand_, std::bind(&OverlayImpl::addTxMetrics<Args...>, this, args...));
 
         txMetrics_.addMetrics(args...);
     }
diff --git a/src/xrpld/overlay/detail/PeerImp.cpp b/src/xrpld/overlay/detail/PeerImp.cpp
index 4e42d46f46..5ac61cfd91 100644
--- a/src/xrpld/overlay/detail/PeerImp.cpp
+++ b/src/xrpld/overlay/detail/PeerImp.cpp
@@ -321,9 +321,9 @@ PeerImp::send(std::shared_ptr<Message> const& m)
             self->stream_,
             boost::asio::buffer(self->sendQueue_.front()->getBuffer(self->compressionEnabled_)),
             bind_executor(
-                self->strand_, [self](error_code const& ec, std::size_t bytesTransferred) {
-                    self->onWriteMessage(ec, bytesTransferred);
-                }));
+                self->strand_,
+                std::bind(
+                    &PeerImp::onWriteMessage, self, std::placeholders::_1, std::placeholders::_2)));
     });
 }
 
@@ -650,7 +650,7 @@ PeerImp::gracefulClose()
         return;
     setTimer();
     stream_.async_shutdown(bind_executor(
-        strand_, [self = shared_from_this()](error_code const& ec) { self->onShutdown(ec); }));
+        strand_, std::bind(&PeerImp::onShutdown, shared_from_this(), std::placeholders::_1)));
 }
 
 void
@@ -666,7 +666,7 @@ PeerImp::setTimer()
         return;
     }
     timer_.async_wait(bind_executor(
-        strand_, [self = shared_from_this()](error_code const& ec) { self->onTimer(ec); }));
+        strand_, std::bind(&PeerImp::onTimer, shared_from_this(), std::placeholders::_1)));
 }
 
 // convenience for ignoring the error code
@@ -975,9 +975,11 @@ PeerImp::onReadMessage(error_code ec, std::size_t bytesTransferred)
         readBuffer_.prepare(std::max(Tuning::kReadBufferBytes, hint)),
         bind_executor(
             strand_,
-            [self = shared_from_this()](error_code const& ec, std::size_t bytesTransferred) {
-                self->onReadMessage(ec, bytesTransferred);
-            }));
+            std::bind(
+                &PeerImp::onReadMessage,
+                shared_from_this(),
+                std::placeholders::_1,
+                std::placeholders::_2)));
 }
 
 void
@@ -1012,16 +1014,18 @@ PeerImp::onWriteMessage(error_code ec, std::size_t bytesTransferred)
             boost::asio::buffer(sendQueue_.front()->getBuffer(compressionEnabled_)),
             bind_executor(
                 strand_,
-                [self = shared_from_this()](error_code const& ec, std::size_t bytesTransferred) {
-                    self->onWriteMessage(ec, bytesTransferred);
-                }));
+                std::bind(
+                    &PeerImp::onWriteMessage,
+                    shared_from_this(),
+                    std::placeholders::_1,
+                    std::placeholders::_2)));
         return;
     }
 
     if (gracefulClose_)
     {
         stream_.async_shutdown(bind_executor(
-            strand_, [self = shared_from_this()](error_code const& ec) { self->onShutdown(ec); }));
+            strand_, std::bind(&PeerImp::onShutdown, shared_from_this(), std::placeholders::_1)));
         return;
     }
 }
@@ -2130,7 +2134,6 @@ PeerImp::onValidatorListMessage(
             publisherListSequences_[pubKey] = applyResult.sequence;
         }
         break;
-        // NOLINTNEXTLINE(bugprone-branch-clone): identical to the next branch only in Release
         case ListDisposition::SameSequence:
         case ListDisposition::KnownSequence:
 #ifndef NDEBUG
diff --git a/src/xrpld/overlay/detail/PeerImp.h b/src/xrpld/overlay/detail/PeerImp.h
index e9ef948d48..4a96f9a6e6 100644
--- a/src/xrpld/overlay/detail/PeerImp.h
+++ b/src/xrpld/overlay/detail/PeerImp.h
@@ -322,11 +322,12 @@ public:
     removeTxQueue(uint256 const& hash) override;
 
     /** Send a set of PeerFinder endpoints as a protocol message. */
-    template <class FwdIt>
+    template <
+        class FwdIt,
+        class = std::enable_if_t<
+            std::is_same_v<typename std::iterator_traits<FwdIt>::value_type, PeerFinder::Endpoint>>>
     void
-    sendEndpoints(FwdIt first, FwdIt last)
-        requires(
-            std::is_same_v<typename std::iterator_traits<FwdIt>::value_type, PeerFinder::Endpoint>);
+    sendEndpoints(FwdIt first, FwdIt last);
 
     beast::IP::Endpoint
     getRemoteAddress() const override
@@ -786,10 +787,9 @@ PeerImp::PeerImp(
         << id_;
 }
 
-template <class FwdIt>
+template <class FwdIt, class>
 void
 PeerImp::sendEndpoints(FwdIt first, FwdIt last)
-    requires(std::is_same_v<typename std::iterator_traits<FwdIt>::value_type, PeerFinder::Endpoint>)
 {
     protocol::TMEndpoints tm;
 
diff --git a/src/xrpld/overlay/detail/ProtocolMessage.h b/src/xrpld/overlay/detail/ProtocolMessage.h
index 156fcfc104..da418f8e82 100644
--- a/src/xrpld/overlay/detail/ProtocolMessage.h
+++ b/src/xrpld/overlay/detail/ProtocolMessage.h
@@ -237,10 +237,12 @@ parseMessageHeader(boost::system::error_code& ec, BufferSequence const& bufs, st
     return std::nullopt;
 }
 
-template <class T, class Buffers>
+template <
+    class T,
+    class Buffers,
+    class = std::enable_if_t<std::is_base_of_v<::google::protobuf::Message, T>>>
 std::shared_ptr<T>
 parseMessageContent(MessageHeader const& header, Buffers const& buffers)
-    requires(std::is_base_of_v<::google::protobuf::Message, T>)
 {
     auto m = std::make_shared<T>();
 
@@ -270,10 +272,13 @@ parseMessageContent(MessageHeader const& header, Buffers const& buffers)
     return m;
 }
 
-template <class T, class Buffers, class Handler>
+template <
+    class T,
+    class Buffers,
+    class Handler,
+    class = std::enable_if_t<std::is_base_of_v<::google::protobuf::Message, T>>>
 bool
 invoke(MessageHeader const& header, Buffers const& buffers, Handler& handler)
-    requires(std::is_base_of_v<::google::protobuf::Message, T>)
 {
     auto const m = parseMessageContent<T>(header, buffers);
     if (!m)
diff --git a/src/xrpld/peerfinder/detail/Bootcache.h b/src/xrpld/peerfinder/detail/Bootcache.h
index cee03fa322..5384bb356a 100644
--- a/src/xrpld/peerfinder/detail/Bootcache.h
+++ b/src/xrpld/peerfinder/detail/Bootcache.h
@@ -3,6 +3,7 @@
 #include <xrpld/peerfinder/PeerfinderManager.h>
 #include <xrpld/peerfinder/detail/Store.h>
 
+#include <xrpl/basics/comparators.h>
 #include <xrpl/beast/net/IPEndpoint.h>
 #include <xrpl/beast/utility/Journal.h>
 #include <xrpl/beast/utility/PropertyStream.h>
@@ -12,8 +13,6 @@
 #include <boost/bimap/unordered_set_of.hpp>
 #include <boost/iterator/transform_iterator.hpp>
 
-#include <functional>
-
 namespace xrpl::PeerFinder {
 
 /** Stores IP addresses useful for gaining initial connections.
@@ -63,9 +62,11 @@ private:
         int valence_;
     };
 
-    using left_t = boost::bimaps::
-        unordered_set_of<beast::IP::Endpoint, boost::hash<beast::IP::Endpoint>, std::equal_to<>>;
-    using right_t = boost::bimaps::multiset_of<Entry, std::less<>>;
+    using left_t = boost::bimaps::unordered_set_of<
+        beast::IP::Endpoint,
+        boost::hash<beast::IP::Endpoint>,
+        xrpl::equal_to<beast::IP::Endpoint>>;
+    using right_t = boost::bimaps::multiset_of<Entry, xrpl::less<Entry>>;
     using map_type = boost::bimap<left_t, right_t>;
     using value_type = map_type::value_type;
 
diff --git a/src/xrpld/peerfinder/detail/Checker.h b/src/xrpld/peerfinder/detail/Checker.h
index 208bad390c..20687448df 100644
--- a/src/xrpld/peerfinder/detail/Checker.h
+++ b/src/xrpld/peerfinder/detail/Checker.h
@@ -8,6 +8,7 @@
 #include <boost/intrusive/list.hpp>
 
 #include <condition_variable>
+#include <functional>
 #include <memory>
 #include <mutex>
 
@@ -182,7 +183,7 @@ Checker<Protocol>::asyncConnect(beast::IP::Endpoint const& endpoint, Handler&& h
     }
     op->socket.async_connect(
         beast::IPAddressConversion::toAsioEndpoint(endpoint),
-        [op](error_code const& ec) { (*op)(ec); });
+        std::bind(&BasicAsyncOp::operator(), op, std::placeholders::_1));
 }
 
 template <class Protocol>
diff --git a/src/xrpld/peerfinder/detail/Logic.h b/src/xrpld/peerfinder/detail/Logic.h
index 8ea348f560..7d10f7f516 100644
--- a/src/xrpld/peerfinder/detail/Logic.h
+++ b/src/xrpld/peerfinder/detail/Logic.h
@@ -802,10 +802,12 @@ public:
                     //
                     checker.asyncConnect(
                         ep.address,
-                        [this, remoteAddress = slot->remoteEndpoint(), checkedAddress = ep.address](
-                            boost::system::error_code const& ec) {
-                            checkComplete(remoteAddress, checkedAddress, ec);
-                        });
+                        std::bind(
+                            &Logic::checkComplete,
+                            this,
+                            slot->remoteEndpoint(),
+                            ep.address,
+                            std::placeholders::_1));
 
                     // Note that we simply discard the first Endpoint
                     // that the neighbor sends when we perform the
diff --git a/src/xrpld/peerfinder/detail/PeerfinderManager.cpp b/src/xrpld/peerfinder/detail/PeerfinderManager.cpp
index 2727a03013..9dbedfe4f1 100644
--- a/src/xrpld/peerfinder/detail/PeerfinderManager.cpp
+++ b/src/xrpld/peerfinder/detail/PeerfinderManager.cpp
@@ -20,6 +20,7 @@
 #include <boost/asio/io_context.hpp>
 #include <boost/asio/ip/tcp.hpp>
 
+#include <functional>
 #include <memory>
 #include <mutex>
 #include <optional>
@@ -60,7 +61,7 @@ public:
         , checker_(io_context_)
         , logic_(clock, store_, checker_, journal)
         , config_(config)
-        , stats_([this] { collectMetrics(); }, collector)
+        , stats_(std::bind(&ManagerImp::collectMetrics, this), collector)
     {
     }
 
diff --git a/src/xrpld/peerfinder/detail/SourceStrings.cpp b/src/xrpld/peerfinder/detail/SourceStrings.cpp
index 7b28db4306..61a3e0c021 100644
--- a/src/xrpld/peerfinder/detail/SourceStrings.cpp
+++ b/src/xrpld/peerfinder/detail/SourceStrings.cpp
@@ -32,11 +32,11 @@ public:
     {
         results.addresses.resize(0);
         results.addresses.reserve(strings_.size());
-        for (auto const& str : strings_)
+        for (int i = 0; i < strings_.size(); ++i)
         {
-            beast::IP::Endpoint ep(beast::IP::Endpoint::fromString(str));
+            beast::IP::Endpoint ep(beast::IP::Endpoint::fromString(strings_[i]));
             if (isUnspecified(ep))
-                ep = beast::IP::Endpoint::fromString(str);
+                ep = beast::IP::Endpoint::fromString(strings_[i]);
             if (!isUnspecified(ep))
                 results.addresses.push_back(ep);
         }
diff --git a/src/xrpld/rpc/CTID.h b/src/xrpld/rpc/CTID.h
index 7566e0e143..c2133a19b5 100644
--- a/src/xrpld/rpc/CTID.h
+++ b/src/xrpld/rpc/CTID.h
@@ -104,9 +104,9 @@ decodeCTID(T const ctid) noexcept
     if ((ctidValue & kCtidPrefixMask) != kCtidPrefix)
         return std::nullopt;
 
-    auto const ledgerSeq = static_cast<uint32_t>((ctidValue >> 32) & 0x0FFF'FFFF);
-    auto const txnIndex = static_cast<uint16_t>((ctidValue >> 16) & 0xFFFF);
-    auto const networkID = static_cast<uint16_t>(ctidValue & 0xFFFF);
+    uint32_t const ledgerSeq = static_cast<uint32_t>((ctidValue >> 32) & 0x0FFF'FFFF);
+    uint16_t const txnIndex = static_cast<uint16_t>((ctidValue >> 16) & 0xFFFF);
+    uint16_t const networkID = static_cast<uint16_t>(ctidValue & 0xFFFF);
 
     return std::make_tuple(ledgerSeq, txnIndex, networkID);
 }
diff --git a/src/xrpld/rpc/Status.h b/src/xrpld/rpc/Status.h
index ff77f2ace7..4f15ab0242 100644
--- a/src/xrpld/rpc/Status.h
+++ b/src/xrpld/rpc/Status.h
@@ -33,11 +33,9 @@ public:
 
     Status() = default;
 
-    // The constraint allows only integers (not enums).  Prevents enum narrowing.
-    template <typename T>
-    Status(T code, Strings d = {})
-        requires(std::is_integral_v<T>)
-        : code_(code), messages_(std::move(d))
+    // The enable_if allows only integers (not enums).  Prevents enum narrowing.
+    template <typename T, typename = std::enable_if_t<std::is_integral_v<T>>>
+    Status(T code, Strings d = {}) : code_(code), messages_(std::move(d))
     {
     }
 
diff --git a/src/xrpld/rpc/detail/Pathfinder.cpp b/src/xrpld/rpc/detail/Pathfinder.cpp
index 5b7f1415a2..fc788dea7d 100644
--- a/src/xrpld/rpc/detail/Pathfinder.cpp
+++ b/src/xrpld/rpc/detail/Pathfinder.cpp
@@ -1158,10 +1158,11 @@ Pathfinder::addLink(
                 {
                     std::ranges::sort(
                         candidates,
-                        [seq = ledger_->seq()](
-                            AccountCandidate const& first, AccountCandidate const& second) {
-                            return compareAccountCandidate(seq, first, second);
-                        });
+                        std::bind(
+                            compareAccountCandidate,
+                            ledger_->seq(),
+                            std::placeholders::_1,
+                            std::placeholders::_2));
 
                     int count = candidates.size();
                     // allow more paths from source
diff --git a/src/xrpld/rpc/detail/RPCCall.cpp b/src/xrpld/rpc/detail/RPCCall.cpp
index af5677008d..123b9fc7a5 100644
--- a/src/xrpld/rpc/detail/RPCCall.cpp
+++ b/src/xrpld/rpc/detail/RPCCall.cpp
@@ -1745,9 +1745,7 @@ rpcClient(
                     static_cast<int>(setup.client.secure) != 0,  // Use SSL
                     config.quiet(),
                     logs,
-                    [&jvOutput](json::Value const& jvInput) {
-                        RPCCallImp::callRPCHandler(&jvOutput, jvInput);
-                    },
+                    std::bind(RPCCallImp::callRPCHandler, &jvOutput, std::placeholders::_1),
                     headers);
                 isService.run();  // This blocks until there are no more
                                   // outstanding async calls.
@@ -1872,16 +1870,24 @@ fromNetwork(
         ioContext,
         strIp,
         iPort,
-        [strMethod, jvParams, headers, strPath, j](
-            boost::asio::streambuf& sb, std::string const& strHost) {
-            RPCCallImp::onRequest(strMethod, jvParams, headers, strPath, sb, strHost, j);
-        },
+        std::bind(
+            &RPCCallImp::onRequest,
+            strMethod,
+            jvParams,
+            headers,
+            strPath,
+            std::placeholders::_1,
+            std::placeholders::_2,
+            j),
         kRpcReplyMaxBytes,
         kRpcWebhookTimeout,
-        [callbackFuncP, j](
-            boost::system::error_code const& ecResult, int iStatus, std::string const& strData) {
-            return RPCCallImp::onResponse(callbackFuncP, ecResult, iStatus, strData, j);
-        },
+        std::bind(
+            &RPCCallImp::onResponse,
+            callbackFuncP,
+            std::placeholders::_1,
+            std::placeholders::_2,
+            std::placeholders::_3,
+            j),
         j);
 }
 
diff --git a/src/xrpld/rpc/handlers/account/GatewayBalances.cpp b/src/xrpld/rpc/handlers/account/GatewayBalances.cpp
index a6730c8e2b..bd1681172c 100644
--- a/src/xrpld/rpc/handlers/account/GatewayBalances.cpp
+++ b/src/xrpld/rpc/handlers/account/GatewayBalances.cpp
@@ -106,8 +106,8 @@ doGatewayBalances(RPC::JsonContext& context)
         // null is treated as a valid 0-sized array of hotwallet
         if (hw.isArrayOrNull())
         {
-            for (auto const& wallet : hw)
-                valid &= addHotWallet(wallet);
+            for (unsigned i = 0; i < hw.size(); ++i)
+                valid &= addHotWallet(hw[i]);
         }
         else if (hw.isString())
         {
diff --git a/src/xrpld/rpc/handlers/orderbook/BookOffers.cpp b/src/xrpld/rpc/handlers/orderbook/BookOffers.cpp
index 63dee76f1b..5d031c2c74 100644
--- a/src/xrpld/rpc/handlers/orderbook/BookOffers.cpp
+++ b/src/xrpld/rpc/handlers/orderbook/BookOffers.cpp
@@ -107,7 +107,7 @@ parseTakerIssuerJSON(
 
     if (taker.isMember(jss::currency))
     {
-        auto& issue = asset.get<Issue>();
+        Issue& issue = asset.get<Issue>();
 
         if (taker.isMember(jss::issuer))
         {
diff --git a/src/xrpld/rpc/handlers/orderbook/GetAggregatePrice.cpp b/src/xrpld/rpc/handlers/orderbook/GetAggregatePrice.cpp
index d2f596ed8e..c1c8712655 100644
--- a/src/xrpld/rpc/handlers/orderbook/GetAggregatePrice.cpp
+++ b/src/xrpld/rpc/handlers/orderbook/GetAggregatePrice.cpp
@@ -40,7 +40,8 @@ namespace xrpl {
 
 using namespace boost::bimaps;
 // sorted descending by lastUpdateTime, ascending by AssetPrice
-using Prices = bimap<multiset_of<std::uint32_t, std::greater<>>, multiset_of<STAmount>>;
+using Prices =
+    bimap<multiset_of<std::uint32_t, std::greater<std::uint32_t>>, multiset_of<STAmount>>;
 
 /** Calls callback "f" on the ledger-object sle and up to three previous
  * metadata objects. Stops early if the callback returns true.