diff --git a/.clang-tidy b/.clang-tidy
index 36b59f43e3..9cfc08ff5b 100644
--- a/.clang-tidy
+++ b/.clang-tidy
@@ -87,16 +87,19 @@ Checks: "-*,
   # cppcoreguidelines-use-default-member-init, # has issues
   # cppcoreguidelines-virtual-class-destructor, # has issues
   hicpp-ignored-remove-result,
-  # misc-definitions-in-headers, # has issues
+  misc-const-correctness,
+  misc-definitions-in-headers,
   misc-header-include-cycle,
   misc-misplaced-const,
+  misc-redundant-expression,
   misc-static-assert,
-  # misc-throw-by-value-catch-by-reference, # has issues
+  misc-throw-by-value-catch-by-reference,
   misc-unused-alias-decls,
   misc-unused-using-decls,
   modernize-deprecated-headers,
   modernize-make-shared,
   modernize-make-unique,
+  llvm-namespace-comment,
   performance-faster-string-find,
   performance-for-range-copy,
   performance-implicit-conversion-in-loop,
@@ -134,10 +137,7 @@ Checks: "-*,
 # ---
 # other checks that have issues that need to be resolved:
 #
-# llvm-namespace-comment,
-# misc-const-correctness,
 # misc-include-cleaner,
-# misc-redundant-expression,
 #
 # readability-inconsistent-declaration-parameter-name, # in this codebase this check will break a lot of arg names
 # readability-static-accessed-through-instance,        # this check is probably unnecessary. it makes the code less readable
diff --git a/.github/workflows/reusable-clang-tidy-files.yml b/.github/workflows/reusable-clang-tidy-files.yml
index 2abc9de43b..fcbb041ed9 100644
--- a/.github/workflows/reusable-clang-tidy-files.yml
+++ b/.github/workflows/reusable-clang-tidy-files.yml
@@ -80,7 +80,7 @@ jobs:
         env:
           TARGETS: ${{ inputs.files != '' && inputs.files || 'src tests' }}
         run: |
-          run-clang-tidy -j ${{ steps.nproc.outputs.nproc }} -p "${BUILD_DIR}" ${TARGETS} 2>&1 | tee clang-tidy-output.txt
+          run-clang-tidy -j ${{ steps.nproc.outputs.nproc }} -p "${BUILD_DIR}" -quiet -allow-no-checks ${TARGETS} 2>&1 | tee clang-tidy-output.txt
 
       - name: Upload clang-tidy output
         if: ${{ github.event.repository.visibility == 'public' && steps.run_clang_tidy.outcome != 'success' }}
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 8670b79db9..d19222dbf0 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -270,14 +270,14 @@ Before running clang-tidy, you must build the project to generate required files
 Then run clang-tidy on your local changes:
 
 ```
-run-clang-tidy -p build src include tests
+run-clang-tidy -p build -allow-no-checks src tests
 ```
 
 This will check all source files in the `src`, `include` and `tests` directories using the compile commands from your `build` directory.
 If you wish to automatically fix whatever clang-tidy finds _and_ is capable of fixing, add `-fix` to the above command:
 
 ```
-run-clang-tidy -p build -fix src include tests
+run-clang-tidy -p build -quiet -fix -allow-no-checks src tests
 ```
 
 ## Contracts and instrumentation
diff --git a/include/xrpl/basics/BasicConfig.h b/include/xrpl/basics/BasicConfig.h
index f02bf07a83..eaa53f93d6 100644
--- a/include/xrpl/basics/BasicConfig.h
+++ b/include/xrpl/basics/BasicConfig.h
@@ -311,7 +311,7 @@ template <class T>
 bool
 set(T& target, T const& defaultValue, std::string const& name, Section const& section)
 {
-    bool found_and_valid = set<T>(target, name, section);
+    bool const found_and_valid = set<T>(target, name, section);
     if (!found_and_valid)
         target = defaultValue;
     return found_and_valid;
diff --git a/include/xrpl/basics/IntrusiveRefCounts.h b/include/xrpl/basics/IntrusiveRefCounts.h
index 3b2be5c625..5a51b3c3bf 100644
--- a/include/xrpl/basics/IntrusiveRefCounts.h
+++ b/include/xrpl/basics/IntrusiveRefCounts.h
@@ -448,7 +448,7 @@ inline void
 partialDestructorFinished(T** o)
 {
     T& self = **o;
-    IntrusiveRefCounts::RefCountPair p =
+    IntrusiveRefCounts::RefCountPair const p =
         self.refCounts.fetch_or(IntrusiveRefCounts::partialDestroyFinishedMask);
     XRPL_ASSERT(
         (!p.partialDestroyFinishedBit && p.partialDestroyStartedBit && !p.strong),
diff --git a/include/xrpl/basics/SlabAllocator.h b/include/xrpl/basics/SlabAllocator.h
index e0c6456c0f..17acbbaa87 100644
--- a/include/xrpl/basics/SlabAllocator.h
+++ b/include/xrpl/basics/SlabAllocator.h
@@ -94,7 +94,7 @@ class SlabAllocator
             std::uint8_t* ret;
 
             {
-                std::lock_guard l(m_);
+                std::lock_guard const l(m_);
 
                 ret = l_;
 
@@ -123,7 +123,7 @@ class SlabAllocator
         {
             XRPL_ASSERT(own(ptr), "xrpl::SlabAllocator::SlabBlock::deallocate : own input");
 
-            std::lock_guard l(m_);
+            std::lock_guard const l(m_);
 
             // Use memcpy to avoid unaligned UB
             // (will optimize to equivalent code)
@@ -210,7 +210,7 @@ public:
 
         // No slab can satisfy our request, so we attempt to allocate a new
         // one here:
-        std::size_t size = slabSize_;
+        std::size_t const size = slabSize_;
 
         // We want to allocate the memory at a 2 MiB boundary, to make it
         // possible to use hugepage mappings on Linux:
diff --git a/include/xrpl/basics/StringUtilities.h b/include/xrpl/basics/StringUtilities.h
index 9cf6cd315d..592eee6d53 100644
--- a/include/xrpl/basics/StringUtilities.h
+++ b/include/xrpl/basics/StringUtilities.h
@@ -66,12 +66,12 @@ strUnHex(std::size_t strSize, Iterator begin, Iterator end)
 
     while (iter != end)
     {
-        int cHigh = digitLookupTable[*iter++];
+        int const cHigh = digitLookupTable[*iter++];
 
         if (cHigh < 0)
             return {};
 
-        int cLow = digitLookupTable[*iter++];
+        int const cLow = digitLookupTable[*iter++];
 
         if (cLow < 0)
             return {};
diff --git a/include/xrpl/basics/base_uint.h b/include/xrpl/basics/base_uint.h
index 6d2a0b9939..4ce135c036 100644
--- a/include/xrpl/basics/base_uint.h
+++ b/include/xrpl/basics/base_uint.h
@@ -212,7 +212,7 @@ private:
         while (in != sv.end())
         {
             std::uint32_t accum = {};
-            for (std::uint32_t shift : {4u, 0u, 12u, 8u, 20u, 16u, 28u, 24u})
+            for (std::uint32_t const shift : {4u, 0u, 12u, 8u, 20u, 16u, 28u, 24u})
             {
                 if (auto const result = hexCharToUInt(*in++, shift, accum);
                     result != ParseResult::okay)
@@ -444,7 +444,7 @@ public:
 
         for (int i = WIDTH; i--;)
         {
-            std::uint64_t n = carry + boost::endian::big_to_native(data_[i]) +
+            std::uint64_t const n = carry + boost::endian::big_to_native(data_[i]) +
                 boost::endian::big_to_native(b.data_[i]);
 
             data_[i] = boost::endian::native_to_big(static_cast<std::uint32_t>(n));
diff --git a/include/xrpl/basics/contract.h b/include/xrpl/basics/contract.h
index f41c272b61..e2d6dafe55 100644
--- a/include/xrpl/basics/contract.h
+++ b/include/xrpl/basics/contract.h
@@ -54,7 +54,7 @@ Throw(Args&&... args)
 
     E e(std::forward<Args>(args)...);
     LogThrow(std::string("Throwing exception of type " + beast::type_name<E>() + ": ") + e.what());
-    throw e;
+    throw std::move(e);
 }
 
 /** Called when faulty logic causes a broken invariant. */
diff --git a/include/xrpl/basics/hardened_hash.h b/include/xrpl/basics/hardened_hash.h
index b05ecda7a6..05e6ab417f 100644
--- a/include/xrpl/basics/hardened_hash.h
+++ b/include/xrpl/basics/hardened_hash.h
@@ -32,7 +32,7 @@ make_seed_pair() noexcept
         // state_t& operator=(state_t const&) = delete;
     };
     static state_t state;
-    std::lock_guard lock(state.mutex);
+    std::lock_guard const lock(state.mutex);
     return {state.dist(state.gen), state.dist(state.gen)};
 }
 
diff --git a/include/xrpl/basics/random.h b/include/xrpl/basics/random.h
index 399439c023..ae3a8c6ec6 100644
--- a/include/xrpl/basics/random.h
+++ b/include/xrpl/basics/random.h
@@ -14,11 +14,13 @@ namespace xrpl {
 
 #ifndef __INTELLISENSE__
 static_assert(
+    // NOLINTNEXTLINE(misc-redundant-expression)
     std::is_integral<beast::xor_shift_engine::result_type>::value &&
         std::is_unsigned<beast::xor_shift_engine::result_type>::value,
     "The Ripple default PRNG engine must return an unsigned integral type.");
 
 static_assert(
+    // NOLINTNEXTLINE(misc-redundant-expression)
     std::numeric_limits<beast::xor_shift_engine::result_type>::max() >=
         std::numeric_limits<std::uint64_t>::max(),
     "The Ripple default PRNG engine return must be at least 64 bits wide.");
@@ -58,7 +60,7 @@ default_prng()
     thread_local beast::xor_shift_engine engine = [] {
         std::uint64_t seed;
         {
-            std::lock_guard lk(m);
+            std::lock_guard const lk(m);
             std::uniform_int_distribution<std::uint64_t> distribution{1};
             seed = distribution(seeder);
         }
diff --git a/include/xrpl/beast/asio/io_latency_probe.h b/include/xrpl/beast/asio/io_latency_probe.h
index 81c8bc0dfa..0718a32af7 100644
--- a/include/xrpl/beast/asio/io_latency_probe.h
+++ b/include/xrpl/beast/asio/io_latency_probe.h
@@ -83,7 +83,7 @@ public:
     void
     sample_one(Handler&& handler)
     {
-        std::lock_guard lock(m_mutex);
+        std::lock_guard const lock(m_mutex);
         if (m_cancel)
             throw std::logic_error("io_latency_probe is canceled");
         boost::asio::post(
@@ -98,7 +98,7 @@ public:
     void
     sample(Handler&& handler)
     {
-        std::lock_guard lock(m_mutex);
+        std::lock_guard const lock(m_mutex);
         if (m_cancel)
             throw std::logic_error("io_latency_probe is canceled");
         boost::asio::post(
@@ -122,14 +122,14 @@ private:
     void
     addref()
     {
-        std::lock_guard lock(m_mutex);
+        std::lock_guard const lock(m_mutex);
         ++m_count;
     }
 
     void
     release()
     {
-        std::lock_guard lock(m_mutex);
+        std::lock_guard const lock(m_mutex);
         if (--m_count == 0)
             m_cond.notify_all();
     }
@@ -192,7 +192,7 @@ private:
             m_handler(elapsed);
 
             {
-                std::lock_guard lock(m_probe->m_mutex);
+                std::lock_guard const lock(m_probe->m_mutex);
                 if (m_probe->m_cancel)
                     return;
             }
diff --git a/include/xrpl/beast/container/aged_map.h b/include/xrpl/beast/container/aged_map.h
index e9505f2763..3815f44329 100644
--- a/include/xrpl/beast/container/aged_map.h
+++ b/include/xrpl/beast/container/aged_map.h
@@ -16,4 +16,4 @@ template <
     class Allocator = std::allocator<std::pair<Key const, T>>>
 using aged_map = detail::aged_ordered_container<false, true, Key, T, Clock, Compare, Allocator>;
 
-}
+}  // namespace beast
diff --git a/include/xrpl/beast/container/aged_multimap.h b/include/xrpl/beast/container/aged_multimap.h
index 7625694f66..bb098b63b2 100644
--- a/include/xrpl/beast/container/aged_multimap.h
+++ b/include/xrpl/beast/container/aged_multimap.h
@@ -16,4 +16,4 @@ template <
     class Allocator = std::allocator<std::pair<Key const, T>>>
 using aged_multimap = detail::aged_ordered_container<true, true, Key, T, Clock, Compare, Allocator>;
 
-}
+}  // namespace beast
diff --git a/include/xrpl/beast/container/aged_multiset.h b/include/xrpl/beast/container/aged_multiset.h
index 8d906c694f..60682db0ca 100644
--- a/include/xrpl/beast/container/aged_multiset.h
+++ b/include/xrpl/beast/container/aged_multiset.h
@@ -15,4 +15,4 @@ template <
     class Allocator = std::allocator<Key>>
 using aged_multiset =
     detail::aged_ordered_container<true, false, Key, void, Clock, Compare, Allocator>;
-}
+}  // namespace beast
diff --git a/include/xrpl/beast/container/aged_set.h b/include/xrpl/beast/container/aged_set.h
index 2c601f5f41..76ff40b63a 100644
--- a/include/xrpl/beast/container/aged_set.h
+++ b/include/xrpl/beast/container/aged_set.h
@@ -15,4 +15,4 @@ template <
     class Allocator = std::allocator<Key>>
 using aged_set = detail::aged_ordered_container<false, false, Key, void, Clock, Compare, Allocator>;
 
-}
+}  // namespace beast
diff --git a/include/xrpl/beast/container/aged_unordered_map.h b/include/xrpl/beast/container/aged_unordered_map.h
index 520ffe5848..ea53320e91 100644
--- a/include/xrpl/beast/container/aged_unordered_map.h
+++ b/include/xrpl/beast/container/aged_unordered_map.h
@@ -17,4 +17,4 @@ template <
     class Allocator = std::allocator<std::pair<Key const, T>>>
 using aged_unordered_map =
     detail::aged_unordered_container<false, true, Key, T, Clock, Hash, KeyEqual, Allocator>;
-}
+}  // namespace beast
diff --git a/include/xrpl/beast/container/aged_unordered_multimap.h b/include/xrpl/beast/container/aged_unordered_multimap.h
index dc6338949b..9cb1443cad 100644
--- a/include/xrpl/beast/container/aged_unordered_multimap.h
+++ b/include/xrpl/beast/container/aged_unordered_multimap.h
@@ -17,4 +17,4 @@ template <
     class Allocator = std::allocator<std::pair<Key const, T>>>
 using aged_unordered_multimap =
     detail::aged_unordered_container<true, true, Key, T, Clock, Hash, KeyEqual, Allocator>;
-}
+}  // namespace beast
diff --git a/include/xrpl/beast/container/aged_unordered_multiset.h b/include/xrpl/beast/container/aged_unordered_multiset.h
index b251f20077..ced01987aa 100644
--- a/include/xrpl/beast/container/aged_unordered_multiset.h
+++ b/include/xrpl/beast/container/aged_unordered_multiset.h
@@ -17,4 +17,4 @@ template <
 using aged_unordered_multiset =
     detail::aged_unordered_container<true, false, Key, void, Clock, Hash, KeyEqual, Allocator>;
 
-}
+}  // namespace beast
diff --git a/include/xrpl/beast/container/aged_unordered_set.h b/include/xrpl/beast/container/aged_unordered_set.h
index a1c032e159..3f4575f6bc 100644
--- a/include/xrpl/beast/container/aged_unordered_set.h
+++ b/include/xrpl/beast/container/aged_unordered_set.h
@@ -16,4 +16,4 @@ template <
     class Allocator = std::allocator<Key>>
 using aged_unordered_set =
     detail::aged_unordered_container<false, false, Key, void, Clock, Hash, KeyEqual, Allocator>;
-}
+}  // namespace beast
diff --git a/include/xrpl/beast/core/List.h b/include/xrpl/beast/core/List.h
index 504dec4c4a..560467c8dd 100644
--- a/include/xrpl/beast/core/List.h
+++ b/include/xrpl/beast/core/List.h
@@ -449,7 +449,7 @@ public:
     iterator
     erase(iterator pos) noexcept
     {
-        Node* node = &*pos;
+        Node const* node = &*pos;
         ++pos;
         node->m_next->m_prev = node->m_prev;
         node->m_prev->m_next = node->m_next;
diff --git a/include/xrpl/beast/test/yield_to.h b/include/xrpl/beast/test/yield_to.h
index 6c49c4a89c..918ca3c0cc 100644
--- a/include/xrpl/beast/test/yield_to.h
+++ b/include/xrpl/beast/test/yield_to.h
@@ -114,7 +114,7 @@ enable_yield_to::spawn(F0&& f, FN&&... fn)
         boost::context::fixedsize_stack(2 * 1024 * 1024),
         [&](yield_context yield) {
             f(yield);
-            std::lock_guard lock{m_};
+            std::lock_guard const lock{m_};
             if (--running_ == 0)
                 cv_.notify_all();
         },
diff --git a/include/xrpl/beast/unit_test/runner.h b/include/xrpl/beast/unit_test/runner.h
index 90d8a2f4b5..c8a6956732 100644
--- a/include/xrpl/beast/unit_test/runner.h
+++ b/include/xrpl/beast/unit_test/runner.h
@@ -228,7 +228,7 @@ template <class>
 void
 runner::testcase(std::string const& name)
 {
-    std::lock_guard lock(mutex_);
+    std::lock_guard const lock(mutex_);
     // Name may not be empty
     BOOST_ASSERT(default_ || !name.empty());
     // Forgot to call pass or fail
@@ -244,7 +244,7 @@ template <class>
 void
 runner::pass()
 {
-    std::lock_guard lock(mutex_);
+    std::lock_guard const lock(mutex_);
     if (default_)
         testcase("");
     on_pass();
@@ -255,7 +255,7 @@ template <class>
 void
 runner::fail(std::string const& reason)
 {
-    std::lock_guard lock(mutex_);
+    std::lock_guard const lock(mutex_);
     if (default_)
         testcase("");
     on_fail(reason);
@@ -267,7 +267,7 @@ template <class>
 void
 runner::log(std::string const& s)
 {
-    std::lock_guard lock(mutex_);
+    std::lock_guard const lock(mutex_);
     if (default_)
         testcase("");
     on_log(s);
diff --git a/include/xrpl/beast/unit_test/suite.h b/include/xrpl/beast/unit_test/suite.h
index 9031f9833e..fa5157e126 100644
--- a/include/xrpl/beast/unit_test/suite.h
+++ b/include/xrpl/beast/unit_test/suite.h
@@ -300,7 +300,7 @@ private:
     static suite**
     p_this_suite()
     {
-        static suite* pts = nullptr;
+        static suite* pts = nullptr;  // NOLINT(misc-const-correctness)
         return &pts;
     }
 
diff --git a/include/xrpl/beast/utility/Zero.h b/include/xrpl/beast/utility/Zero.h
index 00e91a1a47..3b50b3fe00 100644
--- a/include/xrpl/beast/utility/Zero.h
+++ b/include/xrpl/beast/utility/Zero.h
@@ -28,7 +28,7 @@ struct Zero
 
 namespace {
 static constexpr Zero zero{};
-}
+}  // namespace
 
 /** Default implementation of signum calls the method on the class. */
 template <typename T>
diff --git a/include/xrpl/core/ClosureCounter.h b/include/xrpl/core/ClosureCounter.h
index 6802a03f3d..f0f277cc0e 100644
--- a/include/xrpl/core/ClosureCounter.h
+++ b/include/xrpl/core/ClosureCounter.h
@@ -56,7 +56,7 @@ private:
         // a lock.  This removes a small timing window that occurs if the
         // waiting thread is handling a spurious wakeup when closureCount_
         // drops to zero.
-        std::lock_guard lock{mutex_};
+        std::lock_guard const lock{mutex_};
 
         // Update closureCount_.  Notify if stopping and closureCount_ == 0.
         if ((--closureCount_ == 0) && waitForClosures_)
@@ -168,7 +168,7 @@ public:
     {
         std::optional<Substitute<Closure>> ret;
 
-        std::lock_guard lock{mutex_};
+        std::lock_guard const lock{mutex_};
         if (!waitForClosures_)
             ret.emplace(*this, std::forward<Closure>(closure));
 
@@ -191,7 +191,7 @@ public:
     bool
     joined() const
     {
-        std::lock_guard lock{mutex_};
+        std::lock_guard const lock{mutex_};
         return waitForClosures_;
     }
 };
diff --git a/include/xrpl/core/JobQueue.h b/include/xrpl/core/JobQueue.h
index fdb708ee57..994e2b424c 100644
--- a/include/xrpl/core/JobQueue.h
+++ b/include/xrpl/core/JobQueue.h
@@ -16,7 +16,7 @@ namespace xrpl {
 
 namespace perf {
 class PerfLog;
-}
+}  // namespace perf
 
 class Logs;
 struct Coro_create_t
diff --git a/include/xrpl/core/JobTypes.h b/include/xrpl/core/JobTypes.h
index 4dc2fd96cd..98de97a1b4 100644
--- a/include/xrpl/core/JobTypes.h
+++ b/include/xrpl/core/JobTypes.h
@@ -24,7 +24,7 @@ private:
               std::chrono::milliseconds{0})
     {
         using namespace std::chrono_literals;
-        int maxLimit = std::numeric_limits<int>::max();
+        int const maxLimit = std::numeric_limits<int>::max();
 
         auto add = [this](
                        JobType jt,
diff --git a/include/xrpl/core/PeerReservationTable.h b/include/xrpl/core/PeerReservationTable.h
index ffaef2fa08..6d861e5fbe 100644
--- a/include/xrpl/core/PeerReservationTable.h
+++ b/include/xrpl/core/PeerReservationTable.h
@@ -67,7 +67,7 @@ public:
     bool
     contains(PublicKey const& nodeId)
     {
-        std::lock_guard lock(this->mutex_);
+        std::lock_guard const lock(this->mutex_);
         return table_.find({nodeId}) != table_.end();
     }
 
diff --git a/include/xrpl/core/PerfLog.h b/include/xrpl/core/PerfLog.h
index 64bdb3b625..8da6a313c8 100644
--- a/include/xrpl/core/PerfLog.h
+++ b/include/xrpl/core/PerfLog.h
@@ -14,7 +14,7 @@
 
 namespace beast {
 class Journal;
-}
+}  // namespace beast
 
 namespace xrpl {
 class Application;
diff --git a/include/xrpl/core/ServiceRegistry.h b/include/xrpl/core/ServiceRegistry.h
index 9f2555dc34..8b7d4b4464 100644
--- a/include/xrpl/core/ServiceRegistry.h
+++ b/include/xrpl/core/ServiceRegistry.h
@@ -11,13 +11,13 @@ namespace xrpl {
 // Forward declarations
 namespace NodeStore {
 class Database;
-}
+}  // namespace NodeStore
 namespace Resource {
 class Manager;
-}
+}  // namespace Resource
 namespace perf {
 class PerfLog;
-}
+}  // namespace perf
 
 // This is temporary until we migrate all code to use ServiceRegistry.
 class Application;
diff --git a/include/xrpl/core/detail/Workers.h b/include/xrpl/core/detail/Workers.h
index 8d898e35c0..7925d11e62 100644
--- a/include/xrpl/core/detail/Workers.h
+++ b/include/xrpl/core/detail/Workers.h
@@ -13,7 +13,7 @@ namespace xrpl {
 
 namespace perf {
 class PerfLog;
-}
+}  // namespace perf
 
 /**
  * `Workers` is effectively a thread pool. The constructor takes a "callback"
diff --git a/include/xrpl/core/detail/semaphore.h b/include/xrpl/core/detail/semaphore.h
index fad3bf5e29..b3bee00588 100644
--- a/include/xrpl/core/detail/semaphore.h
+++ b/include/xrpl/core/detail/semaphore.h
@@ -55,7 +55,7 @@ public:
     void
     notify()
     {
-        std::lock_guard lock{m_mutex};
+        std::lock_guard const lock{m_mutex};
         ++m_count;
         m_cond.notify_one();
     }
diff --git a/include/xrpl/json/json_value.h b/include/xrpl/json/json_value.h
index fc7625d67a..ef1d0fbcb8 100644
--- a/include/xrpl/json/json_value.h
+++ b/include/xrpl/json/json_value.h
@@ -641,7 +641,7 @@ public:
     SelfType
     operator++(int)
     {
-        SelfType temp(*this);
+        SelfType const temp(*this);
         ++*this;
         return temp;
     }
@@ -649,7 +649,7 @@ public:
     SelfType
     operator--(int)
     {
-        SelfType temp(*this);
+        SelfType const temp(*this);
         --*this;
         return temp;
     }
diff --git a/include/xrpl/ledger/AmendmentTable.h b/include/xrpl/ledger/AmendmentTable.h
index fb90d6e859..6ecfe2a240 100644
--- a/include/xrpl/ledger/AmendmentTable.h
+++ b/include/xrpl/ledger/AmendmentTable.h
@@ -143,7 +143,7 @@ public:
         // Inject appropriate pseudo-transactions
         for (auto const& it : actions)
         {
-            STTx amendTx(ttAMENDMENT, [&it, seq = lastClosedLedger->seq() + 1](auto& obj) {
+            STTx const amendTx(ttAMENDMENT, [&it, seq = lastClosedLedger->seq() + 1](auto& obj) {
                 obj.setAccountID(sfAccount, AccountID());
                 obj.setFieldH256(sfAmendment, it.first);
                 obj.setFieldU32(sfLedgerSequence, seq);
diff --git a/include/xrpl/ledger/CachedSLEs.h b/include/xrpl/ledger/CachedSLEs.h
index 2909501b1d..c05aab8856 100644
--- a/include/xrpl/ledger/CachedSLEs.h
+++ b/include/xrpl/ledger/CachedSLEs.h
@@ -6,4 +6,4 @@
 
 namespace xrpl {
 using CachedSLEs = TaggedCache<uint256, SLE const>;
-}
+}  // namespace xrpl
diff --git a/include/xrpl/ledger/PendingSaves.h b/include/xrpl/ledger/PendingSaves.h
index 76958fc78a..4e952547da 100644
--- a/include/xrpl/ledger/PendingSaves.h
+++ b/include/xrpl/ledger/PendingSaves.h
@@ -31,7 +31,7 @@ public:
     bool
     startWork(LedgerIndex seq)
     {
-        std::lock_guard lock(mutex_);
+        std::lock_guard const lock(mutex_);
 
         auto it = map_.find(seq);
 
@@ -54,7 +54,7 @@ public:
     void
     finishWork(LedgerIndex seq)
     {
-        std::lock_guard lock(mutex_);
+        std::lock_guard const lock(mutex_);
 
         map_.erase(seq);
         await_.notify_all();
@@ -64,7 +64,7 @@ public:
     bool
     pending(LedgerIndex seq)
     {
-        std::lock_guard lock(mutex_);
+        std::lock_guard const lock(mutex_);
         return map_.find(seq) != map_.end();
     }
 
@@ -117,7 +117,7 @@ public:
     std::map<LedgerIndex, bool>
     getSnapshot() const
     {
-        std::lock_guard lock(mutex_);
+        std::lock_guard const lock(mutex_);
 
         return map_;
     }
diff --git a/include/xrpl/nodestore/detail/varint.h b/include/xrpl/nodestore/detail/varint.h
index 98f8d8ff08..c84ed383ed 100644
--- a/include/xrpl/nodestore/detail/varint.h
+++ b/include/xrpl/nodestore/detail/varint.h
@@ -82,6 +82,7 @@ template <class = void>
 std::size_t
 write_varint(void* p0, std::size_t v)
 {
+    // NOLINTNEXTLINE(misc-const-correctness)
     std::uint8_t* p = reinterpret_cast<std::uint8_t*>(p0);
     do
     {
diff --git a/include/xrpl/protocol/AmountConversions.h b/include/xrpl/protocol/AmountConversions.h
index e1a224dac9..7e41eff41a 100644
--- a/include/xrpl/protocol/AmountConversions.h
+++ b/include/xrpl/protocol/AmountConversions.h
@@ -102,7 +102,7 @@ template <typename T>
 T
 toAmount(Issue const& issue, Number const& n, Number::rounding_mode mode = Number::getround())
 {
-    saveNumberRoundMode rm(Number::getround());
+    saveNumberRoundMode const rm(Number::getround());
     if (isXRP(issue))
         Number::setround(mode);
 
diff --git a/include/xrpl/protocol/Issue.h b/include/xrpl/protocol/Issue.h
index c8e598a540..7bd01185c9 100644
--- a/include/xrpl/protocol/Issue.h
+++ b/include/xrpl/protocol/Issue.h
@@ -96,7 +96,7 @@ operator<=>(Issue const& lhs, Issue const& rhs)
 inline Issue const&
 xrpIssue()
 {
-    static Issue issue{xrpCurrency(), xrpAccount()};
+    static Issue const issue{xrpCurrency(), xrpAccount()};
     return issue;
 }
 
@@ -104,7 +104,7 @@ xrpIssue()
 inline Issue const&
 noIssue()
 {
-    static Issue issue{noCurrency(), noAccount()};
+    static Issue const issue{noCurrency(), noAccount()};
     return issue;
 }
 
diff --git a/include/xrpl/protocol/Quality.h b/include/xrpl/protocol/Quality.h
index 09b0f4e7cb..0ec797da0c 100644
--- a/include/xrpl/protocol/Quality.h
+++ b/include/xrpl/protocol/Quality.h
@@ -304,8 +304,8 @@ Quality::ceil_TAmounts_helper(
 
     // Use the existing STAmount implementation for now, but consider
     // replacing with code specific to IOUAMount and XRPAmount
-    Amounts stAmt(toSTAmount(amount.in), toSTAmount(amount.out));
-    STAmount stLim(toSTAmount(limit));
+    Amounts const stAmt(toSTAmount(amount.in), toSTAmount(amount.out));
+    STAmount const stLim(toSTAmount(limit));
     Amounts const stRes = ((*this).*ceil_function)(stAmt, stLim, roundUp...);
     return TAmounts<In, Out>(toAmount<In>(stRes.in), toAmount<Out>(stRes.out));
 }
diff --git a/include/xrpl/protocol/RippleLedgerHash.h b/include/xrpl/protocol/RippleLedgerHash.h
index 2a51298d3d..9dab644663 100644
--- a/include/xrpl/protocol/RippleLedgerHash.h
+++ b/include/xrpl/protocol/RippleLedgerHash.h
@@ -6,4 +6,4 @@ namespace xrpl {
 
 using LedgerHash = uint256;
 
-}
+}  // namespace xrpl
diff --git a/include/xrpl/protocol/STAmount.h b/include/xrpl/protocol/STAmount.h
index dadeec096f..9cd7221d1e 100644
--- a/include/xrpl/protocol/STAmount.h
+++ b/include/xrpl/protocol/STAmount.h
@@ -532,7 +532,7 @@ STAmount::fromNumber(A const& a, Number const& number)
 {
     bool const negative = number.mantissa() < 0;
     Number const working{negative ? -number : number};
-    Asset asset{a};
+    Asset const asset{a};
     if (asset.integral())
     {
         std::uint64_t const intValue = static_cast<std::int64_t>(working);
@@ -716,7 +716,7 @@ roundToAsset(
     std::int32_t scale,
     Number::rounding_mode rounding = Number::getround())
 {
-    NumberRoundModeGuard mg(rounding);
+    NumberRoundModeGuard const mg(rounding);
     STAmount const ret{asset, value};
     if (ret.integral())
         return ret;
diff --git a/include/xrpl/protocol/STBase.h b/include/xrpl/protocol/STBase.h
index 7f06b01ca4..8edeb26424 100644
--- a/include/xrpl/protocol/STBase.h
+++ b/include/xrpl/protocol/STBase.h
@@ -83,7 +83,7 @@ to_json(T const& t)
 
 namespace detail {
 class STVar;
-}
+}  // namespace detail
 
 // VFALCO TODO fix this restriction on copy assignment.
 //
diff --git a/include/xrpl/protocol/STLedgerEntry.h b/include/xrpl/protocol/STLedgerEntry.h
index dde7d49ebd..994a616210 100644
--- a/include/xrpl/protocol/STLedgerEntry.h
+++ b/include/xrpl/protocol/STLedgerEntry.h
@@ -8,7 +8,7 @@ namespace xrpl {
 class Rules;
 namespace test {
 class Invariants_test;
-}
+}  // namespace test
 
 class STLedgerEntry final : public STObject, public CountedObject<STLedgerEntry>
 {
diff --git a/include/xrpl/protocol/STObject.h b/include/xrpl/protocol/STObject.h
index ecfae0086b..3a7d3f4b16 100644
--- a/include/xrpl/protocol/STObject.h
+++ b/include/xrpl/protocol/STObject.h
@@ -1153,7 +1153,7 @@ STObject::getFieldByValue(SField const& field) const
     if (!rf)
         throwFieldNotFound(field);
 
-    SerializedTypeID id = rf->getSType();
+    SerializedTypeID const id = rf->getSType();
 
     if (id == STI_NOTPRESENT)
         return V();  // optional field not present
@@ -1180,7 +1180,7 @@ STObject::getFieldByConstRef(SField const& field, V const& empty) const
     if (!rf)
         throwFieldNotFound(field);
 
-    SerializedTypeID id = rf->getSType();
+    SerializedTypeID const id = rf->getSType();
 
     if (id == STI_NOTPRESENT)
         return empty;  // optional field not present
diff --git a/include/xrpl/protocol/Serializer.h b/include/xrpl/protocol/Serializer.h
index 75f5dbdf96..2d3489fe7b 100644
--- a/include/xrpl/protocol/Serializer.h
+++ b/include/xrpl/protocol/Serializer.h
@@ -69,7 +69,7 @@ public:
     int
     add32(T i)
     {
-        int ret = mData.size();
+        int const ret = mData.size();
         mData.push_back(static_cast<unsigned char>((i >> 24) & 0xff));
         mData.push_back(static_cast<unsigned char>((i >> 16) & 0xff));
         mData.push_back(static_cast<unsigned char>((i >> 8) & 0xff));
@@ -85,7 +85,7 @@ public:
     int
     add64(T i)
     {
-        int ret = mData.size();
+        int const ret = mData.size();
         mData.push_back(static_cast<unsigned char>((i >> 56) & 0xff));
         mData.push_back(static_cast<unsigned char>((i >> 48) & 0xff));
         mData.push_back(static_cast<unsigned char>((i >> 40) & 0xff));
@@ -299,7 +299,7 @@ template <class Iter>
 int
 Serializer::addVL(Iter begin, Iter end, int len)
 {
-    int ret = addEncoded(len);
+    int const ret = addEncoded(len);
     for (; begin != end; ++begin)
     {
         addRaw(begin->data(), begin->size());
diff --git a/include/xrpl/protocol/TxSearched.h b/include/xrpl/protocol/TxSearched.h
index 71bd75005b..c3359ee5ac 100644
--- a/include/xrpl/protocol/TxSearched.h
+++ b/include/xrpl/protocol/TxSearched.h
@@ -4,4 +4,4 @@ namespace xrpl {
 
 enum class TxSearched { All, Some, Unknown };
 
-}
+}  // namespace xrpl
diff --git a/include/xrpl/protocol/detail/token_errors.h b/include/xrpl/protocol/detail/token_errors.h
index 686851f508..54b283c41a 100644
--- a/include/xrpl/protocol/detail/token_errors.h
+++ b/include/xrpl/protocol/detail/token_errors.h
@@ -15,7 +15,7 @@ enum class TokenCodecErrc {
     overflowAdd,
     unknown,
 };
-}
+}  // namespace xrpl
 
 namespace std {
 template <>
@@ -69,7 +69,7 @@ public:
 inline xrpl::detail::TokenCodecErrcCategory const&
 TokenCodecErrcCategory()
 {
-    static xrpl::detail::TokenCodecErrcCategory c;
+    static xrpl::detail::TokenCodecErrcCategory const c;
     return c;
 }
 
diff --git a/include/xrpl/protocol_autogen/.clang-tidy b/include/xrpl/protocol_autogen/.clang-tidy
new file mode 100644
index 0000000000..fbc003598d
--- /dev/null
+++ b/include/xrpl/protocol_autogen/.clang-tidy
@@ -0,0 +1,3 @@
+# This disables all checks for this directory and its subdirectories
+Checks: "-*"
+InheritParentConfig: false
diff --git a/include/xrpl/rdb/DatabaseCon.h b/include/xrpl/rdb/DatabaseCon.h
index bd7b9ca803..7400593214 100644
--- a/include/xrpl/rdb/DatabaseCon.h
+++ b/include/xrpl/rdb/DatabaseCon.h
@@ -14,7 +14,7 @@
 
 namespace soci {
 class session;
-}
+}  // namespace soci
 
 namespace xrpl {
 
diff --git a/include/xrpl/rdb/SociDB.h b/include/xrpl/rdb/SociDB.h
index 83758677b9..9c575359c1 100644
--- a/include/xrpl/rdb/SociDB.h
+++ b/include/xrpl/rdb/SociDB.h
@@ -25,7 +25,7 @@
 
 namespace sqlite_api {
 struct sqlite3;
-}
+}  // namespace sqlite_api
 
 namespace xrpl {
 
diff --git a/include/xrpl/resource/detail/Logic.h b/include/xrpl/resource/detail/Logic.h
index 9a7959f481..66c47bc538 100644
--- a/include/xrpl/resource/detail/Logic.h
+++ b/include/xrpl/resource/detail/Logic.h
@@ -93,7 +93,7 @@ public:
         Entry* entry(nullptr);
 
         {
-            std::lock_guard _(lock_);
+            std::lock_guard const _(lock_);
             auto [resultIt, resultInserted] = table_.emplace(
                 std::piecewise_construct,
                 std::make_tuple(kindInbound, address.at_port(0)),  // Key
@@ -123,7 +123,7 @@ public:
         Entry* entry(nullptr);
 
         {
-            std::lock_guard _(lock_);
+            std::lock_guard const _(lock_);
             auto [resultIt, resultInserted] = table_.emplace(
                 std::piecewise_construct,
                 std::make_tuple(kindOutbound, address),  // Key
@@ -156,7 +156,7 @@ public:
         Entry* entry(nullptr);
 
         {
-            std::lock_guard _(lock_);
+            std::lock_guard const _(lock_);
             auto [resultIt, resultInserted] = table_.emplace(
                 std::piecewise_construct,
                 std::make_tuple(kindUnlimited, address.at_port(1)),  // Key
@@ -191,11 +191,11 @@ public:
         clock_type::time_point const now(m_clock.now());
 
         Json::Value ret(Json::objectValue);
-        std::lock_guard _(lock_);
+        std::lock_guard const _(lock_);
 
         for (auto& inboundEntry : inbound_)
         {
-            int localBalance = inboundEntry.local_balance.value(now);
+            int const localBalance = inboundEntry.local_balance.value(now);
             if ((localBalance + inboundEntry.remote_balance) >= threshold)
             {
                 Json::Value& entry = (ret[inboundEntry.to_string()] = Json::objectValue);
@@ -206,7 +206,7 @@ public:
         }
         for (auto& outboundEntry : outbound_)
         {
-            int localBalance = outboundEntry.local_balance.value(now);
+            int const localBalance = outboundEntry.local_balance.value(now);
             if ((localBalance + outboundEntry.remote_balance) >= threshold)
             {
                 Json::Value& entry = (ret[outboundEntry.to_string()] = Json::objectValue);
@@ -217,7 +217,7 @@ public:
         }
         for (auto& adminEntry : admin_)
         {
-            int localBalance = adminEntry.local_balance.value(now);
+            int const localBalance = adminEntry.local_balance.value(now);
             if ((localBalance + adminEntry.remote_balance) >= threshold)
             {
                 Json::Value& entry = (ret[adminEntry.to_string()] = Json::objectValue);
@@ -236,7 +236,7 @@ public:
         clock_type::time_point const now(m_clock.now());
 
         Gossip gossip;
-        std::lock_guard _(lock_);
+        std::lock_guard const _(lock_);
 
         gossip.items.reserve(inbound_.size());
 
@@ -261,7 +261,7 @@ public:
     {
         auto const elapsed = m_clock.now();
         {
-            std::lock_guard _(lock_);
+            std::lock_guard const _(lock_);
             auto [resultIt, resultInserted] = importTable_.emplace(
                 std::piecewise_construct,
                 std::make_tuple(origin),                                     // Key
@@ -318,7 +318,7 @@ public:
     void
     periodicActivity()
     {
-        std::lock_guard _(lock_);
+        std::lock_guard const _(lock_);
 
         auto const elapsed = m_clock.now();
 
@@ -374,7 +374,7 @@ public:
     void
     erase(Table::iterator iter)
     {
-        std::lock_guard _(lock_);
+        std::lock_guard const _(lock_);
         Entry& entry(iter->second);
         XRPL_ASSERT(entry.refcount == 0, "xrpl::Resource::Logic::erase : entry not used");
         inactive_.erase(inactive_.iterator_to(entry));
@@ -384,14 +384,14 @@ public:
     void
     acquire(Entry& entry)
     {
-        std::lock_guard _(lock_);
+        std::lock_guard const _(lock_);
         ++entry.refcount;
     }
 
     void
     release(Entry& entry)
     {
-        std::lock_guard _(lock_);
+        std::lock_guard const _(lock_);
         if (--entry.refcount == 0)
         {
             JLOG(m_journal.debug()) << "Inactive " << entry;
@@ -442,7 +442,7 @@ public:
         if (!context.empty())
             context = " (" + context + ")";
 
-        std::lock_guard _(lock_);
+        std::lock_guard const _(lock_);
         clock_type::time_point const now(m_clock.now());
         int const balance(entry.add(fee.cost(), now));
         JLOG(getStream(fee.cost(), m_journal)) << "Charging " << entry << " for " << fee << context;
@@ -455,7 +455,7 @@ public:
         if (entry.isUnlimited())
             return false;
 
-        std::lock_guard _(lock_);
+        std::lock_guard const _(lock_);
         bool notify(false);
         auto const elapsed = m_clock.now();
         if (entry.balance(m_clock.now()) >= warningThreshold && elapsed != entry.lastWarningTime)
@@ -478,7 +478,7 @@ public:
         if (entry.isUnlimited())
             return false;
 
-        std::lock_guard _(lock_);
+        std::lock_guard const _(lock_);
         bool drop(false);
         clock_type::time_point const now(m_clock.now());
         int const balance(entry.balance(now));
@@ -500,7 +500,7 @@ public:
     int
     balance(Entry& entry)
     {
-        std::lock_guard _(lock_);
+        std::lock_guard const _(lock_);
         return entry.balance(m_clock.now());
     }
 
@@ -529,7 +529,7 @@ public:
     {
         clock_type::time_point const now(m_clock.now());
 
-        std::lock_guard _(lock_);
+        std::lock_guard const _(lock_);
 
         {
             beast::PropertyStream::Set s("inbound", map);
diff --git a/include/xrpl/server/LoadFeeTrack.h b/include/xrpl/server/LoadFeeTrack.h
index fc031a1833..08be3e0406 100644
--- a/include/xrpl/server/LoadFeeTrack.h
+++ b/include/xrpl/server/LoadFeeTrack.h
@@ -39,28 +39,28 @@ public:
     setRemoteFee(std::uint32_t f)
     {
         JLOG(j_.trace()) << "setRemoteFee: " << f;
-        std::lock_guard sl(lock_);
+        std::lock_guard const sl(lock_);
         remoteTxnLoadFee_ = f;
     }
 
     std::uint32_t
     getRemoteFee() const
     {
-        std::lock_guard sl(lock_);
+        std::lock_guard const sl(lock_);
         return remoteTxnLoadFee_;
     }
 
     std::uint32_t
     getLocalFee() const
     {
-        std::lock_guard sl(lock_);
+        std::lock_guard const sl(lock_);
         return localTxnLoadFee_;
     }
 
     std::uint32_t
     getClusterFee() const
     {
-        std::lock_guard sl(lock_);
+        std::lock_guard const sl(lock_);
         return clusterTxnLoadFee_;
     }
 
@@ -73,14 +73,14 @@ public:
     std::uint32_t
     getLoadFactor() const
     {
-        std::lock_guard sl(lock_);
+        std::lock_guard const sl(lock_);
         return std::max({clusterTxnLoadFee_, localTxnLoadFee_, remoteTxnLoadFee_});
     }
 
     std::pair<std::uint32_t, std::uint32_t>
     getScalingFactors() const
     {
-        std::lock_guard sl(lock_);
+        std::lock_guard const sl(lock_);
 
         return std::make_pair(
             std::max(localTxnLoadFee_, remoteTxnLoadFee_),
@@ -91,7 +91,7 @@ public:
     setClusterFee(std::uint32_t fee)
     {
         JLOG(j_.trace()) << "setClusterFee: " << fee;
-        std::lock_guard sl(lock_);
+        std::lock_guard const sl(lock_);
         clusterTxnLoadFee_ = fee;
     }
 
@@ -103,14 +103,14 @@ public:
     bool
     isLoadedLocal() const
     {
-        std::lock_guard sl(lock_);
+        std::lock_guard const sl(lock_);
         return (raiseCount_ != 0) || (localTxnLoadFee_ != lftNormalFee);
     }
 
     bool
     isLoadedCluster() const
     {
-        std::lock_guard sl(lock_);
+        std::lock_guard const sl(lock_);
         return (raiseCount_ != 0) || (localTxnLoadFee_ != lftNormalFee) ||
             (clusterTxnLoadFee_ != lftNormalFee);
     }
diff --git a/include/xrpl/server/Manifest.h b/include/xrpl/server/Manifest.h
index 7f1bba921e..02c370561a 100644
--- a/include/xrpl/server/Manifest.h
+++ b/include/xrpl/server/Manifest.h
@@ -401,7 +401,7 @@ public:
     void
     for_each_manifest(Function&& f) const
     {
-        std::shared_lock lock{mutex_};
+        std::shared_lock const lock{mutex_};
         for (auto const& [_, manifest] : map_)
         {
             (void)_;
@@ -429,7 +429,7 @@ public:
     void
     for_each_manifest(PreFun&& pf, EachFun&& f) const
     {
-        std::shared_lock lock{mutex_};
+        std::shared_lock const lock{mutex_};
         pf(map_.size());
         for (auto const& [_, manifest] : map_)
         {
diff --git a/include/xrpl/server/Port.h b/include/xrpl/server/Port.h
index 1dfa93b0a7..b00f4f4041 100644
--- a/include/xrpl/server/Port.h
+++ b/include/xrpl/server/Port.h
@@ -19,7 +19,7 @@ namespace boost {
 namespace asio {
 namespace ssl {
 class context;
-}
+}  // namespace ssl
 }  // namespace asio
 }  // namespace boost
 
diff --git a/include/xrpl/server/detail/BaseHTTPPeer.h b/include/xrpl/server/detail/BaseHTTPPeer.h
index f900261b84..8354e63c64 100644
--- a/include/xrpl/server/detail/BaseHTTPPeer.h
+++ b/include/xrpl/server/detail/BaseHTTPPeer.h
@@ -300,7 +300,7 @@ BaseHTTPPeer<Handler, Impl>::on_write(error_code const& ec, std::size_t bytes_tr
         return fail(ec, "write");
     bytes_out_ += bytes_transferred;
     {
-        std::lock_guard lock(mutex_);
+        std::lock_guard const lock(mutex_);
         wq2_.clear();
         wq2_.reserve(wq_.size());
         std::swap(wq2_, wq_);
@@ -392,7 +392,7 @@ BaseHTTPPeer<Handler, Impl>::write(void const* buf, std::size_t bytes)
     if (bytes == 0)
         return;
     if ([&] {
-            std::lock_guard lock(mutex_);
+            std::lock_guard const lock(mutex_);
             wq_.emplace_back(buf, bytes);
             return wq_.size() == 1 && wq2_.size() == 0;
         }())
@@ -443,7 +443,7 @@ BaseHTTPPeer<Handler, Impl>::complete()
     complete_ = true;
 
     {
-        std::lock_guard lock(mutex_);
+        std::lock_guard const lock(mutex_);
         if (!wq_.empty() && !wq2_.empty())
             return;
     }
@@ -476,7 +476,7 @@ BaseHTTPPeer<Handler, Impl>::close(bool graceful)
     {
         graceful_ = true;
         {
-            std::lock_guard lock(mutex_);
+            std::lock_guard const lock(mutex_);
             if (!wq_.empty() || !wq2_.empty())
                 return;
         }
diff --git a/include/xrpl/server/detail/BaseWSPeer.h b/include/xrpl/server/detail/BaseWSPeer.h
index f415520e59..9213a955f0 100644
--- a/include/xrpl/server/detail/BaseWSPeer.h
+++ b/include/xrpl/server/detail/BaseWSPeer.h
@@ -418,7 +418,7 @@ BaseWSPeer<Handler, Impl>::on_ping_pong(
 {
     if (kind == boost::beast::websocket::frame_type::pong)
     {
-        boost::beast::string_view p(payload_.begin());
+        boost::beast::string_view const p(payload_.begin());
         if (payload == p)
         {
             close_on_timer_ = false;
diff --git a/include/xrpl/server/detail/io_list.h b/include/xrpl/server/detail/io_list.h
index 5b1a02e039..f1cc04f683 100644
--- a/include/xrpl/server/detail/io_list.h
+++ b/include/xrpl/server/detail/io_list.h
@@ -165,7 +165,7 @@ io_list::work::destroy()
         return;
     std::function<void(void)> f;
     {
-        std::lock_guard lock(ios_->m_);
+        std::lock_guard const lock(ios_->m_);
         ios_->map_.erase(this);
         if (--ios_->n_ == 0 && ios_->closed_)
         {
@@ -195,7 +195,7 @@ io_list::emplace(Args&&... args)
     auto sp = std::make_shared<T>(std::forward<Args>(args)...);
     decltype(sp) dead;
 
-    std::lock_guard lock(m_);
+    std::lock_guard const lock(m_);
     if (!closed_)
     {
         ++n_;
diff --git a/include/xrpl/shamap/SHAMapItem.h b/include/xrpl/shamap/SHAMapItem.h
index dd098d88aa..da70e16db3 100644
--- a/include/xrpl/shamap/SHAMapItem.h
+++ b/include/xrpl/shamap/SHAMapItem.h
@@ -141,6 +141,7 @@ make_shamapitem(uint256 const& tag, Slice data)
     XRPL_ASSERT(
         data.size() <= megabytes<std::size_t>(16), "xrpl::make_shamapitem : maximum input size");
 
+    // NOLINTNEXTLINE(misc-const-correctness)
     std::uint8_t* raw = detail::slabber.allocate(data.size());
 
     // If we can't grab memory from the slab allocators, we fall back to
diff --git a/include/xrpl/tx/paths/Flow.h b/include/xrpl/tx/paths/Flow.h
index 32e8c3611b..f37c9d56c3 100644
--- a/include/xrpl/tx/paths/Flow.h
+++ b/include/xrpl/tx/paths/Flow.h
@@ -9,7 +9,7 @@ namespace xrpl {
 namespace path {
 namespace detail {
 struct FlowDebugInfo;
-}
+}  // namespace detail
 }  // namespace path
 
 /**
diff --git a/include/xrpl/tx/paths/RippleCalc.h b/include/xrpl/tx/paths/RippleCalc.h
index 4fc4c54f2b..55f552a61f 100644
--- a/include/xrpl/tx/paths/RippleCalc.h
+++ b/include/xrpl/tx/paths/RippleCalc.h
@@ -13,7 +13,7 @@ namespace path {
 
 namespace detail {
 struct FlowDebugInfo;
-}
+}  // namespace detail
 
 /** RippleCalc calculates the quality of a payment path.
 
diff --git a/include/xrpl/tx/paths/detail/StrandFlow.h b/include/xrpl/tx/paths/detail/StrandFlow.h
index 2a94b9b968..a67542269e 100644
--- a/include/xrpl/tx/paths/detail/StrandFlow.h
+++ b/include/xrpl/tx/paths/detail/StrandFlow.h
@@ -571,7 +571,7 @@ flow(
 
     std::size_t const maxTries = 1000;
     std::size_t curTry = 0;
-    std::uint32_t maxOffersToConsider = 1500;
+    std::uint32_t const maxOffersToConsider = 1500;
     std::uint32_t offersConsidered = 0;
 
     // There is a bug in gcc that incorrectly warns about using uninitialized
diff --git a/include/xrpl/tx/transactors/dex/AMMHelpers.h b/include/xrpl/tx/transactors/dex/AMMHelpers.h
index f389fd283b..55f27a3f06 100644
--- a/include/xrpl/tx/transactors/dex/AMMHelpers.h
+++ b/include/xrpl/tx/transactors/dex/AMMHelpers.h
@@ -22,7 +22,7 @@ reduceOffer(auto const& amount)
     static Number const reducedOfferPct(9999, -4);
 
     // Make sure the result is always less than amount or zero.
-    NumberRoundModeGuard mg(Number::towards_zero);
+    NumberRoundModeGuard const mg(Number::towards_zero);
     return amount * reducedOfferPct;
 }
 
@@ -173,7 +173,7 @@ getAMMOfferStartWithTakerGets(
     if (targetQuality.rate() == beast::zero)
         return std::nullopt;
 
-    NumberRoundModeGuard mg(Number::to_nearest);
+    NumberRoundModeGuard const mg(Number::to_nearest);
     auto const f = feeMult(tfee);
     auto const a = 1;
     auto const b = pool.in * (1 - 1 / f) / targetQuality.rate() - 2 * pool.out;
@@ -240,7 +240,7 @@ getAMMOfferStartWithTakerPays(
     if (targetQuality.rate() == beast::zero)
         return std::nullopt;
 
-    NumberRoundModeGuard mg(Number::to_nearest);
+    NumberRoundModeGuard const mg(Number::to_nearest);
     auto const f = feeMult(tfee);
     auto const& a = f;
     auto const b = pool.in * (1 + f);
@@ -435,7 +435,7 @@ swapAssetIn(TAmounts<TIn, TOut> const& pool, TIn const& assetIn, std::uint16_t t
         // 1-fee
         // maximize:
         // fee
-        saveNumberRoundMode _{Number::getround()};
+        saveNumberRoundMode const _{Number::getround()};
 
         Number::setround(Number::upward);
         auto const numerator = pool.in * pool.out;
@@ -499,7 +499,7 @@ swapAssetOut(TAmounts<TIn, TOut> const& pool, TOut const& assetOut, std::uint16_
         // maximize:
         // tfee/100000
 
-        saveNumberRoundMode _{Number::getround()};
+        saveNumberRoundMode const _{Number::getround()};
 
         Number::setround(Number::upward);
         auto const numerator = pool.in * pool.out;
diff --git a/src/libxrpl/basics/Archive.cpp b/src/libxrpl/basics/Archive.cpp
index a09d77d794..e77dabcd68 100644
--- a/src/libxrpl/basics/Archive.cpp
+++ b/src/libxrpl/basics/Archive.cpp
@@ -20,7 +20,7 @@ extractTarLz4(boost::filesystem::path const& src, boost::filesystem::path const&
         Throw<std::runtime_error>("Invalid source file");
 
     using archive_ptr = std::unique_ptr<struct archive, void (*)(struct archive*)>;
-    archive_ptr ar{archive_read_new(), [](struct archive* a) { archive_read_free(a); }};
+    archive_ptr const ar{archive_read_new(), [](struct archive* a) { archive_read_free(a); }};
     if (!ar)
         Throw<std::runtime_error>("Failed to allocate archive");
 
@@ -36,7 +36,8 @@ extractTarLz4(boost::filesystem::path const& src, boost::filesystem::path const&
         Throw<std::runtime_error>(archive_error_string(ar.get()));
     }
 
-    archive_ptr aw{archive_write_disk_new(), [](struct archive* a) { archive_write_free(a); }};
+    archive_ptr const aw{
+        archive_write_disk_new(), [](struct archive* a) { archive_write_free(a); }};
     if (!aw)
         Throw<std::runtime_error>("Failed to allocate archive");
 
diff --git a/src/libxrpl/basics/BasicConfig.cpp b/src/libxrpl/basics/BasicConfig.cpp
index edc8bea7d9..ba10a575d9 100644
--- a/src/libxrpl/basics/BasicConfig.cpp
+++ b/src/libxrpl/basics/BasicConfig.cpp
@@ -126,7 +126,7 @@ BasicConfig::section(std::string const& name)
 Section const&
 BasicConfig::section(std::string const& name) const
 {
-    static Section none("");
+    static Section const none("");
     auto const iter = map_.find(name);
     if (iter == map_.end())
         return none;
diff --git a/src/libxrpl/basics/FileUtilities.cpp b/src/libxrpl/basics/FileUtilities.cpp
index 73f2c2f10d..96ec3fa3ba 100644
--- a/src/libxrpl/basics/FileUtilities.cpp
+++ b/src/libxrpl/basics/FileUtilities.cpp
@@ -26,7 +26,7 @@ getFileContents(
     using namespace boost::filesystem;
     using namespace boost::system::errc;
 
-    path fullPath{canonical(sourcePath, ec)};
+    path const fullPath{canonical(sourcePath, ec)};
     if (ec)
         return {};
 
diff --git a/src/libxrpl/basics/Log.cpp b/src/libxrpl/basics/Log.cpp
index 9cebd1f04a..f0a546ee75 100644
--- a/src/libxrpl/basics/Log.cpp
+++ b/src/libxrpl/basics/Log.cpp
@@ -119,7 +119,7 @@ Logs::open(boost::filesystem::path const& pathToLogFile)
 beast::Journal::Sink&
 Logs::get(std::string const& name)
 {
-    std::lock_guard lock(mutex_);
+    std::lock_guard const lock(mutex_);
     auto const result = sinks_.emplace(name, makeSink(name, thresh_));
     return *result.first->second;
 }
@@ -145,7 +145,7 @@ Logs::threshold() const
 void
 Logs::threshold(beast::severities::Severity thresh)
 {
-    std::lock_guard lock(mutex_);
+    std::lock_guard const lock(mutex_);
     thresh_ = thresh;
     for (auto& sink : sinks_)
         sink.second->threshold(thresh);
@@ -155,7 +155,7 @@ std::vector<std::pair<std::string, std::string>>
 Logs::partition_severities() const
 {
     std::vector<std::pair<std::string, std::string>> list;
-    std::lock_guard lock(mutex_);
+    std::lock_guard const lock(mutex_);
     list.reserve(sinks_.size());
     for (auto const& [name, sink] : sinks_)
         list.emplace_back(name, toString(fromSeverity(sink->threshold())));
@@ -171,7 +171,7 @@ Logs::write(
 {
     std::string s;
     format(s, text, level, partition);
-    std::lock_guard lock(mutex_);
+    std::lock_guard const lock(mutex_);
     file_.writeln(s);
     if (!silent_)
         std::cerr << s << '\n';
@@ -183,7 +183,7 @@ Logs::write(
 std::string
 Logs::rotate()
 {
-    std::lock_guard lock(mutex_);
+    std::lock_guard const lock(mutex_);
     bool const wasOpened = file_.closeAndReopen();
     if (wasOpened)
         return "The log file was closed and reopened.";
@@ -411,7 +411,7 @@ public:
     std::unique_ptr<beast::Journal::Sink>
     set(std::unique_ptr<beast::Journal::Sink> sink)
     {
-        std::lock_guard _(m_);
+        std::lock_guard const _(m_);
 
         using std::swap;
         swap(holder_, sink);
@@ -431,7 +431,7 @@ public:
     beast::Journal::Sink&
     get()
     {
-        std::lock_guard _(m_);
+        std::lock_guard const _(m_);
         return sink_.get();
     }
 };
diff --git a/src/libxrpl/basics/Number.cpp b/src/libxrpl/basics/Number.cpp
index f0655cd8a9..a8adabd5de 100644
--- a/src/libxrpl/basics/Number.cpp
+++ b/src/libxrpl/basics/Number.cpp
@@ -161,7 +161,7 @@ Number::Guard::push(T d) noexcept
 inline unsigned
 Number::Guard::pop() noexcept
 {
-    unsigned d = (digits_ & 0xF000'0000'0000'0000) >> 60;
+    unsigned const d = (digits_ & 0xF000'0000'0000'0000) >> 60;
     digits_ <<= 4;
     return d;
 }
@@ -325,7 +325,7 @@ Number::externalToInternal(rep mantissa)
     // int128_t, negate that, and cast it back down to the internalrep
     // In practice, this is only going to cover the case of
     // std::numeric_limits<rep>::min().
-    int128_t temp = mantissa;
+    int128_t const temp = mantissa;
     return static_cast<internalrep>(-temp);
 }
 
@@ -530,7 +530,7 @@ Number::operator+=(Number const& y)
     uint128_t xm = mantissa_;
     auto xe = exponent_;
 
-    bool yn = y.negative_;
+    bool const yn = y.negative_;
     uint128_t ym = y.mantissa_;
     auto ye = y.exponent_;
     Guard g;
@@ -644,14 +644,14 @@ Number::operator*=(Number const& y)
     // *m = mantissa
     // *e = exponent
 
-    bool xn = negative_;
-    int xs = xn ? -1 : 1;
+    bool const xn = negative_;
+    int const xs = xn ? -1 : 1;
     internalrep xm = mantissa_;
     auto xe = exponent_;
 
-    bool yn = y.negative_;
-    int ys = yn ? -1 : 1;
-    internalrep ym = y.mantissa_;
+    bool const yn = y.negative_;
+    int const ys = yn ? -1 : 1;
+    internalrep const ym = y.mantissa_;
     auto ye = y.exponent_;
 
     auto zm = uint128_t(xm) * uint128_t(ym);
@@ -706,13 +706,13 @@ Number::operator/=(Number const& y)
     // *m = mantissa
     // *e = exponent
 
-    bool np = negative_;
-    int ns = (np ? -1 : 1);
+    bool const np = negative_;
+    int const ns = (np ? -1 : 1);
     auto nm = mantissa_;
     auto ne = exponent_;
 
-    bool dp = y.negative_;
-    int ds = (dp ? -1 : 1);
+    bool const dp = y.negative_;
+    int const ds = (dp ? -1 : 1);
     auto dm = y.mantissa_;
     auto de = y.exponent_;
 
@@ -728,7 +728,7 @@ Number::operator/=(Number const& y)
     // f can be up to 10^(38-19) = 10^19 safely
     static_assert(smallRange.log == 15);
     static_assert(largeRange.log == 18);
-    bool small = Number::getMantissaScale() == MantissaRange::small;
+    bool const small = Number::getMantissaScale() == MantissaRange::small;
     uint128_t const f = small ? 100'000'000'000'000'000 : 10'000'000'000'000'000'000ULL;
     XRPL_ASSERT_PARTS(f >= minMantissa * 10, "Number::operator/=", "factor expected size");
 
@@ -980,8 +980,8 @@ root(Number f, unsigned d)
     auto const di = static_cast<int>(d);
     auto ex = [e = e, di = di]()  // Euclidean remainder of e/d
     {
-        int k = (e >= 0 ? e : e - (di - 1)) / di;
-        int k2 = e - (k * di);
+        int const k = (e >= 0 ? e : e - (di - 1)) / di;
+        int const k2 = e - (k * di);
         if (k2 == 0)
             return 0;
         return di - k2;
diff --git a/src/libxrpl/basics/ResolverAsio.cpp b/src/libxrpl/basics/ResolverAsio.cpp
index aa1cb1470d..305bdb6451 100644
--- a/src/libxrpl/basics/ResolverAsio.cpp
+++ b/src/libxrpl/basics/ResolverAsio.cpp
@@ -152,7 +152,7 @@ public:
     void
     asyncHandlersComplete()
     {
-        std::unique_lock<std::mutex> lk{m_mut};
+        std::unique_lock<std::mutex> const lk{m_mut};
         m_asyncHandlersCompleted = true;
         m_cv.notify_all();
     }
@@ -172,7 +172,7 @@ public:
         if (m_stopped.exchange(false))
         {
             {
-                std::lock_guard lk{m_mut};
+                std::lock_guard const lk{m_mut};
                 m_asyncHandlersCompleted = false;
             }
             addReference();
@@ -327,7 +327,7 @@ public:
             return;
 
         std::string const name(m_work.front().names.back());
-        HandlerType handler(m_work.front().handler);
+        HandlerType const handler(m_work.front().handler);
 
         m_work.front().names.pop_back();
 
diff --git a/src/libxrpl/basics/StringUtilities.cpp b/src/libxrpl/basics/StringUtilities.cpp
index c47618db82..5e3b100b26 100644
--- a/src/libxrpl/basics/StringUtilities.cpp
+++ b/src/libxrpl/basics/StringUtilities.cpp
@@ -37,7 +37,7 @@ bool
 parseUrl(parsedURL& pUrl, std::string const& strUrl)
 {
     // scheme://username:password@hostname:port/rest
-    static boost::regex reUrl(
+    static boost::regex const reUrl(
         "(?i)\\`\\s*"
         // required scheme
         "([[:alpha:]][-+.[:alpha:][:digit:]]*?):"
diff --git a/src/libxrpl/basics/base64.cpp b/src/libxrpl/basics/base64.cpp
index a510fbf6c9..cf6af3db70 100644
--- a/src/libxrpl/basics/base64.cpp
+++ b/src/libxrpl/basics/base64.cpp
@@ -103,7 +103,7 @@ std::size_t constexpr decoded_size(std::size_t n)
 std::size_t
 encode(void* dest, void const* src, std::size_t len)
 {
-    char* out = static_cast<char*>(dest);
+    char* out = static_cast<char*>(dest);  // NOLINT(misc-const-correctness)
     char const* in = static_cast<char const*>(src);
     auto const tab = base64::get_alphabet();
 
@@ -154,7 +154,7 @@ encode(void* dest, void const* src, std::size_t len)
 std::pair<std::size_t, std::size_t>
 decode(void* dest, char const* src, std::size_t len)
 {
-    char* out = static_cast<char*>(dest);
+    char* out = static_cast<char*>(dest);  // NOLINT(misc-const-correctness)
     auto in = reinterpret_cast<unsigned char const*>(src);
     unsigned char c3[3]{}, c4[4]{};
     int i = 0;
diff --git a/src/libxrpl/basics/make_SSLContext.cpp b/src/libxrpl/basics/make_SSLContext.cpp
index de16e8c6cf..c5ff456d25 100644
--- a/src/libxrpl/basics/make_SSLContext.cpp
+++ b/src/libxrpl/basics/make_SSLContext.cpp
@@ -140,7 +140,7 @@ initAnonymous(boost::asio::ssl::context& context)
 
         auto const ts = std::time(nullptr) - (25 * 60 * 60);
 
-        int ret = std::strftime(buf, sizeof(buf) - 1, "%y%m%d000000Z", std::gmtime(&ts));
+        int const ret = std::strftime(buf, sizeof(buf) - 1, "%y%m%d000000Z", std::gmtime(&ts));
 
         buf[ret] = 0;
 
diff --git a/src/libxrpl/beast/clock/basic_seconds_clock.cpp b/src/libxrpl/beast/clock/basic_seconds_clock.cpp
index 4727599740..c928c8c579 100644
--- a/src/libxrpl/beast/clock/basic_seconds_clock.cpp
+++ b/src/libxrpl/beast/clock/basic_seconds_clock.cpp
@@ -41,7 +41,7 @@ seconds_clock_thread::~seconds_clock_thread()
     XRPL_ASSERT(
         thread_.joinable(), "beast::seconds_clock_thread::~seconds_clock_thread : thread joinable");
     {
-        std::lock_guard lock(mut_);
+        std::lock_guard const lock(mut_);
         stop_ = true;
     }  // publish stop_ asap so if waiting thread times-out, it will see it
     cv_.notify_one();
diff --git a/src/libxrpl/beast/core/SemanticVersion.cpp b/src/libxrpl/beast/core/SemanticVersion.cpp
index 34bb5e3df0..0601690560 100644
--- a/src/libxrpl/beast/core/SemanticVersion.cpp
+++ b/src/libxrpl/beast/core/SemanticVersion.cpp
@@ -62,7 +62,7 @@ chopUInt(int& value, int limit, std::string& input)
         return std::isdigit(c, std::locale::classic());
     });
 
-    std::string item(input.begin(), left_iter);
+    std::string const item(input.begin(), left_iter);
 
     // Must not be empty
     if (item.empty())
@@ -320,7 +320,7 @@ compare(SemanticVersion const& lhs, SemanticVersion const& rhs)
             {
                 XRPL_ASSERT(!isNumeric(right), "beast::compare : both inputs non-numeric");
 
-                int result = left.compare(right);
+                int const result = left.compare(right);
 
                 if (result != 0)
                     return result;
diff --git a/src/libxrpl/beast/insight/Collector.cpp b/src/libxrpl/beast/insight/Collector.cpp
index 37b199fa7f..d4a528473b 100644
--- a/src/libxrpl/beast/insight/Collector.cpp
+++ b/src/libxrpl/beast/insight/Collector.cpp
@@ -4,5 +4,5 @@ namespace beast {
 namespace insight {
 
 Collector::~Collector() = default;
-}
+}  // namespace insight
 }  // namespace beast
diff --git a/src/libxrpl/beast/insight/Groups.cpp b/src/libxrpl/beast/insight/Groups.cpp
index 2b4178a9ca..393deca101 100644
--- a/src/libxrpl/beast/insight/Groups.cpp
+++ b/src/libxrpl/beast/insight/Groups.cpp
@@ -98,7 +98,7 @@ public:
     Group::ptr const&
     get(std::string const& name) override
     {
-        std::pair<Items::iterator, bool> result(m_items.emplace(name, Group::ptr()));
+        std::pair<Items::iterator, bool> const result(m_items.emplace(name, Group::ptr()));
         Group::ptr& group(result.first->second);
         if (result.second)
             group = std::make_shared<GroupImp>(name, m_collector);
diff --git a/src/libxrpl/beast/insight/Hook.cpp b/src/libxrpl/beast/insight/Hook.cpp
index d5e0a3439f..f74f3e8705 100644
--- a/src/libxrpl/beast/insight/Hook.cpp
+++ b/src/libxrpl/beast/insight/Hook.cpp
@@ -5,5 +5,5 @@ namespace beast {
 namespace insight {
 
 HookImpl::~HookImpl() = default;
-}
+}  // namespace insight
 }  // namespace beast
diff --git a/src/libxrpl/beast/insight/StatsDCollector.cpp b/src/libxrpl/beast/insight/StatsDCollector.cpp
index 83fc65e92c..7d80e1a052 100644
--- a/src/libxrpl/beast/insight/StatsDCollector.cpp
+++ b/src/libxrpl/beast/insight/StatsDCollector.cpp
@@ -293,14 +293,14 @@ public:
     void
     add(StatsDMetricBase& metric)
     {
-        std::lock_guard _(metricsLock_);
+        std::lock_guard const _(metricsLock_);
         metrics_.push_back(metric);
     }
 
     void
     remove(StatsDMetricBase& metric)
     {
-        std::lock_guard _(metricsLock_);
+        std::lock_guard const _(metricsLock_);
         metrics_.erase(metrics_.iterator_to(metric));
     }
 
@@ -444,7 +444,7 @@ public:
             return;
         }
 
-        std::lock_guard _(metricsLock_);
+        std::lock_guard const _(metricsLock_);
 
         for (auto& m : metrics_)
             m.do_process();
diff --git a/src/libxrpl/beast/net/IPEndpoint.cpp b/src/libxrpl/beast/net/IPEndpoint.cpp
index 70e7bff2c5..7e2799b46c 100644
--- a/src/libxrpl/beast/net/IPEndpoint.cpp
+++ b/src/libxrpl/beast/net/IPEndpoint.cpp
@@ -120,8 +120,7 @@ operator>>(std::istream& is, Endpoint& endpoint)
             addrStr += i;
 
             // don't exceed a reasonable length...
-            if (addrStr.size() == INET6_ADDRSTRLEN ||
-                ((readTo != 0) && readTo == ':' && addrStr.size() > 15))
+            if (addrStr.size() == INET6_ADDRSTRLEN || (readTo == ':' && addrStr.size() > 15))
             {
                 is.setstate(std::ios_base::failbit);
                 return is;
diff --git a/src/libxrpl/beast/utility/beast_PropertyStream.cpp b/src/libxrpl/beast/utility/beast_PropertyStream.cpp
index 454b9d1323..9cf4f23065 100644
--- a/src/libxrpl/beast/utility/beast_PropertyStream.cpp
+++ b/src/libxrpl/beast/utility/beast_PropertyStream.cpp
@@ -158,7 +158,7 @@ PropertyStream::Source::Source(std::string const& name)
 
 PropertyStream::Source::~Source()
 {
-    std::lock_guard _(lock_);
+    std::lock_guard const _(lock_);
     if (parent_ != nullptr)
         parent_->remove(*this);
     removeAll();
@@ -174,8 +174,8 @@ void
 PropertyStream::Source::add(Source& source)
 {
     std::lock(lock_, source.lock_);
-    std::lock_guard lk1(lock_, std::adopt_lock);
-    std::lock_guard lk2(source.lock_, std::adopt_lock);
+    std::lock_guard const lk1(lock_, std::adopt_lock);
+    std::lock_guard const lk2(source.lock_, std::adopt_lock);
 
     XRPL_ASSERT(
         source.parent_ == nullptr, "beast::PropertyStream::Source::add : null source parent");
@@ -187,8 +187,8 @@ void
 PropertyStream::Source::remove(Source& child)
 {
     std::lock(lock_, child.lock_);
-    std::lock_guard lk1(lock_, std::adopt_lock);
-    std::lock_guard lk2(child.lock_, std::adopt_lock);
+    std::lock_guard const lk1(lock_, std::adopt_lock);
+    std::lock_guard const lk2(child.lock_, std::adopt_lock);
 
     XRPL_ASSERT(
         child.parent_ == this, "beast::PropertyStream::Source::remove : child parent match");
@@ -199,10 +199,10 @@ PropertyStream::Source::remove(Source& child)
 void
 PropertyStream::Source::removeAll()
 {
-    std::lock_guard _(lock_);
+    std::lock_guard const _(lock_);
     for (auto iter = children_.begin(); iter != children_.end();)
     {
-        std::lock_guard _cl((*iter)->lock_);
+        std::lock_guard const _cl((*iter)->lock_);
         remove(*(*iter));
     }
 }
@@ -222,7 +222,7 @@ PropertyStream::Source::write(PropertyStream& stream)
     Map map(m_name, stream);
     onWrite(map);
 
-    std::lock_guard _(lock_);
+    std::lock_guard const _(lock_);
 
     for (auto& child : children_)
         child.source().write(stream);
@@ -299,9 +299,9 @@ PropertyStream::Source::peel_name(std::string* path)
     if (path->empty())
         return "";
 
-    std::string::const_iterator first = (*path).begin();
-    std::string::const_iterator last = (*path).end();
-    std::string::const_iterator pos = std::find(first, last, '/');
+    std::string::const_iterator const first = (*path).begin();
+    std::string::const_iterator const last = (*path).end();
+    std::string::const_iterator const pos = std::find(first, last, '/');
     std::string s(first, pos);
 
     if (pos != last)
@@ -320,11 +320,11 @@ PropertyStream::Source::peel_name(std::string* path)
 PropertyStream::Source*
 PropertyStream::Source::find_one_deep(std::string const& name)
 {
-    Source* found = find_one(name);
+    Source* found = find_one(name);  // NOLINT(misc-const-correctness)
     if (found != nullptr)
         return found;
 
-    std::lock_guard _(lock_);
+    std::lock_guard const _(lock_);
     for (auto& s : children_)
     {
         found = s.source().find_one_deep(name);
@@ -355,7 +355,7 @@ PropertyStream::Source::find_path(std::string path)
 PropertyStream::Source*
 PropertyStream::Source::find_one(std::string const& name)
 {
-    std::lock_guard _(lock_);
+    std::lock_guard const _(lock_);
     for (auto& s : children_)
     {
         if (s.source().m_name == name)
diff --git a/src/libxrpl/core/HashRouter.cpp b/src/libxrpl/core/HashRouter.cpp
index dff1394f77..f21daf84a2 100644
--- a/src/libxrpl/core/HashRouter.cpp
+++ b/src/libxrpl/core/HashRouter.cpp
@@ -22,7 +22,7 @@ HashRouter::emplace(uint256 const& key) -> std::pair<Entry&, bool>
 void
 HashRouter::addSuppression(uint256 const& key)
 {
-    std::lock_guard lock(mutex_);
+    std::lock_guard const lock(mutex_);
 
     emplace(key);
 }
@@ -36,7 +36,7 @@ HashRouter::addSuppressionPeer(uint256 const& key, PeerShortID peer)
 std::pair<bool, std::optional<Stopwatch::time_point>>
 HashRouter::addSuppressionPeerWithStatus(uint256 const& key, PeerShortID peer)
 {
-    std::lock_guard lock(mutex_);
+    std::lock_guard const lock(mutex_);
 
     auto result = emplace(key);
     result.first.addPeer(peer);
@@ -46,7 +46,7 @@ HashRouter::addSuppressionPeerWithStatus(uint256 const& key, PeerShortID peer)
 bool
 HashRouter::addSuppressionPeer(uint256 const& key, PeerShortID peer, HashRouterFlags& flags)
 {
-    std::lock_guard lock(mutex_);
+    std::lock_guard const lock(mutex_);
 
     auto [s, created] = emplace(key);
     s.addPeer(peer);
@@ -61,7 +61,7 @@ HashRouter::shouldProcess(
     HashRouterFlags& flags,
     std::chrono::seconds tx_interval)
 {
-    std::lock_guard lock(mutex_);
+    std::lock_guard const lock(mutex_);
 
     auto result = emplace(key);
     auto& s = result.first;
@@ -73,7 +73,7 @@ HashRouter::shouldProcess(
 HashRouterFlags
 HashRouter::getFlags(uint256 const& key)
 {
-    std::lock_guard lock(mutex_);
+    std::lock_guard const lock(mutex_);
 
     return emplace(key).first.getFlags();
 }
@@ -83,7 +83,7 @@ HashRouter::setFlags(uint256 const& key, HashRouterFlags flags)
 {
     XRPL_ASSERT(static_cast<bool>(flags), "xrpl::HashRouter::setFlags : valid input");
 
-    std::lock_guard lock(mutex_);
+    std::lock_guard const lock(mutex_);
 
     auto& s = emplace(key).first;
 
@@ -97,7 +97,7 @@ HashRouter::setFlags(uint256 const& key, HashRouterFlags flags)
 auto
 HashRouter::shouldRelay(uint256 const& key) -> std::optional<std::set<PeerShortID>>
 {
-    std::lock_guard lock(mutex_);
+    std::lock_guard const lock(mutex_);
 
     auto& s = emplace(key).first;
 
diff --git a/src/libxrpl/core/detail/JobQueue.cpp b/src/libxrpl/core/detail/JobQueue.cpp
index 2fe5a5b0fd..434ab146bd 100644
--- a/src/libxrpl/core/detail/JobQueue.cpp
+++ b/src/libxrpl/core/detail/JobQueue.cpp
@@ -26,7 +26,7 @@ JobQueue::JobQueue(
     job_count = m_collector->make_gauge("job_count");
 
     {
-        std::lock_guard lock(m_mutex);
+        std::lock_guard const lock(m_mutex);
 
         for (auto const& x : JobTypes::instance())
         {
@@ -52,7 +52,7 @@ JobQueue::~JobQueue()
 void
 JobQueue::collect()
 {
-    std::lock_guard lock(m_mutex);
+    std::lock_guard const lock(m_mutex);
     job_count = m_jobSet.size();
 }
 
@@ -78,7 +78,7 @@ JobQueue::addRefCountedJob(JobType type, std::string const& name, JobFunction co
         "requires no threads");
 
     {
-        std::lock_guard lock(m_mutex);
+        std::lock_guard const lock(m_mutex);
         auto result = m_jobSet.emplace(type, name, ++m_lastJob, data.load(), func);
         auto const& job = *result.first;
 
@@ -106,9 +106,9 @@ JobQueue::addRefCountedJob(JobType type, std::string const& name, JobFunction co
 int
 JobQueue::getJobCount(JobType t) const
 {
-    std::lock_guard lock(m_mutex);
+    std::lock_guard const lock(m_mutex);
 
-    JobDataMap::const_iterator c = m_jobData.find(t);
+    JobDataMap::const_iterator const c = m_jobData.find(t);
 
     return (c == m_jobData.end()) ? 0 : c->second.waiting;
 }
@@ -116,9 +116,9 @@ JobQueue::getJobCount(JobType t) const
 int
 JobQueue::getJobCountTotal(JobType t) const
 {
-    std::lock_guard lock(m_mutex);
+    std::lock_guard const lock(m_mutex);
 
-    JobDataMap::const_iterator c = m_jobData.find(t);
+    JobDataMap::const_iterator const c = m_jobData.find(t);
 
     return (c == m_jobData.end()) ? 0 : (c->second.waiting + c->second.running);
 }
@@ -129,7 +129,7 @@ JobQueue::getJobCountGE(JobType t) const
     // return the number of jobs at this priority level or greater
     int ret = 0;
 
-    std::lock_guard lock(m_mutex);
+    std::lock_guard const lock(m_mutex);
 
     for (auto const& x : m_jobData)
     {
@@ -143,7 +143,7 @@ JobQueue::getJobCountGE(JobType t) const
 std::unique_ptr<LoadEvent>
 JobQueue::makeLoadEvent(JobType t, std::string const& name)
 {
-    JobDataMap::iterator iter(m_jobData.find(t));
+    JobDataMap::iterator const iter(m_jobData.find(t));
     XRPL_ASSERT(iter != m_jobData.end(), "xrpl::JobQueue::makeLoadEvent : valid job type input");
 
     if (iter == m_jobData.end())
@@ -158,7 +158,7 @@ JobQueue::addLoadEvents(JobType t, int count, std::chrono::milliseconds elapsed)
     if (isStopped())
         LogicError("JobQueue::addLoadEvents() called after JobQueue stopped");
 
-    JobDataMap::iterator iter(m_jobData.find(t));
+    JobDataMap::iterator const iter(m_jobData.find(t));
     XRPL_ASSERT(iter != m_jobData.end(), "xrpl::JobQueue::addLoadEvents : valid job type input");
     iter->second.load().addSamples(count, elapsed);
 }
@@ -181,7 +181,7 @@ JobQueue::getJson(int c)
 
     Json::Value priorities = Json::arrayValue;
 
-    std::lock_guard lock(m_mutex);
+    std::lock_guard const lock(m_mutex);
 
     for (auto& x : m_jobData)
     {
@@ -192,10 +192,10 @@ JobQueue::getJson(int c)
 
         JobTypeData& data(x.second);
 
-        LoadMonitor::Stats stats(data.stats());
+        LoadMonitor::Stats const stats(data.stats());
 
-        int waiting(data.waiting);
-        int running(data.running);
+        int const waiting(data.waiting);
+        int const running(data.running);
 
         if ((stats.count != 0) || (waiting != 0) || (stats.latencyPeak != 0ms) || (running != 0))
         {
@@ -238,7 +238,7 @@ JobQueue::rendezvous()
 JobTypeData&
 JobQueue::getJobTypeData(JobType type)
 {
-    JobDataMap::iterator c(m_jobData.find(type));
+    JobDataMap::iterator const c(m_jobData.find(type));
     XRPL_ASSERT(c != m_jobData.end(), "xrpl::JobQueue::getJobTypeData : valid job type input");
 
     // NIKB: This is ugly and I hate it. We must remove jtINVALID completely
@@ -338,12 +338,12 @@ JobQueue::processTask(int instance)
         {
             Job job;
             {
-                std::lock_guard lock(m_mutex);
+                std::lock_guard const lock(m_mutex);
                 getNextJob(job);
                 ++m_processCount;
             }
             type = job.getType();
-            JobTypeData& data(getJobTypeData(type));
+            JobTypeData const& data(getJobTypeData(type));
             JLOG(m_journal.trace()) << "Doing " << data.name() << "job";
 
             // The amount of time that the job was in the queue
@@ -365,7 +365,7 @@ JobQueue::processTask(int instance)
     }
 
     {
-        std::lock_guard lock(m_mutex);
+        std::lock_guard const lock(m_mutex);
         // Job should be destroyed before stopping
         // otherwise destructors with side effects can access
         // parent objects that are already destroyed.
diff --git a/src/libxrpl/core/detail/LoadMonitor.cpp b/src/libxrpl/core/detail/LoadMonitor.cpp
index 9891bdb8b8..967947ee17 100644
--- a/src/libxrpl/core/detail/LoadMonitor.cpp
+++ b/src/libxrpl/core/detail/LoadMonitor.cpp
@@ -104,7 +104,7 @@ LoadMonitor::addLoadSample(LoadEvent const& s)
 void
 LoadMonitor::addSamples(int count, std::chrono::milliseconds latency)
 {
-    std::lock_guard sl(mutex_);
+    std::lock_guard const sl(mutex_);
 
     update();
     mCounts += count;
@@ -136,7 +136,7 @@ LoadMonitor::isOverTarget(std::chrono::milliseconds avg, std::chrono::millisecon
 bool
 LoadMonitor::isOver()
 {
-    std::lock_guard sl(mutex_);
+    std::lock_guard const sl(mutex_);
 
     update();
 
@@ -153,7 +153,7 @@ LoadMonitor::getStats()
     using namespace std::chrono_literals;
     Stats stats;
 
-    std::lock_guard sl(mutex_);
+    std::lock_guard const sl(mutex_);
 
     update();
 
diff --git a/src/libxrpl/core/detail/Workers.cpp b/src/libxrpl/core/detail/Workers.cpp
index b7d962b79b..a654d20280 100644
--- a/src/libxrpl/core/detail/Workers.cpp
+++ b/src/libxrpl/core/detail/Workers.cpp
@@ -121,7 +121,7 @@ Workers::deleteWorkers(beast::LockFreeStack<Worker>& stack)
 {
     for (;;)
     {
-        Worker* const worker = stack.pop_front();
+        Worker const* const worker = stack.pop_front();
 
         if (worker != nullptr)
         {
@@ -150,7 +150,7 @@ Workers::Worker::Worker(Workers& workers, std::string const& threadName, int con
 Workers::Worker::~Worker()
 {
     {
-        std::lock_guard lock{mutex_};
+        std::lock_guard const lock{mutex_};
         ++wakeCount_;
         shouldExit_ = true;
     }
@@ -162,7 +162,7 @@ Workers::Worker::~Worker()
 void
 Workers::Worker::notify()
 {
-    std::lock_guard lock{mutex_};
+    std::lock_guard const lock{mutex_};
     ++wakeCount_;
     wakeup_.notify_one();
 }
@@ -178,7 +178,7 @@ Workers::Worker::run()
         //
         if (++m_workers.m_activeCount == 1)
         {
-            std::lock_guard lk{m_workers.m_mut};
+            std::lock_guard const lk{m_workers.m_mut};
             m_workers.m_allPaused = false;
         }
 
@@ -225,7 +225,7 @@ Workers::Worker::run()
             // the predicate evaluation and the actual sleep.
             if (--m_workers.m_runningTaskCount == 0)
             {
-                std::lock_guard lk{m_workers.m_mut};
+                std::lock_guard const lk{m_workers.m_mut};
                 m_workers.m_cv.notify_all();
             }
         }
@@ -241,7 +241,7 @@ Workers::Worker::run()
         //
         if (--m_workers.m_activeCount == 0)
         {
-            std::lock_guard lk{m_workers.m_mut};
+            std::lock_guard const lk{m_workers.m_mut};
             m_workers.m_allPaused = true;
             m_workers.m_cv.notify_all();
         }
diff --git a/src/libxrpl/crypto/RFC1751.cpp b/src/libxrpl/crypto/RFC1751.cpp
index becd0aab8d..f7098f3833 100644
--- a/src/libxrpl/crypto/RFC1751.cpp
+++ b/src/libxrpl/crypto/RFC1751.cpp
@@ -312,8 +312,8 @@ RFC1751::wsrch(std::string const& strWord, int iMin, int iMax)
     while (iResult < 0 && iMin != iMax)
     {
         // Have a range to search.
-        int iMid = iMin + ((iMax - iMin) / 2);
-        int iDir = strWord.compare(s_dictionary[iMid]);
+        int const iMid = iMin + ((iMax - iMin) / 2);
+        int const iDir = strWord.compare(s_dictionary[iMid]);
 
         if (iDir == 0)
         {
@@ -349,7 +349,7 @@ RFC1751::etob(std::string& strData, std::vector<std::string> vsHuman)
 
     for (auto& strWord : vsHuman)
     {
-        int l = strWord.length();
+        int const l = strWord.length();
 
         if (l > 4 || l < 1)
             return -1;
diff --git a/src/libxrpl/crypto/csprng.cpp b/src/libxrpl/crypto/csprng.cpp
index 25e24c0b08..343bed9be0 100644
--- a/src/libxrpl/crypto/csprng.cpp
+++ b/src/libxrpl/crypto/csprng.cpp
@@ -42,7 +42,7 @@ csprng_engine::mix_entropy(void* buffer, std::size_t count)
             e = rd();
     }
 
-    std::lock_guard lock(mutex_);
+    std::lock_guard const lock(mutex_);
 
     // We add data to the pool, but we conservatively assume that
     // it contributes no actual entropy.
diff --git a/src/libxrpl/json/Writer.cpp b/src/libxrpl/json/Writer.cpp
index 796ec35dfd..ea7b4b51ae 100644
--- a/src/libxrpl/json/Writer.cpp
+++ b/src/libxrpl/json/Writer.cpp
@@ -80,7 +80,7 @@ public:
     void
     start(CollectionType ct)
     {
-        char ch = (ct == array) ? openBracket : openBrace;
+        char const ch = (ct == array) ? openBracket : openBrace;
         output({&ch, 1});
         stack_.push(Collection());
         stack_.top().type = ct;
diff --git a/src/libxrpl/json/json_reader.cpp b/src/libxrpl/json/json_reader.cpp
index 6475a5b68b..71365ba6c1 100644
--- a/src/libxrpl/json/json_reader.cpp
+++ b/src/libxrpl/json/json_reader.cpp
@@ -93,7 +93,7 @@ Reader::parse(char const* beginDoc, char const* endDoc, Value& root)
         nodes_.pop();
 
     nodes_.push(&root);
-    bool successful = readValue(0);
+    bool const successful = readValue(0);
     Token token{};
     skipCommentTokens(token);
 
@@ -186,7 +186,7 @@ Reader::readToken(Token& token)
 {
     skipSpaces();
     token.start_ = current_;
-    Char c = getNextChar();
+    Char const c = getNextChar();
     bool ok = true;
 
     switch (c)
@@ -275,7 +275,7 @@ Reader::skipSpaces()
 {
     while (current_ != end_)
     {
-        Char c = *current_;
+        Char const c = *current_;
 
         if (c == ' ' || c == '\t' || c == '\r' || c == '\n')
         {
@@ -309,7 +309,7 @@ Reader::match(Location pattern, int patternLength)
 bool
 Reader::readComment()
 {
-    Char c = getNextChar();
+    Char const c = getNextChar();
 
     if (c == '*')
         return readCStyleComment();
@@ -325,7 +325,7 @@ Reader::readCStyleComment()
 {
     while (current_ != end_)
     {
-        Char c = getNextChar();
+        Char const c = getNextChar();
 
         if (c == '*' && *current_ == '/')
             break;
@@ -339,7 +339,7 @@ Reader::readCppStyleComment()
 {
     while (current_ != end_)
     {
-        Char c = getNextChar();
+        Char const c = getNextChar();
 
         if (c == '\r' || c == '\n')
             break;
@@ -444,7 +444,7 @@ Reader::readObject(Token& tokenStart, unsigned depth)
 
         Value& value = currentValue()[name];
         nodes_.push(&value);
-        bool ok = readValue(depth + 1);
+        bool const ok = readValue(depth + 1);
         nodes_.pop();
 
         if (!ok)  // error already set
@@ -506,7 +506,8 @@ Reader::readArray(Token& tokenStart, unsigned depth)
             ok = readToken(token);
         }
 
-        bool badTokenType = (token.type_ != tokenArraySeparator && token.type_ != tokenArrayEnd);
+        bool const badTokenType =
+            (token.type_ != tokenArraySeparator && token.type_ != tokenArrayEnd);
 
         if (!ok || badTokenType)
         {
@@ -525,7 +526,7 @@ bool
 Reader::decodeNumber(Token& token)
 {
     Location current = token.start_;
-    bool isNegative = *current == '-';
+    bool const isNegative = *current == '-';
 
     if (isNegative)
         ++current;
@@ -546,7 +547,7 @@ Reader::decodeNumber(Token& token)
 
     while (current < token.end_ && (value <= Value::maxUInt))
     {
-        Char c = *current++;
+        Char const c = *current++;
 
         if (c < '0' || c > '9')
         {
@@ -606,7 +607,7 @@ Reader::decodeDouble(Token& token)
     double value = 0;
     int const bufferSize = 32;
     int count = 0;
-    int length = int(token.end_ - token.start_);
+    int const length = int(token.end_ - token.start_);
     // Sanity check to avoid buffer overflow exploits.
     if (length < 0)
     {
@@ -627,7 +628,7 @@ Reader::decodeDouble(Token& token)
     }
     else
     {
-        std::string buffer(token.start_, token.end_);
+        std::string const buffer(token.start_, token.end_);
         count = sscanf(buffer.c_str(), format, &value);
     }
     if (count != 1)
@@ -657,7 +658,7 @@ Reader::decodeString(Token& token, std::string& decoded)
 
     while (current != end)
     {
-        Char c = *current++;
+        Char const c = *current++;
 
         if (c == '"')
         {
@@ -668,7 +669,7 @@ Reader::decodeString(Token& token, std::string& decoded)
             if (current == end)
                 return addError("Empty escape sequence in string", token, current);
 
-            Char escape = *current++;
+            Char const escape = *current++;
 
             switch (escape)
             {
@@ -783,7 +784,7 @@ Reader::decodeUnicodeEscapeSequence(
 
     for (int index = 0; index < 4; ++index)
     {
-        Char c = *current++;
+        Char const c = *current++;
         unicode *= 16;
 
         if (c >= '0' && c <= '9')
@@ -825,7 +826,7 @@ Reader::addError(std::string const& message, Token& token, Location extra)
 bool
 Reader::recoverFromError(TokenType skipUntilToken)
 {
-    int errorCount = int(errors_.size());
+    int const errorCount = int(errors_.size());
     Token skip{};
 
     while (true)
@@ -872,7 +873,7 @@ Reader::getLocationLineAndColumn(Location location, int& line, int& column) cons
 
     while (current < location && current != end_)
     {
-        Char c = *current++;
+        Char const c = *current++;
 
         if (c == '\r')
         {
@@ -924,7 +925,7 @@ std::istream&
 operator>>(std::istream& sin, Value& root)
 {
     Json::Reader reader;
-    bool ok = reader.parse(sin, root);
+    bool const ok = reader.parse(sin, root);
 
     // XRPL_ASSERT(ok, "Json::operator>>() : parse succeeded");
     if (!ok)
diff --git a/src/libxrpl/json/json_value.cpp b/src/libxrpl/json/json_value.cpp
index 988a25a3ff..d4351b23ef 100644
--- a/src/libxrpl/json/json_value.cpp
+++ b/src/libxrpl/json/json_value.cpp
@@ -60,6 +60,7 @@ public:
 static ValueAllocator*&
 valueAllocator()
 {
+    // NOLINTNEXTLINE(misc-const-correctness)
     static ValueAllocator* valueAllocator = new DefaultValueAllocator;
     return valueAllocator;
 }
@@ -333,11 +334,11 @@ Value::swap(Value& other) noexcept
 {
     std::swap(value_, other.value_);
 
-    ValueType temp = type_;
+    ValueType const temp = type_;
     type_ = other.type_;
     other.type_ = temp;
 
-    int temp2 = allocated_;
+    int const temp2 = allocated_;
     allocated_ = other.allocated_;
     other.allocated_ = temp2;
 }
@@ -401,7 +402,7 @@ operator<(Value const& x, Value const& y)
 
         case arrayValue:
         case objectValue: {
-            if (int signum = int(x.value_.map_->size()) - y.value_.map_->size())
+            if (int const signum = int(x.value_.map_->size()) - y.value_.map_->size())
                 return signum < 0;
 
             return *x.value_.map_ < *y.value_.map_;
@@ -848,13 +849,13 @@ Value::operator[](UInt index)
     if (type_ == nullValue)
         *this = Value(arrayValue);
 
-    CZString key(index);
+    CZString const key(index);
     ObjectValues::iterator it = value_.map_->lower_bound(key);
 
     if (it != value_.map_->end() && (*it).first == key)
         return (*it).second;
 
-    ObjectValues::value_type defaultValue(key, null);
+    ObjectValues::value_type const defaultValue(key, null);
     it = value_.map_->insert(it, defaultValue);
     return (*it).second;
 }
@@ -869,8 +870,8 @@ Value::operator[](UInt index) const
     if (type_ == nullValue)
         return null;
 
-    CZString key(index);
-    ObjectValues::const_iterator it = value_.map_->find(key);
+    CZString const key(index);
+    ObjectValues::const_iterator const it = value_.map_->find(key);
 
     if (it == value_.map_->end())
         return null;
@@ -893,13 +894,13 @@ Value::resolveReference(char const* key, bool isStatic)
     if (type_ == nullValue)
         *this = Value(objectValue);
 
-    CZString actualKey(key, isStatic ? CZString::noDuplication : CZString::duplicateOnCopy);
+    CZString const actualKey(key, isStatic ? CZString::noDuplication : CZString::duplicateOnCopy);
     ObjectValues::iterator it = value_.map_->lower_bound(actualKey);
 
     if (it != value_.map_->end() && (*it).first == actualKey)
         return (*it).second;
 
-    ObjectValues::value_type defaultValue(actualKey, null);
+    ObjectValues::value_type const defaultValue(actualKey, null);
     it = value_.map_->insert(it, defaultValue);
     Value& value = (*it).second;
     return value;
@@ -928,8 +929,8 @@ Value::operator[](char const* key) const
     if (type_ == nullValue)
         return null;
 
-    CZString actualKey(key, CZString::noDuplication);
-    ObjectValues::const_iterator it = value_.map_->find(actualKey);
+    CZString const actualKey(key, CZString::noDuplication);
+    ObjectValues::const_iterator const it = value_.map_->find(actualKey);
 
     if (it == value_.map_->end())
         return null;
@@ -995,8 +996,8 @@ Value::removeMember(char const* key)
     if (type_ == nullValue)
         return null;
 
-    CZString actualKey(key, CZString::noDuplication);
-    ObjectValues::iterator it = value_.map_->find(actualKey);
+    CZString const actualKey(key, CZString::noDuplication);
+    ObjectValues::iterator const it = value_.map_->find(actualKey);
 
     if (it == value_.map_->end())
         return null;
@@ -1046,7 +1047,7 @@ Value::getMemberNames() const
     Members members;
     members.reserve(value_.map_->size());
     ObjectValues::const_iterator it = value_.map_->begin();
-    ObjectValues::const_iterator itEnd = value_.map_->end();
+    ObjectValues::const_iterator const itEnd = value_.map_->end();
 
     for (; it != itEnd; ++it)
         members.push_back(std::string((*it).first.c_str()));
diff --git a/src/libxrpl/json/json_writer.cpp b/src/libxrpl/json/json_writer.cpp
index b51da5bb68..2d0fc1c288 100644
--- a/src/libxrpl/json/json_writer.cpp
+++ b/src/libxrpl/json/json_writer.cpp
@@ -47,8 +47,8 @@ std::string
 valueToString(Int value)
 {
     char buffer[32];
-    char* current = buffer + sizeof(buffer);
-    bool isNegative = value < 0;
+    char* current = buffer + sizeof(buffer);  // NOLINT(misc-const-correctness)
+    bool const isNegative = value < 0;
 
     if (isNegative)
         value = -value;
@@ -66,7 +66,7 @@ std::string
 valueToString(UInt value)
 {
     char buffer[32];
-    char* current = buffer + sizeof(buffer);
+    char* current = buffer + sizeof(buffer);  // NOLINT(misc-const-correctness)
     uintToString(value, current);
     XRPL_ASSERT(current >= buffer, "Json::valueToString(UInt) : buffer check");
     return current;
@@ -106,7 +106,7 @@ valueToQuotedString(char const* value)
     // We have to walk value and escape any special characters.
     // Appending to std::string is not efficient, but this should be rare.
     // (Note: forward slashes are *not* rare, but I am not escaping them.)
-    unsigned maxsize = (strlen(value) * 2) + 3;  // all-escaped+quotes+NULL
+    unsigned const maxsize = (strlen(value) * 2) + 3;  // all-escaped+quotes+NULL
     std::string result;
     result.reserve(maxsize);  // to avoid lots of mallocs
     result += "\"";
@@ -213,7 +213,7 @@ FastWriter::writeValue(Value const& value)
 
         case arrayValue: {
             document_ += "[";
-            int size = value.size();
+            int const size = value.size();
 
             for (int index = 0; index < size; ++index)
             {
@@ -338,7 +338,7 @@ StyledWriter::writeValue(Value const& value)
 void
 StyledWriter::writeArrayValue(Value const& value)
 {
-    unsigned size = value.size();
+    unsigned const size = value.size();
 
     if (size == 0)
     {
@@ -346,13 +346,13 @@ StyledWriter::writeArrayValue(Value const& value)
     }
     else
     {
-        bool isArrayMultiLine = isMultilineArray(value);
+        bool const isArrayMultiLine = isMultilineArray(value);
 
         if (isArrayMultiLine)
         {
             writeWithIndent("[");
             indent();
-            bool hasChildValue = !childValues_.empty();
+            bool const hasChildValue = !childValues_.empty();
             unsigned index = 0;
 
             while (true)
@@ -401,7 +401,7 @@ StyledWriter::writeArrayValue(Value const& value)
 bool
 StyledWriter::isMultilineArray(Value const& value)
 {
-    int size = value.size();
+    int const size = value.size();
     bool isMultiLine = size * 3 >= rightMargin_;
     childValues_.clear();
 
@@ -449,7 +449,7 @@ StyledWriter::writeIndent()
 {
     if (!document_.empty())
     {
-        char last = document_[document_.length() - 1];
+        char const last = document_[document_.length() - 1];
 
         if (last == ' ')  // already indented
             return;
@@ -573,7 +573,7 @@ StyledStreamWriter::writeValue(Value const& value)
 void
 StyledStreamWriter::writeArrayValue(Value const& value)
 {
-    unsigned size = value.size();
+    unsigned const size = value.size();
 
     if (size == 0)
     {
@@ -581,13 +581,13 @@ StyledStreamWriter::writeArrayValue(Value const& value)
     }
     else
     {
-        bool isArrayMultiLine = isMultilineArray(value);
+        bool const isArrayMultiLine = isMultilineArray(value);
 
         if (isArrayMultiLine)
         {
             writeWithIndent("[");
             indent();
-            bool hasChildValue = !childValues_.empty();
+            bool const hasChildValue = !childValues_.empty();
             unsigned index = 0;
 
             while (true)
@@ -636,7 +636,7 @@ StyledStreamWriter::writeArrayValue(Value const& value)
 bool
 StyledStreamWriter::isMultilineArray(Value const& value)
 {
-    int size = value.size();
+    int const size = value.size();
     bool isMultiLine = size * 3 >= rightMargin_;
     childValues_.clear();
 
diff --git a/src/libxrpl/ledger/ApplyStateTable.cpp b/src/libxrpl/ledger/ApplyStateTable.cpp
index a48c3910e1..9ebbca8ac5 100644
--- a/src/libxrpl/ledger/ApplyStateTable.cpp
+++ b/src/libxrpl/ledger/ApplyStateTable.cpp
@@ -127,8 +127,8 @@ ApplyStateTable::apply(
             auto curNode = item.second.second;
             if ((type == &sfModifiedNode) && (*curNode == *origNode))
                 continue;
-            std::uint16_t nodeType = curNode ? curNode->getFieldU16(sfLedgerEntryType)
-                                             : origNode->getFieldU16(sfLedgerEntryType);
+            std::uint16_t const nodeType = curNode ? curNode->getFieldU16(sfLedgerEntryType)
+                                                   : origNode->getFieldU16(sfLedgerEntryType);
             meta.setAffectedNode(item.first, *type, nodeType);
             if (type == &sfDeletedNode)
             {
diff --git a/src/libxrpl/ledger/ApplyView.cpp b/src/libxrpl/ledger/ApplyView.cpp
index fe2e046b26..476b635511 100644
--- a/src/libxrpl/ledger/ApplyView.cpp
+++ b/src/libxrpl/ledger/ApplyView.cpp
@@ -32,7 +32,7 @@ createRoot(
 auto
 findPreviousPage(ApplyView& view, Keylet const& directory, SLE::ref start)
 {
-    std::uint64_t page = start->getFieldU64(sfIndexPrevious);
+    std::uint64_t const page = start->getFieldU64(sfIndexPrevious);
 
     auto node = start;
 
diff --git a/src/libxrpl/ledger/BookListeners.cpp b/src/libxrpl/ledger/BookListeners.cpp
index 22b78e46bb..8699d891a0 100644
--- a/src/libxrpl/ledger/BookListeners.cpp
+++ b/src/libxrpl/ledger/BookListeners.cpp
@@ -5,21 +5,21 @@ namespace xrpl {
 void
 BookListeners::addSubscriber(InfoSub::ref sub)
 {
-    std::lock_guard sl(mLock);
+    std::lock_guard const sl(mLock);
     mListeners[sub->getSeq()] = sub;
 }
 
 void
 BookListeners::removeSubscriber(std::uint64_t seq)
 {
-    std::lock_guard sl(mLock);
+    std::lock_guard const sl(mLock);
     mListeners.erase(seq);
 }
 
 void
 BookListeners::publish(MultiApiJson const& jvObj, hash_set<std::uint64_t>& havePublished)
 {
-    std::lock_guard sl(mLock);
+    std::lock_guard const sl(mLock);
     auto it = mListeners.cbegin();
 
     while (it != mListeners.cend())
diff --git a/src/libxrpl/ledger/CachedView.cpp b/src/libxrpl/ledger/CachedView.cpp
index 5c15ccdac4..aa075d69a4 100644
--- a/src/libxrpl/ledger/CachedView.cpp
+++ b/src/libxrpl/ledger/CachedView.cpp
@@ -21,7 +21,7 @@ CachedViewImpl::read(Keylet const& k) const
 
     auto const digest = [&]() -> std::optional<uint256> {
         {
-            std::lock_guard lock(mutex_);
+            std::lock_guard const lock(mutex_);
             auto const iter = map_.find(k.key);
             if (iter != map_.end())
             {
@@ -57,7 +57,7 @@ CachedViewImpl::read(Keylet const& k) const
         // Avoid acquiring this lock unless necessary. It is only necessary if
         // the key was not found in the map_. The lock is needed to add the key
         // and digest.
-        std::lock_guard lock(mutex_);
+        std::lock_guard const lock(mutex_);
         map_.emplace(k.key, *digest);
     }
     if (!sle || !k.check(*sle))
diff --git a/src/libxrpl/ledger/Ledger.cpp b/src/libxrpl/ledger/Ledger.cpp
index 87f6350ce1..299a82a1f2 100644
--- a/src/libxrpl/ledger/Ledger.cpp
+++ b/src/libxrpl/ledger/Ledger.cpp
@@ -798,7 +798,7 @@ Ledger::updateSkipList()
     if (header_.seq == 0)  // genesis ledger has no previous ledger
         return;
 
-    std::uint32_t prevIndex = header_.seq - 1;
+    std::uint32_t const prevIndex = header_.seq - 1;
 
     // update record of every 256th ledger
     if ((prevIndex & 0xff) == 0)
diff --git a/src/libxrpl/ledger/ReadView.cpp b/src/libxrpl/ledger/ReadView.cpp
index e0764d6c81..8e6763410c 100644
--- a/src/libxrpl/ledger/ReadView.cpp
+++ b/src/libxrpl/ledger/ReadView.cpp
@@ -58,7 +58,7 @@ makeRulesGivenLedger(
     std::unordered_set<uint256, beast::uhash<>> const& presets)
 {
     Keylet const k = keylet::amendments();
-    std::optional digest = ledger.digest(k.key);
+    std::optional const digest = ledger.digest(k.key);
     if (digest)
     {
         auto const sle = ledger.read(k);
diff --git a/src/libxrpl/ledger/View.cpp b/src/libxrpl/ledger/View.cpp
index 227eafbec8..1702d4243b 100644
--- a/src/libxrpl/ledger/View.cpp
+++ b/src/libxrpl/ledger/View.cpp
@@ -242,7 +242,7 @@ hashOfSeq(ReadView const& ledger, LedgerIndex seq, beast::Journal journal)
     if (seq == (ledger.seq() - 1))
         return ledger.header().parentHash;
 
-    if (int diff = ledger.seq() - seq; diff <= 256)
+    if (int const diff = ledger.seq() - seq; diff <= 256)
     {
         // Within 256...
         auto const hashIndex = ledger.read(keylet::skip());
diff --git a/src/libxrpl/ledger/helpers/OfferHelpers.cpp b/src/libxrpl/ledger/helpers/OfferHelpers.cpp
index 9422153b10..3d63240fd0 100644
--- a/src/libxrpl/ledger/helpers/OfferHelpers.cpp
+++ b/src/libxrpl/ledger/helpers/OfferHelpers.cpp
@@ -16,7 +16,7 @@ offerDelete(ApplyView& view, std::shared_ptr<SLE> const& sle, beast::Journal j)
     auto owner = sle->getAccountID(sfAccount);
 
     // Detect legacy directories.
-    uint256 uDirectory = sle->getFieldH256(sfBookDirectory);
+    uint256 const uDirectory = sle->getFieldH256(sfBookDirectory);
 
     if (!view.dirRemove(keylet::ownerDir(owner), sle->getFieldU64(sfOwnerNode), offerIndex, false))
     {
diff --git a/src/libxrpl/ledger/helpers/RippleStateHelpers.cpp b/src/libxrpl/ledger/helpers/RippleStateHelpers.cpp
index 22a0967939..697b8fc293 100644
--- a/src/libxrpl/ledger/helpers/RippleStateHelpers.cpp
+++ b/src/libxrpl/ledger/helpers/RippleStateHelpers.cpp
@@ -275,8 +275,8 @@ trustDelete(
     beast::Journal j)
 {
     // Detect legacy dirs.
-    std::uint64_t uLowNode = sleRippleState->getFieldU64(sfLowNode);
-    std::uint64_t uHighNode = sleRippleState->getFieldU64(sfHighNode);
+    std::uint64_t const uLowNode = sleRippleState->getFieldU64(sfLowNode);
+    std::uint64_t const uHighNode = sleRippleState->getFieldU64(sfHighNode);
 
     JLOG(j.trace()) << "trustDelete: Deleting ripple line: low";
 
@@ -374,7 +374,7 @@ issueIOU(
 
     JLOG(j.trace()) << "issueIOU: " << to_string(account) << ": " << amount.getFullText();
 
-    bool bSenderHigh = issue.account > account;
+    bool const bSenderHigh = issue.account > account;
 
     auto const index = keylet::line(issue.account, account, issue.currency);
 
@@ -428,7 +428,7 @@ issueIOU(
     if (!receiverAccount)
         return tefINTERNAL;  // LCOV_EXCL_LINE
 
-    bool noRipple = (receiverAccount->getFlags() & lsfDefaultRipple) == 0;
+    bool const noRipple = (receiverAccount->getFlags() & lsfDefaultRipple) == 0;
 
     return trustCreate(
         view,
@@ -468,7 +468,7 @@ redeemIOU(
 
     JLOG(j.trace()) << "redeemIOU: " << to_string(account) << ": " << amount.getFullText();
 
-    bool bSenderHigh = account > issue.account;
+    bool const bSenderHigh = account > issue.account;
 
     if (auto state = view.peek(keylet::line(account, issue.account, issue.currency)))
     {
diff --git a/src/libxrpl/ledger/helpers/TokenHelpers.cpp b/src/libxrpl/ledger/helpers/TokenHelpers.cpp
index 27ee257e64..ce4ba4002a 100644
--- a/src/libxrpl/ledger/helpers/TokenHelpers.cpp
+++ b/src/libxrpl/ledger/helpers/TokenHelpers.cpp
@@ -253,7 +253,7 @@ accountHolds(
     beast::Journal j,
     SpendableHandling includeFullBalance)
 {
-    STAmount amount;
+    STAmount const amount;
     if (isXRP(currency))
     {
         return {xrpLiquid(view, account, 0, j)};
@@ -726,7 +726,7 @@ rippleSendMultiIOU(
     for (auto const& r : receivers)
     {
         auto const& receiverID = r.first;
-        STAmount amount{issue, r.second};
+        STAmount const amount{issue, r.second};
 
         /* If we aren't sending anything or if the sender is the same as the
          * receiver then we don't need to do anything.
@@ -752,7 +752,7 @@ rippleSendMultiIOU(
 
         // Calculate the amount to transfer accounting
         // for any transfer fees if the fee is not waived:
-        STAmount actualSend = (waiveFee == WaiveTransferFee::Yes)
+        STAmount const actualSend = (waiveFee == WaiveTransferFee::Yes)
             ? amount
             : multiply(amount, transferRate(view, issuer));
         actual += actualSend;
@@ -823,9 +823,9 @@ accountSendIOU(
      */
     TER terResult(tesSUCCESS);
 
-    SLE::pointer sender =
+    SLE::pointer const sender =
         uSenderID != beast::zero ? view.peek(keylet::account(uSenderID)) : SLE::pointer();
-    SLE::pointer receiver =
+    SLE::pointer const receiver =
         uReceiverID != beast::zero ? view.peek(keylet::account(uReceiverID)) : SLE::pointer();
 
     if (auto stream = j.trace())
@@ -921,7 +921,7 @@ accountSendMultiIOU(
      * ensure that transfers are balanced.
      */
 
-    SLE::pointer sender =
+    SLE::pointer const sender =
         senderID != beast::zero ? view.peek(keylet::account(senderID)) : SLE::pointer();
 
     if (auto stream = j.trace())
@@ -940,7 +940,7 @@ accountSendMultiIOU(
     for (auto const& r : receivers)
     {
         auto const& receiverID = r.first;
-        STAmount amount{issue, r.second};
+        STAmount const amount{issue, r.second};
 
         if (amount < beast::zero)
         {
@@ -953,7 +953,7 @@ accountSendMultiIOU(
         if (!amount || (senderID == receiverID))
             continue;
 
-        SLE::pointer receiver =
+        SLE::pointer const receiver =
             receiverID != beast::zero ? view.peek(keylet::account(receiverID)) : SLE::pointer();
 
         if (auto stream = j.trace())
@@ -1170,7 +1170,7 @@ rippleSendMultiMPT(
     for (auto const& r : receivers)
     {
         auto const& receiverID = r.first;
-        STAmount amount{mptIssue, r.second};
+        STAmount const amount{mptIssue, r.second};
 
         if (amount < beast::zero)
         {
@@ -1211,7 +1211,7 @@ rippleSendMultiMPT(
         }
 
         // Sending 3rd party MPTs: transit.
-        STAmount actualSend = (waiveFee == WaiveTransferFee::Yes)
+        STAmount const actualSend = (waiveFee == WaiveTransferFee::Yes)
             ? amount
             : multiply(amount, transferRate(view, amount.get<MPTIssue>().getMptID()));
         actual += actualSend;
diff --git a/src/libxrpl/net/HTTPClient.cpp b/src/libxrpl/net/HTTPClient.cpp
index 65205be39c..5cb01cb54b 100644
--- a/src/libxrpl/net/HTTPClient.cpp
+++ b/src/libxrpl/net/HTTPClient.cpp
@@ -347,10 +347,10 @@ public:
             {std::istreambuf_iterator<char>(&mHeader)}, std::istreambuf_iterator<char>()};
         JLOG(j_.trace()) << "Header: \"" << strHeader << "\"";
 
-        static boost::regex reStatus{"\\`HTTP/1\\S+ (\\d{3}) .*\\'"};  // HTTP/1.1 200 OK
-        static boost::regex reSize{
+        static boost::regex const reStatus{"\\`HTTP/1\\S+ (\\d{3}) .*\\'"};  // HTTP/1.1 200 OK
+        static boost::regex const reSize{
             "\\`.*\\r\\nContent-Length:\\s+([0-9]+).*\\'", boost::regex::icase};
-        static boost::regex reBody{"\\`.*\\r\\n\\r\\n(.*)\\'"};
+        static boost::regex const reBody{"\\`.*\\r\\n\\r\\n(.*)\\'"};
 
         boost::smatch smMatch;
         // Match status code.
@@ -428,7 +428,7 @@ public:
             else
             {
                 mResponse.commit(bytes_transferred);
-                std::string strBody{
+                std::string const strBody{
                     {std::istreambuf_iterator<char>(&mResponse)}, std::istreambuf_iterator<char>()};
                 invokeComplete(ecResult, mStatus, mBody + strBody);
             }
@@ -547,7 +547,7 @@ HTTPClient::get(
         complete,
     beast::Journal& j)
 {
-    std::deque<std::string> deqSites(1, strSite);
+    std::deque<std::string> const deqSites(1, strSite);
 
     auto client = std::make_shared<HTTPClientImp>(io_context, port, responseMax, j);
     client->get(bSSL, deqSites, strPath, timeout, complete);
@@ -567,7 +567,7 @@ HTTPClient::request(
         complete,
     beast::Journal& j)
 {
-    std::deque<std::string> deqSites(1, strSite);
+    std::deque<std::string> const deqSites(1, strSite);
 
     auto client = std::make_shared<HTTPClientImp>(io_context, port, responseMax, j);
     client->request(bSSL, deqSites, setRequest, timeout, complete);
diff --git a/src/libxrpl/nodestore/BatchWriter.cpp b/src/libxrpl/nodestore/BatchWriter.cpp
index 98fe78c489..50f4486f59 100644
--- a/src/libxrpl/nodestore/BatchWriter.cpp
+++ b/src/libxrpl/nodestore/BatchWriter.cpp
@@ -37,7 +37,7 @@ BatchWriter::store(std::shared_ptr<NodeObject> const& object)
 int
 BatchWriter::getWriteLoad()
 {
-    std::lock_guard sl(mWriteMutex);
+    std::lock_guard const sl(mWriteMutex);
 
     return std::max(mWriteLoad, static_cast<int>(mWriteSet.size()));
 }
@@ -58,7 +58,7 @@ BatchWriter::writeBatch()
         set.reserve(batchWritePreallocationSize);
 
         {
-            std::lock_guard sl(mWriteMutex);
+            std::lock_guard const sl(mWriteMutex);
 
             mWriteSet.swap(set);
             XRPL_ASSERT(
diff --git a/src/libxrpl/nodestore/Database.cpp b/src/libxrpl/nodestore/Database.cpp
index 4e0d5be05d..5d9d153f57 100644
--- a/src/libxrpl/nodestore/Database.cpp
+++ b/src/libxrpl/nodestore/Database.cpp
@@ -122,7 +122,7 @@ void
 Database::stop()
 {
     {
-        std::lock_guard lock(readLock_);
+        std::lock_guard const lock(readLock_);
 
         if (!readStopping_.exchange(true, std::memory_order_relaxed))
         {
@@ -158,7 +158,7 @@ Database::asyncFetch(
     std::uint32_t ledgerSeq,
     std::function<void(std::shared_ptr<NodeObject> const&)>&& cb)
 {
-    std::lock_guard lock(readLock_);
+    std::lock_guard const lock(readLock_);
 
     if (!isStopping())
     {
@@ -238,7 +238,7 @@ Database::getCountsJson(Json::Value& obj)
     XRPL_ASSERT(obj.isObject(), "xrpl::NodeStore::Database::getCountsJson : valid input type");
 
     {
-        std::unique_lock<std::mutex> lock(readLock_);
+        std::unique_lock<std::mutex> const lock(readLock_);
         obj["read_queue"] = static_cast<Json::UInt>(read_.size());
     }
 
diff --git a/src/libxrpl/nodestore/DatabaseRotatingImp.cpp b/src/libxrpl/nodestore/DatabaseRotatingImp.cpp
index 6cf51fbf31..aa04b17b33 100644
--- a/src/libxrpl/nodestore/DatabaseRotatingImp.cpp
+++ b/src/libxrpl/nodestore/DatabaseRotatingImp.cpp
@@ -33,7 +33,7 @@ DatabaseRotatingImp::rotate(
     // deleted.
     std::shared_ptr<NodeStore::Backend> oldArchiveBackend;
     {
-        std::lock_guard lock(mutex_);
+        std::lock_guard const lock(mutex_);
 
         archiveBackend_->setDeletePath();
         oldArchiveBackend = std::move(archiveBackend_);
@@ -50,14 +50,14 @@ DatabaseRotatingImp::rotate(
 std::string
 DatabaseRotatingImp::getName() const
 {
-    std::lock_guard lock(mutex_);
+    std::lock_guard const lock(mutex_);
     return writableBackend_->getName();
 }
 
 std::int32_t
 DatabaseRotatingImp::getWriteLoad() const
 {
-    std::lock_guard lock(mutex_);
+    std::lock_guard const lock(mutex_);
     return writableBackend_->getWriteLoad();
 }
 
@@ -65,7 +65,7 @@ void
 DatabaseRotatingImp::importDatabase(Database& source)
 {
     auto const backend = [&] {
-        std::lock_guard lock(mutex_);
+        std::lock_guard const lock(mutex_);
         return writableBackend_;
     }();
 
@@ -75,7 +75,7 @@ DatabaseRotatingImp::importDatabase(Database& source)
 void
 DatabaseRotatingImp::sync()
 {
-    std::lock_guard lock(mutex_);
+    std::lock_guard const lock(mutex_);
     writableBackend_->sync();
 }
 
@@ -85,7 +85,7 @@ DatabaseRotatingImp::store(NodeObjectType type, Blob&& data, uint256 const& hash
     auto nObj = NodeObject::createObject(type, std::move(data), hash);
 
     auto const backend = [&] {
-        std::lock_guard lock(mutex_);
+        std::lock_guard const lock(mutex_);
         return writableBackend_;
     }();
 
@@ -133,7 +133,7 @@ DatabaseRotatingImp::fetchNodeObject(
     std::shared_ptr<NodeObject> nodeObject;
 
     auto [writable, archive] = [&] {
-        std::lock_guard lock(mutex_);
+        std::lock_guard const lock(mutex_);
         return std::make_pair(writableBackend_, archiveBackend_);
     }();
 
@@ -147,7 +147,7 @@ DatabaseRotatingImp::fetchNodeObject(
         {
             {
                 // Refresh the writable backend pointer
-                std::lock_guard lock(mutex_);
+                std::lock_guard const lock(mutex_);
                 writable = writableBackend_;
             }
 
@@ -167,7 +167,7 @@ void
 DatabaseRotatingImp::for_each(std::function<void(std::shared_ptr<NodeObject>)> f)
 {
     auto [writable, archive] = [&] {
-        std::lock_guard lock(mutex_);
+        std::lock_guard const lock(mutex_);
         return std::make_pair(writableBackend_, archiveBackend_);
     }();
 
diff --git a/src/libxrpl/nodestore/ManagerImp.cpp b/src/libxrpl/nodestore/ManagerImp.cpp
index da9534f68b..7925ccdb91 100644
--- a/src/libxrpl/nodestore/ManagerImp.cpp
+++ b/src/libxrpl/nodestore/ManagerImp.cpp
@@ -80,14 +80,14 @@ ManagerImp::make_Database(
 void
 ManagerImp::insert(Factory& factory)
 {
-    std::lock_guard _(mutex_);
+    std::lock_guard const _(mutex_);
     list_.push_back(&factory);
 }
 
 void
 ManagerImp::erase(Factory& factory)
 {
-    std::lock_guard _(mutex_);
+    std::lock_guard const _(mutex_);
     auto const iter = std::find_if(
         list_.begin(), list_.end(), [&factory](Factory* other) { return other == &factory; });
     XRPL_ASSERT(iter != list_.end(), "xrpl::NodeStore::ManagerImp::erase : valid input");
@@ -97,7 +97,7 @@ ManagerImp::erase(Factory& factory)
 Factory*
 ManagerImp::find(std::string const& name)
 {
-    std::lock_guard _(mutex_);
+    std::lock_guard const _(mutex_);
     auto const iter = std::find_if(list_.begin(), list_.end(), [&name](Factory* other) {
         return boost::iequals(name, other->getName());
     });
diff --git a/src/libxrpl/nodestore/backend/MemoryFactory.cpp b/src/libxrpl/nodestore/backend/MemoryFactory.cpp
index 0366fe3573..a245af3030 100644
--- a/src/libxrpl/nodestore/backend/MemoryFactory.cpp
+++ b/src/libxrpl/nodestore/backend/MemoryFactory.cpp
@@ -45,7 +45,7 @@ public:
     MemoryDB&
     open(std::string const& path)
     {
-        std::lock_guard _(mutex_);
+        std::lock_guard const _(mutex_);
         auto const result =
             map_.emplace(std::piecewise_construct, std::make_tuple(path), std::make_tuple());
         MemoryDB& db = result.first->second;
@@ -120,9 +120,9 @@ public:
     {
         XRPL_ASSERT(db_, "xrpl::NodeStore::MemoryBackend::fetch : non-null database");
 
-        std::lock_guard _(db_->mutex);
+        std::lock_guard const _(db_->mutex);
 
-        Map::iterator iter = db_->table.find(hash);
+        Map::iterator const iter = db_->table.find(hash);
         if (iter == db_->table.end())
         {
             pObject->reset();
@@ -140,7 +140,7 @@ public:
         for (auto const& h : hashes)
         {
             std::shared_ptr<NodeObject> nObj;
-            Status status = fetch(h, &nObj);
+            Status const status = fetch(h, &nObj);
             if (status != ok)
             {
                 results.push_back({});
@@ -158,7 +158,7 @@ public:
     store(std::shared_ptr<NodeObject> const& object) override
     {
         XRPL_ASSERT(db_, "xrpl::NodeStore::MemoryBackend::store : non-null database");
-        std::lock_guard _(db_->mutex);
+        std::lock_guard const _(db_->mutex);
         db_->table.emplace(object->getHash(), object);
     }
 
diff --git a/src/libxrpl/nodestore/backend/NuDBFactory.cpp b/src/libxrpl/nodestore/backend/NuDBFactory.cpp
index 2d8cffa85a..424778f280 100644
--- a/src/libxrpl/nodestore/backend/NuDBFactory.cpp
+++ b/src/libxrpl/nodestore/backend/NuDBFactory.cpp
@@ -214,7 +214,7 @@ public:
         for (auto const& h : hashes)
         {
             std::shared_ptr<NodeObject> nObj;
-            Status status = fetch(h, &nObj);
+            Status const status = fetch(h, &nObj);
             if (status != ok)
             {
                 results.push_back({});
@@ -231,7 +231,7 @@ public:
     void
     do_insert(std::shared_ptr<NodeObject> const& no)
     {
-        EncodedBlob e(no);
+        EncodedBlob const e(no);
         nudb::error_code ec;
         nudb::detail::buffer bf;
         auto const result = nodeobject_compress(e.getData(), e.getSize(), bf);
@@ -353,7 +353,7 @@ private:
         auto const kp = (folder / "nudb.key").string();
 
         std::size_t const defaultSize = nudb::block_size(kp);  // Default 4K from NuDB
-        std::size_t blockSize = defaultSize;
+        std::size_t const blockSize = defaultSize;
         std::string blockSizeStr;
 
         if (!get_if_exists(keyValues, "nudb_block_size", blockSizeStr))
@@ -434,7 +434,7 @@ public:
 void
 registerNuDBFactory(Manager& manager)
 {
-    static NuDBFactory instance{manager};
+    static NuDBFactory const instance{manager};
 }
 
 }  // namespace NodeStore
diff --git a/src/libxrpl/nodestore/backend/NullFactory.cpp b/src/libxrpl/nodestore/backend/NullFactory.cpp
index ab5b7d0117..617dfd893d 100644
--- a/src/libxrpl/nodestore/backend/NullFactory.cpp
+++ b/src/libxrpl/nodestore/backend/NullFactory.cpp
@@ -117,7 +117,7 @@ public:
 void
 registerNullFactory(Manager& manager)
 {
-    static NullFactory instance{manager};
+    static NullFactory const instance{manager};
 }
 
 }  // namespace NodeStore
diff --git a/src/libxrpl/nodestore/backend/RocksDBFactory.cpp b/src/libxrpl/nodestore/backend/RocksDBFactory.cpp
index ac040f178b..4ce7c3f10c 100644
--- a/src/libxrpl/nodestore/backend/RocksDBFactory.cpp
+++ b/src/libxrpl/nodestore/backend/RocksDBFactory.cpp
@@ -37,18 +37,17 @@ public:
     static void
     thread_entry(void* ptr)
     {
-        ThreadParams* const p(reinterpret_cast<ThreadParams*>(ptr));
-        void (*f)(void*) = p->f;
+        ThreadParams const* const p(reinterpret_cast<ThreadParams*>(ptr));
+        auto const f = p->f;
+
         void* a(p->a);
         delete p;
 
         static std::atomic<std::size_t> n;
         std::size_t const id(++n);
-        std::stringstream ss;
-        ss << "rocksdb #" << id;
-        beast::setCurrentThreadName(ss.str());
+        beast::setCurrentThreadName("rocksdb #" + std::to_string(id));
 
-        (*f)(a);
+        f(a);
     }
 
     void
@@ -89,7 +88,7 @@ public:
         rocksdb::BlockBasedTableOptions table_options;
         m_options.env = env;
 
-        bool hard_set = keyValues.exists("hard_set") && get<bool>(keyValues, "hard_set");
+        bool const hard_set = keyValues.exists("hard_set") && get<bool>(keyValues, "hard_set");
 
         if (keyValues.exists("cache_mb"))
         {
@@ -162,7 +161,7 @@ public:
 
         if (keyValues.exists("bbt_options"))
         {
-            rocksdb::ConfigOptions config_options;
+            rocksdb::ConfigOptions const config_options;
             auto const s = rocksdb::GetBlockBasedTableOptionsFromString(
                 config_options, table_options, get(keyValues, "bbt_options"), &table_options);
             if (!s.ok())
@@ -212,7 +211,7 @@ public:
         }
         rocksdb::DB* db = nullptr;
         m_options.create_if_missing = createIfMissing;
-        rocksdb::Status status = rocksdb::DB::Open(m_options, m_name, &db);
+        rocksdb::Status const status = rocksdb::DB::Open(m_options, m_name, &db);
         if (!status.ok() || (db == nullptr))
         {
             Throw<std::runtime_error>(
@@ -235,7 +234,7 @@ public:
             m_db.reset();
             if (m_deletePath)
             {
-                boost::filesystem::path dir = m_name;
+                boost::filesystem::path const dir = m_name;
                 boost::filesystem::remove_all(dir);
             }
         }
@@ -262,7 +261,7 @@ public:
 
         std::string string;
 
-        rocksdb::Status getStatus = m_db->Get(options, slice, &string);
+        rocksdb::Status const getStatus = m_db->Get(options, slice, &string);
 
         if (getStatus.ok())
         {
@@ -308,7 +307,7 @@ public:
         for (auto const& h : hashes)
         {
             std::shared_ptr<NodeObject> nObj;
-            Status status = fetch(h, &nObj);
+            Status const status = fetch(h, &nObj);
             if (status != ok)
             {
                 results.push_back({});
@@ -339,7 +338,7 @@ public:
 
         for (auto const& e : batch)
         {
-            EncodedBlob encoded(e);
+            EncodedBlob const encoded(e);
 
             wb.Put(
                 rocksdb::Slice(std::bit_cast<char const*>(encoded.getKey()), m_keyBytes),
@@ -456,7 +455,7 @@ public:
 void
 registerRocksDBFactory(Manager& manager)
 {
-    static RocksDBFactory instance{manager};
+    static RocksDBFactory const instance{manager};
 }
 
 }  // namespace NodeStore
diff --git a/src/libxrpl/protocol/AccountID.cpp b/src/libxrpl/protocol/AccountID.cpp
index 4edbf5c0e7..2c64457c87 100644
--- a/src/libxrpl/protocol/AccountID.cpp
+++ b/src/libxrpl/protocol/AccountID.cpp
@@ -55,7 +55,7 @@ public:
         packed_spinlock sl(locks_, index % 64);
 
         {
-            std::lock_guard lock(sl);
+            std::lock_guard const lock(sl);
 
             // The check against the first character of the encoding ensures
             // that we don't mishandle the case of the all-zero account:
@@ -68,7 +68,7 @@ public:
         XRPL_ASSERT(ret.size() <= 38, "xrpl::detail::AccountIdCache : maximum result size");
 
         {
-            std::lock_guard lock(sl);
+            std::lock_guard const lock(sl);
             cache_[index].id = id;
             std::strcpy(cache_[index].encoding, ret.c_str());
         }
diff --git a/src/libxrpl/protocol/InnerObjectFormats.cpp b/src/libxrpl/protocol/InnerObjectFormats.cpp
index bccfe210d1..8429c51aea 100644
--- a/src/libxrpl/protocol/InnerObjectFormats.cpp
+++ b/src/libxrpl/protocol/InnerObjectFormats.cpp
@@ -164,7 +164,7 @@ InnerObjectFormats::InnerObjectFormats()
 InnerObjectFormats const&
 InnerObjectFormats::getInstance()
 {
-    static InnerObjectFormats instance;
+    static InnerObjectFormats const instance;
     return instance;
 }
 
diff --git a/src/libxrpl/protocol/LedgerFormats.cpp b/src/libxrpl/protocol/LedgerFormats.cpp
index 30725f44a9..9f8bd6a2ba 100644
--- a/src/libxrpl/protocol/LedgerFormats.cpp
+++ b/src/libxrpl/protocol/LedgerFormats.cpp
@@ -40,7 +40,7 @@ LedgerFormats::LedgerFormats()
 LedgerFormats const&
 LedgerFormats::getInstance()
 {
-    static LedgerFormats instance;
+    static LedgerFormats const instance;
     return instance;
 }
 
diff --git a/src/libxrpl/protocol/NFTokenID.cpp b/src/libxrpl/protocol/NFTokenID.cpp
index d867cdb8c9..a808ef1fcf 100644
--- a/src/libxrpl/protocol/NFTokenID.cpp
+++ b/src/libxrpl/protocol/NFTokenID.cpp
@@ -159,7 +159,7 @@ insertNFTokenID(
     }
     else if (type == ttNFTOKEN_CANCEL_OFFER)
     {
-        std::vector<uint256> result = getNFTokenIDFromDeletedOffer(transactionMeta);
+        std::vector<uint256> const result = getNFTokenIDFromDeletedOffer(transactionMeta);
 
         response[jss::nftoken_ids] = Json::Value(Json::arrayValue);
         for (auto const& nftID : result)
diff --git a/src/libxrpl/protocol/PublicKey.cpp b/src/libxrpl/protocol/PublicKey.cpp
index 2e08c49a4e..fc63edd2fc 100644
--- a/src/libxrpl/protocol/PublicKey.cpp
+++ b/src/libxrpl/protocol/PublicKey.cpp
@@ -130,11 +130,11 @@ ecdsaCanonicality(Slice const& sig)
     if (!r || !s || !p.empty())
         return std::nullopt;
 
-    uint264 R(sliceToHex(*r));
+    uint264 const R(sliceToHex(*r));
     if (R >= G)
         return std::nullopt;
 
-    uint264 S(sliceToHex(*s));
+    uint264 const S(sliceToHex(*s));
     if (S >= G)
         return std::nullopt;
 
diff --git a/src/libxrpl/protocol/QualityFunction.cpp b/src/libxrpl/protocol/QualityFunction.cpp
index ebc59dcc83..1774603a61 100644
--- a/src/libxrpl/protocol/QualityFunction.cpp
+++ b/src/libxrpl/protocol/QualityFunction.cpp
@@ -31,7 +31,7 @@ QualityFunction::outFromAvgQ(Quality const& quality)
 {
     if (m_ != 0 && quality.rate() != beast::zero)
     {
-        saveNumberRoundMode rm(Number::setround(Number::rounding_mode::upward));
+        saveNumberRoundMode const rm(Number::setround(Number::rounding_mode::upward));
         auto const out = (1 / quality.rate() - b_) / m_;
         if (out <= 0)
             return std::nullopt;
diff --git a/src/libxrpl/protocol/Rules.cpp b/src/libxrpl/protocol/Rules.cpp
index 4ef052d2cc..fd54a1eff2 100644
--- a/src/libxrpl/protocol/Rules.cpp
+++ b/src/libxrpl/protocol/Rules.cpp
@@ -39,7 +39,7 @@ setCurrentTransactionRules(std::optional<Rules> r)
     // Make global changes associated with the rules before the value is moved.
     // Push the appropriate setting, instead of having the class pull every time
     // the value is needed. That could get expensive fast.
-    bool enableLargeNumbers =
+    bool const enableLargeNumbers =
         !r || (r->enabled(featureSingleAssetVault) || r->enabled(featureLendingProtocol));
     Number::setMantissaScale(enableLargeNumbers ? MantissaRange::large : MantissaRange::small);
 
diff --git a/src/libxrpl/protocol/STAmount.cpp b/src/libxrpl/protocol/STAmount.cpp
index 8c0068a275..0a0da2193e 100644
--- a/src/libxrpl/protocol/STAmount.cpp
+++ b/src/libxrpl/protocol/STAmount.cpp
@@ -154,7 +154,7 @@ STAmount::STAmount(SerialIter& sit, SField const& name) : STBase(name)
 
     if (value != 0u)
     {
-        bool isNegative = (offset & 256) == 0;
+        bool const isNegative = (offset & 256) == 0;
         offset = (offset & 255) - 97;  // center the range
 
         if (value < cMinValue || value > cMaxValue || offset < cMinOffset || offset > cMaxOffset)
@@ -410,7 +410,7 @@ operator+(STAmount const& v1, STAmount const& v2)
     // This addition cannot overflow an std::int64_t. It can overflow an
     // STAmount and the constructor will throw.
 
-    std::int64_t fv = vv1 + vv2;
+    std::int64_t const fv = vv1 + vv2;
 
     if ((fv >= -10) && (fv <= 10))
         return {v1.getFName(), v1.asset()};
@@ -454,13 +454,13 @@ getRate(STAmount const& offerOut, STAmount const& offerIn)
 
     try
     {
-        STAmount r = divide(offerIn, offerOut, noIssue());
+        STAmount const r = divide(offerIn, offerOut, noIssue());
         if (r == beast::zero)  // offer is too good
             return 0;
         XRPL_ASSERT(
             (r.exponent() >= -100) && (r.exponent() <= 155),
             "xrpl::getRate : exponent inside range");
-        std::uint64_t ret = r.exponent() + 100;
+        std::uint64_t const ret = r.exponent() + 100;
         return (ret << (64 - 8)) | r.mantissa();
     }
     catch (...)
@@ -502,8 +502,8 @@ canAdd(STAmount const& a, STAmount const& b)
     // XRP case (overflow & underflow check)
     if (isXRP(a) && isXRP(b))
     {
-        XRPAmount A = a.xrp();
-        XRPAmount B = b.xrp();
+        XRPAmount const A = a.xrp();
+        XRPAmount const B = b.xrp();
 
         return !(
             (B > XRPAmount{0} &&
@@ -517,16 +517,16 @@ canAdd(STAmount const& a, STAmount const& b)
     {
         static STAmount const one{IOUAmount{1, 0}, noIssue()};
         static STAmount const maxLoss{IOUAmount{1, -4}, noIssue()};
-        STAmount lhs = divide((a - b) + b, a, noIssue()) - one;
-        STAmount rhs = divide((b - a) + a, b, noIssue()) - one;
+        STAmount const lhs = divide((a - b) + b, a, noIssue()) - one;
+        STAmount const rhs = divide((b - a) + a, b, noIssue()) - one;
         return ((rhs.negative() ? -rhs : rhs) + (lhs.negative() ? -lhs : lhs)) <= maxLoss;
     }
 
     // MPT (overflow & underflow check)
     if (a.holds<MPTIssue>() && b.holds<MPTIssue>())
     {
-        MPTAmount A = a.mpt();
-        MPTAmount B = b.mpt();
+        MPTAmount const A = a.mpt();
+        MPTAmount const B = b.mpt();
         return !(
             (B > MPTAmount{0} &&
              A > MPTAmount{std::numeric_limits<MPTAmount::value_type>::max()} - B) ||
@@ -570,8 +570,8 @@ canSubtract(STAmount const& a, STAmount const& b)
     // XRP case (underflow & overflow check)
     if (isXRP(a) && isXRP(b))
     {
-        XRPAmount A = a.xrp();
-        XRPAmount B = b.xrp();
+        XRPAmount const A = a.xrp();
+        XRPAmount const B = b.xrp();
         // Check for underflow
         if (B > XRPAmount{0} && A < B)
             return false;
@@ -593,8 +593,8 @@ canSubtract(STAmount const& a, STAmount const& b)
     // MPT case (underflow & overflow check)
     if (a.holds<MPTIssue>() && b.holds<MPTIssue>())
     {
-        MPTAmount A = a.mpt();
-        MPTAmount B = b.mpt();
+        MPTAmount const A = a.mpt();
+        MPTAmount const B = b.mpt();
 
         // Underflow check
         if (B > MPTAmount{0} && A < B)
@@ -847,7 +847,7 @@ STAmount::canonicalize()
 
         if (getSTNumberSwitchover())
         {
-            Number num(mIsNegative, mValue, mOffset, Number::unchecked{});
+            Number const num(mIsNegative, mValue, mOffset, Number::unchecked{});
             auto set = [&](auto const& val) {
                 auto const value = val.value();
                 mIsNegative = value < 0;
@@ -977,8 +977,8 @@ amountFromQuality(std::uint64_t rate)
     if (rate == 0)
         return STAmount(noIssue());
 
-    std::uint64_t mantissa = rate & ~(255ull << (64 - 8));
-    int exponent = static_cast<int>(rate >> (64 - 8)) - 100;
+    std::uint64_t const mantissa = rate & ~(255ull << (64 - 8));
+    int const exponent = static_cast<int>(rate >> (64 - 8)) - 100;
 
     return STAmount(noIssue(), mantissa, exponent);
 }
@@ -1474,7 +1474,7 @@ roundToScale(STAmount const& value, std::int32_t scale, Number::rounding_mode ro
 
     STAmount const referenceValue{value.asset(), STAmount::cMinValue, scale, value.negative()};
 
-    NumberRoundModeGuard mg(rounding);
+    NumberRoundModeGuard const mg(rounding);
     // With an IOU, the the result of addition will be truncated to the
     // precision of the larger value, which in this case is referenceValue. Then
     // remove the reference value via subtraction, and we're left with the
@@ -1516,8 +1516,8 @@ mulRoundImpl(STAmount const& v1, STAmount const& v2, Asset const& asset, bool ro
 
     if (v1.native() && v2.native() && xrp)
     {
-        std::uint64_t minV = std::min(getSNValue(v1), getSNValue(v2));
-        std::uint64_t maxV = std::max(getSNValue(v1), getSNValue(v2));
+        std::uint64_t const minV = std::min(getSNValue(v1), getSNValue(v2));
+        std::uint64_t const maxV = std::max(getSNValue(v1), getSNValue(v2));
 
         if (minV > 3000000000ull)  // sqrt(cMaxNative)
             Throw<std::runtime_error>("Native value overflow");
diff --git a/src/libxrpl/protocol/STIssue.cpp b/src/libxrpl/protocol/STIssue.cpp
index bc39ea1b55..5acf4abcb6 100644
--- a/src/libxrpl/protocol/STIssue.cpp
+++ b/src/libxrpl/protocol/STIssue.cpp
@@ -38,7 +38,7 @@ STIssue::STIssue(SerialIter& sit, SField const& name) : STBase{name}
         // - 160 bits MPT issuer account
         // - 160 bits black hole account
         // - 32 bits sequence
-        AccountID account = static_cast<AccountID>(sit.get160());
+        AccountID const account = static_cast<AccountID>(sit.get160());
         // MPT
         if (noAccount() == account)
         {
@@ -50,7 +50,7 @@ STIssue::STIssue(SerialIter& sit, SField const& name) : STBase{name}
                 mptID.data() + sizeof(sequence),
                 currencyOrAccount.data(),
                 sizeof(currencyOrAccount));
-            MPTIssue issue{mptID};
+            MPTIssue const issue{mptID};
             asset_ = issue;
         }
         else
diff --git a/src/libxrpl/protocol/STLedgerEntry.cpp b/src/libxrpl/protocol/STLedgerEntry.cpp
index 02e5ddb451..5a80559c98 100644
--- a/src/libxrpl/protocol/STLedgerEntry.cpp
+++ b/src/libxrpl/protocol/STLedgerEntry.cpp
@@ -147,7 +147,7 @@ STLedgerEntry::thread(
     uint256& prevTxID,
     std::uint32_t& prevLedgerID)
 {
-    uint256 oldPrevTxID = getFieldH256(sfPreviousTxnID);
+    uint256 const oldPrevTxID = getFieldH256(sfPreviousTxnID);
 
     JLOG(debugLog().info()) << "Thread Tx:" << txID << " prev:" << oldPrevTxID;
 
diff --git a/src/libxrpl/protocol/STNumber.cpp b/src/libxrpl/protocol/STNumber.cpp
index aab4bdc0f5..8899a76a35 100644
--- a/src/libxrpl/protocol/STNumber.cpp
+++ b/src/libxrpl/protocol/STNumber.cpp
@@ -177,7 +177,7 @@ partsFromString(std::string const& number)
     //   6 = exponent sign
     //   7 = exponent number
 
-    bool negative = (match[1].matched && (match[1] == "-"));
+    bool const negative = (match[1].matched && (match[1] == "-"));
 
     std::uint64_t mantissa = 0;
     int exponent = 0;
@@ -241,6 +241,7 @@ numberFromJson(SField const& field, Json::Value const& value)
         // Number mantissas are much bigger than the allowable parsed values, so
         // it can't be out of range.
         static_assert(
+            // NOLINTNEXTLINE(misc-redundant-expression)
             std::numeric_limits<std::uint64_t>::max() >=
             std::numeric_limits<decltype(parts.mantissa)>::max());
     }
diff --git a/src/libxrpl/protocol/STObject.cpp b/src/libxrpl/protocol/STObject.cpp
index 182653d11d..f758760337 100644
--- a/src/libxrpl/protocol/STObject.cpp
+++ b/src/libxrpl/protocol/STObject.cpp
@@ -156,7 +156,7 @@ STObject::applyTemplate(SOTemplate const& type)
     auto throwFieldErr = [](std::string const& field, char const* description) {
         std::stringstream ss;
         ss << "Field '" << field << "' " << description;
-        std::string text{ss.str()};
+        std::string const text{ss.str()};
         JLOG(debugLog().error()) << "STObject::applyTemplate failed: " << text;
         Throw<FieldErr>(text);
     };
@@ -400,7 +400,7 @@ STObject::getFieldIndex(SField const& field) const
 STBase const&
 STObject::peekAtField(SField const& field) const
 {
-    int index = getFieldIndex(field);
+    int const index = getFieldIndex(field);
 
     if (index == -1)
         throwFieldNotFound(field);
@@ -411,7 +411,7 @@ STObject::peekAtField(SField const& field) const
 STBase&
 STObject::getField(SField const& field)
 {
-    int index = getFieldIndex(field);
+    int const index = getFieldIndex(field);
 
     if (index == -1)
         throwFieldNotFound(field);
@@ -428,7 +428,7 @@ STObject::getFieldSType(int index) const
 STBase const*
 STObject::peekAtPField(SField const& field) const
 {
-    int index = getFieldIndex(field);
+    int const index = getFieldIndex(field);
 
     if (index == -1)
         return nullptr;
@@ -439,7 +439,7 @@ STObject::peekAtPField(SField const& field) const
 STBase*
 STObject::getPField(SField const& field, bool createOkay)
 {
-    int index = getFieldIndex(field);
+    int const index = getFieldIndex(field);
 
     if (index == -1)
     {
@@ -455,7 +455,7 @@ STObject::getPField(SField const& field, bool createOkay)
 bool
 STObject::isFieldPresent(SField const& field) const
 {
-    int index = getFieldIndex(field);
+    int const index = getFieldIndex(field);
 
     if (index == -1)
         return false;
@@ -519,7 +519,7 @@ STObject::getFlags(void) const
 STBase*
 STObject::makeFieldPresent(SField const& field)
 {
-    int index = getFieldIndex(field);
+    int const index = getFieldIndex(field);
 
     if (index == -1)
     {
@@ -529,7 +529,7 @@ STObject::makeFieldPresent(SField const& field)
         return getPIndex(emplace_back(detail::nonPresentObject, field));
     }
 
-    STBase* f = getPIndex(index);
+    STBase* f = getPIndex(index);  // NOLINT(misc-const-correctness)
 
     if (f->getSType() != STI_NOTPRESENT)
         return f;
@@ -541,7 +541,7 @@ STObject::makeFieldPresent(SField const& field)
 void
 STObject::makeFieldAbsent(SField const& field)
 {
-    int index = getFieldIndex(field);
+    int const index = getFieldIndex(field);
 
     if (index == -1)
         throwFieldNotFound(field);
@@ -556,7 +556,7 @@ STObject::makeFieldAbsent(SField const& field)
 bool
 STObject::delField(SField const& field)
 {
-    int index = getFieldIndex(field);
+    int const index = getFieldIndex(field);
 
     if (index == -1)
         return false;
@@ -640,7 +640,7 @@ STObject::getAccountID(SField const& field) const
 Blob
 STObject::getFieldVL(SField const& field) const
 {
-    STBlob empty;
+    STBlob const 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 702ad28414..c928f49375 100644
--- a/src/libxrpl/protocol/STParsedJSON.cpp
+++ b/src/libxrpl/protocol/STParsedJSON.cpp
@@ -1093,7 +1093,7 @@ parseArray(
             auto ret = parseObject(ss.str(), objectFields, nameField, depth + 1, error);
             if (!ret)
             {
-                std::string errMsg = error["error_message"].asString();
+                std::string const errMsg = error["error_message"].asString();
                 error["error_message"] = "Error at '" + ss.str() + "'. " + errMsg;
                 return std::nullopt;
             }
diff --git a/src/libxrpl/protocol/STPathSet.cpp b/src/libxrpl/protocol/STPathSet.cpp
index fde33fb58e..2536c18e4e 100644
--- a/src/libxrpl/protocol/STPathSet.cpp
+++ b/src/libxrpl/protocol/STPathSet.cpp
@@ -45,7 +45,7 @@ STPathSet::STPathSet(SerialIter& sit, SField const& name) : STBase(name)
     std::vector<STPathElement> path;
     for (;;)
     {
-        int iType = sit.get8();
+        int const iType = sit.get8();
 
         if (iType == STPathElement::typeNone || iType == STPathElement::typeBoundary)
         {
@@ -205,7 +205,7 @@ STPathSet::add(Serializer& s) const
 
         for (auto const& speElement : spPath)
         {
-            int iType = speElement.getNodeType();
+            int const iType = speElement.getNodeType();
 
             s.add8(iType);
 
diff --git a/src/libxrpl/protocol/STTx.cpp b/src/libxrpl/protocol/STTx.cpp
index 7da1919f35..f8600e167f 100644
--- a/src/libxrpl/protocol/STTx.cpp
+++ b/src/libxrpl/protocol/STTx.cpp
@@ -77,7 +77,7 @@ STTx::STTx(STObject&& object) : STObject(std::move(object))
 
 STTx::STTx(SerialIter& sit) : STObject(sfTransaction)
 {
-    int length = sit.getBytesLeft();
+    int const length = sit.getBytesLeft();
 
     if ((length < txMinSizeBytes) || (length > txMaxSizeBytes))
         Throw<std::runtime_error>("Transaction length invalid");
@@ -329,7 +329,7 @@ STTx::getJson(JsonOptions options, bool binary) const
 
     if (binary)
     {
-        Serializer s = STObject::getSerializer();
+        Serializer const s = STObject::getSerializer();
         std::string const dataBin = strHex(s.peekData());
 
         if (V1)
@@ -378,7 +378,7 @@ STTx::getMetaSQL(
     TxnSql status,
     std::string const& escapedMetaData) const
 {
-    static boost::format bfTrans("('%s', '%s', '%s', '%d', '%d', '%c', %s, %s)");
+    static boost::format const bfTrans("('%s', '%s', '%s', '%d', '%d', '%c', %s, %s)");
     std::string rTxn = sqlBlobLiteral(rawTxn.peekData());
 
     auto format = TxFormats::getInstance().findByType(tx_type_);
@@ -656,18 +656,18 @@ isMemoOkay(STObject const& st, std::string& reason)
             static constexpr std::array<char, 256> const allowedSymbols = []() {
                 std::array<char, 256> a{};
 
-                std::string_view symbols(
+                std::string_view const symbols(
                     "0123456789"
                     "-._~:/?#[]@!$&'()*+,;=%"
                     "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
                     "abcdefghijklmnopqrstuvwxyz");
 
-                for (unsigned char c : symbols)
+                for (unsigned char const c : symbols)
                     a[c] = 1;
                 return a;
             }();
 
-            for (unsigned char c : *optData)
+            for (unsigned char const c : *optData)
             {
                 if (allowedSymbols[c] == 0)
                 {
diff --git a/src/libxrpl/protocol/SecretKey.cpp b/src/libxrpl/protocol/SecretKey.cpp
index aa398e9fe1..f58bb81a88 100644
--- a/src/libxrpl/protocol/SecretKey.cpp
+++ b/src/libxrpl/protocol/SecretKey.cpp
@@ -185,7 +185,7 @@ public:
 
             if (secp256k1_ec_seckey_tweak_add(secp256k1Context(), rpk.data(), tweak.data()) == 1)
             {
-                SecretKey sk{Slice{rpk.data(), rpk.size()}};
+                SecretKey const sk{Slice{rpk.data(), rpk.size()}};
                 secure_erase(rpk.data(), rpk.size());
                 return sk;
             }
@@ -270,7 +270,7 @@ randomSecretKey()
 {
     std::uint8_t buf[32];
     beast::rngfill(buf, sizeof(buf), crypto_prng());
-    SecretKey sk(Slice{buf, sizeof(buf)});
+    SecretKey const sk(Slice{buf, sizeof(buf)});
     secure_erase(buf, sizeof(buf));
     return sk;
 }
@@ -281,7 +281,7 @@ generateSecretKey(KeyType type, Seed const& seed)
     if (type == KeyType::ed25519)
     {
         auto key = sha512Half_s(Slice(seed.data(), seed.size()));
-        SecretKey sk{Slice{key.data(), key.size()}};
+        SecretKey const sk{Slice{key.data(), key.size()}};
         secure_erase(key.data(), key.size());
         return sk;
     }
@@ -289,7 +289,7 @@ generateSecretKey(KeyType type, Seed const& seed)
     if (type == KeyType::secp256k1)
     {
         auto key = detail::deriveDeterministicRootKey(seed);
-        SecretKey sk{Slice{key.data(), key.size()}};
+        SecretKey const sk{Slice{key.data(), key.size()}};
         secure_erase(key.data(), key.size());
         return sk;
     }
@@ -335,7 +335,7 @@ generateKeyPair(KeyType type, Seed const& seed)
     switch (type)
     {
         case KeyType::secp256k1: {
-            detail::Generator g(seed);
+            detail::Generator const g(seed);
             return g(0);
         }
         default:
diff --git a/src/libxrpl/protocol/Seed.cpp b/src/libxrpl/protocol/Seed.cpp
index 8aa1d8b67d..6d33013f2f 100644
--- a/src/libxrpl/protocol/Seed.cpp
+++ b/src/libxrpl/protocol/Seed.cpp
@@ -48,7 +48,7 @@ randomSeed()
 {
     std::array<std::uint8_t, 16> buffer{};
     beast::rngfill(buffer.data(), buffer.size(), crypto_prng());
-    Seed seed(makeSlice(buffer));
+    Seed const seed(makeSlice(buffer));
     secure_erase(buffer.data(), buffer.size());
     return seed;
 }
diff --git a/src/libxrpl/protocol/Serializer.cpp b/src/libxrpl/protocol/Serializer.cpp
index 0e8beae0d9..4e6a49f572 100644
--- a/src/libxrpl/protocol/Serializer.cpp
+++ b/src/libxrpl/protocol/Serializer.cpp
@@ -23,7 +23,7 @@ namespace xrpl {
 int
 Serializer::add16(std::uint16_t i)
 {
-    int ret = mData.size();
+    int const ret = mData.size();
     mData.push_back(static_cast<unsigned char>(i >> 8));
     mData.push_back(static_cast<unsigned char>(i & 0xff));
     return ret;
@@ -73,7 +73,7 @@ Serializer::addInteger(std::int32_t i)
 int
 Serializer::addRaw(Blob const& vector)
 {
-    int ret = mData.size();
+    int const ret = mData.size();
     mData.insert(mData.end(), vector.begin(), vector.end());
     return ret;
 }
@@ -81,7 +81,7 @@ Serializer::addRaw(Blob const& vector)
 int
 Serializer::addRaw(Slice slice)
 {
-    int ret = mData.size();
+    int const ret = mData.size();
     mData.insert(mData.end(), slice.begin(), slice.end());
     return ret;
 }
@@ -89,7 +89,7 @@ Serializer::addRaw(Slice slice)
 int
 Serializer::addRaw(Serializer const& s)
 {
-    int ret = mData.size();
+    int const ret = mData.size();
     mData.insert(mData.end(), s.begin(), s.end());
     return ret;
 }
@@ -97,7 +97,7 @@ Serializer::addRaw(Serializer const& s)
 int
 Serializer::addRaw(void const* ptr, int len)
 {
-    int ret = mData.size();
+    int const ret = mData.size();
     mData.insert(mData.end(), (char const*)ptr, ((char const*)ptr) + len);
     return ret;
 }
@@ -105,7 +105,7 @@ Serializer::addRaw(void const* ptr, int len)
 int
 Serializer::addFieldID(int type, int name)
 {
-    int ret = mData.size();
+    int const ret = mData.size();
     XRPL_ASSERT(
         (type > 0) && (type < 256) && (name > 0) && (name < 256),
         "xrpl::Serializer::addFieldID : inputs inside range");
@@ -143,7 +143,7 @@ Serializer::addFieldID(int type, int name)
 int
 Serializer::add8(unsigned char byte)
 {
-    int ret = mData.size();
+    int const ret = mData.size();
     mData.push_back(byte);
     return ret;
 }
@@ -177,7 +177,7 @@ Serializer::getSHA512Half() const
 int
 Serializer::addVL(Blob const& vector)
 {
-    int ret = addEncoded(vector.size());
+    int const ret = addEncoded(vector.size());
     addRaw(vector);
     XRPL_ASSERT(
         mData.size() == (ret + vector.size() + encodeLengthLength(vector.size())),
@@ -188,7 +188,7 @@ Serializer::addVL(Blob const& vector)
 int
 Serializer::addVL(Slice const& slice)
 {
-    int ret = addEncoded(slice.size());
+    int const ret = addEncoded(slice.size());
     if (!slice.empty())
         addRaw(slice.data(), slice.size());
     return ret;
@@ -197,7 +197,7 @@ Serializer::addVL(Slice const& slice)
 int
 Serializer::addVL(void const* ptr, int len)
 {
-    int ret = addEncoded(len);
+    int const ret = addEncoded(len);
 
     if (len != 0)
         addRaw(ptr, len);
@@ -343,7 +343,7 @@ SerialIter::get8()
 {
     if (remain_ < 1)
         Throw<std::runtime_error>("invalid SerialIter get8");
-    unsigned char t = *p_;
+    unsigned char const t = *p_;
     ++p_;
     ++used_;
     --remain_;
@@ -469,23 +469,23 @@ SerialIter::getRaw(int size)
 int
 SerialIter::getVLDataLength()
 {
-    int b1 = get8();
+    int const b1 = get8();
     int datLen = 0;
-    int lenLen = Serializer::decodeLengthLength(b1);
+    int const lenLen = Serializer::decodeLengthLength(b1);
     if (lenLen == 1)
     {
         datLen = Serializer::decodeVLLength(b1);
     }
     else if (lenLen == 2)
     {
-        int b2 = get8();
+        int const b2 = get8();
         datLen = Serializer::decodeVLLength(b1, b2);
     }
     else
     {
         XRPL_ASSERT(lenLen == 3, "xrpl::SerialIter::getVLDataLength : lenLen is 3");
-        int b2 = get8();
-        int b3 = get8();
+        int const b2 = get8();
+        int const b3 = get8();
         datLen = Serializer::decodeVLLength(b1, b2, b3);
     }
     return datLen;
@@ -496,7 +496,7 @@ SerialIter::getSlice(std::size_t bytes)
 {
     if (bytes > remain_)
         Throw<std::runtime_error>("invalid SerialIter getSlice");
-    Slice s(p_, bytes);
+    Slice const s(p_, bytes);
     p_ += bytes;
     used_ += bytes;
     remain_ -= bytes;
diff --git a/src/libxrpl/protocol/TxMeta.cpp b/src/libxrpl/protocol/TxMeta.cpp
index 19a2755a29..3c797a7c8c 100644
--- a/src/libxrpl/protocol/TxMeta.cpp
+++ b/src/libxrpl/protocol/TxMeta.cpp
@@ -39,7 +39,7 @@ TxMeta::TxMeta(uint256 const& txid, std::uint32_t ledger, Blob const& vec)
 {
     SerialIter sit(makeSlice(vec));
 
-    STObject obj(sit, sfMetadata);
+    STObject const obj(sit, sfMetadata);
     result_ = obj.getFieldU8(sfTransactionResult);
     index_ = obj.getFieldU32(sfTransactionIndex);
     nodes_ = obj.getFieldArray(sfAffectedNodes);
@@ -89,7 +89,7 @@ TxMeta::getAffectedAccounts() const
     // Meta#getAffectedAccounts
     for (auto const& node : nodes_)
     {
-        int index =
+        int const index =
             node.getFieldIndex((node.getFName() == sfCreatedNode) ? sfNewFields : sfFinalFields);
 
         if (index != -1)
@@ -146,7 +146,7 @@ TxMeta::getAffectedAccounts() const
 STObject&
 TxMeta::getAffectedNode(SLE::ref node, SField const& type)
 {
-    uint256 index = node->key();
+    uint256 const index = node->key();
     for (auto& n : nodes_)
     {
         if (n.getFieldH256(sfLedgerIndex) == index)
diff --git a/src/libxrpl/protocol/XChainAttestations.cpp b/src/libxrpl/protocol/XChainAttestations.cpp
index 314bf9f6d3..c255f743e3 100644
--- a/src/libxrpl/protocol/XChainAttestations.cpp
+++ b/src/libxrpl/protocol/XChainAttestations.cpp
@@ -74,7 +74,7 @@ AttestationBase::sameEventHelper(AttestationBase const& lhs, AttestationBase con
 bool
 AttestationBase::verify(STXChainBridge const& bridge) const
 {
-    std::vector<std::uint8_t> msg = message(bridge);
+    std::vector<std::uint8_t> const msg = message(bridge);
     return xrpl::verify(publicKey, makeSlice(msg), signature);
 }
 
diff --git a/src/libxrpl/protocol/tokens.cpp b/src/libxrpl/protocol/tokens.cpp
index bca8919c4e..e2a77fbf10 100644
--- a/src/libxrpl/protocol/tokens.cpp
+++ b/src/libxrpl/protocol/tokens.cpp
@@ -445,7 +445,7 @@ b256_to_b58_be(std::span<std::uint8_t const> input, std::span<std::uint8_t> out)
         std::array<std::uint8_t, 10> const b58_be =
             xrpl::b58_fast::detail::b58_10_to_b58_be(base_58_10_coeff[i]);
         std::size_t to_skip = 0;
-        std::span<std::uint8_t const> b58_be_s{b58_be.data(), b58_be.size()};
+        std::span<std::uint8_t const> const b58_be_s{b58_be.data(), b58_be.size()};
         if (skip_zeros)
         {
             to_skip = count_leading_zeros(b58_be_s);
@@ -507,7 +507,7 @@ b58_to_b256_be(std::string_view input, std::span<std::uint8_t> out)
     XRPL_ASSERT(
         num_b_58_10_coeffs <= b_58_10_coeff.size(),
         "xrpl::b58_fast::detail::b58_to_b256_be : maximum coeff");
-    for (unsigned char c : input.substr(0, partial_coeff_len))
+    for (unsigned char const c : input.substr(0, partial_coeff_len))
     {
         auto cur_val = ::xrpl::alphabetReverse[c];
         if (cur_val < 0)
@@ -521,7 +521,7 @@ b58_to_b256_be(std::string_view input, std::span<std::uint8_t> out)
     {
         for (int j = 0; j < num_full_coeffs; ++j)
         {
-            unsigned char c = input[partial_coeff_len + (j * 10) + i];
+            unsigned char const c = input[partial_coeff_len + (j * 10) + i];
             auto cur_val = ::xrpl::alphabetReverse[c];
             if (cur_val < 0)
             {
@@ -626,7 +626,7 @@ encodeBase58Token(
     size_t const checksum_i = input.size() + 1;
     // buf[checksum_i..checksum_i + 4] = checksum
     checksum(buf.data() + checksum_i, buf.data(), checksum_i);
-    std::span<std::uint8_t const> b58Span(buf.data(), input.size() + 5);
+    std::span<std::uint8_t const> const b58Span(buf.data(), input.size() + 5);
     return detail::b256_to_b58_be(b58Span, out);
 }
 // Convert from base 58 to base 256, largest coefficients first
@@ -680,8 +680,8 @@ encodeBase58Token(TokenType type, void const* token, std::size_t size)
     // over-allocation, this function uses 128 (again, over-allocation assuming
     // 2 base 58 char per byte)
     sr.resize(128);
-    std::span<std::uint8_t> outSp(reinterpret_cast<std::uint8_t*>(sr.data()), sr.size());
-    std::span<std::uint8_t const> inSp(reinterpret_cast<std::uint8_t const*>(token), size);
+    std::span<std::uint8_t> const outSp(reinterpret_cast<std::uint8_t*>(sr.data()), sr.size());
+    std::span<std::uint8_t const> const inSp(reinterpret_cast<std::uint8_t const*>(token), size);
     auto r = b58_fast::encodeBase58Token(type, inSp, outSp);
     if (!r)
         return {};
@@ -696,7 +696,7 @@ decodeBase58Token(std::string const& s, TokenType type)
     // The largest object encoded as base58 is 33 bytes; 64 is plenty (and
     // there's no benefit making it smaller)
     sr.resize(64);
-    std::span<std::uint8_t> outSp(reinterpret_cast<std::uint8_t*>(sr.data()), sr.size());
+    std::span<std::uint8_t> const outSp(reinterpret_cast<std::uint8_t*>(sr.data()), sr.size());
     auto r = b58_fast::decodeBase58Token(type, s, outSp);
     if (!r)
         return {};
diff --git a/src/libxrpl/rdb/DatabaseCon.cpp b/src/libxrpl/rdb/DatabaseCon.cpp
index d064192a14..bca14f9bfa 100644
--- a/src/libxrpl/rdb/DatabaseCon.cpp
+++ b/src/libxrpl/rdb/DatabaseCon.cpp
@@ -25,7 +25,7 @@ public:
     std::shared_ptr<Checkpointer>
     fromId(std::uintptr_t id)
     {
-        std::lock_guard l{mutex_};
+        std::lock_guard const l{mutex_};
         auto it = checkpointers_.find(id);
         if (it != checkpointers_.end())
             return it->second;
@@ -35,7 +35,7 @@ public:
     void
     erase(std::uintptr_t id)
     {
-        std::lock_guard lock{mutex_};
+        std::lock_guard const lock{mutex_};
         checkpointers_.erase(id);
     }
 
@@ -45,7 +45,7 @@ public:
         JobQueue& jobQueue,
         ServiceRegistry& registry)
     {
-        std::lock_guard lock{mutex_};
+        std::lock_guard const lock{mutex_};
         auto const id = nextId_++;
         auto const r = makeCheckpointer(id, session, jobQueue, registry);
         checkpointers_[id] = r;
@@ -67,7 +67,7 @@ DatabaseCon::~DatabaseCon()
     {
         checkpointers.erase(checkpointer_->id());
 
-        std::weak_ptr<Checkpointer> wk(checkpointer_);
+        std::weak_ptr<Checkpointer> const wk(checkpointer_);
         checkpointer_.reset();
 
         // The references to our Checkpointer held by 'checkpointer_' and
diff --git a/src/libxrpl/rdb/SociDB.cpp b/src/libxrpl/rdb/SociDB.cpp
index ac96985407..780e05854f 100644
--- a/src/libxrpl/rdb/SociDB.cpp
+++ b/src/libxrpl/rdb/SociDB.cpp
@@ -93,7 +93,7 @@ open(soci::session& s, std::string const& beName, std::string const& connectionS
 static sqlite_api::sqlite3*
 getConnection(soci::session& s)
 {
-    sqlite_api::sqlite3* result = nullptr;
+    sqlite_api::sqlite3* result = nullptr;  // NOLINT(misc-const-correctness)
     auto be = s.get_backend();
     if (auto b = dynamic_cast<soci::sqlite3_session_backend*>(be))
         result = b->conn_;
@@ -222,7 +222,7 @@ public:
     schedule() override
     {
         {
-            std::lock_guard lock(mutex_);
+            std::lock_guard const lock(mutex_);
             if (running_)
                 return;
             running_ = true;
@@ -242,7 +242,7 @@ public:
                         self->checkpoint();
                 }))
         {
-            std::lock_guard lock(mutex_);
+            std::lock_guard const lock(mutex_);
             running_ = false;
         }
     }
@@ -256,7 +256,8 @@ public:
             return;
 
         int log = 0, ckpt = 0;
-        int ret = sqlite3_wal_checkpoint_v2(conn, nullptr, SQLITE_CHECKPOINT_PASSIVE, &log, &ckpt);
+        int const ret =
+            sqlite3_wal_checkpoint_v2(conn, nullptr, SQLITE_CHECKPOINT_PASSIVE, &log, &ckpt);
 
         auto fname = sqlite3_db_filename(conn, "main");
         if (ret != SQLITE_OK)
@@ -269,7 +270,7 @@ public:
             JLOG(j_.trace()) << "WAL(" << fname << "): frames=" << log << ", written=" << ckpt;
         }
 
-        std::lock_guard lock(mutex_);
+        std::lock_guard const lock(mutex_);
         running_ = false;
     }
 
diff --git a/src/libxrpl/resource/ResourceManager.cpp b/src/libxrpl/resource/ResourceManager.cpp
index 1e7aadfa8d..d0e45d4c0e 100644
--- a/src/libxrpl/resource/ResourceManager.cpp
+++ b/src/libxrpl/resource/ResourceManager.cpp
@@ -50,7 +50,7 @@ public:
     ~ManagerImp() override
     {
         {
-            std::lock_guard lock(mutex_);
+            std::lock_guard const lock(mutex_);
             stop_ = true;
             cond_.notify_one();
         }
diff --git a/src/libxrpl/server/InfoSub.cpp b/src/libxrpl/server/InfoSub.cpp
index 5857e4d6ae..ea70dc3a83 100644
--- a/src/libxrpl/server/InfoSub.cpp
+++ b/src/libxrpl/server/InfoSub.cpp
@@ -65,7 +65,7 @@ InfoSub::onSendEmpty()
 void
 InfoSub::insertSubAccountInfo(AccountID const& account, bool rt)
 {
-    std::lock_guard sl(mLock);
+    std::lock_guard const sl(mLock);
 
     if (rt)
     {
@@ -80,7 +80,7 @@ InfoSub::insertSubAccountInfo(AccountID const& account, bool rt)
 void
 InfoSub::deleteSubAccountInfo(AccountID const& account, bool rt)
 {
-    std::lock_guard sl(mLock);
+    std::lock_guard const sl(mLock);
 
     if (rt)
     {
@@ -95,14 +95,14 @@ InfoSub::deleteSubAccountInfo(AccountID const& account, bool rt)
 bool
 InfoSub::insertSubAccountHistory(AccountID const& account)
 {
-    std::lock_guard sl(mLock);
+    std::lock_guard const sl(mLock);
     return accountHistorySubscriptions_.insert(account).second;
 }
 
 void
 InfoSub::deleteSubAccountHistory(AccountID const& account)
 {
-    std::lock_guard sl(mLock);
+    std::lock_guard const sl(mLock);
     accountHistorySubscriptions_.erase(account);
 }
 
diff --git a/src/libxrpl/server/LoadFeeTrack.cpp b/src/libxrpl/server/LoadFeeTrack.cpp
index e206b50863..d698e2420e 100644
--- a/src/libxrpl/server/LoadFeeTrack.cpp
+++ b/src/libxrpl/server/LoadFeeTrack.cpp
@@ -12,7 +12,7 @@ namespace xrpl {
 bool
 LoadFeeTrack::raiseLocalFee()
 {
-    std::lock_guard sl(lock_);
+    std::lock_guard const sl(lock_);
 
     if (++raiseCount_ < 2)
         return false;
@@ -37,7 +37,7 @@ LoadFeeTrack::raiseLocalFee()
 bool
 LoadFeeTrack::lowerLocalFee()
 {
-    std::lock_guard sl(lock_);
+    std::lock_guard const sl(lock_);
     std::uint32_t const origFee = localTxnLoadFee_;
     raiseCount_ = 0;
 
diff --git a/src/libxrpl/server/Manifest.cpp b/src/libxrpl/server/Manifest.cpp
index 4526bf6c16..f4634982d0 100644
--- a/src/libxrpl/server/Manifest.cpp
+++ b/src/libxrpl/server/Manifest.cpp
@@ -279,7 +279,7 @@ loadValidatorToken(std::vector<std::string> const& blob, beast::Journal journal)
 std::optional<PublicKey>
 ManifestCache::getSigningKey(PublicKey const& pk) const
 {
-    std::shared_lock lock{mutex_};
+    std::shared_lock const lock{mutex_};
     auto const iter = map_.find(pk);
 
     if (iter != map_.end() && !iter->second.revoked())
@@ -291,7 +291,7 @@ ManifestCache::getSigningKey(PublicKey const& pk) const
 PublicKey
 ManifestCache::getMasterKey(PublicKey const& pk) const
 {
-    std::shared_lock lock{mutex_};
+    std::shared_lock const lock{mutex_};
 
     if (auto const iter = signingToMasterKeys_.find(pk); iter != signingToMasterKeys_.end())
         return iter->second;
@@ -302,7 +302,7 @@ ManifestCache::getMasterKey(PublicKey const& pk) const
 std::optional<std::uint32_t>
 ManifestCache::getSequence(PublicKey const& pk) const
 {
-    std::shared_lock lock{mutex_};
+    std::shared_lock const lock{mutex_};
     auto const iter = map_.find(pk);
 
     if (iter != map_.end() && !iter->second.revoked())
@@ -314,7 +314,7 @@ ManifestCache::getSequence(PublicKey const& pk) const
 std::optional<std::string>
 ManifestCache::getDomain(PublicKey const& pk) const
 {
-    std::shared_lock lock{mutex_};
+    std::shared_lock const lock{mutex_};
     auto const iter = map_.find(pk);
 
     if (iter != map_.end() && !iter->second.revoked())
@@ -326,7 +326,7 @@ ManifestCache::getDomain(PublicKey const& pk) const
 std::optional<std::string>
 ManifestCache::getManifest(PublicKey const& pk) const
 {
-    std::shared_lock lock{mutex_};
+    std::shared_lock const lock{mutex_};
     auto const iter = map_.find(pk);
 
     if (iter != map_.end() && !iter->second.revoked())
@@ -338,7 +338,7 @@ ManifestCache::getManifest(PublicKey const& pk) const
 bool
 ManifestCache::revoked(PublicKey const& pk) const
 {
-    std::shared_lock lock{mutex_};
+    std::shared_lock const lock{mutex_};
     auto const iter = map_.find(pk);
 
     if (iter != map_.end())
@@ -437,12 +437,12 @@ ManifestCache::applyManifest(Manifest m)
     };
 
     {
-        std::shared_lock sl{mutex_};
+        std::shared_lock const sl{mutex_};
         if (auto d = prewriteCheck(map_.find(m.masterKey), /*checkSig*/ true, sl))
             return *d;
     }
 
-    std::unique_lock sl{mutex_};
+    std::unique_lock const sl{mutex_};
     auto const iter = map_.find(m.masterKey);
     // Since we released the previously held read lock, it's possible that the
     // collections have been written to. This means we need to run
@@ -562,7 +562,7 @@ ManifestCache::save(
     std::string const& dbTable,
     std::function<bool(PublicKey const&)> const& isTrusted)
 {
-    std::shared_lock lock{mutex_};
+    std::shared_lock const lock{mutex_};
     auto db = dbCon.checkoutDb();
 
     saveManifests(*db, dbTable, isTrusted, map_, j_);
diff --git a/src/libxrpl/server/Vacuum.cpp b/src/libxrpl/server/Vacuum.cpp
index 89764b777a..bcf5941e95 100644
--- a/src/libxrpl/server/Vacuum.cpp
+++ b/src/libxrpl/server/Vacuum.cpp
@@ -9,7 +9,7 @@ namespace xrpl {
 bool
 doVacuumDB(DatabaseCon::Setup const& setup, beast::Journal j)
 {
-    boost::filesystem::path dbPath = setup.dataDir / TxDBName;
+    boost::filesystem::path const dbPath = setup.dataDir / TxDBName;
 
     uintmax_t const dbSize = file_size(dbPath);
     XRPL_ASSERT(dbSize != static_cast<uintmax_t>(-1), "ripple:doVacuumDB : file_size succeeded");
diff --git a/src/libxrpl/server/Wallet.cpp b/src/libxrpl/server/Wallet.cpp
index 95c2e89a20..8da934a921 100644
--- a/src/libxrpl/server/Wallet.cpp
+++ b/src/libxrpl/server/Wallet.cpp
@@ -199,13 +199,13 @@ bool
 createFeatureVotes(soci::session& session)
 {
     soci::transaction tr(session);
-    std::string sql =
+    std::string const sql =
         "SELECT count(*) FROM sqlite_master "
         "WHERE type='table' AND name='FeatureVotes'";
     // SOCI requires boost::optional (not std::optional) as the parameter.
     boost::optional<int> featureVotesCount;
     session << sql, soci::into(featureVotesCount);
-    bool exists = static_cast<bool>(*featureVotesCount);
+    bool const exists = static_cast<bool>(*featureVotesCount);
 
     // Create FeatureVotes table in WalletDB if it doesn't exist
     if (!exists)
@@ -232,8 +232,8 @@ readAmendments(
         return safe_cast<AmendmentVote>(dbVote.value_or(1));
     };
 
-    soci::transaction tr(session);
-    std::string sql =
+    soci::transaction const tr(session);
+    std::string const sql =
         "SELECT AmendmentHash, AmendmentName, Veto FROM "
         "( SELECT AmendmentHash, AmendmentName, Veto, RANK() OVER "
         "(  PARTITION BY AmendmentHash ORDER BY ROWID DESC ) "
diff --git a/src/libxrpl/shamap/SHAMap.cpp b/src/libxrpl/shamap/SHAMap.cpp
index 8a853e4d1b..505d20651e 100644
--- a/src/libxrpl/shamap/SHAMap.cpp
+++ b/src/libxrpl/shamap/SHAMap.cpp
@@ -85,11 +85,11 @@ SHAMap::dirtyUp(
     while (!stack.empty())
     {
         auto node = intr_ptr::dynamic_pointer_cast<SHAMapInnerNode>(stack.top().first);
-        SHAMapNodeID nodeID = stack.top().second;
+        SHAMapNodeID const nodeID = stack.top().second;
         stack.pop();
         XRPL_ASSERT(node, "xrpl::SHAMap::dirtyUp : non-null node");
 
-        int branch = selectBranch(nodeID, target);
+        int const branch = selectBranch(nodeID, target);
         XRPL_ASSERT(branch >= 0, "xrpl::SHAMap::dirtyUp : valid branch");
 
         node = unshareNode(std::move(node), nodeID);
@@ -129,7 +129,7 @@ SHAMap::walkTowardsKey(uint256 const& id, SharedPtrNodeStack* stack) const
 SHAMapLeafNode*
 SHAMap::findKey(uint256 const& id) const
 {
-    SHAMapLeafNode* leaf = walkTowardsKey(id);
+    SHAMapLeafNode* leaf = walkTowardsKey(id);  // NOLINT(misc-const-correctness)
     if ((leaf != nullptr) && leaf->peekItem()->key() != id)
         leaf = nullptr;
     return leaf;
@@ -253,7 +253,7 @@ SHAMap::fetchNode(SHAMapHash const& hash) const
 SHAMapTreeNode*
 SHAMap::descendThrow(SHAMapInnerNode* parent, int branch) const
 {
-    SHAMapTreeNode* ret = descend(parent, branch);
+    SHAMapTreeNode* ret = descend(parent, branch);  // NOLINT(misc-const-correctness)
 
     if ((ret == nullptr) && !parent->isEmptyBranch(branch))
         Throw<SHAMapMissingNode>(type_, parent->getChildHash(branch));
@@ -275,7 +275,7 @@ SHAMap::descendThrow(SHAMapInnerNode& parent, int branch) const
 SHAMapTreeNode*
 SHAMap::descend(SHAMapInnerNode* parent, int branch) const
 {
-    SHAMapTreeNode* ret = parent->getChildPointer(branch);
+    SHAMapTreeNode* ret = parent->getChildPointer(branch);  // NOLINT(misc-const-correctness)
     if ((ret != nullptr) || !backed_)
         return ret;
 
@@ -326,7 +326,7 @@ SHAMap::descend(
     XRPL_ASSERT(
         !parent->isEmptyBranch(branch), "xrpl::SHAMap::descend : parent branch is non-empty");
 
-    SHAMapTreeNode* child = parent->getChildPointer(branch);
+    SHAMapTreeNode* child = parent->getChildPointer(branch);  // NOLINT(misc-const-correctness)
 
     if (child == nullptr)
     {
@@ -353,7 +353,7 @@ SHAMap::descendAsync(
 {
     pending = false;
 
-    SHAMapTreeNode* ret = parent->getChildPointer(branch);
+    SHAMapTreeNode* ret = parent->getChildPointer(branch);  // NOLINT(misc-const-correctness)
     if (ret != nullptr)
         return ret;
 
@@ -513,7 +513,7 @@ SHAMapLeafNode const*
 SHAMap::peekFirstItem(SharedPtrNodeStack& stack) const
 {
     XRPL_ASSERT(stack.empty(), "xrpl::SHAMap::peekFirstItem : empty stack input");
-    SHAMapLeafNode* node = firstBelow(root_, stack);
+    SHAMapLeafNode const* node = firstBelow(root_, stack);
     if (node == nullptr)
     {
         while (!stack.empty())
@@ -555,7 +555,7 @@ SHAMap::peekNextItem(uint256 const& id, SharedPtrNodeStack& stack) const
 boost::intrusive_ptr<SHAMapItem const> const&
 SHAMap::peekItem(uint256 const& id) const
 {
-    SHAMapLeafNode* leaf = findKey(id);
+    SHAMapLeafNode const* leaf = findKey(id);
 
     if (leaf == nullptr)
         return no_item;
@@ -566,7 +566,7 @@ SHAMap::peekItem(uint256 const& id) const
 boost::intrusive_ptr<SHAMapItem const> const&
 SHAMap::peekItem(uint256 const& id, SHAMapHash& hash) const
 {
-    SHAMapLeafNode* leaf = findKey(id);
+    SHAMapLeafNode const* leaf = findKey(id);
 
     if (leaf == nullptr)
         return no_item;
@@ -667,7 +667,7 @@ SHAMap::delItem(uint256 const& id)
     if (!leaf || (leaf->peekItem()->key() != id))
         return false;
 
-    SHAMapNodeType type = leaf->getType();
+    SHAMapNodeType const type = leaf->getType();
 
     using TreeNodeType = intr_ptr::SharedPtr<SHAMapTreeNode>;
 
@@ -677,7 +677,7 @@ SHAMap::delItem(uint256 const& id)
     while (!stack.empty())
     {
         auto node = intr_ptr::static_pointer_cast<SHAMapInnerNode>(stack.top().first);
-        SHAMapNodeID nodeID = stack.top().second;
+        SHAMapNodeID const nodeID = stack.top().second;
         stack.pop();
 
         node = unshareNode(std::move(node), nodeID);
@@ -741,7 +741,7 @@ SHAMap::addGiveItem(SHAMapNodeType type, boost::intrusive_ptr<SHAMapItem const>
     XRPL_ASSERT(type != SHAMapNodeType::tnINNER, "xrpl::SHAMap::addGiveItem : valid type input");
 
     // add the specified item, does not update
-    uint256 tag = item->key();
+    uint256 const tag = item->key();
 
     SharedPtrNodeStack stack;
     walkTowardsKey(tag, &stack);
@@ -763,7 +763,7 @@ SHAMap::addGiveItem(SHAMapNodeType type, boost::intrusive_ptr<SHAMapItem const>
     {
         // easy case, we end on an inner node
         auto inner = intr_ptr::static_pointer_cast<SHAMapInnerNode>(node);
-        int branch = selectBranch(nodeID, tag);
+        int const branch = selectBranch(nodeID, tag);
         XRPL_ASSERT(
             inner->isEmptyBranch(branch), "xrpl::SHAMap::addGiveItem : inner branch is empty");
         inner->setChild(branch, makeTypedLeaf(type, std::move(item), cowid_));
@@ -825,7 +825,7 @@ bool
 SHAMap::updateGiveItem(SHAMapNodeType type, boost::intrusive_ptr<SHAMapItem const> item)
 {
     // can't change the tag but can change the hash
-    uint256 tag = item->key();
+    uint256 const tag = item->key();
 
     XRPL_ASSERT(state_ != SHAMapState::Immutable, "xrpl::SHAMap::updateGiveItem : not immutable");
 
@@ -1007,7 +1007,7 @@ SHAMap::walkSubTree(bool doWrite, NodeObjectType t)
             {
                 // No need to do I/O. If the node isn't linked,
                 // it can't need to be flushed
-                int branch = pos;
+                int const branch = pos;
                 auto child = node->getChild(pos++);
 
                 if (child && (child->cowid() != 0))
diff --git a/src/libxrpl/shamap/SHAMapDelta.cpp b/src/libxrpl/shamap/SHAMapDelta.cpp
index 0b5a09d4a7..ded57760f1 100644
--- a/src/libxrpl/shamap/SHAMapDelta.cpp
+++ b/src/libxrpl/shamap/SHAMapDelta.cpp
@@ -241,14 +241,14 @@ SHAMap::walkMap(std::vector<SHAMapMissingNode>& missingNodes, int maxMissing) co
 
     while (!nodeStack.empty())
     {
-        intr_ptr::SharedPtr<SHAMapInnerNode> node = std::move(nodeStack.top());
+        intr_ptr::SharedPtr<SHAMapInnerNode> const node = std::move(nodeStack.top());
         nodeStack.pop();
 
         for (int i = 0; i < 16; ++i)
         {
             if (!node->isEmptyBranch(i))
             {
-                intr_ptr::SharedPtr<SHAMapTreeNode> nextNode = descendNoStore(*node, i);
+                intr_ptr::SharedPtr<SHAMapTreeNode> const nextNode = descendNoStore(*node, i);
 
                 if (nextNode)
                 {
@@ -310,7 +310,8 @@ SHAMap::walkMapParallel(std::vector<SHAMapMissingNode>& missingNodes, int maxMis
                     {
                         while (!nodeStack.empty())
                         {
-                            intr_ptr::SharedPtr<SHAMapInnerNode> node = std::move(nodeStack.top());
+                            intr_ptr::SharedPtr<SHAMapInnerNode> const node =
+                                std::move(nodeStack.top());
                             XRPL_ASSERT(node, "xrpl::SHAMap::walkMapParallel : non-null node");
                             nodeStack.pop();
 
@@ -318,7 +319,7 @@ SHAMap::walkMapParallel(std::vector<SHAMapMissingNode>& missingNodes, int maxMis
                             {
                                 if (node->isEmptyBranch(i))
                                     continue;
-                                intr_ptr::SharedPtr<SHAMapTreeNode> nextNode =
+                                intr_ptr::SharedPtr<SHAMapTreeNode> const nextNode =
                                     descendNoStore(*node, i);
 
                                 if (nextNode)
@@ -332,7 +333,7 @@ SHAMap::walkMapParallel(std::vector<SHAMapMissingNode>& missingNodes, int maxMis
                                 }
                                 else
                                 {
-                                    std::lock_guard l{m};
+                                    std::lock_guard const l{m};
                                     missingNodes.emplace_back(type_, node->getChildHash(i));
                                     if (--maxMissing <= 0)
                                         return;
@@ -342,7 +343,7 @@ SHAMap::walkMapParallel(std::vector<SHAMapMissingNode>& missingNodes, int maxMis
                     }
                     catch (SHAMapMissingNode const& e)
                     {
-                        std::lock_guard l(m);
+                        std::lock_guard const l(m);
                         exceptions.push_back(e);
                     }
                 },
@@ -352,7 +353,7 @@ SHAMap::walkMapParallel(std::vector<SHAMapMissingNode>& missingNodes, int maxMis
     for (std::thread& worker : workers)
         worker.join();
 
-    std::lock_guard l(m);
+    std::lock_guard const l(m);
     if (exceptions.empty())
         return true;
     std::stringstream ss;
diff --git a/src/libxrpl/shamap/SHAMapInnerNode.cpp b/src/libxrpl/shamap/SHAMapInnerNode.cpp
index 599d343745..91249d139e 100644
--- a/src/libxrpl/shamap/SHAMapInnerNode.cpp
+++ b/src/libxrpl/shamap/SHAMapInnerNode.cpp
@@ -82,7 +82,7 @@ SHAMapInnerNode::clone(std::uint32_t cowid) const
     }
 
     spinlock sl(lock_);
-    std::lock_guard lock(sl);
+    std::lock_guard const lock(sl);
 
     if (thisIsSparse)
     {
@@ -313,7 +313,7 @@ SHAMapInnerNode::getChildPointer(int branch)
     auto const index = *getChildIndex(branch);
 
     packed_spinlock sl(lock_, index);
-    std::lock_guard lock(sl);
+    std::lock_guard const lock(sl);
     return hashesAndChildren_.getChildren()[index].get();
 }
 
@@ -328,7 +328,7 @@ SHAMapInnerNode::getChild(int branch)
     auto const index = *getChildIndex(branch);
 
     packed_spinlock sl(lock_, index);
-    std::lock_guard lock(sl);
+    std::lock_guard const lock(sl);
     return hashesAndChildren_.getChildren()[index];
 }
 
@@ -361,7 +361,7 @@ SHAMapInnerNode::canonicalizeChild(int branch, intr_ptr::SharedPtr<SHAMapTreeNod
         "hash do match");
 
     packed_spinlock sl(lock_, childIndex);
-    std::lock_guard lock(sl);
+    std::lock_guard const lock(sl);
 
     if (children[childIndex])
     {
diff --git a/src/libxrpl/shamap/SHAMapNodeID.cpp b/src/libxrpl/shamap/SHAMapNodeID.cpp
index 97a8b26a3b..e5dbebc871 100644
--- a/src/libxrpl/shamap/SHAMapNodeID.cpp
+++ b/src/libxrpl/shamap/SHAMapNodeID.cpp
@@ -87,7 +87,7 @@ deserializeSHAMapNodeID(void const* data, std::size_t size)
 
     if (size == 33)
     {
-        unsigned int depth = *(static_cast<unsigned char const*>(data) + 32);
+        unsigned int const depth = *(static_cast<unsigned char const*>(data) + 32);
         if (depth <= SHAMap::leafDepth)
         {
             auto const id = uint256::fromVoid(data);
diff --git a/src/libxrpl/shamap/SHAMapSync.cpp b/src/libxrpl/shamap/SHAMapSync.cpp
index 14ccdca2eb..2074b43cb4 100644
--- a/src/libxrpl/shamap/SHAMapSync.cpp
+++ b/src/libxrpl/shamap/SHAMapSync.cpp
@@ -41,7 +41,7 @@ SHAMap::visitNodes(std::function<bool(SHAMapTreeNode&)> const& function) const
         {
             if (!node->isEmptyBranch(pos))
             {
-                intr_ptr::SharedPtr<SHAMapTreeNode> child = descendNoStore(*node, pos);
+                intr_ptr::SharedPtr<SHAMapTreeNode> const child = descendNoStore(*node, pos);
                 if (!function(*child))
                     return;
 
@@ -124,7 +124,7 @@ SHAMap::visitDifferences(
             if (!node->isEmptyBranch(i))
             {
                 auto const& childHash = node->getChildHash(i);
-                SHAMapNodeID childID = nodeID.getChildNodeID(i);
+                SHAMapNodeID const childID = nodeID.getChildNodeID(i);
                 auto next = descendThrow(node, i);
 
                 if (next->isInner())
@@ -160,7 +160,7 @@ SHAMap::gmn_ProcessNodes(MissingNodes& mn, MissingNodes::StackEntry& se)
 
     while (currentChild < 16)
     {
-        int branch = (firstChild + currentChild++) % 16;
+        int const branch = (firstChild + currentChild++) % 16;
         if (node->isEmptyBranch(branch))
             continue;
 
@@ -182,7 +182,7 @@ SHAMap::gmn_ProcessNodes(MissingNodes& mn, MissingNodes::StackEntry& se)
                 [node, nodeID, branch, &mn](
                     intr_ptr::SharedPtr<SHAMapTreeNode> found, SHAMapHash const&) {
                     // a read completed asynchronously
-                    std::unique_lock<std::mutex> lock{mn.deferLock_};
+                    std::unique_lock<std::mutex> const lock{mn.deferLock_};
                     mn.finishedReads_.emplace_back(node, nodeID, branch, std::move(found));
                     mn.deferCondVar_.notify_one();
                 });
@@ -327,7 +327,7 @@ SHAMap::getMissingNodes(int max, SHAMapSyncFilter* filter)
             if ((node == nullptr) && !mn.stack_.empty())
             {
                 // Pick up where we left off with this node's parent
-                bool was = fullBelow;  // was full below
+                bool const was = fullBelow;  // was full below
 
                 pos = mn.stack_.top();
                 mn.stack_.pop();
@@ -404,7 +404,7 @@ SHAMap::getNodeFat(
 
     while ((node != nullptr) && node->isInner() && (nodeID.getDepth() < wanted.getDepth()))
     {
-        int branch = selectBranch(nodeID, wanted.getNodeID());
+        int const branch = selectBranch(nodeID, wanted.getNodeID());
         auto inner = safe_downcast<SHAMapInnerNode*>(node);
         if (inner->isEmptyBranch(branch))
             return false;
@@ -445,7 +445,7 @@ SHAMap::getNodeFat(
             // We descend inner nodes with only a single child
             // without decrementing the depth
             auto inner = safe_downcast<SHAMapInnerNode*>(node);
-            int bc = inner->getBranchCount();
+            int const bc = inner->getBranchCount();
 
             if ((depth > 0) || (bc == 1))
             {
@@ -709,7 +709,7 @@ SHAMap::hasInnerNode(SHAMapNodeID const& targetNodeID, SHAMapHash const& targetN
 
     while (node->isInner() && (nodeID.getDepth() < targetNodeID.getDepth()))
     {
-        int branch = selectBranch(nodeID, targetNodeID.getNodeID());
+        int const branch = selectBranch(nodeID, targetNodeID.getNodeID());
         auto inner = safe_downcast<SHAMapInnerNode*>(node);
         if (inner->isEmptyBranch(branch))
             return false;
@@ -734,7 +734,7 @@ SHAMap::hasLeafNode(uint256 const& tag, SHAMapHash const& targetNodeHash) const
 
     do
     {
-        int branch = selectBranch(nodeID, tag);
+        int const branch = selectBranch(nodeID, tag);
         auto inner = safe_downcast<SHAMapInnerNode*>(node);
         if (inner->isEmptyBranch(branch))
             return false;  // Dead end, node must not be here
diff --git a/src/libxrpl/tx/ApplyContext.cpp b/src/libxrpl/tx/ApplyContext.cpp
index edca31c04a..d503643662 100644
--- a/src/libxrpl/tx/ApplyContext.cpp
+++ b/src/libxrpl/tx/ApplyContext.cpp
@@ -98,7 +98,7 @@ ApplyContext::checkInvariantsHelper(
         // short-circuits). While the logic is still correct, the log
         // message won't be. Every failed invariant should write to the log,
         // not just the first one.
-        std::array<bool, sizeof...(Is)> finalizers{
+        std::array<bool, sizeof...(Is)> const finalizers{
             {std::get<Is>(checkers).finalize(tx, result, fee, *view_, journal)...}};
 
         // call each check's finalizer to see that it passes
diff --git a/src/libxrpl/tx/Transactor.cpp b/src/libxrpl/tx/Transactor.cpp
index 9560c4e752..7d2ac06fc1 100644
--- a/src/libxrpl/tx/Transactor.cpp
+++ b/src/libxrpl/tx/Transactor.cpp
@@ -34,7 +34,7 @@ preflight0(PreflightContext const& ctx, std::uint32_t flagMask)
 
     if (!isPseudoTx(ctx.tx) || ctx.tx.isFieldPresent(sfNetworkID))
     {
-        uint32_t nodeNID = ctx.registry.get().getNetworkIDService().getNetworkID();
+        uint32_t const nodeNID = ctx.registry.get().getNetworkIDService().getNetworkID();
         std::optional<uint32_t> txNID = ctx.tx[~sfNetworkID];
 
         if (nodeNID <= 1024)
@@ -777,7 +777,7 @@ Transactor::checkMultiSign(
     beast::Journal const j)
 {
     // Get id's SignerList and Quorum.
-    std::shared_ptr<STLedgerEntry const> sleAccountSigners = view.read(keylet::signers(id));
+    std::shared_ptr<STLedgerEntry const> const sleAccountSigners = view.read(keylet::signers(id));
     // If the signer list doesn't exist the account is not multi-signing.
     if (!sleAccountSigners)
     {
@@ -1073,15 +1073,15 @@ Transactor::operator()()
     //
     // raii classes for the current ledger rules.
     // fixUniversalNumber predate the rulesGuard and should be replaced.
-    NumberSO stNumberSO{view().rules().enabled(fixUniversalNumber)};
-    CurrentTransactionRulesGuard currentTransactionRulesGuard(view().rules());
+    NumberSO const stNumberSO{view().rules().enabled(fixUniversalNumber)};
+    CurrentTransactionRulesGuard const currentTransactionRulesGuard(view().rules());
 
 #ifdef DEBUG
     {
         Serializer ser;
         ctx_.tx.add(ser);
         SerialIter sit(ser.slice());
-        STTx s2(sit);
+        STTx const s2(sit);
 
         if (!s2.isEquivalent(ctx_.tx))
         {
diff --git a/src/libxrpl/tx/apply.cpp b/src/libxrpl/tx/apply.cpp
index caf716eda6..c8016002c2 100644
--- a/src/libxrpl/tx/apply.cpp
+++ b/src/libxrpl/tx/apply.cpp
@@ -116,7 +116,7 @@ template <typename PreflightChecks>
 ApplyResult
 apply(ServiceRegistry& registry, OpenView& view, PreflightChecks&& preflightChecks)
 {
-    NumberSO stNumberSO{view.rules().enabled(fixUniversalNumber)};
+    NumberSO const stNumberSO{view.rules().enabled(fixUniversalNumber)};
     return doApply(preclaim(preflightChecks(), registry, view), registry, view);
 }
 
diff --git a/src/libxrpl/tx/invariants/FreezeInvariant.cpp b/src/libxrpl/tx/invariants/FreezeInvariant.cpp
index c8723b9bbf..0048da7a84 100644
--- a/src/libxrpl/tx/invariants/FreezeInvariant.cpp
+++ b/src/libxrpl/tx/invariants/FreezeInvariant.cpp
@@ -127,7 +127,7 @@ TransfersNotFrozen::calculateBalanceChange(
     bool isDelete)
 {
     auto const getBalance = [](auto const& line, auto const& other, bool zero) {
-        STAmount amt = line ? line->at(sfBalance) : other->at(sfBalance).zeroed();
+        STAmount const amt = line ? line->at(sfBalance) : other->at(sfBalance).zeroed();
         return zero ? amt.zeroed() : amt;
     };
 
diff --git a/src/libxrpl/tx/invariants/MPTInvariant.cpp b/src/libxrpl/tx/invariants/MPTInvariant.cpp
index a3a5bf897d..7b76e70c86 100644
--- a/src/libxrpl/tx/invariants/MPTInvariant.cpp
+++ b/src/libxrpl/tx/invariants/MPTInvariant.cpp
@@ -56,7 +56,7 @@ ValidMPTIssuance::finalize(
     {
         auto const& rules = view.rules();
         [[maybe_unused]]
-        bool enforceCreatedByIssuer =
+        bool const enforceCreatedByIssuer =
             rules.enabled(featureSingleAssetVault) || rules.enabled(featureLendingProtocol);
         if (mptCreatedByIssuer_)
         {
diff --git a/src/libxrpl/tx/paths/BookStep.cpp b/src/libxrpl/tx/paths/BookStep.cpp
index 3e492d8a19..ddba0c1ae9 100644
--- a/src/libxrpl/tx/paths/BookStep.cpp
+++ b/src/libxrpl/tx/paths/BookStep.cpp
@@ -1009,7 +1009,7 @@ BookStep<TIn, TOut, TDerived>::revImp(
             return DebtDirection::issues;
         }();
         auto const r = forEachOffer(sb, afView, prevStepDebtDir, eachOffer);
-        boost::container::flat_set<uint256> toRm = std::move(std::get<0>(r));
+        boost::container::flat_set<uint256> const toRm = std::move(std::get<0>(r));
         std::uint32_t const offersConsumed = std::get<1>(r);
         offersUsed_ = offersConsumed;
         SetUnion(ofrsToRm, toRm);
@@ -1171,7 +1171,7 @@ BookStep<TIn, TOut, TDerived>::fwdImp(
             return DebtDirection::issues;
         }();
         auto const r = forEachOffer(sb, afView, prevStepDebtDir, eachOffer);
-        boost::container::flat_set<uint256> toRm = std::move(std::get<0>(r));
+        boost::container::flat_set<uint256> const toRm = std::move(std::get<0>(r));
         std::uint32_t const offersConsumed = std::get<1>(r);
         offersUsed_ = offersConsumed;
         SetUnion(ofrsToRm, toRm);
diff --git a/src/libxrpl/tx/paths/OfferStream.cpp b/src/libxrpl/tx/paths/OfferStream.cpp
index b7dc431b23..acb2df1429 100644
--- a/src/libxrpl/tx/paths/OfferStream.cpp
+++ b/src/libxrpl/tx/paths/OfferStream.cpp
@@ -203,7 +203,7 @@ TOfferStreamBase<TIn, TOut>::step()
         if (!tip_.step(j_))
             return false;
 
-        std::shared_ptr<SLE> entry = tip_.entry();
+        std::shared_ptr<SLE> const entry = tip_.entry();
 
         // If we exceed the maximum number of allowed steps, we're done.
         if (!counter_.step())
diff --git a/src/libxrpl/tx/transactors/account/AccountSet.cpp b/src/libxrpl/tx/transactors/account/AccountSet.cpp
index d99324f802..af3edb5768 100644
--- a/src/libxrpl/tx/transactors/account/AccountSet.cpp
+++ b/src/libxrpl/tx/transactors/account/AccountSet.cpp
@@ -63,8 +63,9 @@ AccountSet::preflight(PreflightContext const& ctx)
     //
     // RequireAuth
     //
-    bool bSetRequireAuth = ((uTxFlags & tfRequireAuth) != 0u) || (uSetFlag == asfRequireAuth);
-    bool bClearRequireAuth = ((uTxFlags & tfOptionalAuth) != 0u) || (uClearFlag == asfRequireAuth);
+    bool const bSetRequireAuth = ((uTxFlags & tfRequireAuth) != 0u) || (uSetFlag == asfRequireAuth);
+    bool const bClearRequireAuth =
+        ((uTxFlags & tfOptionalAuth) != 0u) || (uClearFlag == asfRequireAuth);
 
     if (bSetRequireAuth && bClearRequireAuth)
     {
@@ -75,8 +76,9 @@ AccountSet::preflight(PreflightContext const& ctx)
     //
     // RequireDestTag
     //
-    bool bSetRequireDest = ((uTxFlags & tfRequireDestTag) != 0u) || (uSetFlag == asfRequireDest);
-    bool bClearRequireDest =
+    bool const bSetRequireDest =
+        ((uTxFlags & tfRequireDestTag) != 0u) || (uSetFlag == asfRequireDest);
+    bool const bClearRequireDest =
         ((uTxFlags & tfOptionalDestTag) != 0u) || (uClearFlag == asfRequireDest);
 
     if (bSetRequireDest && bClearRequireDest)
@@ -88,8 +90,9 @@ AccountSet::preflight(PreflightContext const& ctx)
     //
     // DisallowXRP
     //
-    bool bSetDisallowXRP = ((uTxFlags & tfDisallowXRP) != 0u) || (uSetFlag == asfDisallowXRP);
-    bool bClearDisallowXRP = ((uTxFlags & tfAllowXRP) != 0u) || (uClearFlag == asfDisallowXRP);
+    bool const bSetDisallowXRP = ((uTxFlags & tfDisallowXRP) != 0u) || (uSetFlag == asfDisallowXRP);
+    bool const bClearDisallowXRP =
+        ((uTxFlags & tfAllowXRP) != 0u) || (uClearFlag == asfDisallowXRP);
 
     if (bSetDisallowXRP && bClearDisallowXRP)
     {
@@ -100,7 +103,7 @@ AccountSet::preflight(PreflightContext const& ctx)
     // TransferRate
     if (tx.isFieldPresent(sfTransferRate))
     {
-        std::uint32_t uRate = tx.getFieldU32(sfTransferRate);
+        std::uint32_t const uRate = tx.getFieldU32(sfTransferRate);
 
         if ((uRate != 0u) && (uRate < QUALITY_ONE))
         {
@@ -217,7 +220,7 @@ AccountSet::preclaim(PreclaimContext const& ctx)
     std::uint32_t const uSetFlag = ctx.tx.getFieldU32(sfSetFlag);
 
     // legacy AccountSet flags
-    bool bSetRequireAuth = ((uTxFlags & tfRequireAuth) != 0u) || (uSetFlag == asfRequireAuth);
+    bool const bSetRequireAuth = ((uTxFlags & tfRequireAuth) != 0u) || (uSetFlag == asfRequireAuth);
 
     //
     // RequireAuth
@@ -531,7 +534,7 @@ AccountSet::doApply()
     //
     if (tx.isFieldPresent(sfTransferRate))
     {
-        std::uint32_t uRate = tx.getFieldU32(sfTransferRate);
+        std::uint32_t const uRate = tx.getFieldU32(sfTransferRate);
 
         if (uRate == 0 || uRate == QUALITY_ONE)
         {
diff --git a/src/libxrpl/tx/transactors/account/SignerListSet.cpp b/src/libxrpl/tx/transactors/account/SignerListSet.cpp
index 22fb98afd8..90ab8daf6f 100644
--- a/src/libxrpl/tx/transactors/account/SignerListSet.cpp
+++ b/src/libxrpl/tx/transactors/account/SignerListSet.cpp
@@ -167,7 +167,7 @@ removeSignersFromLedger(
 {
     // We have to examine the current SignerList so we know how much to
     // reduce the OwnerCount.
-    SLE::pointer signers = view.peek(signerListKeylet);
+    SLE::pointer const signers = view.peek(signerListKeylet);
 
     // If the signer list doesn't exist we've already succeeded in deleting it.
     if (!signers)
@@ -299,7 +299,7 @@ SignerListSet::replaceSignerList()
     std::uint32_t const oldOwnerCount{(*sle)[sfOwnerCount]};
 
     constexpr int addedOwnerCount = 1;
-    std::uint32_t flags{lsfOneOwnerCount};
+    std::uint32_t const flags{lsfOneOwnerCount};
 
     XRPAmount const newReserve{view().fees().accountReserve(oldOwnerCount + addedOwnerCount)};
 
@@ -339,7 +339,7 @@ SignerListSet::destroySignerList()
     auto const accountKeylet = keylet::account(account_);
     // Destroying the signer list is only allowed if either the master key
     // is enabled or there is a regular key.
-    SLE::pointer ledgerEntry = view().peek(accountKeylet);
+    SLE::pointer const ledgerEntry = view().peek(accountKeylet);
     if (!ledgerEntry)
         return tefINTERNAL;  // LCOV_EXCL_LINE
 
diff --git a/src/libxrpl/tx/transactors/bridge/XChainBridge.cpp b/src/libxrpl/tx/transactors/bridge/XChainBridge.cpp
index f0e57919d9..9074122cdf 100644
--- a/src/libxrpl/tx/transactors/bridge/XChainBridge.cpp
+++ b/src/libxrpl/tx/transactors/bridge/XChainBridge.cpp
@@ -119,7 +119,7 @@ checkAttestationPublicKey(
         else
         {
             // regular key
-            if (std::optional<AccountID> regularKey =
+            if (std::optional<AccountID> const regularKey =
                     (*sleAttestationSigningAccount)[~sfRegularKey];
                 regularKey != accountFromPK)
             {
@@ -326,7 +326,8 @@ onClaim(
     std::unordered_map<AccountID, std::uint32_t> const& signersList,
     beast::Journal j)
 {
-    XChainClaimAttestation::MatchFields toMatch{sendingAmount, wasLockingChainSend, std::nullopt};
+    XChainClaimAttestation::MatchFields const toMatch{
+        sendingAmount, wasLockingChainSend, std::nullopt};
     return claimHelper(attestations, view, toMatch, CheckDst::ignore, quorum, signersList, j);
 }
 
@@ -638,7 +639,7 @@ finalizeClaimHelper(
                 auto const round_mode = innerSb.rules().enabled(fixXChainRewardRounding)
                     ? Number::rounding_mode::downward
                     : Number::getround();
-                saveNumberRoundMode _{Number::setround(round_mode)};
+                saveNumberRoundMode const _{Number::setround(round_mode)};
 
                 STAmount const den{rewardAccounts.size()};
                 return divide(rewardPool, den, rewardPool.issue());
diff --git a/src/libxrpl/tx/transactors/check/CheckCash.cpp b/src/libxrpl/tx/transactors/check/CheckCash.cpp
index 09b3177ce7..fa908c3aa3 100644
--- a/src/libxrpl/tx/transactors/check/CheckCash.cpp
+++ b/src/libxrpl/tx/transactors/check/CheckCash.cpp
@@ -365,7 +365,7 @@ CheckCash::doApply()
             STAmount const savedLimit = sleTrustLine->at(tweakedLimit);
 
             // Make sure the tweaked limits are restored when we leave scope.
-            scope_exit fixup([&psb, &trustLineKey, &tweakedLimit, &savedLimit]() {
+            scope_exit const fixup([&psb, &trustLineKey, &tweakedLimit, &savedLimit]() {
                 if (auto const sleTrustLine = psb.peek(trustLineKey))
                     sleTrustLine->at(tweakedLimit) = savedLimit;
             });
diff --git a/src/libxrpl/tx/transactors/dex/AMMBid.cpp b/src/libxrpl/tx/transactors/dex/AMMBid.cpp
index a1ace702dc..f5b9445ead 100644
--- a/src/libxrpl/tx/transactors/dex/AMMBid.cpp
+++ b/src/libxrpl/tx/transactors/dex/AMMBid.cpp
@@ -54,7 +54,7 @@ AMMBid::preflight(PreflightContext const& ctx)
         }
         if (ctx.rules.enabled(fixAMMv1_3))
         {
-            AccountID account = ctx.tx[sfAccount];
+            AccountID const account = ctx.tx[sfAccount];
             std::set<AccountID> unique;
             for (auto const& obj : authAccounts)
             {
diff --git a/src/libxrpl/tx/transactors/dex/AMMCreate.cpp b/src/libxrpl/tx/transactors/dex/AMMCreate.cpp
index 6dabf084bf..069fadf103 100644
--- a/src/libxrpl/tx/transactors/dex/AMMCreate.cpp
+++ b/src/libxrpl/tx/transactors/dex/AMMCreate.cpp
@@ -246,7 +246,7 @@ applyCreate(ApplyContext& ctx_, Sandbox& sb, AccountID const& account_, beast::J
         // Set AMM flag on AMM trustline
         if (!isXRP(amount))
         {
-            SLE::pointer sleRippleState = sb.peek(keylet::line(accountId, amount.issue()));
+            SLE::pointer const sleRippleState = sb.peek(keylet::line(accountId, amount.issue()));
             if (!sleRippleState)
             {
                 return tecINTERNAL;  // LCOV_EXCL_LINE
diff --git a/src/libxrpl/tx/transactors/dex/AMMHelpers.cpp b/src/libxrpl/tx/transactors/dex/AMMHelpers.cpp
index 20ffab52ca..386608229b 100644
--- a/src/libxrpl/tx/transactors/dex/AMMHelpers.cpp
+++ b/src/libxrpl/tx/transactors/dex/AMMHelpers.cpp
@@ -7,7 +7,7 @@ ammLPTokens(STAmount const& asset1, STAmount const& asset2, Issue const& lptIssu
 {
     // AMM invariant: sqrt(asset1 * asset2) >= LPTokensBalance
     auto const rounding = isFeatureEnabled(fixAMMv1_3) ? Number::downward : Number::getround();
-    NumberRoundModeGuard g(rounding);
+    NumberRoundModeGuard const g(rounding);
     auto const tokens = root2(asset1 * asset2);
     return toSTAmount(lptIssue, tokens);
 }
@@ -142,7 +142,7 @@ adjustLPTokens(STAmount const& lptAMMBalance, STAmount const& lpTokens, IsDeposi
 {
     // Force rounding downward to ensure adjusted tokens are less or equal
     // to requested tokens.
-    saveNumberRoundMode rm(Number::setround(Number::rounding_mode::downward));
+    saveNumberRoundMode const rm(Number::setround(Number::rounding_mode::downward));
     if (isDeposit == IsDeposit::Yes)
         return (lptAMMBalance + lpTokens) - lptAMMBalance;
     return (lpTokens - lptAMMBalance) + lptAMMBalance;
@@ -251,7 +251,7 @@ solveQuadraticEqSmallest(Number const& a, Number const& b, Number const& c)
 STAmount
 multiply(STAmount const& amount, Number const& frac, Number::rounding_mode rm)
 {
-    NumberRoundModeGuard g(rm);
+    NumberRoundModeGuard const g(rm);
     auto const t = amount * frac;
     return toSTAmount(amount.issue(), t, rm);
 }
@@ -270,7 +270,7 @@ getRoundedAsset(
     auto const rm = detail::getAssetRounding(isDeposit);
     if (isDeposit == IsDeposit::Yes)
         return multiply(balance, productCb(), rm);
-    NumberRoundModeGuard g(rm);
+    NumberRoundModeGuard const g(rm);
     return toSTAmount(balance.issue(), productCb(), rm);
 }
 
@@ -304,7 +304,7 @@ getRoundedLPTokens(
         auto const rm = detail::getLPTokenRounding(isDeposit);
         if (isDeposit == IsDeposit::Yes)
         {
-            NumberRoundModeGuard g(rm);
+            NumberRoundModeGuard const g(rm);
             return toSTAmount(lptAMMBalance.issue(), productCb(), rm);
         }
         return multiply(lptAMMBalance, productCb(), rm);
diff --git a/src/libxrpl/tx/transactors/dex/OfferCreate.cpp b/src/libxrpl/tx/transactors/dex/OfferCreate.cpp
index 76c49aee57..20524f73ae 100644
--- a/src/libxrpl/tx/transactors/dex/OfferCreate.cpp
+++ b/src/libxrpl/tx/transactors/dex/OfferCreate.cpp
@@ -79,8 +79,8 @@ OfferCreate::preflight(PreflightContext const& ctx)
         return temBAD_SEQUENCE;
     }
 
-    STAmount saTakerPays = tx[sfTakerPays];
-    STAmount saTakerGets = tx[sfTakerGets];
+    STAmount const saTakerPays = tx[sfTakerPays];
+    STAmount const saTakerGets = tx[sfTakerGets];
 
     if (!isLegalNet(saTakerPays) || !isLegalNet(saTakerGets))
         return temBAD_AMOUNT;
@@ -737,7 +737,8 @@ OfferCreate::applyGuts(Sandbox& sb, Sandbox& sbCancel)
         return {tefINTERNAL, false};
 
     {
-        XRPAmount reserve = sb.fees().accountReserve(sleCreator->getFieldU32(sfOwnerCount) + 1);
+        XRPAmount const reserve =
+            sb.fees().accountReserve(sleCreator->getFieldU32(sfOwnerCount) + 1);
 
         if (preFeeBalance_ < reserve)
         {
diff --git a/src/libxrpl/tx/transactors/escrow/EscrowCancel.cpp b/src/libxrpl/tx/transactors/escrow/EscrowCancel.cpp
index 1250d950cd..e47f008357 100644
--- a/src/libxrpl/tx/transactors/escrow/EscrowCancel.cpp
+++ b/src/libxrpl/tx/transactors/escrow/EscrowCancel.cpp
@@ -33,7 +33,7 @@ escrowCancelPreclaimHelper<Issue>(
     AccountID const& account,
     STAmount const& amount)
 {
-    AccountID issuer = amount.getIssuer();
+    AccountID const issuer = amount.getIssuer();
     // If the issuer is the same as the account, return tecINTERNAL
     if (issuer == account)
         return tecINTERNAL;  // LCOV_EXCL_LINE
@@ -52,7 +52,7 @@ escrowCancelPreclaimHelper<MPTIssue>(
     AccountID const& account,
     STAmount const& amount)
 {
-    AccountID issuer = amount.getIssuer();
+    AccountID const issuer = amount.getIssuer();
     // If the issuer is the same as the account, return tecINTERNAL
     if (issuer == account)
         return tecINTERNAL;  // LCOV_EXCL_LINE
diff --git a/src/libxrpl/tx/transactors/escrow/EscrowCreate.cpp b/src/libxrpl/tx/transactors/escrow/EscrowCreate.cpp
index 634b9b3a06..ed0bbeea44 100644
--- a/src/libxrpl/tx/transactors/escrow/EscrowCreate.cpp
+++ b/src/libxrpl/tx/transactors/escrow/EscrowCreate.cpp
@@ -163,7 +163,7 @@ escrowCreatePreclaimHelper<Issue>(
     AccountID const& dest,
     STAmount const& amount)
 {
-    AccountID issuer = amount.getIssuer();
+    AccountID const issuer = amount.getIssuer();
     // If the issuer is the same as the account, return tecNO_PERMISSION
     if (issuer == account)
         return tecNO_PERMISSION;
@@ -233,7 +233,7 @@ escrowCreatePreclaimHelper<MPTIssue>(
     AccountID const& dest,
     STAmount const& amount)
 {
-    AccountID issuer = amount.getIssuer();
+    AccountID const issuer = amount.getIssuer();
     // If the issuer is the same as the account, return tecNO_PERMISSION
     if (issuer == account)
         return tecNO_PERMISSION;
diff --git a/src/libxrpl/tx/transactors/escrow/EscrowFinish.cpp b/src/libxrpl/tx/transactors/escrow/EscrowFinish.cpp
index f64229ff69..e05ba87bbb 100644
--- a/src/libxrpl/tx/transactors/escrow/EscrowFinish.cpp
+++ b/src/libxrpl/tx/transactors/escrow/EscrowFinish.cpp
@@ -127,7 +127,7 @@ escrowFinishPreclaimHelper<Issue>(
     AccountID const& dest,
     STAmount const& amount)
 {
-    AccountID issuer = amount.getIssuer();
+    AccountID const issuer = amount.getIssuer();
     // If the issuer is the same as the account, return tesSUCCESS
     if (issuer == dest)
         return tesSUCCESS;
@@ -150,7 +150,7 @@ escrowFinishPreclaimHelper<MPTIssue>(
     AccountID const& dest,
     STAmount const& amount)
 {
-    AccountID issuer = amount.getIssuer();
+    AccountID const issuer = amount.getIssuer();
     // If the issuer is the same as the dest, return tesSUCCESS
     if (issuer == dest)
         return tesSUCCESS;
diff --git a/src/libxrpl/tx/transactors/lending/LendingHelpers.cpp b/src/libxrpl/tx/transactors/lending/LendingHelpers.cpp
index ad4cd8440d..bad55e9222 100644
--- a/src/libxrpl/tx/transactors/lending/LendingHelpers.cpp
+++ b/src/libxrpl/tx/transactors/lending/LendingHelpers.cpp
@@ -1253,7 +1253,7 @@ checkLoanGuards(
     // loan can't be amortized in the specified number of payments, raise an
     // error
     {
-        NumberRoundModeGuard mg(Number::upward);
+        NumberRoundModeGuard const mg(Number::upward);
 
         if (std::int64_t const computedPayments{
                 properties.loanState.valueOutstanding / roundedPayment};
@@ -1486,7 +1486,7 @@ computeLoanProperties(
 
     auto const [totalValueOutstanding, loanScale] = [&]() {
         // only round up if there should be interest
-        NumberRoundModeGuard mg(periodicRate == 0 ? Number::to_nearest : Number::upward);
+        NumberRoundModeGuard const mg(periodicRate == 0 ? Number::to_nearest : Number::upward);
         // Use STAmount's internal rounding instead of roundToAsset, because
         // we're going to use this result to determine the scale for all the
         // other rounding.
diff --git a/src/libxrpl/tx/transactors/lending/LoanBrokerCoverClawback.cpp b/src/libxrpl/tx/transactors/lending/LoanBrokerCoverClawback.cpp
index 24aa3f8bf2..627b16794b 100644
--- a/src/libxrpl/tx/transactors/lending/LoanBrokerCoverClawback.cpp
+++ b/src/libxrpl/tx/transactors/lending/LoanBrokerCoverClawback.cpp
@@ -137,11 +137,11 @@ determineClawAmount(
 {
     auto const maxClawAmount = [&]() {
         // Always round the minimum required up
-        NumberRoundModeGuard mg1(Number::upward);
+        NumberRoundModeGuard const mg1(Number::upward);
         auto const minRequiredCover =
             tenthBipsOfValue(sleBroker[sfDebtTotal], TenthBips32(sleBroker[sfCoverRateMinimum]));
         // The subtraction probably won't round, but round down if it does.
-        NumberRoundModeGuard mg2(Number::downward);
+        NumberRoundModeGuard const mg2(Number::downward);
         return sleBroker[sfCoverAvailable] - minRequiredCover;
     }();
     if (maxClawAmount <= beast::zero)
diff --git a/src/libxrpl/tx/transactors/lending/LoanBrokerCoverWithdraw.cpp b/src/libxrpl/tx/transactors/lending/LoanBrokerCoverWithdraw.cpp
index 6946992376..d03edad0a2 100644
--- a/src/libxrpl/tx/transactors/lending/LoanBrokerCoverWithdraw.cpp
+++ b/src/libxrpl/tx/transactors/lending/LoanBrokerCoverWithdraw.cpp
@@ -119,7 +119,7 @@ LoanBrokerCoverWithdraw::preclaim(PreclaimContext const& ctx)
     auto const minimumCover = [&]() {
         // Always round the minimum required up.
         // Applies to `tenthBipsOfValue` as well as `roundToAsset`.
-        NumberRoundModeGuard mg(Number::upward);
+        NumberRoundModeGuard const mg(Number::upward);
         return roundToAsset(
             vaultAsset,
             tenthBipsOfValue(currentDebtTotal, TenthBips32(sleBroker->at(sfCoverRateMinimum))),
diff --git a/src/libxrpl/tx/transactors/lending/LoanManage.cpp b/src/libxrpl/tx/transactors/lending/LoanManage.cpp
index 6cc9df1aab..adef5374b9 100644
--- a/src/libxrpl/tx/transactors/lending/LoanManage.cpp
+++ b/src/libxrpl/tx/transactors/lending/LoanManage.cpp
@@ -144,7 +144,7 @@ LoanManage::defaultLoan(
     TenthBips32 const coverRateLiquidation{brokerSle->at(sfCoverRateLiquidation)};
     auto const defaultCovered = [&]() {
         // Always round the minimum required up.
-        NumberRoundModeGuard mg(Number::upward);
+        NumberRoundModeGuard const mg(Number::upward);
         auto const minimumCover = tenthBipsOfValue(brokerDebtTotalProxy.value(), coverRateMinimum);
         // Round the liquidation amount up, too
         auto const covered = roundToAsset(
diff --git a/src/libxrpl/tx/transactors/lending/LoanPay.cpp b/src/libxrpl/tx/transactors/lending/LoanPay.cpp
index 8739cb645a..f748a670fd 100644
--- a/src/libxrpl/tx/transactors/lending/LoanPay.cpp
+++ b/src/libxrpl/tx/transactors/lending/LoanPay.cpp
@@ -117,7 +117,7 @@ LoanPay::calculateBaseFee(ReadView const& view, STTx const& tx)
 
     // If making an overpayment, count it as a full payment because it will do
     // about the same amount of work, if not more.
-    NumberRoundModeGuard mg(tx.isFlag(tfLoanOverpayment) ? Number::upward : Number::downward);
+    NumberRoundModeGuard const mg(tx.isFlag(tfLoanOverpayment) ? Number::upward : Number::downward);
     // Estimate how many payments will be made
     Number const numPaymentEstimate = static_cast<std::int64_t>(amount / regularPayment);
 
@@ -277,7 +277,7 @@ LoanPay::doApply()
         // Round the minimum required cover up to be conservative. This ensures
         // CoverAvailable never drops below the theoretical minimum, protecting
         // the broker's solvency.
-        NumberRoundModeGuard mg(Number::upward);
+        NumberRoundModeGuard const mg(Number::upward);
         return coverAvailableProxy >=
             roundToAsset(
                    asset, tenthBipsOfValue(debtTotalProxy.value(), coverRateMinimum), loanScale) &&
diff --git a/src/libxrpl/tx/transactors/lending/LoanSet.cpp b/src/libxrpl/tx/transactors/lending/LoanSet.cpp
index f046a24961..9cc4042365 100644
--- a/src/libxrpl/tx/transactors/lending/LoanSet.cpp
+++ b/src/libxrpl/tx/transactors/lending/LoanSet.cpp
@@ -466,7 +466,7 @@ LoanSet::doApply()
         // Round the minimum required cover up to be conservative. This ensures
         // CoverAvailable never drops below the theoretical minimum, protecting
         // the broker's solvency.
-        NumberRoundModeGuard mg(Number::upward);
+        NumberRoundModeGuard const mg(Number::upward);
         if (brokerSle->at(sfCoverAvailable) < tenthBipsOfValue(newDebtTotal, coverRateMinimum))
         {
             JLOG(j_.warn()) << "Insufficient first-loss capital to cover the loan.";
diff --git a/src/libxrpl/tx/transactors/nft/NFTokenUtils.cpp b/src/libxrpl/tx/transactors/nft/NFTokenUtils.cpp
index 6a8b830bf0..3368887d94 100644
--- a/src/libxrpl/tx/transactors/nft/NFTokenUtils.cpp
+++ b/src/libxrpl/tx/transactors/nft/NFTokenUtils.cpp
@@ -64,7 +64,7 @@ getPageForToken(
     // A suitable page doesn't exist; we'll have to create one.
     if (!cp)
     {
-        STArray arr;
+        STArray const arr;
         cp = std::make_shared<SLE>(last);
         cp->setFieldArray(sfNFTokens, arr);
         view.insert(cp);
@@ -245,7 +245,7 @@ insertToken(ApplyView& view, AccountID owner, STObject&& nft)
     // First, we need to locate the page the NFT belongs to, creating it
     // if necessary. This operation may fail if it is impossible to insert
     // the NFT.
-    std::shared_ptr<SLE> page =
+    std::shared_ptr<SLE> const page =
         getPageForToken(view, owner, nft[sfNFTokenID], [](ApplyView& view, AccountID const& owner) {
             adjustOwnerCount(
                 view,
@@ -338,7 +338,7 @@ mergePages(ApplyView& view, std::shared_ptr<SLE> const& p1, std::shared_ptr<SLE>
 TER
 removeToken(ApplyView& view, AccountID const& owner, uint256 const& nftokenID)
 {
-    std::shared_ptr<SLE> page = locatePage(view, owner, nftokenID);
+    std::shared_ptr<SLE> const page = locatePage(view, owner, nftokenID);
 
     // If the page couldn't be found, the given NFT isn't owned by this account
     if (!page)
@@ -519,7 +519,7 @@ removeToken(
 std::optional<STObject>
 findToken(ReadView const& view, AccountID const& owner, uint256 const& nftokenID)
 {
-    std::shared_ptr<SLE const> page = locatePage(view, owner, nftokenID);
+    std::shared_ptr<SLE const> const page = locatePage(view, owner, nftokenID);
 
     // If the page couldn't be found, the given NFT isn't owned by this account
     if (!page)
@@ -612,7 +612,7 @@ notTooManyOffers(ReadView const& view, uint256 const& nftokenID)
     std::size_t totalOffers = 0;
 
     {
-        Dir buys(view, keylet::nft_buys(nftokenID));
+        Dir const buys(view, keylet::nft_buys(nftokenID));
         for (auto iter = buys.begin(); iter != buys.end(); iter.next_page())
         {
             totalOffers += iter.page_size();
@@ -622,7 +622,7 @@ notTooManyOffers(ReadView const& view, uint256 const& nftokenID)
     }
 
     {
-        Dir sells(view, keylet::nft_sells(nftokenID));
+        Dir const sells(view, keylet::nft_sells(nftokenID));
         for (auto iter = sells.begin(); iter != sells.end(); iter.next_page())
         {
             totalOffers += iter.page_size();
diff --git a/src/libxrpl/tx/transactors/system/Batch.cpp b/src/libxrpl/tx/transactors/system/Batch.cpp
index b8b0d3234a..cd3ac9a16c 100644
--- a/src/libxrpl/tx/transactors/system/Batch.cpp
+++ b/src/libxrpl/tx/transactors/system/Batch.cpp
@@ -123,7 +123,7 @@ Batch::calculateBaseFee(ReadView const& view, STTx const& tx)
     }
     // LCOV_EXCL_STOP
 
-    XRPAmount signerFees = signerCount * view.fees().base;
+    XRPAmount const signerFees = signerCount * view.fees().base;
 
     // LCOV_EXCL_START
     if (signerFees > maxAmount - txnFees)
diff --git a/src/libxrpl/tx/transactors/system/Change.cpp b/src/libxrpl/tx/transactors/system/Change.cpp
index 2648902095..a1d9183ca4 100644
--- a/src/libxrpl/tx/transactors/system/Change.cpp
+++ b/src/libxrpl/tx/transactors/system/Change.cpp
@@ -142,7 +142,7 @@ Change::preCompute()
 TER
 Change::applyAmendment()
 {
-    uint256 amendment(ctx_.tx.getFieldH256(sfAmendment));
+    uint256 const amendment(ctx_.tx.getFieldH256(sfAmendment));
 
     auto const k = keylet::amendments();
 
diff --git a/src/libxrpl/tx/transactors/system/TicketCreate.cpp b/src/libxrpl/tx/transactors/system/TicketCreate.cpp
index 0c41e503e4..c4e281c357 100644
--- a/src/libxrpl/tx/transactors/system/TicketCreate.cpp
+++ b/src/libxrpl/tx/transactors/system/TicketCreate.cpp
@@ -70,7 +70,7 @@ TicketCreate::doApply()
             return tecINSUFFICIENT_RESERVE;
     }
 
-    beast::Journal viewJ{ctx_.registry.get().getJournal("View")};
+    beast::Journal const viewJ{ctx_.registry.get().getJournal("View")};
 
     // The starting ticket sequence is the same as the current account
     // root sequence.  Before we got here to doApply(), the transaction
@@ -88,7 +88,7 @@ TicketCreate::doApply()
     {
         std::uint32_t const curTicketSeq = firstTicketSeq + i;
         Keylet const ticketKeylet = keylet::ticket(account_, curTicketSeq);
-        SLE::pointer sleTicket = std::make_shared<SLE>(ticketKeylet);
+        SLE::pointer const sleTicket = std::make_shared<SLE>(ticketKeylet);
 
         sleTicket->setAccountID(sfAccount, account_);
         sleTicket->setFieldU32(sfTicketSequence, curTicketSeq);
diff --git a/src/libxrpl/tx/transactors/token/MPTokenAuthorize.cpp b/src/libxrpl/tx/transactors/token/MPTokenAuthorize.cpp
index 464ede9de7..3ddc6d2c05 100644
--- a/src/libxrpl/tx/transactors/token/MPTokenAuthorize.cpp
+++ b/src/libxrpl/tx/transactors/token/MPTokenAuthorize.cpp
@@ -38,7 +38,7 @@ MPTokenAuthorize::preclaim(PreclaimContext const& ctx)
     //       `holderID` is NOT used
     if (!holderID)
     {
-        std::shared_ptr<SLE const> sleMpt =
+        std::shared_ptr<SLE const> const sleMpt =
             ctx.view.read(keylet::mptoken(ctx.tx[sfMPTokenIssuanceID], accountID));
 
         // There is an edge case where all holders have zero balance, issuance
diff --git a/src/libxrpl/tx/transactors/token/TrustSet.cpp b/src/libxrpl/tx/transactors/token/TrustSet.cpp
index 37935f07c2..feefa6a7ac 100644
--- a/src/libxrpl/tx/transactors/token/TrustSet.cpp
+++ b/src/libxrpl/tx/transactors/token/TrustSet.cpp
@@ -318,7 +318,7 @@ TrustSet::doApply()
     bool const bQualityOut(ctx_.tx.isFieldPresent(sfQualityOut));
 
     Currency const currency(saLimitAmount.getCurrency());
-    AccountID uDstAccountID(saLimitAmount.getIssuer());
+    AccountID const uDstAccountID(saLimitAmount.getIssuer());
 
     // true, if current is high account.
     bool const bHigh = account_ > uDstAccountID;
@@ -350,7 +350,7 @@ TrustSet::doApply()
     XRPAmount const reserveCreate(
         (uOwnerCount < 2) ? XRPAmount(beast::zero) : view().fees().accountReserve(uOwnerCount + 1));
 
-    std::uint32_t uQualityIn(bQualityIn ? ctx_.tx.getFieldU32(sfQualityIn) : 0);
+    std::uint32_t const uQualityIn(bQualityIn ? ctx_.tx.getFieldU32(sfQualityIn) : 0);
     std::uint32_t uQualityOut(bQualityOut ? ctx_.tx.getFieldU32(sfQualityOut) : 0);
 
     if (bQualityOut && QUALITY_ONE == uQualityOut)
@@ -368,7 +368,7 @@ TrustSet::doApply()
 
     auto viewJ = ctx_.registry.get().getJournal("View");
 
-    SLE::pointer sleDst = view().peek(keylet::account(uDstAccountID));
+    SLE::pointer const sleDst = view().peek(keylet::account(uDstAccountID));
 
     if (!sleDst)
     {
@@ -379,7 +379,8 @@ TrustSet::doApply()
     STAmount saLimitAllow = saLimitAmount;
     saLimitAllow.setIssuer(account_);
 
-    SLE::pointer sleRippleState = view().peek(keylet::line(account_, uDstAccountID, currency));
+    SLE::pointer const sleRippleState =
+        view().peek(keylet::line(account_, uDstAccountID, currency));
 
     if (sleRippleState)
     {
@@ -625,7 +626,7 @@ TrustSet::doApply()
     else
     {
         // Zero balance in currency.
-        STAmount saBalance(Issue{currency, noAccount()});
+        STAmount const saBalance(Issue{currency, noAccount()});
 
         auto const k = keylet::line(account_, uDstAccountID, currency);
 
diff --git a/src/libxrpl/tx/transactors/vault/VaultClawback.cpp b/src/libxrpl/tx/transactors/vault/VaultClawback.cpp
index a650aed310..6a4d6a579e 100644
--- a/src/libxrpl/tx/transactors/vault/VaultClawback.cpp
+++ b/src/libxrpl/tx/transactors/vault/VaultClawback.cpp
@@ -334,7 +334,7 @@ VaultClawback::doApply()
         lossUnrealized <= (assetsTotal - assetsAvailable),
         "xrpl::VaultClawback::doApply : loss and assets do balance");
 
-    AccountID holder = tx[sfHolder];
+    AccountID const holder = tx[sfHolder];
     STAmount sharesDestroyed = {share};
     STAmount assetsRecovered = {vault->at(sfAsset)};
 
diff --git a/src/test/app/AMMCalc_test.cpp b/src/test/app/AMMCalc_test.cpp
index b4043f239b..c3091a166d 100644
--- a/src/test/app/AMMCalc_test.cpp
+++ b/src/test/app/AMMCalc_test.cpp
@@ -37,7 +37,7 @@ class AMMCalc_test : public beast::unit_test::suite
         str = boost::regex_replace(str, boost::regex("^(A|O)[(]"), "");
         boost::smatch match;
         // XXX(val))?
-        boost::regex rx("^([^(]+)[(]([^)]+)[)]([)])?$");
+        boost::regex const rx("^([^(]+)[(]([^)]+)[)]([)])?$");
         if (boost::regex_search(str, match, rx))
         {
             if (delimited != nullptr)
@@ -65,12 +65,12 @@ class AMMCalc_test : public beast::unit_test::suite
         str = boost::regex_replace(str, boost::regex("^T[(]"), "");
         // XXX(rate))?
         boost::smatch match;
-        boost::regex rx("^([^(]+)[(]([^)]+)[)]([)])?$");
+        boost::regex const rx("^([^(]+)[(]([^)]+)[)]([)])?$");
         if (boost::regex_search(str, match, rx))
         {
             std::string const currency = match[1];
             // input is rate * 100, no fraction
-            std::uint32_t rate = 10'000'000 * std::stoi(match[2].str());
+            std::uint32_t const rate = 10'000'000 * std::stoi(match[2].str());
             // true if delimited - )
             return {{currency, rate, match[3] != ""}};
         }
@@ -310,7 +310,7 @@ class AMMCalc_test : public beast::unit_test::suite
     {
         using namespace jtx;
         auto const a = arg();
-        boost::regex re(",");
+        boost::regex const re(",");
         token_iter p(a.begin(), a.end(), re, -1);
         // Token is denoted as CUR(xxx), where CUR is the currency code
         //    and xxx is the amount, for instance: XRP(100) or USD(11.5)
@@ -391,7 +391,7 @@ class AMMCalc_test : public beast::unit_test::suite
             //     10 is AMM trading fee
             else if (*p == "changespq")
             {
-                Env env(*this);
+                Env const env(*this);
                 if (auto const pool = getAmounts(++p))
                 {
                     if (auto const offer = getAmounts(p))
diff --git a/src/test/app/AMMClawback_test.cpp b/src/test/app/AMMClawback_test.cpp
index 9033fe2bdd..245ee38ac2 100644
--- a/src/test/app/AMMClawback_test.cpp
+++ b/src/test/app/AMMClawback_test.cpp
@@ -18,8 +18,8 @@ class AMMClawback_test : public beast::unit_test::suite
         // Test if holder does not exist.
         {
             Env env(*this);
-            Account gw{"gateway"};
-            Account alice{"alice"};
+            Account const gw{"gateway"};
+            Account const alice{"alice"};
             env.fund(XRP(100000), gw, alice);
             env.close();
 
@@ -32,7 +32,7 @@ class AMMClawback_test : public beast::unit_test::suite
             env.trust(USD(10000), alice);
             env(pay(gw, alice, USD(100)));
 
-            AMM amm(env, alice, XRP(100), USD(100));
+            AMM const amm(env, alice, XRP(100), USD(100));
             env.close();
 
             env(amm::ammClawback(gw, Account("unknown"), USD, XRP, std::nullopt),
@@ -44,7 +44,7 @@ class AMMClawback_test : public beast::unit_test::suite
         {
             Env env(*this);
             Account gw{"gateway"};
-            Account alice{"alice"};
+            Account const alice{"alice"};
             env.fund(XRP(100000), gw, alice);
             env.close();
 
@@ -75,8 +75,8 @@ class AMMClawback_test : public beast::unit_test::suite
         // return temMALFORMED error.
         {
             Env env(*this);
-            Account gw{"gateway"};
-            Account alice{"alice"};
+            Account const gw{"gateway"};
+            Account const alice{"alice"};
             env.fund(XRP(10000), gw, alice);
             env.close();
 
@@ -91,7 +91,7 @@ class AMMClawback_test : public beast::unit_test::suite
             env(pay(gw, alice, USD(100)));
             env.close();
 
-            AMM amm(env, gw, XRP(100), USD(100), ter(tesSUCCESS));
+            AMM const amm(env, gw, XRP(100), USD(100), ter(tesSUCCESS));
 
             // Issuer can not clawback from himself.
             env(amm::ammClawback(gw, gw, USD, XRP, std::nullopt), ter(temMALFORMED));
@@ -103,8 +103,8 @@ class AMMClawback_test : public beast::unit_test::suite
         // Test if the Asset field matches the Account field.
         {
             Env env(*this);
-            Account gw{"gateway"};
-            Account alice{"alice"};
+            Account const gw{"gateway"};
+            Account const alice{"alice"};
             env.fund(XRP(10000), gw, alice);
             env.close();
 
@@ -119,7 +119,7 @@ class AMMClawback_test : public beast::unit_test::suite
             env(pay(gw, alice, USD(100)));
             env.close();
 
-            AMM amm(env, gw, XRP(100), USD(100), ter(tesSUCCESS));
+            AMM const amm(env, gw, XRP(100), USD(100), ter(tesSUCCESS));
 
             // The Asset's issuer field is alice, while the Account field is gw.
             // This should return temMALFORMED because they do not match.
@@ -131,8 +131,8 @@ class AMMClawback_test : public beast::unit_test::suite
         // Test if the Amount field matches the Asset field.
         {
             Env env(*this);
-            Account gw{"gateway"};
-            Account alice{"alice"};
+            Account const gw{"gateway"};
+            Account const alice{"alice"};
             env.fund(XRP(10000), gw, alice);
             env.close();
 
@@ -147,7 +147,7 @@ class AMMClawback_test : public beast::unit_test::suite
             env(pay(gw, alice, USD(100)));
             env.close();
 
-            AMM amm(env, gw, XRP(100), USD(100), ter(tesSUCCESS));
+            AMM const amm(env, gw, XRP(100), USD(100), ter(tesSUCCESS));
 
             // The Asset's issuer subfield is gw account and Amount's issuer
             // subfield is alice account. Return temBAD_AMOUNT because
@@ -160,8 +160,8 @@ class AMMClawback_test : public beast::unit_test::suite
         // Test if the Amount is invalid, which is less than zero.
         {
             Env env(*this);
-            Account gw{"gateway"};
-            Account alice{"alice"};
+            Account const gw{"gateway"};
+            Account const alice{"alice"};
             env.fund(XRP(10000), gw, alice);
             env.close();
 
@@ -176,7 +176,7 @@ class AMMClawback_test : public beast::unit_test::suite
             env(pay(gw, alice, USD(100)));
             env.close();
 
-            AMM amm(env, gw, XRP(100), USD(100), ter(tesSUCCESS));
+            AMM const amm(env, gw, XRP(100), USD(100), ter(tesSUCCESS));
 
             // Return temBAD_AMOUNT if the Amount value is less than 0.
             env(amm::ammClawback(
@@ -193,8 +193,8 @@ class AMMClawback_test : public beast::unit_test::suite
         // transaction is prohibited.
         {
             Env env(*this);
-            Account gw{"gateway"};
-            Account alice{"alice"};
+            Account const gw{"gateway"};
+            Account const alice{"alice"};
             env.fund(XRP(10000), gw, alice);
             env.close();
 
@@ -207,7 +207,7 @@ class AMMClawback_test : public beast::unit_test::suite
             env.require(balance(gw, alice["USD"](-100)));
 
             // gw creates AMM pool of XRP/USD.
-            AMM amm(env, gw, XRP(100), USD(100), ter(tesSUCCESS));
+            AMM const amm(env, gw, XRP(100), USD(100), ter(tesSUCCESS));
 
             // If asfAllowTrustLineClawback is not set, the issuer is not
             // allowed to send the AMMClawback transaction.
@@ -217,8 +217,8 @@ class AMMClawback_test : public beast::unit_test::suite
         // Test invalid flag.
         {
             Env env(*this);
-            Account gw{"gateway"};
-            Account alice{"alice"};
+            Account const gw{"gateway"};
+            Account const alice{"alice"};
             env.fund(XRP(10000), gw, alice);
             env.close();
 
@@ -233,7 +233,7 @@ class AMMClawback_test : public beast::unit_test::suite
             env(pay(gw, alice, USD(100)));
             env.close();
 
-            AMM amm(env, gw, XRP(100), USD(100), ter(tesSUCCESS));
+            AMM const amm(env, gw, XRP(100), USD(100), ter(tesSUCCESS));
 
             // Return temINVALID_FLAG when providing invalid flag.
             env(amm::ammClawback(gw, alice, USD, XRP, std::nullopt),
@@ -245,8 +245,8 @@ class AMMClawback_test : public beast::unit_test::suite
         // are not issued by the same issuer.
         {
             Env env(*this);
-            Account gw{"gateway"};
-            Account alice{"alice"};
+            Account const gw{"gateway"};
+            Account const alice{"alice"};
             env.fund(XRP(10000), gw, alice);
             env.close();
 
@@ -262,7 +262,7 @@ class AMMClawback_test : public beast::unit_test::suite
             env.close();
 
             // gw creates AMM pool of XRP/USD.
-            AMM amm(env, gw, XRP(100), USD(100), ter(tesSUCCESS));
+            AMM const amm(env, gw, XRP(100), USD(100), ter(tesSUCCESS));
 
             // Return temINVALID_FLAG because the issuer set tfClawTwoAssets,
             // but the issuer only issues USD in the pool. The issuer is not
@@ -276,8 +276,8 @@ class AMMClawback_test : public beast::unit_test::suite
         // Test clawing back XRP is being prohibited.
         {
             Env env(*this);
-            Account gw{"gateway"};
-            Account alice{"alice"};
+            Account const gw{"gateway"};
+            Account const alice{"alice"};
             env.fund(XRP(1000000), gw, alice);
             env.close();
 
@@ -293,7 +293,7 @@ class AMMClawback_test : public beast::unit_test::suite
             env.close();
 
             // Alice creates AMM pool of XRP/USD.
-            AMM amm(env, alice, XRP(1000), USD(2000), ter(tesSUCCESS));
+            AMM const amm(env, alice, XRP(1000), USD(2000), ter(tesSUCCESS));
             env.close();
 
             // Clawback XRP is prohibited.
@@ -309,8 +309,8 @@ class AMMClawback_test : public beast::unit_test::suite
         if (!features[featureAMMClawback])
         {
             Env env(*this, features);
-            Account gw{"gateway"};
-            Account alice{"alice"};
+            Account const gw{"gateway"};
+            Account const alice{"alice"};
             env.fund(XRP(1000000), gw, alice);
             env.close();
 
@@ -342,9 +342,9 @@ class AMMClawback_test : public beast::unit_test::suite
         // issuer. Claw back USD, and EUR goes back to the holder.
         {
             Env env(*this, features);
-            Account gw{"gateway"};
-            Account gw2{"gateway2"};
-            Account alice{"alice"};
+            Account const gw{"gateway"};
+            Account const gw2{"gateway2"};
+            Account const alice{"alice"};
             env.fund(XRP(1000000), gw, gw2, alice);
             env.close();
 
@@ -370,7 +370,7 @@ class AMMClawback_test : public beast::unit_test::suite
             env.require(balance(alice, EUR(3000)));
 
             // Alice creates AMM pool of EUR/USD.
-            AMM amm(env, alice, EUR(1000), USD(2000), ter(tesSUCCESS));
+            AMM const amm(env, alice, EUR(1000), USD(2000), ter(tesSUCCESS));
             env.close();
 
             BEAST_EXPECT(
@@ -422,8 +422,8 @@ class AMMClawback_test : public beast::unit_test::suite
         // to the holder.
         {
             Env env(*this, features);
-            Account gw{"gateway"};
-            Account alice{"alice"};
+            Account const gw{"gateway"};
+            Account const alice{"alice"};
             env.fund(XRP(1000000), gw, alice);
             env.close();
 
@@ -441,7 +441,7 @@ class AMMClawback_test : public beast::unit_test::suite
             env.require(balance(alice, USD(3000)));
 
             // Alice creates AMM pool of XRP/USD.
-            AMM amm(env, alice, XRP(1000), USD(2000), ter(tesSUCCESS));
+            AMM const amm(env, alice, XRP(1000), USD(2000), ter(tesSUCCESS));
             env.close();
 
             BEAST_EXPECT(amm.expectBalances(USD(2000), XRP(1000), IOUAmount{1414213562373095, -9}));
@@ -501,9 +501,9 @@ class AMMClawback_test : public beast::unit_test::suite
         // balance in AMM pool.
         {
             Env env(*this, features);
-            Account gw{"gateway"};
-            Account gw2{"gateway2"};
-            Account alice{"alice"};
+            Account const gw{"gateway"};
+            Account const gw2{"gateway2"};
+            Account const alice{"alice"};
             env.fund(XRP(1000000), gw, gw2, alice);
             env.close();
 
@@ -527,7 +527,7 @@ class AMMClawback_test : public beast::unit_test::suite
             env.require(balance(alice, EUR(6000)));
 
             // Alice creates AMM pool of EUR/USD
-            AMM amm(env, alice, EUR(5000), USD(4000), ter(tesSUCCESS));
+            AMM const amm(env, alice, EUR(5000), USD(4000), ter(tesSUCCESS));
             env.close();
 
             if (!features[fixAMMv1_3])
@@ -672,8 +672,8 @@ class AMMClawback_test : public beast::unit_test::suite
         // creates the AMM pool EUR/XRP.
         {
             Env env(*this, features);
-            Account gw{"gateway"};
-            Account gw2{"gateway2"};
+            Account const gw{"gateway"};
+            Account const gw2{"gateway2"};
             Account alice{"alice"};
             Account bob{"bob"};
             env.fund(XRP(1000000), gw, gw2, alice, bob);
@@ -1082,9 +1082,9 @@ class AMMClawback_test : public beast::unit_test::suite
         // issuer. Claw back all the USD for different users.
         {
             Env env(*this, features);
-            Account gw{"gateway"};
-            Account gw2{"gateway2"};
-            Account alice{"alice"};
+            Account const gw{"gateway"};
+            Account const gw2{"gateway2"};
+            Account const alice{"alice"};
             Account bob{"bob"};
             Account carol{"carol"};
             env.fund(XRP(1000000), gw, gw2, alice, bob, carol);
@@ -1288,7 +1288,7 @@ class AMMClawback_test : public beast::unit_test::suite
         // different users.
         {
             Env env(*this, features);
-            Account gw{"gateway"};
+            Account const gw{"gateway"};
             Account alice{"alice"};
             Account bob{"bob"};
             env.fund(XRP(1000000), gw, alice, bob);
@@ -1400,8 +1400,8 @@ class AMMClawback_test : public beast::unit_test::suite
         // Test AMMClawback for USD/EUR pool. The assets are issued by different
         // issuer. Claw back all the USD for different users.
         Env env(*this, features);
-        Account gw{"gateway"};
-        Account alice{"alice"};
+        Account const gw{"gateway"};
+        Account const alice{"alice"};
         Account bob{"bob"};
         Account carol{"carol"};
         env.fund(XRP(1000000), gw, alice, bob, carol);
@@ -1534,9 +1534,9 @@ class AMMClawback_test : public beast::unit_test::suite
         // Test AMMClawback for USD/EUR pool. The assets are issued by different
         // issuer. Claw back all the USD for different users.
         Env env(*this, features);
-        Account gw{"gateway"};
-        Account gw2{"gateway2"};
-        Account alice{"alice"};
+        Account const gw{"gateway"};
+        Account const gw2{"gateway2"};
+        Account const alice{"alice"};
         Account bob{"bob"};
         env.fund(XRP(1000000), gw, gw2, alice, bob);
         env.close();
@@ -1629,7 +1629,7 @@ class AMMClawback_test : public beast::unit_test::suite
         // gw and gw2 issues token for each other. Test AMMClawback from
         // each other.
         Env env(*this, features);
-        Account gw{"gateway"};
+        Account const gw{"gateway"};
         Account gw2{"gateway2"};
         Account alice{"alice"};
         env.fund(XRP(1000000), gw, gw2, alice);
@@ -1815,8 +1815,8 @@ class AMMClawback_test : public beast::unit_test::suite
         using namespace jtx;
 
         Env env(*this, features);
-        Account gw{"gateway"};
-        Account alice{"alice"};
+        Account const gw{"gateway"};
+        Account const alice{"alice"};
         env.fund(XRP(1000000), gw, alice);
         env.close();
 
@@ -1829,7 +1829,7 @@ class AMMClawback_test : public beast::unit_test::suite
         env.trust(USD(100000), alice);
         env(pay(gw, alice, USD(5000)));
 
-        AMM amm(env, gw, USD(1000), XRP(2000), ter(tesSUCCESS));
+        AMM const amm(env, gw, USD(1000), XRP(2000), ter(tesSUCCESS));
         env.close();
 
         // Alice did not deposit in the amm pool. So AMMClawback from Alice
@@ -1846,9 +1846,9 @@ class AMMClawback_test : public beast::unit_test::suite
         // test individually frozen trustline.
         {
             Env env(*this, features);
-            Account gw{"gateway"};
-            Account gw2{"gateway2"};
-            Account alice{"alice"};
+            Account const gw{"gateway"};
+            Account const gw2{"gateway2"};
+            Account const alice{"alice"};
             env.fund(XRP(1000000), gw, gw2, alice);
             env.close();
 
@@ -1872,7 +1872,7 @@ class AMMClawback_test : public beast::unit_test::suite
             env.require(balance(alice, EUR(3000)));
 
             // Alice creates AMM pool of EUR/USD.
-            AMM amm(env, alice, EUR(1000), USD(2000), ter(tesSUCCESS));
+            AMM const amm(env, alice, EUR(1000), USD(2000), ter(tesSUCCESS));
             env.close();
 
             BEAST_EXPECT(
@@ -1910,9 +1910,9 @@ class AMMClawback_test : public beast::unit_test::suite
         // test individually frozen trustline of both USD and EUR currency.
         {
             Env env(*this, features);
-            Account gw{"gateway"};
-            Account gw2{"gateway2"};
-            Account alice{"alice"};
+            Account const gw{"gateway"};
+            Account const gw2{"gateway2"};
+            Account const alice{"alice"};
             env.fund(XRP(1000000), gw, gw2, alice);
             env.close();
 
@@ -1936,7 +1936,7 @@ class AMMClawback_test : public beast::unit_test::suite
             env.require(balance(alice, EUR(3000)));
 
             // Alice creates AMM pool of EUR/USD.
-            AMM amm(env, alice, EUR(1000), USD(2000), ter(tesSUCCESS));
+            AMM const amm(env, alice, EUR(1000), USD(2000), ter(tesSUCCESS));
             env.close();
 
             BEAST_EXPECT(
@@ -1960,9 +1960,9 @@ class AMMClawback_test : public beast::unit_test::suite
         // test gw global freeze.
         {
             Env env(*this, features);
-            Account gw{"gateway"};
-            Account gw2{"gateway2"};
-            Account alice{"alice"};
+            Account const gw{"gateway"};
+            Account const gw2{"gateway2"};
+            Account const alice{"alice"};
             env.fund(XRP(1000000), gw, gw2, alice);
             env.close();
 
@@ -1986,7 +1986,7 @@ class AMMClawback_test : public beast::unit_test::suite
             env.require(balance(alice, EUR(3000)));
 
             // Alice creates AMM pool of EUR/USD.
-            AMM amm(env, alice, EUR(1000), USD(2000), ter(tesSUCCESS));
+            AMM const amm(env, alice, EUR(1000), USD(2000), ter(tesSUCCESS));
             env.close();
 
             BEAST_EXPECT(
@@ -2010,8 +2010,8 @@ class AMMClawback_test : public beast::unit_test::suite
         // global freeze.
         {
             Env env(*this, features);
-            Account gw{"gateway"};
-            Account alice{"alice"};
+            Account const gw{"gateway"};
+            Account const alice{"alice"};
             Account bob{"bob"};
             Account carol{"carol"};
             env.fund(XRP(1000000), gw, alice, bob, carol);
@@ -2149,7 +2149,7 @@ class AMMClawback_test : public beast::unit_test::suite
         // Test AMMClawback for USD/XRP pool. Claw back USD, and XRP goes back
         // to the holder.
         Env env(*this, features, std::make_unique<CaptureLogs>(&logs));
-        Account gw{"gateway"};
+        Account const gw{"gateway"};
         Account alice{"alice"};
         env.fund(XRP(1000000000), gw, alice);
         env.close();
@@ -2357,7 +2357,7 @@ class AMMClawback_test : public beast::unit_test::suite
             Account gw{"gateway"}, alice{"alice"}, bob{"bob"};
             auto const USD = setupAccounts(env, gw, alice, bob);
 
-            Account gw2{"gateway2"};
+            Account const gw2{"gateway2"};
             env.fund(XRP(100000), gw2);
             env.close();
             auto const EUR = gw2["EUR"];
diff --git a/src/test/app/AMMExtended_test.cpp b/src/test/app/AMMExtended_test.cpp
index 9de1714389..cc63f3d124 100644
--- a/src/test/app/AMMExtended_test.cpp
+++ b/src/test/app/AMMExtended_test.cpp
@@ -61,9 +61,9 @@ private:
         env(offer(carol, XRP(50), USD(50)));
 
         // Good quality path
-        AMM ammCarol(env, carol, BTC(1'000), USD(100'100));
+        AMM const ammCarol(env, carol, BTC(1'000), USD(100'100));
 
-        PathSet paths(Path(XRP, USD), Path(USD));
+        PathSet const paths(Path(XRP, USD), Path(USD));
 
         env(pay(alice, bob, USD(100)),
             json(paths.json()),
@@ -114,7 +114,7 @@ private:
             env(pay(gw2, bob, USD2(50)));
             env.close();
 
-            AMM ammDan(env, dan, XRP(10'000), USD1(10'000));
+            AMM const ammDan(env, dan, XRP(10'000), USD1(10'000));
 
             env(pay(alice, carol, USD2(50)),
                 path(~USD1, bob),
@@ -145,7 +145,7 @@ private:
             env(pay(gw2, bob, USD2(50)));
             env.close();
 
-            AMM ammDan(env, dan, XRP(10'000), USD1(10'050));
+            AMM const ammDan(env, dan, XRP(10'000), USD1(10'050));
 
             env(pay(alice, carol, USD2(50)),
                 path(~USD1, bob),
@@ -269,7 +269,7 @@ private:
 
         fund(env, gw, {bob, alice}, XRP(300'000), {USD(100)}, Fund::All);
 
-        AMM ammAlice(env, alice, XRP(150'000), USD(50));
+        AMM const ammAlice(env, alice, XRP(150'000), USD(50));
 
         // Existing offer pays better than this wants.
         // Partially consume existing offer.
@@ -302,7 +302,7 @@ private:
 
         env(pay(gw, alice, alice["USD"](500)));
 
-        AMM ammAlice(env, alice, XRP(150'000), USD(51));
+        AMM const ammAlice(env, alice, XRP(150'000), USD(51));
         env(offer(bob, USD(1), XRP(3'000)));
 
         BEAST_EXPECT(ammAlice.expectBalances(XRP(153'000), USD(50), ammAlice.tokens()));
@@ -334,7 +334,7 @@ private:
         env.require(owners(alice, 1), owners(bob, 1));
 
         env(pay(gw, alice, alice["USD"](100)));
-        AMM ammBob(env, bob, USD(200), XRP(1'500));
+        AMM const ammBob(env, bob, USD(200), XRP(1'500));
 
         env(pay(alice, alice, XRP(500)), sendmax(USD(100)));
 
@@ -459,7 +459,7 @@ private:
         env(pay(gw2, dan, dan["EUR"](400)));
         env.close();
 
-        AMM ammCarol(env, carol, USD1(5'000), XRP(50'000));
+        AMM const ammCarol(env, carol, USD1(5'000), XRP(50'000));
 
         env(offer(dan, XRP(500), EUR1(50)));
         env.close();
@@ -513,7 +513,7 @@ private:
 
         env(pay(gw1, bob, bob["USD"](1'200)));
 
-        AMM ammBob(env, bob, XRP(1'000), USD1(1'200));
+        AMM const ammBob(env, bob, XRP(1'000), USD1(1'200));
         // Alice has 350 fees - a reserve of 50 = 250 reserve = 100 available.
         // Ask for more than available to prove reserve works.
         env(offer(alice, USD1(200), XRP(200)));
@@ -548,7 +548,7 @@ private:
         env(pay(gw, bob, USD(1)));
         env(pay(gw, alice, USD(200)));
 
-        AMM ammAlice(env, alice, USD(150), XRP(150'100));
+        AMM const ammAlice(env, alice, USD(150), XRP(150'100));
         env(offer(bob, XRP(100), USD(0.1)));
 
         BEAST_EXPECT(ammAlice.expectBalances(USD(150.1), XRP(150'000), ammAlice.tokens()));
@@ -601,7 +601,7 @@ private:
 
         env(pay(gw, bob, bob["USD"](2'200)));
 
-        AMM ammBob(env, bob, XRP(1'000), USD(2'200));
+        AMM const ammBob(env, bob, XRP(1'000), USD(2'200));
         // Alice has 350 fees - a reserve of 50 = 250 reserve = 100 available.
         // Ask for more than available to prove reserve works.
         // Taker pays 100 USD for 100 XRP.
@@ -629,7 +629,7 @@ private:
         auto const starting_xrp = XRP(100.1) + reserve(env, 1) + env.current()->fees().base * 2;
         fund(env, gw, {alice, bob}, starting_xrp, {XTS(100), XXX(100)}, Fund::All);
 
-        AMM ammAlice(env, alice, XTS(100), XXX(100));
+        AMM const ammAlice(env, alice, XTS(100), XXX(100));
 
         Json::Value payment;
         payment[jss::secret] = toBase58(generateSeed("bob"));
@@ -677,8 +677,8 @@ private:
             //   o carol has EUR but wants USD.
             // Note that carol's offer must come last.  If carol's offer is
             // placed before AMM is created, then autobridging will not occur.
-            AMM ammAlice(env, alice, XRP(10'000), USD(10'100));
-            AMM ammBob(env, bob, EUR(10'000), XRP(10'100));
+            AMM const ammAlice(env, alice, XRP(10'000), USD(10'100));
+            AMM const ammBob(env, bob, EUR(10'000), XRP(10'100));
 
             // Carol makes an offer that consumes AMM liquidity and
             // fully consumes Carol's offer.
@@ -704,7 +704,7 @@ private:
             // Note that carol's offer must come last.  If carol's offer is
             // placed before AMM and bob's offer are created, then autobridging
             // will not occur.
-            AMM ammAlice(env, alice, XRP(10'000), USD(10'100));
+            AMM const ammAlice(env, alice, XRP(10'000), USD(10'100));
             env(offer(bob, EUR(100), XRP(100)));
             env.close();
 
@@ -734,7 +734,7 @@ private:
             // autobridging will not occur.
             env(offer(alice, XRP(100), USD(100)));
             env.close();
-            AMM ammBob(env, bob, EUR(10'000), XRP(10'100));
+            AMM const ammBob(env, bob, EUR(10'000), XRP(10'100));
 
             // Carol makes an offer that consumes AMM liquidity and
             // fully consumes Carol's offer.
@@ -764,7 +764,7 @@ private:
         {
             Env env{*this, features};
             fund(env, gw, {alice, bob}, {USD(20'000)}, Fund::All);
-            AMM ammBob(env, bob, XRP(20'000), USD(200));
+            AMM const ammBob(env, bob, XRP(20'000), USD(200));
             // alice submits a tfSell | tfFillOrKill offer that does not cross.
             env(offer(alice, USD(2.1), XRP(210), tfSell | tfFillOrKill), ter(killedCode));
 
@@ -774,7 +774,7 @@ private:
         {
             Env env{*this, features};
             fund(env, gw, {alice, bob}, {USD(1'000)}, Fund::All);
-            AMM ammBob(env, bob, XRP(20'000), USD(200));
+            AMM const ammBob(env, bob, XRP(20'000), USD(200));
             // alice submits a tfSell | tfFillOrKill offer that crosses.
             // Even though tfSell is present it doesn't matter this time.
             env(offer(alice, USD(2), XRP(220), tfSell | tfFillOrKill));
@@ -790,7 +790,7 @@ private:
             // returns more than was asked for (because of the tfSell flag).
             Env env{*this, features};
             fund(env, gw, {alice, bob}, {USD(1'000)}, Fund::All);
-            AMM ammBob(env, bob, XRP(20'000), USD(200));
+            AMM const ammBob(env, bob, XRP(20'000), USD(200));
 
             env(offer(alice, USD(10), XRP(1'500), tfSell | tfFillOrKill));
             env.close();
@@ -809,7 +809,7 @@ private:
             // which matches alice's offer quality is ~ 10XRP/0.01996USD.
             Env env{*this, features};
             fund(env, gw, {alice, bob}, {USD(10'000)}, Fund::All);
-            AMM ammBob(env, bob, XRP(5000), USD(10));
+            AMM const ammBob(env, bob, XRP(5000), USD(10));
 
             env(offer(alice, USD(1), XRP(501), tfSell | tfFillOrKill), ter(tecKILLED));
             env.close();
@@ -876,7 +876,7 @@ private:
             //   o carol has EUR but wants USD.
             // Note that Carol's offer must come last.  If Carol's offer is
             // placed before AMM is created, then autobridging will not occur.
-            AMM ammAlice(env, alice, XRP(10'000), USD(10'100));
+            AMM const ammAlice(env, alice, XRP(10'000), USD(10'100));
             env(offer(bob, EUR(100), XRP(100)));
             env.close();
 
@@ -907,7 +907,7 @@ private:
             //   o carol has EUR but wants USD.
             // Note that Carol's offer must come last.  If Carol's offer is
             // placed before AMM is created, then autobridging will not occur.
-            AMM ammAlice(env, alice, XRP(10'000), USD(10'050));
+            AMM const ammAlice(env, alice, XRP(10'000), USD(10'050));
             env(offer(bob, EUR(100), XRP(100)));
             env.close();
 
@@ -953,7 +953,7 @@ private:
             //   o carol has EUR but wants USD.
             // Note that Carol's offer must come last.  If Carol's offer is
             // placed before AMM is created, then autobridging will not occur.
-            AMM ammAlice(env, alice, XRP(10'000), USD(10'100));
+            AMM const ammAlice(env, alice, XRP(10'000), USD(10'100));
             env(offer(bob, EUR(100), XRP(100)));
             env.close();
 
@@ -995,7 +995,7 @@ private:
             //   o carol has EUR but wants USD.
             // Note that Carol's offer must come last.  If Carol's offer is
             // placed before AMM is created, then autobridging will not occur.
-            AMM ammAlice(env, alice, XRP(10'000), USD(10'100));
+            AMM const ammAlice(env, alice, XRP(10'000), USD(10'100));
             env(offer(bob, EUR(100), XRP(100)));
             env.close();
 
@@ -1029,7 +1029,7 @@ private:
 
         env.fund(XRP(30'000) + f, alice, bob);
         env.close();
-        AMM ammBob(env, bob, XRP(10'000), USD_bob(10'100));
+        AMM const ammBob(env, bob, XRP(10'000), USD_bob(10'100));
 
         env(offer(alice, USD_bob(100), XRP(100)));
         env.close();
@@ -1086,7 +1086,7 @@ private:
             BEAST_EXPECT(expectHolding(env, dan, A_BUX(none)));
             BEAST_EXPECT(expectHolding(env, dan, D_BUX(none)));
 
-            AMM ammBob(env, bob, A_BUX(30), D_BUX(30));
+            AMM const ammBob(env, bob, A_BUX(30), D_BUX(30));
 
             env(trust(ann, D_BUX(100)));
             env.close();
@@ -1143,7 +1143,7 @@ private:
         env(pay(bob, carol, B_BUX(400)));
         env(pay(ann, carol, A_BUX(400)));
 
-        AMM ammCarol(env, carol, A_BUX(300), B_BUX(330));
+        AMM const ammCarol(env, carol, A_BUX(300), B_BUX(330));
 
         // cam puts an offer on the books that her upcoming offer could cross.
         // But this offer should be deleted, not crossed, by her upcoming
@@ -1215,7 +1215,7 @@ private:
         env(pay(gw, alice, USD(1'000)));
         env.close();
         // Alice is able to create AMM since the GW has authorized her
-        AMM ammAlice(env, alice, USD(1'000), XRP(1'050));
+        AMM const ammAlice(env, alice, USD(1'000), XRP(1'050));
 
         // Set up authorized trust line for AMM.
         env(trust(gw, STAmount{Issue{USD.currency, ammAlice.ammAccount()}, 10}),
@@ -1250,7 +1250,7 @@ private:
 
         // Alice doesn't have the funds
         {
-            AMM ammAlice(env, alice, USD(1'000), XRP(1'000), ter(tecUNFUNDED_AMM));
+            AMM const ammAlice(env, alice, USD(1'000), XRP(1'000), ter(tecUNFUNDED_AMM));
         }
 
         env(fset(gw, asfRequireAuth));
@@ -1267,7 +1267,7 @@ private:
 
         // Alice should not be able to create AMM without authorization.
         {
-            AMM ammAlice(env, alice, USD(1'000), XRP(1'000), ter(tecNO_LINE));
+            AMM const ammAlice(env, alice, USD(1'000), XRP(1'000), ter(tecNO_LINE));
         }
 
         // Set up a trust line for Alice, but don't authorize it. Alice
@@ -1276,7 +1276,7 @@ private:
         env.close();
 
         {
-            AMM ammAlice(env, alice, USD(1'000), XRP(1'000), ter(tecNO_AUTH));
+            AMM const ammAlice(env, alice, USD(1'000), XRP(1'000), ter(tecNO_AUTH));
         }
 
         // Finally, set up an authorized trust line for Alice. Now Alice's
@@ -1286,7 +1286,7 @@ private:
         env(pay(gw, alice, USD(1'000)));
         env.close();
 
-        AMM ammAlice(env, alice, USD(1'000), XRP(1'050));
+        AMM const ammAlice(env, alice, USD(1'000), XRP(1'050));
 
         // Set up authorized trust line for AMM.
         env(trust(gw, STAmount{Issue{USD.currency, ammAlice.ammAccount()}, 10}),
@@ -1349,7 +1349,7 @@ private:
         env.fund(XRP(100'000'250), alice);
         fund(env, gw, {carol, bob}, {USD(100)}, Fund::All);
         fund(env, gw, {alice}, {USD(100)}, Fund::IOUOnly);
-        AMM ammCarol(env, carol, XRP(100), USD(100));
+        AMM const ammCarol(env, carol, XRP(100), USD(100));
 
         STPathSet st;
         STAmount sa;
@@ -1383,7 +1383,7 @@ private:
         env.trust(AUD(2'000), bob, carol);
         env(pay(gw, carol, AUD(51)));
         env.close();
-        AMM ammCarol(env, carol, XRP(40), AUD(51));
+        AMM const ammCarol(env, carol, XRP(40), AUD(51));
         env(pay(alice, bob, AUD(10)), sendmax(XRP(100)), paths(XRP));
         env.close();
         // AMM offer is 51.282052XRP/11AUD, 11AUD/1.1 = 10AUD to bob
@@ -1404,7 +1404,7 @@ private:
             // XRP -> IOU receive max
             Env env = pathTestEnv();
             fund(env, gw, {alice, bob, charlie}, {USD(11)}, Fund::All);
-            AMM ammCharlie(env, charlie, XRP(10), USD(11));
+            AMM const ammCharlie(env, charlie, XRP(10), USD(11));
             auto [st, sa, da] = find_paths(env, alice, bob, USD(-1), XRP(1).value());
             BEAST_EXPECT(sa == XRP(1));
             BEAST_EXPECT(equal(da, USD(1)));
@@ -1420,7 +1420,7 @@ private:
             // IOU -> XRP receive max
             Env env = pathTestEnv();
             fund(env, gw, {alice, bob, charlie}, {USD(11)}, Fund::All);
-            AMM ammCharlie(env, charlie, XRP(11), USD(10));
+            AMM const ammCharlie(env, charlie, XRP(11), USD(10));
             env.close();
             auto [st, sa, da] = find_paths(env, alice, bob, drops(-1), USD(1).value());
             BEAST_EXPECT(sa == USD(1));
@@ -1441,13 +1441,13 @@ private:
         testcase("Path Find: XRP -> XRP and XRP -> IOU");
         using namespace jtx;
         Env env = pathTestEnv();
-        Account A1{"A1"};
-        Account A2{"A2"};
-        Account A3{"A3"};
-        Account G1{"G1"};
-        Account G2{"G2"};
-        Account G3{"G3"};
-        Account M1{"M1"};
+        Account const A1{"A1"};
+        Account const A2{"A2"};
+        Account const A3{"A3"};
+        Account const G1{"G1"};
+        Account const G2{"G2"};
+        Account const G3{"G3"};
+        Account const M1{"M1"};
 
         env.fund(XRP(100'000), A1);
         env.fund(XRP(10'000), A2);
@@ -1472,8 +1472,8 @@ private:
         env(pay(G3, M1, G3["ABC"](25'000)));
         env.close();
 
-        AMM ammM1_G1_G2(env, M1, G1["XYZ"](1'000), G2["XYZ"](1'000));
-        AMM ammM1_XRP_G3(env, M1, XRP(10'000), G3["ABC"](1'000));
+        AMM const ammM1_G1_G2(env, M1, G1["XYZ"](1'000), G2["XYZ"](1'000));
+        AMM const ammM1_XRP_G3(env, M1, XRP(10'000), G3["ABC"](1'000));
 
         STPathSet st;
         STAmount sa, da;
@@ -1526,10 +1526,10 @@ private:
         testcase("Path Find: non-XRP -> XRP");
         using namespace jtx;
         Env env = pathTestEnv();
-        Account A1{"A1"};
-        Account A2{"A2"};
-        Account G3{"G3"};
-        Account M1{"M1"};
+        Account const A1{"A1"};
+        Account const A2{"A2"};
+        Account const G3{"G3"};
+        Account const M1{"M1"};
 
         env.fund(XRP(1'000), A1, A2, G3);
         env.fund(XRP(11'000), M1);
@@ -1544,7 +1544,7 @@ private:
         env(pay(G3, M1, G3["ABC"](1'200)));
         env.close();
 
-        AMM ammM1(env, M1, G3["ABC"](1'000), XRP(10'010));
+        AMM const ammM1(env, M1, G3["ABC"](1'000), XRP(10'010));
 
         STPathSet st;
         STAmount sa, da;
@@ -1562,16 +1562,16 @@ private:
         testcase("Path Find: non-XRP -> non-XRP, same currency");
         using namespace jtx;
         Env env = pathTestEnv();
-        Account A1{"A1"};
-        Account A2{"A2"};
-        Account A3{"A3"};
-        Account A4{"A4"};
-        Account G1{"G1"};
-        Account G2{"G2"};
-        Account G3{"G3"};
-        Account G4{"G4"};
-        Account M1{"M1"};
-        Account M2{"M2"};
+        Account const A1{"A1"};
+        Account const A2{"A2"};
+        Account const A3{"A3"};
+        Account const A4{"A4"};
+        Account const G1{"G1"};
+        Account const G2{"G2"};
+        Account const G3{"G3"};
+        Account const G4{"G4"};
+        Account const M1{"M1"};
+        Account const M2{"M2"};
 
         env.fund(XRP(1'000), A1, A2, A3, G1, G2, G3, G4);
         env.fund(XRP(10'000), A4);
@@ -1596,9 +1596,9 @@ private:
         env(pay(G2, M2, G2["HKD"](5'000)));
         env.close();
 
-        AMM ammM1(env, M1, G1["HKD"](1'010), G2["HKD"](1'000));
-        AMM ammM2XRP_G2(env, M2, XRP(10'000), G2["HKD"](1'010));
-        AMM ammM2G1_XRP(env, M2, G1["HKD"](1'010), XRP(10'000));
+        AMM const ammM1(env, M1, G1["HKD"](1'010), G2["HKD"](1'000));
+        AMM const ammM2XRP_G2(env, M2, XRP(10'000), G2["HKD"](1'010));
+        AMM const ammM2G1_XRP(env, M2, G1["HKD"](1'010), XRP(10'000));
 
         STPathSet st;
         STAmount sa, da;
@@ -1692,12 +1692,12 @@ private:
         testcase("Path Find: non-XRP -> non-XRP, same currency");
         using namespace jtx;
         Env env = pathTestEnv();
-        Account A1{"A1"};
-        Account A2{"A2"};
-        Account A3{"A3"};
-        Account G1{"G1"};
-        Account G2{"G2"};
-        Account M1{"M1"};
+        Account const A1{"A1"};
+        Account const A2{"A2"};
+        Account const A3{"A3"};
+        Account const G1{"G1"};
+        Account const G2{"G2"};
+        Account const M1{"M1"};
 
         env.fund(XRP(11'000), M1);
         env.fund(XRP(1'000), A1, A2, A3, G1, G2);
@@ -1716,7 +1716,7 @@ private:
         env(pay(G2, M1, G2["HKD"](5'000)));
         env.close();
 
-        AMM ammM1(env, M1, G1["HKD"](1'010), G2["HKD"](1'000));
+        AMM const ammM1(env, M1, G1["HKD"](1'010), G2["HKD"](1'000));
 
         // E) Gateway to user
         //  Source -> OB -> AC -> Destination
@@ -1759,7 +1759,7 @@ private:
         // tecPATH_DRY, but the entire path should not be marked as dry.
         // This is the second error case to test (when flowV1 is used).
         env(offer(bob, EUR(50), XRP(50)));
-        AMM ammBob(env, bob, ammXrpPool, USD(150));
+        AMM const ammBob(env, bob, ammXrpPool, USD(150));
 
         env(pay(alice, carol, USD(1'000'000)),
             path(~XRP, ~USD),
@@ -1783,7 +1783,7 @@ private:
 
             fund(env, gw, {alice, bob, carol}, XRP(10'000), {BTC(100), USD(150)}, Fund::All);
 
-            AMM ammBob(env, bob, BTC(100), USD(150));
+            AMM const ammBob(env, bob, BTC(100), USD(150));
 
             env(pay(alice, carol, USD(50)), path(~USD), sendmax(BTC(50)));
 
@@ -1799,8 +1799,8 @@ private:
 
             fund(env, gw, {alice, carol, bob}, XRP(10'000), {BTC(100), USD(150)}, Fund::All);
 
-            AMM ammBobBTC_XRP(env, bob, BTC(100), XRP(150));
-            AMM ammBobXRP_USD(env, bob, XRP(100), USD(150));
+            AMM const ammBobBTC_XRP(env, bob, BTC(100), XRP(150));
+            AMM const ammBobXRP_USD(env, bob, XRP(100), USD(150));
 
             env(pay(alice, carol, USD(50)), path(~XRP, ~USD), sendmax(BTC(50)));
 
@@ -1817,7 +1817,7 @@ private:
 
             fund(env, gw, {alice, carol, bob}, XRP(10'000), {USD(150)}, Fund::All);
 
-            AMM ammBob(env, bob, XRP(100), USD(150));
+            AMM const ammBob(env, bob, XRP(100), USD(150));
 
             env(pay(alice, carol, USD(50)), path(~USD), sendmax(XRP(50)));
 
@@ -1833,7 +1833,7 @@ private:
 
             fund(env, gw, {alice, carol, bob}, XRP(10'000), {USD(100)}, Fund::All);
 
-            AMM ammBob(env, bob, USD(100), XRP(150));
+            AMM const ammBob(env, bob, USD(100), XRP(150));
 
             env(pay(alice, carol, XRP(50)), path(~XRP), sendmax(USD(50)));
 
@@ -1863,7 +1863,7 @@ private:
             env(offer(bob, BTC(50), USD(50)));
             env(offer(bob, BTC(40), EUR(50)));
             env.close();
-            AMM ammBob(env, bob, EUR(100), USD(150));
+            AMM const ammBob(env, bob, EUR(100), USD(150));
 
             // unfund offer
             env(pay(bob, gw, EUR(50)));
@@ -1914,7 +1914,7 @@ private:
             env.close();
 
             // This is multiplath, which generates limited # of offers
-            AMM ammBobBTC_USD(env, bob, BTC(50), USD(50));
+            AMM const ammBobBTC_USD(env, bob, BTC(50), USD(50));
             env(offer(bob, BTC(60), EUR(50)));
             env(offer(carol, BTC(1'000), EUR(1)));
             env(offer(bob, EUR(50), USD(50)));
@@ -1928,7 +1928,7 @@ private:
 
             auto flowJournal = env.app().getJournal("Flow");
             auto const flowResult = [&] {
-                STAmount deliver(USD(51));
+                STAmount const deliver(USD(51));
                 STAmount smax(BTC(61));
                 PaymentSandbox sb(env.current().get(), tapNONE);
                 STPathSet paths;
@@ -1941,10 +1941,10 @@ private:
                 };
                 {
                     // BTC -> USD
-                    STPath p1({IPE(USD.issue())});
+                    STPath const p1({IPE(USD.issue())});
                     paths.push_back(p1);
                     // BTC -> EUR -> USD
-                    STPath p2({IPE(EUR.issue()), IPE(USD.issue())});
+                    STPath const p2({IPE(EUR.issue()), IPE(USD.issue())});
                     paths.push_back(p2);
                 }
 
@@ -2007,7 +2007,7 @@ private:
             env.close();
 
             // env(offer(bob, USD(1), drops(2)), txflags(tfPassive));
-            AMM ammBob(env, bob, USD(8), XRPAmount{21});
+            AMM const ammBob(env, bob, USD(8), XRPAmount{21});
             env(offer(bob, drops(1), EUR(1'000)), txflags(tfPassive));
 
             env(pay(alice, carol, EUR(1)),
@@ -2034,7 +2034,7 @@ private:
             env(rate(gw, 1.25));
             env.close();
 
-            AMM amm(env, bob, GBP(1'000), USD(1'000));
+            AMM const amm(env, bob, GBP(1'000), USD(1'000));
 
             env(pay(alice, carol, USD(100)),
                 path(~USD),
@@ -2075,7 +2075,7 @@ private:
             env(offer(ed, GBP(1'000), EUR(1'000)), txflags(tfPassive));
             env.close();
 
-            AMM amm(env, bob, EUR(1'000), USD(1'000));
+            AMM const amm(env, bob, EUR(1'000), USD(1'000));
 
             env(pay(alice, carol, USD(100)),
                 path(~EUR, ~USD),
@@ -2109,8 +2109,8 @@ private:
             env(rate(gw, 1.25));
             env.close();
 
-            AMM amm1(env, bob, GBP(1'000), EUR(1'000));
-            AMM amm2(env, ed, EUR(1'000), USD(1'000));
+            AMM const amm1(env, bob, GBP(1'000), EUR(1'000));
+            AMM const amm2(env, ed, EUR(1'000), USD(1'000));
 
             env(pay(alice, carol, USD(100)),
                 path(~EUR, ~USD),
@@ -2159,7 +2159,7 @@ private:
             env(rate(gw, 1.25));
             env.close();
 
-            AMM amm(env, bob, USD(1'000), EUR(1'100));
+            AMM const amm(env, bob, USD(1'000), EUR(1'100));
             env(offer(alice, EUR(100), USD(100)));
             env.close();
 
@@ -2178,7 +2178,7 @@ private:
             env(rate(gw, 1.25));
             env.close();
 
-            AMM amm(env, bob, GBP(1'000), USD(1'000));
+            AMM const amm(env, bob, GBP(1'000), USD(1'000));
 
             // requested quality limit is 100USD/178.58GBP = 0.55997
             // trade quality is 100USD/178.5714 = 0.55999
@@ -2209,7 +2209,7 @@ private:
             env(rate(gw, 1.25));
             env.close();
 
-            AMM amm(env, bob, GBP(1'000), USD(1'200));
+            AMM const amm(env, bob, GBP(1'000), USD(1'200));
 
             // requested quality limit is 90USD/120GBP = 0.75
             // trade quality is 22.5USD/30GBP = 0.75
@@ -2259,7 +2259,7 @@ private:
             env(offer(ed, GBP(1'000), EUR(1'000)), txflags(tfPassive));
             env.close();
 
-            AMM amm(env, bob, EUR(1'000), USD(1'400));
+            AMM const amm(env, bob, EUR(1'000), USD(1'400));
 
             // requested quality limit is 95USD/140GBP = 0.6785
             // trade quality is 59.7321USD/88.0262GBP = 0.6785
@@ -2340,7 +2340,7 @@ private:
             env(rate(gw, 1.25));
             env.close();
 
-            AMM amm(env, bob, GBP(1'000), EUR(1'000));
+            AMM const amm(env, bob, GBP(1'000), EUR(1'000));
 
             env(offer(ed, EUR(1'000), USD(1'400)), txflags(tfPassive));
             env.close();
@@ -2412,8 +2412,8 @@ private:
             env(rate(gw, 1.25));
             env.close();
 
-            AMM amm1(env, bob, GBP(1'000), EUR(1'000));
-            AMM amm2(env, ed, EUR(1'000), USD(1'400));
+            AMM const amm1(env, bob, GBP(1'000), EUR(1'000));
+            AMM const amm2(env, ed, EUR(1'000), USD(1'400));
 
             // requested quality limit is 90USD/145GBP = 0.6206
             // trade quality is 66.7432USD/107.5308GBP = 0.6206
@@ -2474,8 +2474,8 @@ private:
             env(rate(gw, 1.25));
             env.close();
 
-            AMM amm1(env, alice, GBP(1'000), EUR(1'000));
-            AMM amm2(env, bob, EUR(1'000), USD(1'400));
+            AMM const amm1(env, alice, GBP(1'000), EUR(1'000));
+            AMM const amm2(env, bob, EUR(1'000), USD(1'400));
 
             // requested quality limit is 90USD/120GBP = 0.75
             // trade quality is 81.1111USD/108.1481GBP = 0.75
@@ -2534,7 +2534,7 @@ private:
 
             fund(env, gw, {alice, bob, carol}, XRP(10'000), {USD(2'000)});
 
-            AMM ammBob(env, bob, XRP(1'000), USD(1'050));
+            AMM const ammBob(env, bob, XRP(1'000), USD(1'050));
             env(offer(bob, XRP(100), USD(50)));
 
             env(pay(alice, carol, USD(100)),
@@ -2561,8 +2561,8 @@ private:
             // fails with tecPATH_DRY.
             fund(env, gw, {alice, bob}, XRP(10'000), {USD(200), EUR(200)}, Fund::All);
 
-            AMM ammAliceXRP_USD(env, alice, XRP(100), USD(101));
-            AMM ammAliceXRP_EUR(env, alice, XRP(100), EUR(101));
+            AMM const ammAliceXRP_USD(env, alice, XRP(100), USD(101));
+            AMM const ammAliceXRP_EUR(env, alice, XRP(100), EUR(101));
             env.close();
 
             TER const expectedTer = TER{temBAD_PATH_LOOP};
@@ -2579,8 +2579,8 @@ private:
             // with tecPATH_DRY.
             fund(env, gw, {alice, bob}, XRP(10'000), {USD(200), EUR(200)}, Fund::All);
 
-            AMM ammAliceXRP_USD(env, alice, XRP(100), USD(100));
-            AMM ammAliceXRP_EUR(env, alice, XRP(100), EUR(100));
+            AMM const ammAliceXRP_USD(env, alice, XRP(100), USD(100));
+            AMM const ammAliceXRP_EUR(env, alice, XRP(100), EUR(100));
             // EUR -> //XRP -> //USD ->XRP
             env(pay(alice, bob, XRP(1)),
                 path(~XRP, ~USD, ~XRP),
@@ -2597,9 +2597,9 @@ private:
             // with tecPATH_DRY.
             fund(env, gw, {alice, bob}, XRP(10'000), {USD(200), EUR(200), JPY(200)}, Fund::All);
 
-            AMM ammAliceXRP_USD(env, alice, XRP(100), USD(100));
-            AMM ammAliceXRP_EUR(env, alice, XRP(100), EUR(100));
-            AMM ammAliceXRP_JPY(env, alice, XRP(100), JPY(100));
+            AMM const ammAliceXRP_USD(env, alice, XRP(100), USD(100));
+            AMM const ammAliceXRP_EUR(env, alice, XRP(100), EUR(100));
+            AMM const ammAliceXRP_JPY(env, alice, XRP(100), JPY(100));
 
             env(pay(alice, bob, JPY(1)),
                 path(~XRP, ~EUR, ~XRP, ~JPY),
@@ -2628,7 +2628,7 @@ private:
         env(pay(gw, dan, USD(1)));
         n_offers(env, 2'000, bob, XRP(1), USD(1));
         n_offers(env, 1, dan, XRP(1), USD(1));
-        AMM ammEd(env, ed, XRP(9), USD(11));
+        AMM const ammEd(env, ed, XRP(9), USD(11));
 
         // Alice offers to buy 1000 XRP for 1000 USD. She takes Bob's first
         // offer, removes 999 more as unfunded, then hits the step limit.
@@ -2687,7 +2687,7 @@ private:
                 txflags(tfPartialPayment),
                 ter(temBAD_AMOUNT));
             env(pay(gw, carol, USD(50)));
-            AMM ammCarol(env, carol, XRP(10), USD(15));
+            AMM const ammCarol(env, carol, XRP(10), USD(15));
             env(pay(alice, bob, USD(10)),
                 paths(XRP),
                 deliver_min(USD(7)),
@@ -2703,7 +2703,7 @@ private:
             fund(env, gw, {alice, bob}, XRP(10'000));
             env.trust(USD(1'100), alice, bob);
             env(pay(gw, bob, USD(1'100)));
-            AMM ammBob(env, bob, XRP(1'000), USD(1'100));
+            AMM const ammBob(env, bob, XRP(1'000), USD(1'100));
             env(pay(alice, alice, USD(10'000)),
                 paths(XRP),
                 deliver_min(USD(100)),
@@ -2717,7 +2717,7 @@ private:
             fund(env, gw, {alice, bob, carol}, XRP(10'000));
             env.trust(USD(1'200), bob, carol);
             env(pay(gw, bob, USD(1'200)));
-            AMM ammBob(env, bob, XRP(5'500), USD(1'200));
+            AMM const ammBob(env, bob, XRP(5'500), USD(1'200));
             env(pay(alice, carol, USD(10'000)),
                 paths(XRP),
                 deliver_min(USD(200)),
@@ -2743,7 +2743,7 @@ private:
             env(pay(gw, dan, USD(1'100)));
             env(offer(bob, XRP(100), USD(100)));
             env(offer(bob, XRP(1'000), USD(100)));
-            AMM ammDan(env, dan, XRP(1'000), USD(1'100));
+            AMM const ammDan(env, dan, XRP(1'000), USD(1'100));
             if (!features[fixAMMv1_1])
             {
                 env(pay(alice, carol, USD(10'000)),
@@ -2794,7 +2794,7 @@ private:
         env(pay(gw, alice, USD(500)));
         env.close();
 
-        AMM ammAlice(env, alice, XRP(100), USD(140));
+        AMM const ammAlice(env, alice, XRP(100), USD(140));
 
         // becky pays herself USD (10) by consuming part of alice's offer.
         // Make sure the payment works if PaymentAuth is not involved.
@@ -2829,7 +2829,7 @@ private:
 
         env(pay(gw, alice, USD(150)));
         env(pay(gw, carol, USD(150)));
-        AMM ammCarol(env, carol, USD(100), XRPAmount(101));
+        AMM const ammCarol(env, carol, USD(100), XRPAmount(101));
 
         // Make sure bob's trust line is all set up so he can receive USD.
         env(pay(alice, bob, USD(50)));
@@ -2926,7 +2926,7 @@ private:
         env(pay(G1, alice, G1["USD"](205)));
         env.close();
 
-        AMM ammAlice(env, alice, XRP(500), G1["USD"](105));
+        AMM const ammAlice(env, alice, XRP(500), G1["USD"](105));
 
         {
             auto lines = getAccountLines(env, bob);
@@ -3040,11 +3040,11 @@ private:
         using namespace test::jtx;
         Env env(*this, features);
 
-        Account G1{"G1"};
-        Account A1{"A1"};
-        Account A2{"A2"};
-        Account A3{"A3"};
-        Account A4{"A4"};
+        Account const G1{"G1"};
+        Account const A1{"A1"};
+        Account const A2{"A2"};
+        Account const A3{"A3"};
+        Account const A4{"A4"};
 
         env.fund(XRP(12'000), G1);
         env.fund(XRP(1'000), A1);
@@ -3063,7 +3063,7 @@ private:
         env(pay(G1, A4, G1["BTC"](100)));
         env.close();
 
-        AMM ammG1(env, G1, XRP(10'000), G1["USD"](100));
+        AMM const ammG1(env, G1, XRP(10'000), G1["USD"](100));
         env(offer(A1, XRP(10'000), G1["USD"](100)), txflags(tfPassive));
         env(offer(A2, G1["USD"](100), XRP(10'000)), txflags(tfPassive));
         env.close();
@@ -3129,7 +3129,7 @@ private:
             env.require(nflags(G1, asfNoFreeze));
 
             //    test: assets can't be bought on the market
-            AMM ammA3(env, A3, G1["BTC"](1), XRP(1), ter(tecFROZEN));
+            AMM const ammA3(env, A3, G1["BTC"](1), XRP(1), ter(tecFROZEN));
 
             //    test: assets can't be sold on the market
             // AMM is bidirectional
@@ -3170,10 +3170,10 @@ private:
         using namespace test::jtx;
         Env env(*this, features);
 
-        Account G1{"G1"};
-        Account A2{"A2"};
-        Account A3{"A3"};
-        Account A4{"A4"};
+        Account const G1{"G1"};
+        Account const A2{"A2"};
+        Account const A3{"A3"};
+        Account const A4{"A4"};
 
         env.fund(XRP(2'000), G1, A3, A4);
         env.fund(XRP(2'000), A2);
@@ -3188,7 +3188,7 @@ private:
         env(pay(G1, A4, G1["USD"](2'001)));
         env.close();
 
-        AMM ammA3(env, A3, XRP(1'000), G1["USD"](1'001));
+        AMM const ammA3(env, A3, XRP(1'000), G1["USD"](1'001));
 
         // removal after successful payment
         //    test: make a payment with partially consuming offer
@@ -3299,8 +3299,8 @@ private:
 
         fund(env, gw, {alice, bob, carol}, XRP(10'000), {USD(2'000), EUR(1'000)});
 
-        AMM bobXRP_USD(env, bob, XRP(1'000), USD(1'000));
-        AMM bobUSD_EUR(env, bob, USD(1'000), EUR(1'000));
+        AMM const bobXRP_USD(env, bob, XRP(1'000), USD(1'000));
+        AMM const bobUSD_EUR(env, bob, USD(1'000), EUR(1'000));
 
         // payment path: XRP -> XRP/USD -> USD/EUR -> EUR/USD
         env(pay(alice, carol, USD(100)),
@@ -3327,10 +3327,10 @@ private:
             fund(env, bob, {alice, gw}, {BobUSD(100), BobEUR(100)}, Fund::IOUOnly);
             env.close();
 
-            AMM ammBobXRP_USD(env, bob, XRP(100), BobUSD(100));
+            AMM const ammBobXRP_USD(env, bob, XRP(100), BobUSD(100));
             env(offer(gw, XRP(100), USD(100)), txflags(tfPassive));
 
-            AMM ammBobUSD_EUR(env, bob, BobUSD(100), BobEUR(100));
+            AMM const ammBobUSD_EUR(env, bob, BobUSD(100), BobEUR(100));
             env(offer(gw, USD(100), EUR(100)), txflags(tfPassive));
 
             Path const p = [&] {
@@ -3340,7 +3340,7 @@ private:
                 return result;
             }();
 
-            PathSet paths(p);
+            PathSet const paths(p);
 
             env(pay(alice, alice, EUR(1)),
                 json(paths.json()),
@@ -3354,7 +3354,7 @@ private:
 
             fund(env, gw, {alice, bob, carol}, XRP(10'000), {USD(100)});
 
-            AMM ammBob(env, bob, XRP(100), USD(100));
+            AMM const ammBob(env, bob, XRP(100), USD(100));
 
             // payment path: XRP -> XRP/USD -> USD/XRP
             env(pay(alice, carol, XRP(100)),
@@ -3368,7 +3368,7 @@ private:
 
             fund(env, gw, {alice, bob, carol}, XRP(10'000), {USD(100)});
 
-            AMM ammBob(env, bob, XRP(100), USD(100));
+            AMM const ammBob(env, bob, XRP(100), USD(100));
 
             // payment path: XRP -> XRP/USD -> USD/XRP
             env(pay(alice, carol, XRP(100)),
@@ -3398,7 +3398,7 @@ private:
             env(pay(gw, alice, USD(100)));
             env.close();
 
-            AMM ammBob(env, bob, XRP(100), USD(100));
+            AMM const ammBob(env, bob, XRP(100), USD(100));
 
             // payment path: USD -> USD/XRP -> XRP/USD
             env(pay(alice, carol, USD(100)),
@@ -3421,9 +3421,9 @@ private:
             env(pay(gw, bob, EUR(200)));
             env(pay(gw, bob, CNY(100)));
 
-            AMM ammBobXRP_USD(env, bob, XRP(100), USD(100));
-            AMM ammBobUSD_EUR(env, bob, USD(100), EUR(100));
-            AMM ammBobEUR_CNY(env, bob, EUR(100), CNY(100));
+            AMM const ammBobXRP_USD(env, bob, XRP(100), USD(100));
+            AMM const ammBobUSD_EUR(env, bob, USD(100), EUR(100));
+            AMM const ammBobEUR_CNY(env, bob, EUR(100), CNY(100));
 
             // payment path: XRP->XRP/USD->USD/EUR->USD/CNY
             env(pay(alice, carol, CNY(100)),
diff --git a/src/test/app/AMM_test.cpp b/src/test/app/AMM_test.cpp
index 704ced2b86..c19eb971a7 100644
--- a/src/test/app/AMM_test.cpp
+++ b/src/test/app/AMM_test.cpp
@@ -87,7 +87,7 @@ private:
             env(rate(gw, 1.25));
             env.close();
             // no transfer fee on create
-            AMM ammAlice(env, alice, USD(20'000), BTC(0.5));
+            AMM const ammAlice(env, alice, USD(20'000), BTC(0.5));
             BEAST_EXPECT(ammAlice.expectBalances(USD(20'000), BTC(0.5), IOUAmount{100, 0}));
             BEAST_EXPECT(expectHolding(env, alice, USD(0)));
             BEAST_EXPECT(expectHolding(env, alice, BTC(0)));
@@ -104,7 +104,7 @@ private:
             env.close();
             env(pay(gw, alice, USD(10'000)));
             env.close();
-            AMM ammAlice(env, alice, XRP(10'000), USD(10'000));
+            AMM const ammAlice(env, alice, XRP(10'000), USD(10'000));
         }
 
         // Cleared global freeze
@@ -118,10 +118,10 @@ private:
             env.close();
             env(fset(gw, asfGlobalFreeze));
             env.close();
-            AMM ammAliceFail(env, alice, XRP(10'000), USD(10'000), ter(tecFROZEN));
+            AMM const ammAliceFail(env, alice, XRP(10'000), USD(10'000), ter(tecFROZEN));
             env(fclear(gw, asfGlobalFreeze));
             env.close();
-            AMM ammAlice(env, alice, XRP(10'000), USD(10'000));
+            AMM const ammAlice(env, alice, XRP(10'000), USD(10'000));
         }
 
         // Trading fee
@@ -153,7 +153,7 @@ private:
         {
             Env env{*this};
             fund(env, gw, {alice}, {USD(30'000)}, Fund::All);
-            AMM ammAlice(env, alice, XRP(10'000), XRP(10'000), ter(temBAD_AMM_TOKENS));
+            AMM const ammAlice(env, alice, XRP(10'000), XRP(10'000), ter(temBAD_AMM_TOKENS));
             BEAST_EXPECT(!ammAlice.ammExists());
         }
 
@@ -161,7 +161,7 @@ private:
         {
             Env env{*this};
             fund(env, gw, {alice}, {USD(30'000)}, Fund::All);
-            AMM ammAlice(env, alice, USD(10'000), USD(10'000), ter(temBAD_AMM_TOKENS));
+            AMM const ammAlice(env, alice, USD(10'000), USD(10'000), ter(temBAD_AMM_TOKENS));
             BEAST_EXPECT(!ammAlice.ammExists());
         }
 
@@ -169,13 +169,13 @@ private:
         {
             Env env{*this};
             fund(env, gw, {alice}, {USD(30'000)}, Fund::All);
-            AMM ammAlice(env, alice, XRP(0), USD(10'000), ter(temBAD_AMOUNT));
+            AMM const ammAlice(env, alice, XRP(0), USD(10'000), ter(temBAD_AMOUNT));
             BEAST_EXPECT(!ammAlice.ammExists());
-            AMM ammAlice1(env, alice, XRP(10'000), USD(0), ter(temBAD_AMOUNT));
+            AMM const ammAlice1(env, alice, XRP(10'000), USD(0), ter(temBAD_AMOUNT));
             BEAST_EXPECT(!ammAlice1.ammExists());
-            AMM ammAlice2(env, alice, XRP(10'000), USD(-10'000), ter(temBAD_AMOUNT));
+            AMM const ammAlice2(env, alice, XRP(10'000), USD(-10'000), ter(temBAD_AMOUNT));
             BEAST_EXPECT(!ammAlice2.ammExists());
-            AMM ammAlice3(env, alice, XRP(-10'000), USD(10'000), ter(temBAD_AMOUNT));
+            AMM const ammAlice3(env, alice, XRP(-10'000), USD(10'000), ter(temBAD_AMOUNT));
             BEAST_EXPECT(!ammAlice3.ammExists());
         }
 
@@ -183,7 +183,7 @@ private:
         {
             Env env{*this};
             fund(env, gw, {alice}, {USD(30'000)}, Fund::All);
-            AMM ammAlice(env, alice, XRP(10'000), BAD(10'000), ter(temBAD_CURRENCY));
+            AMM const ammAlice(env, alice, XRP(10'000), BAD(10'000), ter(temBAD_CURRENCY));
             BEAST_EXPECT(!ammAlice.ammExists());
         }
 
@@ -191,7 +191,7 @@ private:
         {
             Env env{*this};
             fund(env, gw, {alice}, {USD(30'000)}, Fund::All);
-            AMM ammAlice(env, alice, XRP(10'000), USD(40'000), ter(tecUNFUNDED_AMM));
+            AMM const ammAlice(env, alice, XRP(10'000), USD(40'000), ter(tecUNFUNDED_AMM));
             BEAST_EXPECT(!ammAlice.ammExists());
         }
 
@@ -199,7 +199,7 @@ private:
         {
             Env env{*this};
             fund(env, gw, {alice}, {USD(30'000)}, Fund::All);
-            AMM ammAlice(env, alice, XRP(40'000), USD(10'000), ter(tecUNFUNDED_AMM));
+            AMM const ammAlice(env, alice, XRP(40'000), USD(10'000), ter(tecUNFUNDED_AMM));
             BEAST_EXPECT(!ammAlice.ammExists());
         }
 
@@ -207,7 +207,7 @@ private:
         {
             Env env{*this};
             fund(env, gw, {alice}, {USD(30'000)}, Fund::All);
-            AMM ammAlice(
+            AMM const ammAlice(
                 env,
                 alice,
                 XRP(10'000),
@@ -224,14 +224,14 @@ private:
 
         // AMM already exists
         testAMM([&](AMM& ammAlice, Env& env) {
-            AMM ammCarol(env, carol, XRP(10'000), USD(10'000), ter(tecDUPLICATE));
+            AMM const ammCarol(env, carol, XRP(10'000), USD(10'000), ter(tecDUPLICATE));
         });
 
         // Invalid flags
         {
             Env env{*this};
             fund(env, gw, {alice}, {USD(30'000)}, Fund::All);
-            AMM ammAlice(
+            AMM const ammAlice(
                 env,
                 alice,
                 XRP(10'000),
@@ -249,9 +249,9 @@ private:
         // Invalid Account
         {
             Env env{*this};
-            Account bad("bad");
+            Account const bad("bad");
             env.memoize(bad);
-            AMM ammAlice(
+            AMM const ammAlice(
                 env,
                 bad,
                 XRP(10'000),
@@ -275,7 +275,7 @@ private:
             env.close();
             env(trust(gw, alice["USD"](30'000)));
             env.close();
-            AMM ammAlice(env, alice, XRP(10'000), USD(10'000), ter(tecNO_AUTH));
+            AMM const ammAlice(env, alice, XRP(10'000), USD(10'000), ter(tecNO_AUTH));
             BEAST_EXPECT(!ammAlice.ammExists());
         }
 
@@ -288,7 +288,7 @@ private:
             env.close();
             env(trust(gw, alice["USD"](30'000)));
             env.close();
-            AMM ammAlice(env, alice, XRP(10'000), USD(10'000), ter(tecFROZEN));
+            AMM const ammAlice(env, alice, XRP(10'000), USD(10'000), ter(tecFROZEN));
             BEAST_EXPECT(!ammAlice.ammExists());
         }
 
@@ -301,7 +301,7 @@ private:
             env.close();
             env(trust(gw, alice["USD"](0), tfSetFreeze));
             env.close();
-            AMM ammAlice(env, alice, XRP(10'000), USD(10'000), ter(tecFROZEN));
+            AMM const ammAlice(env, alice, XRP(10'000), USD(10'000), ter(tecFROZEN));
             BEAST_EXPECT(!ammAlice.ammExists());
         }
 
@@ -317,7 +317,7 @@ private:
             env.close();
             env(offer(alice, XRP(101), USD(100)));
             env(offer(alice, XRP(102), USD(100)));
-            AMM ammAlice(env, alice, XRP(1'000), USD(1'000), ter(tecUNFUNDED_AMM));
+            AMM const ammAlice(env, alice, XRP(1'000), USD(1'000), ter(tecUNFUNDED_AMM));
         }
 
         // Insufficient reserve, IOU/IOU
@@ -334,14 +334,14 @@ private:
             env.close();
             env(offer(alice, EUR(101), USD(100)));
             env(offer(alice, EUR(102), USD(100)));
-            AMM ammAlice(env, alice, EUR(1'000), USD(1'000), ter(tecINSUF_RESERVE_LINE));
+            AMM const ammAlice(env, alice, EUR(1'000), USD(1'000), ter(tecINSUF_RESERVE_LINE));
         }
 
         // Insufficient fee
         {
             Env env(*this);
             fund(env, gw, {alice}, XRP(2'000), {USD(2'000), EUR(2'000)});
-            AMM ammAlice(
+            AMM const ammAlice(
                 env,
                 alice,
                 EUR(1'000),
@@ -360,13 +360,13 @@ private:
         // AMM with one LPToken from another AMM.
         testAMM([&](AMM& ammAlice, Env& env) {
             fund(env, gw, {alice}, {EUR(10'000)}, Fund::IOUOnly);
-            AMM ammAMMToken(
+            AMM const ammAMMToken(
                 env,
                 alice,
                 EUR(10'000),
                 STAmount{ammAlice.lptIssue(), 1'000'000},
                 ter(tecAMM_INVALID_TOKENS));
-            AMM ammAMMToken1(
+            AMM const ammAMMToken1(
                 env,
                 alice,
                 STAmount{ammAlice.lptIssue(), 1'000'000},
@@ -377,10 +377,10 @@ private:
         // AMM with two LPTokens from other AMMs.
         testAMM([&](AMM& ammAlice, Env& env) {
             fund(env, gw, {alice}, {EUR(10'000)}, Fund::IOUOnly);
-            AMM ammAlice1(env, alice, XRP(10'000), EUR(10'000));
+            AMM const ammAlice1(env, alice, XRP(10'000), EUR(10'000));
             auto const token1 = ammAlice.lptIssue();
             auto const token2 = ammAlice1.lptIssue();
-            AMM ammAMMTokens(
+            AMM const ammAMMTokens(
                 env,
                 alice,
                 STAmount{token1, 1'000'000},
@@ -393,21 +393,21 @@ private:
             Env env(*this);
             env.fund(XRP(30'000), gw);
             env(fclear(gw, asfDefaultRipple));
-            AMM ammGw(env, gw, XRP(10'000), USD(10'000), ter(terNO_RIPPLE));
+            AMM const ammGw(env, gw, XRP(10'000), USD(10'000), ter(terNO_RIPPLE));
             env.fund(XRP(30'000), alice);
             env.trust(USD(30'000), alice);
             env(pay(gw, alice, USD(30'000)));
-            AMM ammAlice(env, alice, XRP(10'000), USD(10'000), ter(terNO_RIPPLE));
+            AMM const ammAlice(env, alice, XRP(10'000), USD(10'000), ter(terNO_RIPPLE));
             Account const gw1("gw1");
             env.fund(XRP(30'000), gw1);
             env(fclear(gw1, asfDefaultRipple));
             env.trust(USD(30'000), gw1);
             env(pay(gw, gw1, USD(30'000)));
             auto const USD1 = gw1["USD"];
-            AMM ammGwGw1(env, gw, USD(10'000), USD1(10'000), ter(terNO_RIPPLE));
+            AMM const ammGwGw1(env, gw, USD(10'000), USD1(10'000), ter(terNO_RIPPLE));
             env.trust(USD1(30'000), alice);
             env(pay(gw1, alice, USD1(30'000)));
-            AMM ammAlice1(env, alice, USD(10'000), USD1(10'000), ter(terNO_RIPPLE));
+            AMM const ammAlice1(env, alice, USD(10'000), USD1(10'000), ter(terNO_RIPPLE));
         }
     }
 
@@ -429,106 +429,65 @@ private:
                 std::optional<STAmount>,
                 std::optional<STAmount>,
                 std::optional<STAmount>,
-                std::optional<std::uint16_t>>>
-                invalidOptions = {
-                    // flags, tokens, asset1In, asset2in, EPrice, tfee
-                    {tfLPToken, 1'000, std::nullopt, USD(100), std::nullopt, std::nullopt},
-                    {tfLPToken, 1'000, XRP(100), std::nullopt, std::nullopt, std::nullopt},
-                    {tfLPToken,
-                     1'000,
-                     std::nullopt,
-                     std::nullopt,
-                     STAmount{USD, 1, -1},
-                     std::nullopt},
-                    {tfLPToken,
-                     std::nullopt,
-                     USD(100),
-                     std::nullopt,
-                     STAmount{USD, 1, -1},
-                     std::nullopt},
-                    {tfLPToken, 1'000, XRP(100), std::nullopt, STAmount{USD, 1, -1}, std::nullopt},
-                    {tfLPToken, 1'000, std::nullopt, std::nullopt, std::nullopt, 1'000},
-                    {tfSingleAsset, 1'000, std::nullopt, std::nullopt, std::nullopt, std::nullopt},
-                    {tfSingleAsset,
-                     std::nullopt,
-                     std::nullopt,
-                     USD(100),
-                     std::nullopt,
-                     std::nullopt},
-                    {tfSingleAsset,
-                     std::nullopt,
-                     std::nullopt,
-                     std::nullopt,
-                     STAmount{USD, 1, -1},
-                     std::nullopt},
-                    {tfSingleAsset, std::nullopt, USD(100), std::nullopt, std::nullopt, 1'000},
-                    {tfTwoAsset, 1'000, std::nullopt, std::nullopt, std::nullopt, std::nullopt},
-                    {tfTwoAsset,
-                     std::nullopt,
-                     XRP(100),
-                     USD(100),
-                     STAmount{USD, 1, -1},
-                     std::nullopt},
-                    {tfTwoAsset, std::nullopt, XRP(100), std::nullopt, std::nullopt, std::nullopt},
-                    {tfTwoAsset, std::nullopt, XRP(100), USD(100), std::nullopt, 1'000},
-                    {tfTwoAsset,
-                     std::nullopt,
-                     std::nullopt,
-                     USD(100),
-                     STAmount{USD, 1, -1},
-                     std::nullopt},
-                    {tfOneAssetLPToken,
-                     1'000,
-                     std::nullopt,
-                     std::nullopt,
-                     std::nullopt,
-                     std::nullopt},
-                    {tfOneAssetLPToken,
-                     std::nullopt,
-                     XRP(100),
-                     USD(100),
-                     std::nullopt,
-                     std::nullopt},
-                    {tfOneAssetLPToken,
-                     std::nullopt,
-                     XRP(100),
-                     std::nullopt,
-                     STAmount{USD, 1, -1},
-                     std::nullopt},
-                    {tfOneAssetLPToken, 1'000, XRP(100), std::nullopt, std::nullopt, 1'000},
-                    {tfLimitLPToken, 1'000, std::nullopt, std::nullopt, std::nullopt, std::nullopt},
-                    {tfLimitLPToken, 1'000, USD(100), std::nullopt, std::nullopt, std::nullopt},
-                    {tfLimitLPToken, std::nullopt, USD(100), XRP(100), std::nullopt, std::nullopt},
-                    {tfLimitLPToken,
-                     std::nullopt,
-                     XRP(100),
-                     std::nullopt,
-                     STAmount{USD, 1, -1},
-                     1'000},
-                    {tfTwoAssetIfEmpty,
-                     std::nullopt,
-                     std::nullopt,
-                     std::nullopt,
-                     std::nullopt,
-                     1'000},
-                    {tfTwoAssetIfEmpty,
-                     1'000,
-                     std::nullopt,
-                     std::nullopt,
-                     std::nullopt,
-                     std::nullopt},
-                    {tfTwoAssetIfEmpty,
-                     std::nullopt,
-                     XRP(100),
-                     USD(100),
-                     STAmount{USD, 1, -1},
-                     std::nullopt},
-                    {tfTwoAssetIfEmpty | tfLPToken,
-                     std::nullopt,
-                     XRP(100),
-                     USD(100),
-                     STAmount{USD, 1, -1},
-                     std::nullopt}};
+                std::optional<std::uint16_t>>> const invalidOptions = {
+                // flags, tokens, asset1In, asset2in, EPrice, tfee
+                {tfLPToken, 1'000, std::nullopt, USD(100), std::nullopt, std::nullopt},
+                {tfLPToken, 1'000, XRP(100), std::nullopt, std::nullopt, std::nullopt},
+                {tfLPToken, 1'000, std::nullopt, std::nullopt, STAmount{USD, 1, -1}, std::nullopt},
+                {tfLPToken,
+                 std::nullopt,
+                 USD(100),
+                 std::nullopt,
+                 STAmount{USD, 1, -1},
+                 std::nullopt},
+                {tfLPToken, 1'000, XRP(100), std::nullopt, STAmount{USD, 1, -1}, std::nullopt},
+                {tfLPToken, 1'000, std::nullopt, std::nullopt, std::nullopt, 1'000},
+                {tfSingleAsset, 1'000, std::nullopt, std::nullopt, std::nullopt, std::nullopt},
+                {tfSingleAsset, std::nullopt, std::nullopt, USD(100), std::nullopt, std::nullopt},
+                {tfSingleAsset,
+                 std::nullopt,
+                 std::nullopt,
+                 std::nullopt,
+                 STAmount{USD, 1, -1},
+                 std::nullopt},
+                {tfSingleAsset, std::nullopt, USD(100), std::nullopt, std::nullopt, 1'000},
+                {tfTwoAsset, 1'000, std::nullopt, std::nullopt, std::nullopt, std::nullopt},
+                {tfTwoAsset, std::nullopt, XRP(100), USD(100), STAmount{USD, 1, -1}, std::nullopt},
+                {tfTwoAsset, std::nullopt, XRP(100), std::nullopt, std::nullopt, std::nullopt},
+                {tfTwoAsset, std::nullopt, XRP(100), USD(100), std::nullopt, 1'000},
+                {tfTwoAsset,
+                 std::nullopt,
+                 std::nullopt,
+                 USD(100),
+                 STAmount{USD, 1, -1},
+                 std::nullopt},
+                {tfOneAssetLPToken, 1'000, std::nullopt, std::nullopt, std::nullopt, std::nullopt},
+                {tfOneAssetLPToken, std::nullopt, XRP(100), USD(100), std::nullopt, std::nullopt},
+                {tfOneAssetLPToken,
+                 std::nullopt,
+                 XRP(100),
+                 std::nullopt,
+                 STAmount{USD, 1, -1},
+                 std::nullopt},
+                {tfOneAssetLPToken, 1'000, XRP(100), std::nullopt, std::nullopt, 1'000},
+                {tfLimitLPToken, 1'000, std::nullopt, std::nullopt, std::nullopt, std::nullopt},
+                {tfLimitLPToken, 1'000, USD(100), std::nullopt, std::nullopt, std::nullopt},
+                {tfLimitLPToken, std::nullopt, USD(100), XRP(100), std::nullopt, std::nullopt},
+                {tfLimitLPToken, std::nullopt, XRP(100), std::nullopt, STAmount{USD, 1, -1}, 1'000},
+                {tfTwoAssetIfEmpty, std::nullopt, std::nullopt, std::nullopt, std::nullopt, 1'000},
+                {tfTwoAssetIfEmpty, 1'000, std::nullopt, std::nullopt, std::nullopt, std::nullopt},
+                {tfTwoAssetIfEmpty,
+                 std::nullopt,
+                 XRP(100),
+                 USD(100),
+                 STAmount{USD, 1, -1},
+                 std::nullopt},
+                {tfTwoAssetIfEmpty | tfLPToken,
+                 std::nullopt,
+                 XRP(100),
+                 USD(100),
+                 STAmount{USD, 1, -1},
+                 std::nullopt}};
             for (auto const& it : invalidOptions)
             {
                 ammAlice.deposit(
@@ -1445,7 +1404,7 @@ private:
 
         testAMM(
             [&](AMM& ammAlice, Env& env) {
-                WithdrawArg args{
+                WithdrawArg const args{
                     .asset1Out = XRP(100),
                     .err = ter(tecAMM_BALANCE),
                 };
@@ -1455,7 +1414,7 @@ private:
 
         testAMM(
             [&](AMM& ammAlice, Env& env) {
-                WithdrawArg args{
+                WithdrawArg const args{
                     .asset1Out = USD(100),
                     .err = ter(tecAMM_BALANCE),
                 };
@@ -1478,7 +1437,7 @@ private:
             env(pay(gw, alice, USD(10'000)));
             env.close();
             AMM ammAlice(env, alice, XRP(10'000), USD(10'000));
-            WithdrawArg args{
+            WithdrawArg const args{
                 .account = bob,
                 .asset1Out = USD(100),
                 .err = ter(tecNO_AUTH),
@@ -1516,79 +1475,58 @@ private:
                 std::optional<STAmount>,
                 std::optional<IOUAmount>,
                 std::optional<std::uint32_t>,
-                NotTEC>>
-                invalidOptions = {
-                    // tokens, asset1Out, asset2Out, EPrice, flags, ter
-                    {std::nullopt,
-                     std::nullopt,
-                     std::nullopt,
-                     std::nullopt,
-                     std::nullopt,
-                     temMALFORMED},
-                    {std::nullopt,
-                     std::nullopt,
-                     std::nullopt,
-                     std::nullopt,
-                     tfSingleAsset | tfTwoAsset,
-                     temMALFORMED},
-                    {1'000, std::nullopt, std::nullopt, std::nullopt, tfWithdrawAll, temMALFORMED},
-                    {std::nullopt,
-                     USD(0),
-                     XRP(100),
-                     std::nullopt,
-                     tfWithdrawAll | tfLPToken,
-                     temMALFORMED},
-                    {std::nullopt,
-                     std::nullopt,
-                     USD(100),
-                     std::nullopt,
-                     tfWithdrawAll,
-                     temMALFORMED},
-                    {std::nullopt,
-                     std::nullopt,
-                     std::nullopt,
-                     std::nullopt,
-                     tfWithdrawAll | tfOneAssetWithdrawAll,
-                     temMALFORMED},
-                    {std::nullopt,
-                     USD(100),
-                     std::nullopt,
-                     std::nullopt,
-                     tfWithdrawAll,
-                     temMALFORMED},
-                    {std::nullopt,
-                     std::nullopt,
-                     std::nullopt,
-                     std::nullopt,
-                     tfOneAssetWithdrawAll,
-                     temMALFORMED},
-                    {1'000, std::nullopt, USD(100), std::nullopt, std::nullopt, temMALFORMED},
-                    {std::nullopt,
-                     std::nullopt,
-                     std::nullopt,
-                     IOUAmount{250, 0},
-                     tfWithdrawAll,
-                     temMALFORMED},
-                    {1'000,
-                     std::nullopt,
-                     std::nullopt,
-                     IOUAmount{250, 0},
-                     std::nullopt,
-                     temMALFORMED},
-                    {std::nullopt,
-                     std::nullopt,
-                     USD(100),
-                     IOUAmount{250, 0},
-                     std::nullopt,
-                     temMALFORMED},
-                    {std::nullopt,
-                     XRP(100),
-                     USD(100),
-                     IOUAmount{250, 0},
-                     std::nullopt,
-                     temMALFORMED},
-                    {1'000, XRP(100), USD(100), std::nullopt, std::nullopt, temMALFORMED},
-                    {std::nullopt, XRP(100), USD(100), std::nullopt, tfWithdrawAll, temMALFORMED}};
+                NotTEC>> const invalidOptions = {
+                // tokens, asset1Out, asset2Out, EPrice, flags, ter
+                {std::nullopt,
+                 std::nullopt,
+                 std::nullopt,
+                 std::nullopt,
+                 std::nullopt,
+                 temMALFORMED},
+                {std::nullopt,
+                 std::nullopt,
+                 std::nullopt,
+                 std::nullopt,
+                 tfSingleAsset | tfTwoAsset,
+                 temMALFORMED},
+                {1'000, std::nullopt, std::nullopt, std::nullopt, tfWithdrawAll, temMALFORMED},
+                {std::nullopt,
+                 USD(0),
+                 XRP(100),
+                 std::nullopt,
+                 tfWithdrawAll | tfLPToken,
+                 temMALFORMED},
+                {std::nullopt, std::nullopt, USD(100), std::nullopt, tfWithdrawAll, temMALFORMED},
+                {std::nullopt,
+                 std::nullopt,
+                 std::nullopt,
+                 std::nullopt,
+                 tfWithdrawAll | tfOneAssetWithdrawAll,
+                 temMALFORMED},
+                {std::nullopt, USD(100), std::nullopt, std::nullopt, tfWithdrawAll, temMALFORMED},
+                {std::nullopt,
+                 std::nullopt,
+                 std::nullopt,
+                 std::nullopt,
+                 tfOneAssetWithdrawAll,
+                 temMALFORMED},
+                {1'000, std::nullopt, USD(100), std::nullopt, std::nullopt, temMALFORMED},
+                {std::nullopt,
+                 std::nullopt,
+                 std::nullopt,
+                 IOUAmount{250, 0},
+                 tfWithdrawAll,
+                 temMALFORMED},
+                {1'000, std::nullopt, std::nullopt, IOUAmount{250, 0}, std::nullopt, temMALFORMED},
+                {std::nullopt,
+                 std::nullopt,
+                 USD(100),
+                 IOUAmount{250, 0},
+                 std::nullopt,
+                 temMALFORMED},
+                {std::nullopt, XRP(100), USD(100), IOUAmount{250, 0}, std::nullopt, temMALFORMED},
+                {1'000, XRP(100), USD(100), std::nullopt, std::nullopt, temMALFORMED},
+                {std::nullopt, XRP(100), USD(100), std::nullopt, tfWithdrawAll, temMALFORMED}};
             for (auto const& it : invalidOptions)
             {
                 ammAlice.withdraw(
@@ -1984,7 +1922,7 @@ private:
             BEAST_EXPECT(!env.le(keylet::ownerDir(ammAlice.ammAccount())));
 
             // Can create AMM for the XRP/USD pair
-            AMM ammCarol(env, carol, XRP(10'000), USD(10'000));
+            AMM const ammCarol(env, carol, XRP(10'000), USD(10'000));
             BEAST_EXPECT(
                 ammCarol.expectBalances(XRP(10'000), USD(10'000), IOUAmount{10'000'000, 0}));
         });
@@ -3147,12 +3085,12 @@ private:
 
             fund(env, gw, {alice, bob}, XRP(2'000), {USD(2'000)});
             AMM amm(env, gw, XRP(1'000), USD(1'010), false, 1'000);
-            Json::Value tx = amm.bid({.account = alice, .bidMin = 500});
+            Json::Value const tx = amm.bid({.account = alice, .bidMin = 500});
 
             {
                 auto jtx = env.jt(tx, seq(1), fee(baseFee));
                 env.app().config().features.erase(featureAMM);
-                PreflightContext pfCtx(
+                PreflightContext const pfCtx(
                     env.app(), *jtx.stx, env.current()->rules(), tapNONE, env.journal);
                 auto pf = Transactor::invokePreflight<AMMBid>(pfCtx);
                 BEAST_EXPECT(pf == temDISABLED);
@@ -3163,7 +3101,7 @@ private:
                 auto jtx = env.jt(tx, seq(1), fee(baseFee));
                 jtx.jv["TxnSignature"] = "deadbeef";
                 jtx.stx = env.ust(jtx);
-                PreflightContext pfCtx(
+                PreflightContext const pfCtx(
                     env.app(), *jtx.stx, env.current()->rules(), tapNONE, env.journal);
                 auto pf = Transactor::invokePreflight<AMMBid>(pfCtx);
                 BEAST_EXPECT(!isTesSuccess(pf));
@@ -3174,7 +3112,7 @@ private:
                 jtx.jv["Asset2"]["currency"] = "XRP";
                 jtx.jv["Asset2"].removeMember("issuer");
                 jtx.stx = env.ust(jtx);
-                PreflightContext pfCtx(
+                PreflightContext const pfCtx(
                     env.app(), *jtx.stx, env.current()->rules(), tapNONE, env.journal);
                 auto pf = Transactor::invokePreflight<AMMBid>(pfCtx);
                 BEAST_EXPECT(pf == temBAD_AMM_TOKENS);
@@ -3198,7 +3136,7 @@ private:
                 Env env(*this);
                 fund(env, gw, {alice, carol}, XRP(1'000), {USD(100)});
                 // XRP balance is below reserve
-                AMM ammAlice(env, acct, XRP(10), USD(10));
+                AMM const ammAlice(env, acct, XRP(10), USD(10));
                 // Pay below reserve
                 env(pay(carol, ammAlice.ammAccount(), XRP(10)), ter(tecNO_PERMISSION));
                 // Pay above reserve
@@ -3210,7 +3148,7 @@ private:
                 Env env(*this);
                 fund(env, gw, {alice, carol}, XRP(10'000'000), {USD(10'000)});
                 // XRP balance is above reserve
-                AMM ammAlice(env, acct, XRP(1'000'000), USD(100));
+                AMM const ammAlice(env, acct, XRP(1'000'000), USD(100));
                 // Pay below reserve
                 env(pay(carol, ammAlice.ammAccount(), XRP(10)), ter(tecNO_PERMISSION));
                 // Pay above reserve
@@ -3635,7 +3573,7 @@ private:
             env.close();
             env(offer(bob, XRP(50), USD(150)), txflags(tfPassive));
             env.close();
-            AMM ammAlice(env, alice, XRP(1'000), USD(1'050));
+            AMM const ammAlice(env, alice, XRP(1'000), USD(1'050));
             env(pay(alice, carol, USD(200)), sendmax(XRP(200)), txflags(tfPartialPayment));
             env.close();
             BEAST_EXPECT(ammAlice.expectBalances(XRP(1'050), USD(1'000), ammAlice.tokens()));
@@ -3962,13 +3900,13 @@ private:
                 XRP(100'000),
                 {EUR(50'000), BTC(50'000), ETH(50'000), USD(50'000)});
             fund(env, gw, {carol, bob}, XRP(1'000), {USD(200)}, Fund::Acct);
-            AMM xrp_eur(env, alice, XRP(10'100), EUR(10'000));
-            AMM eur_btc(env, alice, EUR(10'000), BTC(10'200));
-            AMM btc_usd(env, alice, BTC(10'100), USD(10'000));
-            AMM xrp_usd(env, alice, XRP(10'150), USD(10'200));
-            AMM xrp_eth(env, alice, XRP(10'000), ETH(10'100));
-            AMM eth_eur(env, alice, ETH(10'900), EUR(11'000));
-            AMM eur_usd(env, alice, EUR(10'100), USD(10'000));
+            AMM const xrp_eur(env, alice, XRP(10'100), EUR(10'000));
+            AMM const eur_btc(env, alice, EUR(10'000), BTC(10'200));
+            AMM const btc_usd(env, alice, BTC(10'100), USD(10'000));
+            AMM const xrp_usd(env, alice, XRP(10'150), USD(10'200));
+            AMM const xrp_eth(env, alice, XRP(10'000), ETH(10'100));
+            AMM const eth_eur(env, alice, ETH(10'900), EUR(11'000));
+            AMM const eur_usd(env, alice, EUR(10'100), USD(10'000));
             env(pay(bob, carol, USD(100)),
                 path(~EUR, ~BTC, ~USD),
                 path(~USD),
@@ -4043,11 +3981,11 @@ private:
                 XRP(40'000),
                 {EUR(50'000), BTC(50'000), ETH(50'000), USD(50'000)});
             fund(env, gw, {carol, bob}, XRP(1000), {USD(200)}, Fund::Acct);
-            AMM xrp_eur(env, alice, XRP(10'100), EUR(10'000));
-            AMM eur_btc(env, alice, EUR(10'000), BTC(10'200));
-            AMM btc_usd(env, alice, BTC(10'100), USD(10'000));
-            AMM xrp_eth(env, alice, XRP(10'000), ETH(10'100));
-            AMM eth_eur(env, alice, ETH(10'900), EUR(11'000));
+            AMM const xrp_eur(env, alice, XRP(10'100), EUR(10'000));
+            AMM const eur_btc(env, alice, EUR(10'000), BTC(10'200));
+            AMM const btc_usd(env, alice, BTC(10'100), USD(10'000));
+            AMM const xrp_eth(env, alice, XRP(10'000), ETH(10'100));
+            AMM const eth_eur(env, alice, ETH(10'900), EUR(11'000));
             env(pay(bob, carol, USD(100)),
                 path(~EUR, ~BTC, ~USD),
                 path(~ETH, ~EUR, ~BTC, ~USD),
@@ -4188,7 +4126,7 @@ private:
             Env env(*this, features);
             fund(env, gw, {alice, carol, bob}, XRP(30'000), {USD(30'000)});
             env(offer(bob, XRP(100), USD(100.001)));
-            AMM ammAlice(env, alice, XRP(10'000), USD(10'100));
+            AMM const ammAlice(env, alice, XRP(10'000), USD(10'100));
             env(offer(carol, USD(100), XRP(100)));
             if (!features[fixAMMv1_1])
             {
@@ -4413,7 +4351,7 @@ private:
             env.trust(TSTB(10'000), C);
             env(pay(A, C, TSTA(10'000)));
             env(pay(B, C, TSTB(10'000)));
-            AMM amm(env, C, TSTA(5'000), TSTB(5'000));
+            AMM const amm(env, C, TSTA(5'000), TSTB(5'000));
             auto const ammIss = Issue(TSTA.currency, amm.ammAccount());
 
             // Can TrustSet only for AMM LP tokens
@@ -4463,7 +4401,7 @@ private:
         std::string lp2TakerPays;
         // Execute with AMM first
         prep(
-            [&](Env& env) { AMM amm(env, LP1, TST(25), XRP(250)); },
+            [&](Env& env) { AMM const amm(env, LP1, TST(25), XRP(250)); },
             [&](Env& env) {
                 lp2TSTBalance = getAccountLines(env, LP2, TST)["lines"][0u]["balance"].asString();
                 auto const offer = getAccountOffers(env, LP2)["offers"][0u];
@@ -4767,7 +4705,7 @@ private:
             Account const ed("ed");
             fund(env, gw, {alice, bob, carol, ed}, XRP(1'000), {USD(2'000), EUR(2'000)});
             env(offer(carol, EUR(5), USD(5)));
-            AMM ammAlice(env, alice, USD(1'005), EUR(1'000));
+            AMM const ammAlice(env, alice, USD(1'005), EUR(1'000));
             env(pay(bob, ed, USD(10)), path(~USD), sendmax(EUR(15)), txflags(tfNoRippleDirect));
             BEAST_EXPECT(expectHolding(env, ed, USD(2'010)));
             if (!features[fixAMMv1_1])
@@ -4795,7 +4733,7 @@ private:
             fund(env, gw, {alice, bob, carol, ed}, XRP(1'000), {USD(2'000), EUR(2'000)});
             env(offer(carol, EUR(5), USD(5)));
             // Set 0.25% fee
-            AMM ammAlice(env, alice, USD(1'005), EUR(1'000), false, 250);
+            AMM const ammAlice(env, alice, USD(1'005), EUR(1'000), false, 250);
             env(pay(bob, ed, USD(10)), path(~USD), sendmax(EUR(15)), txflags(tfNoRippleDirect));
             BEAST_EXPECT(expectHolding(env, ed, USD(2'010)));
             if (!features[fixAMMv1_1])
@@ -4828,7 +4766,7 @@ private:
             fund(env, gw, {alice, bob, carol, ed}, XRP(1'000), {USD(2'000), EUR(2'000)});
             env(offer(carol, EUR(10), USD(10)));
             // Set 1% fee
-            AMM ammAlice(env, alice, USD(1'005), EUR(1'000), false, 1'000);
+            AMM const ammAlice(env, alice, USD(1'005), EUR(1'000), false, 1'000);
             env(pay(bob, ed, USD(10)), path(~USD), sendmax(EUR(15)), txflags(tfNoRippleDirect));
             BEAST_EXPECT(expectHolding(env, ed, USD(2'010)));
             BEAST_EXPECT(expectHolding(env, bob, EUR(1'990)));
@@ -4846,7 +4784,7 @@ private:
             fund(env, gw, {alice, bob, carol, ed}, XRP(1'000), {USD(2'000), EUR(2'000)});
             env(offer(carol, EUR(9), USD(9)));
             // Set 1% fee
-            AMM ammAlice(env, alice, USD(1'005), EUR(1'000), false, 1'000);
+            AMM const ammAlice(env, alice, USD(1'005), EUR(1'000), false, 1'000);
             env(pay(bob, ed, USD(10)), path(~USD), sendmax(EUR(15)), txflags(tfNoRippleDirect));
             BEAST_EXPECT(expectHolding(env, ed, USD(2'010)));
             BEAST_EXPECT(expectHolding(env, bob, STAmount{EUR, UINT64_C(1'989'993923296712), -12}));
@@ -5187,7 +5125,7 @@ private:
         Env env(*this);
         env.fund(XRP(2'000), gw);
         env.fund(XRP(2'000), alice);
-        AMM amm(env, gw, XRP(1'000), USD(1'000));
+        AMM const amm(env, gw, XRP(1'000), USD(1'000));
         env(fset(gw, asfAllowTrustLineClawback), ter(tecOWNERS));
     }
 
@@ -5737,7 +5675,7 @@ private:
         auto const xrpIouAmounts10_100 = TAmounts{XRPAmount{10}, IOUAmount{100}};
         auto const iouXrpAmounts10_100 = TAmounts{IOUAmount{10}, XRPAmount{100}};
         // clang-format off
-        std::vector<std::tuple<std::string, std::string, Quality, std::uint16_t, Status>> tests = {
+        std::vector<std::tuple<std::string, std::string, Quality, std::uint16_t, Status>> const tests = {
             //Pool In              ,  Pool Out,             Quality                     , Fee,  Status
             {"0.001519763260828713", "1558701",             Quality{5414253689393440221}, 1000, FailShouldSucceed},
             {"0.01099814367603737",  "1892611",             Quality{5482264816516900274}, 1000, FailShouldSucceed},
@@ -5797,14 +5735,14 @@ private:
         };
         // clang-format on
 
-        boost::regex rx("^\\d+$");
+        boost::regex const rx("^\\d+$");
         boost::smatch match;
         // tests that succeed should have the same amounts pre-fix and post-fix
-        std::vector<std::pair<STAmount, STAmount>> successAmounts;
-        Env env(*this, features, std::make_unique<CaptureLogs>(&logs));
+        std::vector<std::pair<STAmount, STAmount>> const successAmounts;
+        Env const env(*this, features, std::make_unique<CaptureLogs>(&logs));
         auto rules = env.current()->rules();
-        CurrentTransactionRulesGuard rg(rules);
-        NumberMantissaScaleGuard sg(MantissaRange::small);
+        CurrentTransactionRulesGuard const rg(rules);
+        NumberMantissaScaleGuard const sg(MantissaRange::small);
 
         for (auto const& t : tests)
         {
@@ -5923,7 +5861,7 @@ private:
         using namespace jtx;
 
         testAMM([&](AMM& ammAlice, Env& env) {
-            WithdrawArg args{
+            WithdrawArg const args{
                 .flags = tfSingleAsset,
                 .err = ter(temMALFORMED),
             };
@@ -5931,7 +5869,7 @@ private:
         });
 
         testAMM([&](AMM& ammAlice, Env& env) {
-            WithdrawArg args{
+            WithdrawArg const args{
                 .flags = tfOneAssetLPToken,
                 .err = ter(temMALFORMED),
             };
@@ -5939,7 +5877,7 @@ private:
         });
 
         testAMM([&](AMM& ammAlice, Env& env) {
-            WithdrawArg args{
+            WithdrawArg const args{
                 .flags = tfLimitLPToken,
                 .err = ter(temMALFORMED),
             };
@@ -5947,7 +5885,7 @@ private:
         });
 
         testAMM([&](AMM& ammAlice, Env& env) {
-            WithdrawArg args{
+            WithdrawArg const args{
                 .asset1Out = XRP(100),
                 .asset2Out = XRP(100),
                 .err = ter(temBAD_AMM_TOKENS),
@@ -5956,7 +5894,7 @@ private:
         });
 
         testAMM([&](AMM& ammAlice, Env& env) {
-            WithdrawArg args{
+            WithdrawArg const args{
                 .asset1Out = XRP(100),
                 .asset2Out = BAD(100),
                 .err = ter(temBAD_CURRENCY),
@@ -6234,7 +6172,7 @@ private:
                 env(pay(bitstamp, trader, usdBIT(100'000)));
                 env.close();
 
-                AMM amm{env, trader, usdGH(input.poolUsdGH), usdBIT(input.poolUsdBIT)};
+                AMM const amm{env, trader, usdGH(input.poolUsdGH), usdBIT(input.poolUsdBIT)};
                 env.close();
 
                 IOUAmount const preSwapLPTokenBalance = amm.getLPTokensBalance();
@@ -6343,7 +6281,7 @@ private:
             env(offer(alice, XRP(1), USD(0.01)));
             env.close();
 
-            AMM amm(env, gw, XRP(200'000), USD(100'000));
+            AMM const amm(env, gw, XRP(200'000), USD(100'000));
 
             // The offer doesn't cross AMM in pre-amendment code
             // It crosses AMM in post-amendment code
@@ -6376,7 +6314,7 @@ private:
             // There is no blocking offer
             // env(offer(alice, XRP(1), USD(0.01)));
 
-            AMM amm(env, gw, XRP(200'000), USD(100'000));
+            AMM const amm(env, gw, XRP(200'000), USD(100'000));
 
             // The offer crosses AMM
             env(offer(carol, USD(0.49), XRP(1)));
@@ -6398,7 +6336,7 @@ private:
             // It crosses AMM in post-amendment code
             env(offer(bob, USD(1), XRPAmount(500)));
             env.close();
-            AMM amm(env, alice, XRP(1'000), USD(500));
+            AMM const amm(env, alice, XRP(1'000), USD(500));
             env(offer(carol, XRP(100), USD(55)));
             env.close();
             if (!features[fixAMMv1_1])
@@ -6428,7 +6366,7 @@ private:
             Env env(*this, features);
             fund(env, gw, {alice, carol, bob}, XRP(10'000), {USD(1'000)});
 
-            AMM amm(env, alice, XRP(1'000), USD(500));
+            AMM const amm(env, alice, XRP(1'000), USD(500));
             env(offer(carol, XRP(100), USD(55)));
             env.close();
             BEAST_EXPECT(amm.expectBalances(
@@ -6561,12 +6499,12 @@ private:
         // clawback-enabled issuer
         if (!features[featureAMMClawback])
         {
-            AMM amm(env, gw, XRP(100), USD(100), ter(tecNO_PERMISSION));
-            AMM amm1(env, alice, USD(100), XRP(100), ter(tecNO_PERMISSION));
+            AMM const amm(env, gw, XRP(100), USD(100), ter(tecNO_PERMISSION));
+            AMM const amm1(env, alice, USD(100), XRP(100), ter(tecNO_PERMISSION));
             env(fclear(gw, asfAllowTrustLineClawback));
             env.close();
             // Can't be cleared
-            AMM amm2(env, gw, XRP(100), USD(100), ter(tecNO_PERMISSION));
+            AMM const amm2(env, gw, XRP(100), USD(100), ter(tecNO_PERMISSION));
         }
         // If featureAMMClawback is enabled, AMMCreate is allowed for
         // clawback-enabled issuer. Clawback from the AMM Account is not
@@ -6575,8 +6513,8 @@ private:
         // AMMClawback transaction to claw back from AMM Account.
         else
         {
-            AMM amm(env, gw, XRP(100), USD(100), ter(tesSUCCESS));
-            AMM amm1(env, alice, USD(100), XRP(200), ter(tecDUPLICATE));
+            AMM const amm(env, gw, XRP(100), USD(100), ter(tesSUCCESS));
+            AMM const amm1(env, alice, USD(100), XRP(200), ter(tecDUPLICATE));
 
             // Construct the amount being clawed back using AMM account.
             // By doing this, we make the clawback transaction's Amount field's
@@ -6588,7 +6526,7 @@ private:
             // is confusing.
             auto const error =
                 features[featureSingleAssetVault] ? ter{tecPSEUDO_ACCOUNT} : ter{tecAMM_ACCOUNT};
-            Issue usd(USD.issue().currency, amm.ammAccount());
+            Issue const usd(USD.issue().currency, amm.ammAccount());
             auto amount = amountFromString(usd, "10");
             env(claw(gw, amount), error);
         }
@@ -6712,8 +6650,8 @@ private:
             env(pay(gw, alice, USD(10'000)));
             env.close();
 
-            STAmount amount = XRP(10'000);
-            STAmount amount2 = USD(10'000);
+            STAmount const amount = XRP(10'000);
+            STAmount const amount2 = USD(10'000);
             auto const keylet = keylet::amm(amount.issue(), amount2.issue());
             for (int i = 0; i < 256; ++i)
             {
@@ -6725,7 +6663,7 @@ private:
                     sig(autofill));
             }
 
-            AMM ammAlice(
+            AMM const ammAlice(
                 env,
                 alice,
                 amount,
@@ -6747,7 +6685,7 @@ private:
         STAmount xrpBalance{XRPAmount(692'614'492'126)};
         STAmount xpmBalance{XPM, UINT64_C(18'610'359'80246901), -8};
         STAmount amount{XPM, UINT64_C(6'566'496939465400), -12};
-        std::uint16_t tfee = 941;
+        std::uint16_t const tfee = 941;
 
         auto test = [&](auto&& cb, std::uint16_t tfee_) {
             Env env(*this, features);
@@ -6758,7 +6696,7 @@ private:
 
             AMM amm(env, gw, xrpBalance, xpmBalance, CreateArg{.tfee = tfee_});
             // AMM LPToken balance required to replicate single deposit failure
-            STAmount lptAMMBalance{amm.lptIssue(), UINT64_C(3'234'987'266'485968), -6};
+            STAmount const lptAMMBalance{amm.lptIssue(), UINT64_C(3'234'987'266'485968), -6};
             auto const burn = IOUAmount{amm.getLPTokensBalance() - lptAMMBalance};
             // burn tokens to get to the required AMM state
             env(amm.bid(BidArg{.account = gw, .bidMin = burn, .bidMax = burn}));
@@ -6793,8 +6731,8 @@ private:
     {
         auto const [amount, amount2, lptBalance] = amm.balances(GBP, EUR);
 
-        NumberMantissaScaleGuard sg(MantissaRange::small);
-        NumberRoundModeGuard g(env.enabled(fixAMMv1_3) ? Number::upward : Number::getround());
+        NumberMantissaScaleGuard const sg(MantissaRange::small);
+        NumberRoundModeGuard const g(env.enabled(fixAMMv1_3) ? Number::upward : Number::getround());
         auto const res = root2(amount * amount2);
 
         if (shouldFail)
diff --git a/src/test/app/AccountDelete_test.cpp b/src/test/app/AccountDelete_test.cpp
index 91780800e9..4382fb27c7 100644
--- a/src/test/app/AccountDelete_test.cpp
+++ b/src/test/app/AccountDelete_test.cpp
@@ -452,7 +452,7 @@ public:
         // Verify the existence of the expected ledger entries.
         Keylet const aliceOwnerDirKey{keylet::ownerDir(alice.id())};
         {
-            std::shared_ptr<ReadView const> closed{env.closed()};
+            std::shared_ptr<ReadView const> const closed{env.closed()};
             BEAST_EXPECT(closed->exists(keylet::account(alice.id())));
             BEAST_EXPECT(closed->exists(aliceOwnerDirKey));
 
@@ -486,7 +486,7 @@ public:
         // Verify that alice's account root is gone as well as her directory
         // nodes and all of her offers.
         {
-            std::shared_ptr<ReadView const> closed{env.closed()};
+            std::shared_ptr<ReadView const> const closed{env.closed()};
             BEAST_EXPECT(!closed->exists(keylet::account(alice.id())));
             BEAST_EXPECT(!closed->exists(aliceOwnerDirKey));
 
@@ -539,7 +539,7 @@ public:
         env(acctdelete(gw, alice), fee(acctDelFee), ter(tecHAS_OBLIGATIONS));
         env.close();
         {
-            std::shared_ptr<ReadView const> closed{env.closed()};
+            std::shared_ptr<ReadView const> const closed{env.closed()};
             BEAST_EXPECT(closed->exists(keylet::account(alice.id())));
             BEAST_EXPECT(closed->exists(keylet::account(gw.id())));
         }
@@ -590,7 +590,7 @@ public:
         env(acctdelete(alice, env.master), fee(XRP(1)), ter(telINSUF_FEE_P));
         env.close();
         {
-            std::shared_ptr<ReadView const> closed{env.closed()};
+            std::shared_ptr<ReadView const> const closed{env.closed()};
             BEAST_EXPECT(closed->exists(keylet::account(alice.id())));
             BEAST_EXPECT(env.balance(env.master) == masterBalance);
         }
@@ -617,7 +617,7 @@ public:
         env.require(owners(bob, 250));
 
         {
-            std::shared_ptr<ReadView const> closed{env.closed()};
+            std::shared_ptr<ReadView const> const closed{env.closed()};
             BEAST_EXPECT(closed->exists(keylet::account(bob.id())));
             for (std::uint32_t i = 0; i < 250; ++i)
             {
@@ -636,7 +636,7 @@ public:
         verifyDeliveredAmount(env, bobOldBalance - acctDelFee);
         env.close();
         {
-            std::shared_ptr<ReadView const> closed{env.closed()};
+            std::shared_ptr<ReadView const> const closed{env.closed()};
             BEAST_EXPECT(!closed->exists(keylet::account(bob.id())));
             for (std::uint32_t i = 0; i < 250; ++i)
             {
diff --git a/src/test/app/AccountSet_test.cpp b/src/test/app/AccountSet_test.cpp
index 748f276433..246f18c445 100644
--- a/src/test/app/AccountSet_test.cpp
+++ b/src/test/app/AccountSet_test.cpp
@@ -195,7 +195,7 @@ public:
         std::size_t const maxLength = 256;
         for (std::size_t len = maxLength - 1; len <= maxLength + 1; ++len)
         {
-            std::string domain2 = std::string(len - domain.length() - 1, 'a') + "." + domain;
+            std::string const domain2 = std::string(len - domain.length() - 1, 'a') + "." + domain;
 
             BEAST_EXPECT(domain2.length() == len);
 
@@ -373,7 +373,7 @@ public:
         //
         // Two out-of-bound values are currently in the ledger (March 2020)
         // They are 4.0 and 4.294967295.  So those are the values we test.
-        for (double transferRate : {4.0, 4.294967295})
+        for (double const transferRate : {4.0, 4.294967295})
         {
             Env env(*this);
             env.fund(XRP(10000), gw, alice, bob);
diff --git a/src/test/app/AccountTxPaging_test.cpp b/src/test/app/AccountTxPaging_test.cpp
index 09b517c37c..1f2e909927 100644
--- a/src/test/app/AccountTxPaging_test.cpp
+++ b/src/test/app/AccountTxPaging_test.cpp
@@ -47,9 +47,9 @@ class AccountTxPaging_test : public beast::unit_test::suite
         using namespace test::jtx;
 
         Env env(*this);
-        Account A1{"A1"};
-        Account A2{"A2"};
-        Account A3{"A3"};
+        Account const A1{"A1"};
+        Account const A2{"A2"};
+        Account const A3{"A3"};
 
         env.fund(XRP(10000), A1, A2, A3);
         env.close();
diff --git a/src/test/app/AmendmentTable_test.cpp b/src/test/app/AmendmentTable_test.cpp
index 39e516304b..007715f9d1 100644
--- a/src/test/app/AmendmentTable_test.cpp
+++ b/src/test/app/AmendmentTable_test.cpp
@@ -1067,7 +1067,7 @@ public:
         // Since the local validator vote record expires after 24 hours,
         // with 23 hour flapping the amendment will go live.  But with 25
         // hour flapping the amendment will not go live.
-        for (int flapRateHours : {23, 25})
+        for (int const flapRateHours : {23, 25})
         {
             test::jtx::Env env{*this, feat};
             auto const testAmendment = amendmentId("validatorFlapping");
diff --git a/src/test/app/Batch_test.cpp b/src/test/app/Batch_test.cpp
index a548eb6b49..f301b6d60f 100644
--- a/src/test/app/Batch_test.cpp
+++ b/src/test/app/Batch_test.cpp
@@ -960,7 +960,7 @@ class Batch_test : public beast::unit_test::suite
 
             env.close();
             {
-                std::vector<TestLedgerData> testCases = {
+                std::vector<TestLedgerData> const testCases = {
                     {0, "Batch", "tesSUCCESS", batchID, std::nullopt},
                 };
                 validateClosedLedger(env, testCases);
@@ -969,7 +969,7 @@ class Batch_test : public beast::unit_test::suite
             env.close();
             {
                 // next ledger is empty
-                std::vector<TestLedgerData> testCases = {};
+                std::vector<TestLedgerData> const testCases = {};
                 validateClosedLedger(env, testCases);
             }
 
@@ -1002,7 +1002,7 @@ class Batch_test : public beast::unit_test::suite
 
             env.close();
             {
-                std::vector<TestLedgerData> testCases = {
+                std::vector<TestLedgerData> const testCases = {
                     {0, "Batch", "tesSUCCESS", batchID, std::nullopt},
                 };
                 validateClosedLedger(env, testCases);
@@ -1011,7 +1011,7 @@ class Batch_test : public beast::unit_test::suite
             env.close();
             {
                 // next ledger is empty
-                std::vector<TestLedgerData> testCases = {};
+                std::vector<TestLedgerData> const testCases = {};
                 validateClosedLedger(env, testCases);
             }
 
@@ -1044,7 +1044,7 @@ class Batch_test : public beast::unit_test::suite
 
             env.close();
             {
-                std::vector<TestLedgerData> testCases = {
+                std::vector<TestLedgerData> const testCases = {
                     {0, "Batch", "tesSUCCESS", batchID, std::nullopt},
                 };
                 validateClosedLedger(env, testCases);
@@ -1053,7 +1053,7 @@ class Batch_test : public beast::unit_test::suite
             env.close();
             {
                 // next ledger is empty
-                std::vector<TestLedgerData> testCases = {};
+                std::vector<TestLedgerData> const testCases = {};
                 validateClosedLedger(env, testCases);
             }
 
@@ -1086,7 +1086,7 @@ class Batch_test : public beast::unit_test::suite
 
             env.close();
             {
-                std::vector<TestLedgerData> testCases = {
+                std::vector<TestLedgerData> const testCases = {
                     {0, "Batch", "tesSUCCESS", batchID, std::nullopt},
                 };
                 validateClosedLedger(env, testCases);
@@ -1095,7 +1095,7 @@ class Batch_test : public beast::unit_test::suite
             env.close();
             {
                 // next ledger is empty
-                std::vector<TestLedgerData> testCases = {};
+                std::vector<TestLedgerData> const testCases = {};
                 validateClosedLedger(env, testCases);
             }
 
@@ -1128,7 +1128,7 @@ class Batch_test : public beast::unit_test::suite
 
             env.close();
             {
-                std::vector<TestLedgerData> testCases = {
+                std::vector<TestLedgerData> const testCases = {
                     {0, "Batch", "tesSUCCESS", batchID, std::nullopt},
                 };
                 validateClosedLedger(env, testCases);
@@ -1137,7 +1137,7 @@ class Batch_test : public beast::unit_test::suite
             env.close();
             {
                 // next ledger is empty
-                std::vector<TestLedgerData> testCases = {};
+                std::vector<TestLedgerData> const testCases = {};
                 validateClosedLedger(env, testCases);
             }
 
@@ -1463,7 +1463,7 @@ class Batch_test : public beast::unit_test::suite
                 batch::inner(pay(alice, bob, XRP(2)), seq + 2));
             env.close();
 
-            std::vector<TestLedgerData> testCases = {
+            std::vector<TestLedgerData> const testCases = {
                 {0, "Batch", "tesSUCCESS", batchID, std::nullopt},
                 {1, "Payment", "tesSUCCESS", txIDs[0], batchID},
                 {2, "Payment", "tesSUCCESS", txIDs[1], batchID},
@@ -1495,7 +1495,7 @@ class Batch_test : public beast::unit_test::suite
                 batch::inner(pay(alice, bob, XRP(9999)), seq + 2));
             env.close();
 
-            std::vector<TestLedgerData> testCases = {
+            std::vector<TestLedgerData> const testCases = {
                 {0, "Batch", "tesSUCCESS", batchID, std::nullopt},
             };
             validateClosedLedger(env, testCases);
@@ -1524,7 +1524,7 @@ class Batch_test : public beast::unit_test::suite
                 batch::inner(trust(alice, USD(1000), tfSetfAuth), seq + 2));
             env.close();
 
-            std::vector<TestLedgerData> testCases = {
+            std::vector<TestLedgerData> const testCases = {
                 {0, "Batch", "tesSUCCESS", batchID, std::nullopt},
             };
             validateClosedLedger(env, testCases);
@@ -1553,7 +1553,7 @@ class Batch_test : public beast::unit_test::suite
                 batch::inner(trust(alice, USD(1000), tfSetfAuth), 0, seq + 2));
             env.close();
 
-            std::vector<TestLedgerData> testCases = {
+            std::vector<TestLedgerData> const testCases = {
                 {0, "Batch", "tesSUCCESS", batchID, std::nullopt},
             };
             validateClosedLedger(env, testCases);
@@ -1605,7 +1605,7 @@ class Batch_test : public beast::unit_test::suite
                 batch::inner(pay(alice, bob, XRP(9999)), seq + 3));
             env.close();
 
-            std::vector<TestLedgerData> testCases = {
+            std::vector<TestLedgerData> const testCases = {
                 {0, "Batch", "tesSUCCESS", batchID, std::nullopt},
                 {1, "Payment", "tecUNFUNDED_PAYMENT", txIDs[0], batchID},
                 {2, "Payment", "tecUNFUNDED_PAYMENT", txIDs[1], batchID},
@@ -1638,7 +1638,7 @@ class Batch_test : public beast::unit_test::suite
                 batch::inner(pay(alice, bob, XRP(2)), seq + 3));
             env.close();
 
-            std::vector<TestLedgerData> testCases = {
+            std::vector<TestLedgerData> const testCases = {
                 {0, "Batch", "tesSUCCESS", batchID, std::nullopt},
                 {1, "Payment", "tecUNFUNDED_PAYMENT", txIDs[0], batchID},
                 {2, "Payment", "tesSUCCESS", txIDs[1], batchID},
@@ -1670,7 +1670,7 @@ class Batch_test : public beast::unit_test::suite
                 batch::inner(pay(alice, bob, XRP(2)), seq + 3));
             env.close();
 
-            std::vector<TestLedgerData> testCases = {
+            std::vector<TestLedgerData> const testCases = {
                 {0, "Batch", "tesSUCCESS", batchID, std::nullopt},
                 {1, "Payment", "tesSUCCESS", txIDs[0], batchID},
             };
@@ -1701,7 +1701,7 @@ class Batch_test : public beast::unit_test::suite
                 batch::inner(pay(alice, bob, XRP(2)), seq + 3));
             env.close();
 
-            std::vector<TestLedgerData> testCases = {
+            std::vector<TestLedgerData> const testCases = {
                 {0, "Batch", "tesSUCCESS", batchID, std::nullopt},
                 {1, "Payment", "tesSUCCESS", txIDs[1], batchID},
             };
@@ -1732,7 +1732,7 @@ class Batch_test : public beast::unit_test::suite
                 batch::inner(pay(alice, bob, XRP(2)), seq + 3));
             env.close();
 
-            std::vector<TestLedgerData> testCases = {
+            std::vector<TestLedgerData> const testCases = {
                 {0, "Batch", "tesSUCCESS", batchID, std::nullopt},
                 {1, "Payment", "tesSUCCESS", txIDs[1], batchID},
             };
@@ -1769,7 +1769,7 @@ class Batch_test : public beast::unit_test::suite
                 batch::inner(pay(alice, dave, XRP(100)), seq + 6));
             env.close();
 
-            std::vector<TestLedgerData> testCases = {
+            std::vector<TestLedgerData> const testCases = {
                 {0, "Batch", "tesSUCCESS", batchID, std::nullopt},
                 {1, "OfferCreate", "tecKILLED", txIDs[0], batchID},
                 {2, "OfferCreate", "tecKILLED", txIDs[1], batchID},
@@ -1821,7 +1821,7 @@ class Batch_test : public beast::unit_test::suite
                 batch::inner(pay(alice, bob, XRP(3)), seq + 4));
             env.close();
 
-            std::vector<TestLedgerData> testCases = {
+            std::vector<TestLedgerData> const testCases = {
                 {0, "Batch", "tesSUCCESS", batchID, std::nullopt},
                 {1, "Payment", "tecUNFUNDED_PAYMENT", txIDs[0], batchID},
             };
@@ -1852,7 +1852,7 @@ class Batch_test : public beast::unit_test::suite
                 batch::inner(pay(alice, bob, XRP(4)), seq + 4));
             env.close();
 
-            std::vector<TestLedgerData> testCases = {
+            std::vector<TestLedgerData> const testCases = {
                 {0, "Batch", "tesSUCCESS", batchID, std::nullopt},
                 {1, "Payment", "tesSUCCESS", txIDs[0], batchID},
                 {2, "Payment", "tesSUCCESS", txIDs[1], batchID},
@@ -1887,7 +1887,7 @@ class Batch_test : public beast::unit_test::suite
                 batch::inner(pay(alice, bob, XRP(3)), seq + 4));
             env.close();
 
-            std::vector<TestLedgerData> testCases = {
+            std::vector<TestLedgerData> const testCases = {
                 {0, "Batch", "tesSUCCESS", batchID, std::nullopt},
                 {1, "Payment", "tesSUCCESS", txIDs[0], batchID},
                 {2, "Payment", "tesSUCCESS", txIDs[1], batchID},
@@ -1921,7 +1921,7 @@ class Batch_test : public beast::unit_test::suite
                 batch::inner(pay(alice, bob, XRP(3)), seq + 4));
             env.close();
 
-            std::vector<TestLedgerData> testCases = {
+            std::vector<TestLedgerData> const testCases = {
                 {0, "Batch", "tesSUCCESS", batchID, std::nullopt},
                 {1, "Payment", "tesSUCCESS", txIDs[0], batchID},
                 {2, "Payment", "tesSUCCESS", txIDs[1], batchID},
@@ -1954,7 +1954,7 @@ class Batch_test : public beast::unit_test::suite
                 batch::inner(pay(alice, bob, XRP(3)), seq + 4));
             env.close();
 
-            std::vector<TestLedgerData> testCases = {
+            std::vector<TestLedgerData> const testCases = {
                 {0, "Batch", "tesSUCCESS", batchID, std::nullopt},
                 {1, "Payment", "tesSUCCESS", txIDs[0], batchID},
                 {2, "Payment", "tesSUCCESS", txIDs[1], batchID},
@@ -1987,7 +1987,7 @@ class Batch_test : public beast::unit_test::suite
                 batch::inner(pay(alice, dave, XRP(100)), seq + 4));
             env.close();
 
-            std::vector<TestLedgerData> testCases = {
+            std::vector<TestLedgerData> const testCases = {
                 {0, "Batch", "tesSUCCESS", batchID, std::nullopt},
                 {1, "Payment", "tesSUCCESS", txIDs[0], batchID},
                 {2, "Payment", "tesSUCCESS", txIDs[1], batchID},
@@ -2038,7 +2038,7 @@ class Batch_test : public beast::unit_test::suite
                 batch::inner(pay(alice, bob, XRP(3)), seq + 4));
             env.close();
 
-            std::vector<TestLedgerData> testCases = {
+            std::vector<TestLedgerData> const testCases = {
                 {0, "Batch", "tesSUCCESS", batchID, std::nullopt},
                 {1, "Payment", "tesSUCCESS", txIDs[0], batchID},
                 {2, "Payment", "tecUNFUNDED_PAYMENT", txIDs[1], batchID},
@@ -2073,7 +2073,7 @@ class Batch_test : public beast::unit_test::suite
                 batch::inner(pay(alice, bob, XRP(3)), seq + 4));
             env.close();
 
-            std::vector<TestLedgerData> testCases = {
+            std::vector<TestLedgerData> const testCases = {
                 {0, "Batch", "tesSUCCESS", batchID, std::nullopt},
                 {1, "Payment", "tesSUCCESS", txIDs[0], batchID},
                 {2, "Payment", "tesSUCCESS", txIDs[1], batchID},
@@ -2108,7 +2108,7 @@ class Batch_test : public beast::unit_test::suite
                 batch::inner(pay(alice, bob, XRP(3)), seq + 3));
             env.close();
 
-            std::vector<TestLedgerData> testCases = {
+            std::vector<TestLedgerData> const testCases = {
                 {0, "Batch", "tesSUCCESS", batchID, std::nullopt},
                 {1, "Payment", "tesSUCCESS", txIDs[0], batchID},
                 {2, "Payment", "tesSUCCESS", txIDs[1], batchID},
@@ -2142,7 +2142,7 @@ class Batch_test : public beast::unit_test::suite
                 batch::inner(pay(alice, bob, XRP(3)), seq + 3));
             env.close();
 
-            std::vector<TestLedgerData> testCases = {
+            std::vector<TestLedgerData> const testCases = {
                 {0, "Batch", "tesSUCCESS", batchID, std::nullopt},
                 {1, "Payment", "tesSUCCESS", txIDs[0], batchID},
                 {2, "Payment", "tesSUCCESS", txIDs[1], batchID},
@@ -2175,7 +2175,7 @@ class Batch_test : public beast::unit_test::suite
                     offer(alice, alice["USD"](100), XRP(100), tfImmediateOrCancel), seq + 3));
             env.close();
 
-            std::vector<TestLedgerData> testCases = {
+            std::vector<TestLedgerData> const testCases = {
                 {0, "Batch", "tesSUCCESS", batchID, std::nullopt},
                 {1, "Payment", "tesSUCCESS", txIDs[0], batchID},
                 {2, "Payment", "tesSUCCESS", txIDs[1], batchID},
@@ -2339,7 +2339,7 @@ class Batch_test : public beast::unit_test::suite
         // - has no `Signers` field
         // + has `tfInnerBatchTxn` flag
         {
-            STTx amendTx(ttAMENDMENT, [seq = env.closed()->header().seq + 1](auto& obj) {
+            STTx const amendTx(ttAMENDMENT, [seq = env.closed()->header().seq + 1](auto& obj) {
                 obj.setAccountID(sfAccount, AccountID());
                 obj.setFieldH256(sfAmendment, fixBatchInnerSigs);
                 obj.setFieldU32(sfLedgerSequence, seq);
@@ -2397,7 +2397,7 @@ class Batch_test : public beast::unit_test::suite
             batch::sig(bob));
         env.close();
 
-        std::vector<TestLedgerData> testCases = {
+        std::vector<TestLedgerData> const testCases = {
             {0, "Batch", "tesSUCCESS", batchID, std::nullopt},
             {1, "Payment", "tesSUCCESS", txIDs[0], batchID},
             {2, "AccountSet", "tesSUCCESS", txIDs[1], batchID},
@@ -2446,7 +2446,7 @@ class Batch_test : public beast::unit_test::suite
             batch::inner(pay(alice, bob, XRP(1)), seq + 2));
         env.close();
 
-        std::vector<TestLedgerData> testCases = {
+        std::vector<TestLedgerData> const testCases = {
             {0, "Batch", "tesSUCCESS", batchID, std::nullopt},
             {1, "AccountSet", "tesSUCCESS", txIDs[0], batchID},
             {2, "Payment", "tesSUCCESS", txIDs[1], batchID},
@@ -2501,7 +2501,7 @@ class Batch_test : public beast::unit_test::suite
                 batch::inner(pay(alice, bob, XRP(2)), seq + 3));
             env.close();
 
-            std::vector<TestLedgerData> testCases = {
+            std::vector<TestLedgerData> const testCases = {
                 {0, "Batch", "tesSUCCESS", batchID, std::nullopt},
                 {1, "Payment", "tesSUCCESS", txIDs[0], batchID},
                 {2, "AccountDelete", "tesSUCCESS", txIDs[1], batchID},
@@ -2544,7 +2544,7 @@ class Batch_test : public beast::unit_test::suite
                 batch::inner(pay(alice, bob, XRP(2)), seq + 3));
             env.close();
 
-            std::vector<TestLedgerData> testCases = {
+            std::vector<TestLedgerData> const testCases = {
                 {0, "Batch", "tesSUCCESS", batchID, std::nullopt},
                 {1, "Payment", "tesSUCCESS", txIDs[0], batchID},
                 {2, "AccountDelete", "tecHAS_OBLIGATIONS", txIDs[1], batchID},
@@ -2585,7 +2585,7 @@ class Batch_test : public beast::unit_test::suite
                 batch::inner(pay(alice, bob, XRP(2)), seq + 3));
             env.close();
 
-            std::vector<TestLedgerData> testCases = {
+            std::vector<TestLedgerData> const testCases = {
                 {0, "Batch", "tesSUCCESS", batchID, std::nullopt},
             };
             validateClosedLedger(env, testCases);
@@ -2626,7 +2626,7 @@ class Batch_test : public beast::unit_test::suite
         // Just use an XRP asset
         PrettyAsset const asset{xrpIssue(), 1'000'000};
 
-        Vault vault{env};
+        Vault const vault{env};
 
         auto const deposit = asset(50'000);
         auto const debtMaximumValue = asset(25'000).value();
@@ -2821,7 +2821,7 @@ class Batch_test : public beast::unit_test::suite
                 batch::sig(bob));
             env.close();
 
-            std::vector<TestLedgerData> testCases = {
+            std::vector<TestLedgerData> const testCases = {
                 {0, "Batch", "tesSUCCESS", batchID, std::nullopt},
                 {1, "CheckCreate", "tesSUCCESS", txIDs[0], batchID},
                 {2, "CheckCash", "tesSUCCESS", txIDs[1], batchID},
@@ -2867,7 +2867,7 @@ class Batch_test : public beast::unit_test::suite
                 batch::sig(bob));
             env.close();
 
-            std::vector<TestLedgerData> testCases = {
+            std::vector<TestLedgerData> const testCases = {
                 {0, "Batch", "tesSUCCESS", batchID, std::nullopt},
                 {1, "CheckCreate", "tecDST_TAG_NEEDED", txIDs[0], batchID},
                 {2, "CheckCash", "tecNO_ENTRY", txIDs[1], batchID},
@@ -2932,7 +2932,7 @@ class Batch_test : public beast::unit_test::suite
             batch::sig(bob));
         env.close();
 
-        std::vector<TestLedgerData> testCases = {
+        std::vector<TestLedgerData> const testCases = {
             {0, "Batch", "tesSUCCESS", batchID, std::nullopt},
             {1, "TicketCreate", "tesSUCCESS", txIDs[0], batchID},
             {2, "CheckCreate", "tesSUCCESS", txIDs[1], batchID},
@@ -2992,7 +2992,7 @@ class Batch_test : public beast::unit_test::suite
             batch::sig(alice, bob));
         env.close();
 
-        std::vector<TestLedgerData> testCases = {
+        std::vector<TestLedgerData> const testCases = {
             {0, "Batch", "tesSUCCESS", batchID, std::nullopt},
             {1, "CheckCreate", "tesSUCCESS", txIDs[0], batchID},
             {2, "CheckCash", "tesSUCCESS", txIDs[1], batchID},
@@ -3026,7 +3026,7 @@ class Batch_test : public beast::unit_test::suite
             env.fund(XRP(10000), alice, bob);
             env.close();
 
-            std::uint32_t aliceTicketSeq{env.seq(alice) + 1};
+            std::uint32_t const aliceTicketSeq{env.seq(alice) + 1};
             env(ticket::create(alice, 10));
             env.close();
 
@@ -3044,7 +3044,7 @@ class Batch_test : public beast::unit_test::suite
                 ticket::use(aliceTicketSeq));
             env.close();
 
-            std::vector<TestLedgerData> testCases = {
+            std::vector<TestLedgerData> const testCases = {
                 {0, "Batch", "tesSUCCESS", batchID, std::nullopt},
                 {1, "Payment", "tesSUCCESS", txIDs[0], batchID},
                 {2, "Payment", "tesSUCCESS", txIDs[1], batchID},
@@ -3092,7 +3092,7 @@ class Batch_test : public beast::unit_test::suite
                 batch::inner(pay(alice, bob, XRP(2)), 0, aliceTicketSeq + 1));
             env.close();
 
-            std::vector<TestLedgerData> testCases = {
+            std::vector<TestLedgerData> const testCases = {
                 {0, "Batch", "tesSUCCESS", batchID, std::nullopt},
                 {1, "Payment", "tesSUCCESS", txIDs[0], batchID},
                 {2, "Payment", "tesSUCCESS", txIDs[1], batchID},
@@ -3123,7 +3123,7 @@ class Batch_test : public beast::unit_test::suite
             env.fund(XRP(10000), alice, bob);
             env.close();
 
-            std::uint32_t aliceTicketSeq{env.seq(alice) + 1};
+            std::uint32_t const aliceTicketSeq{env.seq(alice) + 1};
             env(ticket::create(alice, 10));
             env.close();
 
@@ -3141,7 +3141,7 @@ class Batch_test : public beast::unit_test::suite
                 ticket::use(aliceTicketSeq));
             env.close();
 
-            std::vector<TestLedgerData> testCases = {
+            std::vector<TestLedgerData> const testCases = {
                 {0, "Batch", "tesSUCCESS", batchID, std::nullopt},
                 {1, "Payment", "tesSUCCESS", txIDs[0], batchID},
                 {2, "Payment", "tesSUCCESS", txIDs[1], batchID},
@@ -3202,7 +3202,7 @@ class Batch_test : public beast::unit_test::suite
             env.close();
 
             {
-                std::vector<TestLedgerData> testCases = {
+                std::vector<TestLedgerData> const testCases = {
                     {0, "Batch", "tesSUCCESS", batchID, std::nullopt},
                     {1, "Payment", "tesSUCCESS", txIDs[0], batchID},
                     {2, "Payment", "tesSUCCESS", txIDs[1], batchID},
@@ -3213,7 +3213,7 @@ class Batch_test : public beast::unit_test::suite
             env.close();
             {
                 // next ledger contains noop txn
-                std::vector<TestLedgerData> testCases = {
+                std::vector<TestLedgerData> const testCases = {
                     {0, "AccountSet", "tesSUCCESS", noopTxnID, std::nullopt},
                 };
                 validateClosedLedger(env, testCases);
@@ -3246,7 +3246,7 @@ class Batch_test : public beast::unit_test::suite
             env.close();
 
             {
-                std::vector<TestLedgerData> testCases = {
+                std::vector<TestLedgerData> const testCases = {
                     {0, "Batch", "tesSUCCESS", batchID, std::nullopt},
                     {1, "Payment", "tesSUCCESS", txIDs[0], batchID},
                     {2, "Payment", "tesSUCCESS", txIDs[1], batchID},
@@ -3257,7 +3257,7 @@ class Batch_test : public beast::unit_test::suite
             env.close();
             {
                 // next ledger is empty
-                std::vector<TestLedgerData> testCases = {};
+                std::vector<TestLedgerData> const testCases = {};
                 validateClosedLedger(env, testCases);
             }
         }
@@ -3285,7 +3285,7 @@ class Batch_test : public beast::unit_test::suite
             env.close();
 
             {
-                std::vector<TestLedgerData> testCases = {
+                std::vector<TestLedgerData> const testCases = {
                     {0, "Batch", "tesSUCCESS", batchID, std::nullopt},
                     {1, "Payment", "tesSUCCESS", txIDs[0], batchID},
                     {2, "Payment", "tesSUCCESS", txIDs[1], batchID},
@@ -3296,7 +3296,7 @@ class Batch_test : public beast::unit_test::suite
             env.close();
             {
                 // next ledger is empty
-                std::vector<TestLedgerData> testCases = {};
+                std::vector<TestLedgerData> const testCases = {};
                 validateClosedLedger(env, testCases);
             }
         }
@@ -3327,7 +3327,7 @@ class Batch_test : public beast::unit_test::suite
             env.close();
 
             {
-                std::vector<TestLedgerData> testCases = {
+                std::vector<TestLedgerData> const testCases = {
                     {0, "AccountSet", "tesSUCCESS", noopTxnID, std::nullopt},
                     {1, "Batch", "tesSUCCESS", batchID, std::nullopt},
                     {2, "Payment", "tesSUCCESS", txIDs[0], batchID},
@@ -3339,7 +3339,7 @@ class Batch_test : public beast::unit_test::suite
             env.close();
             {
                 // next ledger contains no transactions
-                std::vector<TestLedgerData> testCases = {};
+                std::vector<TestLedgerData> const testCases = {};
                 validateClosedLedger(env, testCases);
             }
         }
@@ -3365,7 +3365,7 @@ class Batch_test : public beast::unit_test::suite
             env.fund(XRP(10000), alice, bob);
             env.close();
 
-            std::uint32_t aliceTicketSeq{env.seq(alice) + 1};
+            std::uint32_t const aliceTicketSeq{env.seq(alice) + 1};
             env(ticket::create(alice, 10));
             env.close();
 
@@ -3387,7 +3387,7 @@ class Batch_test : public beast::unit_test::suite
             env.close();
 
             {
-                std::vector<TestLedgerData> testCases = {
+                std::vector<TestLedgerData> const testCases = {
                     {0, "Batch", "tesSUCCESS", batchID, std::nullopt},
                     {1, "Payment", "tesSUCCESS", txIDs[0], batchID},
                     {2, "Payment", "tesSUCCESS", txIDs[1], batchID},
@@ -3398,7 +3398,7 @@ class Batch_test : public beast::unit_test::suite
             env.close();
             {
                 // next ledger is empty
-                std::vector<TestLedgerData> testCases = {};
+                std::vector<TestLedgerData> const testCases = {};
                 validateClosedLedger(env, testCases);
             }
         }
@@ -3412,7 +3412,7 @@ class Batch_test : public beast::unit_test::suite
             env.fund(XRP(10000), alice, bob);
             env.close();
 
-            std::uint32_t aliceTicketSeq{env.seq(alice) + 1};
+            std::uint32_t const aliceTicketSeq{env.seq(alice) + 1};
             env(ticket::create(alice, 10));
             env.close();
 
@@ -3434,7 +3434,7 @@ class Batch_test : public beast::unit_test::suite
 
             env.close();
             {
-                std::vector<TestLedgerData> testCases = {
+                std::vector<TestLedgerData> const testCases = {
                     {0, "Batch", "tesSUCCESS", batchID, std::nullopt},
                     {1, "Payment", "tesSUCCESS", txIDs[0], batchID},
                     {2, "Payment", "tesSUCCESS", txIDs[1], batchID},
@@ -3445,7 +3445,7 @@ class Batch_test : public beast::unit_test::suite
             env.close();
             {
                 // next ledger is empty
-                std::vector<TestLedgerData> testCases = {};
+                std::vector<TestLedgerData> const testCases = {};
                 validateClosedLedger(env, testCases);
             }
         }
@@ -3473,7 +3473,7 @@ class Batch_test : public beast::unit_test::suite
             env.fund(XRP(10000), alice, bob);
             env.close();
 
-            std::uint32_t aliceTicketSeq{env.seq(alice) + 1};
+            std::uint32_t const aliceTicketSeq{env.seq(alice) + 1};
             env(ticket::create(alice, 10));
             env.close();
 
@@ -3497,7 +3497,7 @@ class Batch_test : public beast::unit_test::suite
 
             env.close();
             {
-                std::vector<TestLedgerData> testCases = {
+                std::vector<TestLedgerData> const testCases = {
                     {0, "Batch", "tesSUCCESS", batchID, std::nullopt},
                     {1, "CheckCreate", "tesSUCCESS", txIDs[0], batchID},
                     {2, "Payment", "tesSUCCESS", txIDs[1], batchID},
@@ -3509,7 +3509,7 @@ class Batch_test : public beast::unit_test::suite
             env.close();
             {
                 // next ledger is empty
-                std::vector<TestLedgerData> testCases = {};
+                std::vector<TestLedgerData> const testCases = {};
                 validateClosedLedger(env, testCases);
             }
         }
@@ -3520,7 +3520,7 @@ class Batch_test : public beast::unit_test::suite
             env.fund(XRP(10000), alice, bob);
             env.close();
 
-            std::uint32_t aliceTicketSeq{env.seq(alice) + 1};
+            std::uint32_t const aliceTicketSeq{env.seq(alice) + 1};
             env(ticket::create(alice, 10));
             env.close();
 
@@ -3546,7 +3546,7 @@ class Batch_test : public beast::unit_test::suite
 
             env.close();
             {
-                std::vector<TestLedgerData> testCases = {
+                std::vector<TestLedgerData> const testCases = {
                     {0, "CheckCreate", "tesSUCCESS", objTxnID, std::nullopt},
                     {1, "Batch", "tesSUCCESS", batchID, std::nullopt},
                     {2, "CheckCash", "tesSUCCESS", txIDs[0], batchID},
@@ -3567,7 +3567,7 @@ class Batch_test : public beast::unit_test::suite
             env.fund(XRP(10000), alice, bob);
             env.close();
 
-            std::uint32_t aliceTicketSeq{env.seq(alice) + 1};
+            std::uint32_t const aliceTicketSeq{env.seq(alice) + 1};
             env(ticket::create(alice, 10));
             env.close();
 
@@ -3591,7 +3591,7 @@ class Batch_test : public beast::unit_test::suite
 
             env.close();
             {
-                std::vector<TestLedgerData> testCases = {
+                std::vector<TestLedgerData> const testCases = {
                     {0, "Batch", "tesSUCCESS", batchID, std::nullopt},
                     {1, "CheckCreate", "tesSUCCESS", txIDs[0], batchID},
                     {2, "Payment", "tesSUCCESS", txIDs[1], batchID},
@@ -3687,7 +3687,7 @@ class Batch_test : public beast::unit_test::suite
         env(payTxn2, ter(terPRE_SEQ));
         env.close();
 
-        std::vector<TestLedgerData> testCases = {
+        std::vector<TestLedgerData> const testCases = {
             {0, "Payment", "tesSUCCESS", payTxn1ID, std::nullopt},
             {1, "Batch", "tesSUCCESS", batchID, std::nullopt},
             {2, "Payment", "tesSUCCESS", txIDs[0], batchID},
@@ -3698,7 +3698,7 @@ class Batch_test : public beast::unit_test::suite
         env.close();
         {
             // next ledger includes the payment txn
-            std::vector<TestLedgerData> testCases = {
+            std::vector<TestLedgerData> const testCases = {
                 {0, "Payment", "tesSUCCESS", payTxn2ID, std::nullopt},
             };
             validateClosedLedger(env, testCases);
@@ -3910,7 +3910,7 @@ class Batch_test : public beast::unit_test::suite
                 batch::inner(pay(alice, bob, XRP(2)), seq + 2));
             env.close();
 
-            std::vector<TestLedgerData> testCases = {
+            std::vector<TestLedgerData> const testCases = {
                 {0, "Batch", "tesSUCCESS", batchID, std::nullopt},
                 {1, "Payment", "tesSUCCESS", txIDs[0], batchID},
                 {2, "Payment", "tesSUCCESS", txIDs[1], batchID},
@@ -3959,7 +3959,7 @@ class Batch_test : public beast::unit_test::suite
                 batch::sig(bob));
             env.close();
 
-            std::vector<TestLedgerData> testCases = {
+            std::vector<TestLedgerData> const testCases = {
                 {0, "Batch", "tesSUCCESS", batchID, std::nullopt},
                 {1, "Payment", "tesSUCCESS", txIDs[0], batchID},
                 {2, "Payment", "tesSUCCESS", txIDs[1], batchID},
@@ -4009,7 +4009,7 @@ class Batch_test : public beast::unit_test::suite
                 batch::inner(pay(alice, bob, XRP(2)), seq + 2));
             env.close();
 
-            std::vector<TestLedgerData> testCases = {
+            std::vector<TestLedgerData> const testCases = {
                 {0, "Batch", "tesSUCCESS", batchID, std::nullopt},
                 {1, "AccountSet", "tesSUCCESS", txIDs[0], batchID},
                 {2, "Payment", "tesSUCCESS", txIDs[1], batchID},
@@ -4029,8 +4029,8 @@ class Batch_test : public beast::unit_test::suite
         // MPTokenIssuanceSet with granular permission
         {
             test::jtx::Env env{*this, features};
-            Account alice{"alice"};
-            Account bob{"bob"};
+            Account const alice{"alice"};
+            Account const bob{"bob"};
             env.fund(XRP(100000), alice, bob);
             env.close();
 
@@ -4071,7 +4071,7 @@ class Batch_test : public beast::unit_test::suite
                 batch::inner(jv2, seq + 2));
             env.close();
 
-            std::vector<TestLedgerData> testCases = {
+            std::vector<TestLedgerData> const testCases = {
                 {0, "Batch", "tesSUCCESS", batchID, std::nullopt},
                 {1, "MPTokenIssuanceSet", "tesSUCCESS", txIDs[0], batchID},
                 {2, "MPTokenIssuanceSet", "tesSUCCESS", txIDs[1], batchID},
@@ -4084,9 +4084,9 @@ class Batch_test : public beast::unit_test::suite
         // with granular permission
         {
             test::jtx::Env env{*this, features};
-            Account gw{"gw"};
-            Account alice{"alice"};
-            Account bob{"bob"};
+            Account const gw{"gw"};
+            Account const alice{"alice"};
+            Account const bob{"bob"};
             env.fund(XRP(10000), gw, alice, bob);
             env(fset(gw, asfRequireAuth));
             env.close();
@@ -4112,7 +4112,7 @@ class Batch_test : public beast::unit_test::suite
                 batch::inner(jv2, seq + 2));
             env.close();
 
-            std::vector<TestLedgerData> testCases = {
+            std::vector<TestLedgerData> const testCases = {
                 {0, "Batch", "tesSUCCESS", batchID, std::nullopt},
                 {1, "TrustSet", "tesSUCCESS", txIDs[0], batchID},
                 {2, "TrustSet", "tesSUCCESS", txIDs[1], batchID},
@@ -4123,9 +4123,9 @@ class Batch_test : public beast::unit_test::suite
         // inner transaction not authorized by the delegating account.
         {
             test::jtx::Env env{*this, features};
-            Account gw{"gw"};
-            Account alice{"alice"};
-            Account bob{"bob"};
+            Account const gw{"gw"};
+            Account const alice{"alice"};
+            Account const bob{"bob"};
             env.fund(XRP(10000), gw, alice, bob);
             env(fset(gw, asfRequireAuth));
             env.close();
@@ -4152,7 +4152,7 @@ class Batch_test : public beast::unit_test::suite
                 batch::inner(jv2, seq + 2));
             env.close();
 
-            std::vector<TestLedgerData> testCases = {
+            std::vector<TestLedgerData> const testCases = {
                 {0, "Batch", "tesSUCCESS", batchID, std::nullopt},
                 {1, "TrustSet", "tesSUCCESS", txIDs[0], batchID},
             };
diff --git a/src/test/app/Check_test.cpp b/src/test/app/Check_test.cpp
index 671f8aab1a..1e5d90f650 100644
--- a/src/test/app/Check_test.cpp
+++ b/src/test/app/Check_test.cpp
@@ -1880,7 +1880,7 @@ class Check_test : public beast::unit_test::suite
         // Automatic trust line creation should fail if the check destination
         // can't afford the reserve for the trust line.
         {
-            AccountOwns gw1{*this, env, "gw1", 0};
+            AccountOwns const gw1{*this, env, "gw1", 0};
 
             // Fund gw1 with noripple (even though that's atypical for a
             // gateway) so it does not have any flags set.  We'll set flags
@@ -2000,7 +2000,7 @@ class Check_test : public beast::unit_test::suite
         {
             // No account root flags on any participant.
             // Automatic trust line from issuer to destination.
-            AccountOwns gw1{*this, env, "gw1", 0};
+            AccountOwns const gw1{*this, env, "gw1", 0};
 
             BEAST_EXPECT((*env.le(gw1))[sfFlags] == 0);
             BEAST_EXPECT((*env.le(alice))[sfFlags] == 0);
@@ -2053,7 +2053,7 @@ class Check_test : public beast::unit_test::suite
             // Transfer of assets using offers does not require rippling.
             // So bob's offer is successfully crossed which creates the
             // trust line.
-            AccountOwns gw1{*this, env, "gw1", 0};
+            AccountOwns const gw1{*this, env, "gw1", 0};
             IOU const OF1 = gw1["OF1"];
             env(offer(alice, XRP(97), OF1(97)));
             env.close();
@@ -2102,7 +2102,7 @@ class Check_test : public beast::unit_test::suite
         {
             // gw1 enables rippling.
             // Automatic trust line from issuer to non-issuer should still work.
-            AccountOwns gw1{*this, env, "gw1", 0};
+            AccountOwns const gw1{*this, env, "gw1", 0};
             env(fset(gw1, asfDefaultRipple));
             env.close();
 
@@ -2150,7 +2150,7 @@ class Check_test : public beast::unit_test::suite
             // to non-issuer should work.
 
             // Use offers to automatically create the trust line.
-            AccountOwns gw1{*this, env, "gw1", 0};
+            AccountOwns const gw1{*this, env, "gw1", 0};
             IOU const OF2 = gw1["OF2"];
             env(offer(alice, XRP(95), OF2(95)));
             env.close();
@@ -2191,7 +2191,7 @@ class Check_test : public beast::unit_test::suite
             // change any outcomes.
             //
             // Automatic trust line from issuer to non-issuer should still work.
-            AccountOwns gw1{*this, env, "gw1", 0};
+            AccountOwns const gw1{*this, env, "gw1", 0};
             env(fset(gw1, asfDepositAuth));
             env(fset(alice, asfDepositAuth));
             env(fset(bob, asfDepositAuth));
@@ -2241,7 +2241,7 @@ class Check_test : public beast::unit_test::suite
             // automatic trust line creation.
 
             // Use offers to automatically create the trust line.
-            AccountOwns gw1{*this, env, "gw1", 0};
+            AccountOwns const gw1{*this, env, "gw1", 0};
             IOU const OF3 = gw1["OF3"];
             env(offer(alice, XRP(93), OF3(93)));
             env.close();
@@ -2278,7 +2278,7 @@ class Check_test : public beast::unit_test::suite
         {
             // Set lsfGlobalFreeze on gw1.  That should stop any automatic
             // trust lines from being created.
-            AccountOwns gw1{*this, env, "gw1", 0};
+            AccountOwns const gw1{*this, env, "gw1", 0};
             env(fset(gw1, asfGlobalFreeze));
             env.close();
 
@@ -2320,7 +2320,7 @@ class Check_test : public beast::unit_test::suite
             // no automatic trust line creation between non-issuers.
 
             // Use offers to automatically create the trust line.
-            AccountOwns gw1{*this, env, "gw1", 0};
+            AccountOwns const gw1{*this, env, "gw1", 0};
             IOU const OF4 = gw1["OF4"];
             env(offer(alice, XRP(91), OF4(91)), ter(tecFROZEN));
             env.close();
@@ -2370,7 +2370,7 @@ class Check_test : public beast::unit_test::suite
 
             // Use offers to automatically create the trust line.
             IOU const OF5 = gw2["OF5"];
-            std::uint32_t gw2OfferSeq = {env.seq(gw2)};
+            std::uint32_t const gw2OfferSeq = {env.seq(gw2)};
             env(offer(gw2, XRP(92), OF5(92)));
             ++gw2.owners;
             env.close();
@@ -2423,7 +2423,7 @@ class Check_test : public beast::unit_test::suite
             // no automatic trust line creation between non-issuers.
 
             // Use offers to automatically create the trust line.
-            AccountOwns gw2{*this, env, "gw2", 0};
+            AccountOwns const gw2{*this, env, "gw2", 0};
             IOU const OF5 = gw2["OF5"];
             env(offer(alice, XRP(91), OF5(91)), ter(tecUNFUNDED_OFFER));
             env.close();
diff --git a/src/test/app/Clawback_test.cpp b/src/test/app/Clawback_test.cpp
index d169e9e165..902acf3222 100644
--- a/src/test/app/Clawback_test.cpp
+++ b/src/test/app/Clawback_test.cpp
@@ -52,7 +52,7 @@ class Clawback_test : public beast::unit_test::suite
         // Also, asfAllowTrustLineClawback cannot be cleared.
         {
             Env env(*this, features);
-            Account alice{"alice"};
+            Account const alice{"alice"};
 
             env.fund(XRP(1000), alice);
             env.close();
@@ -77,7 +77,7 @@ class Clawback_test : public beast::unit_test::suite
         // asfNoFreeze has been set
         {
             Env env(*this, features);
-            Account alice{"alice"};
+            Account const alice{"alice"};
 
             env.fund(XRP(1000), alice);
             env.close();
@@ -103,8 +103,8 @@ class Clawback_test : public beast::unit_test::suite
         {
             Env env(*this, features);
 
-            Account alice{"alice"};
-            Account bob{"bob"};
+            Account const alice{"alice"};
+            Account const bob{"bob"};
 
             env.fund(XRP(1000), alice, bob);
             env.close();
@@ -146,7 +146,7 @@ class Clawback_test : public beast::unit_test::suite
         {
             Env env(*this, features - featureClawback);
 
-            Account alice{"alice"};
+            Account const alice{"alice"};
 
             env.fund(XRP(1000), alice);
             env.close();
@@ -183,8 +183,8 @@ class Clawback_test : public beast::unit_test::suite
         {
             Env env(*this, features - featureClawback);
 
-            Account alice{"alice"};
-            Account bob{"bob"};
+            Account const alice{"alice"};
+            Account const bob{"bob"};
 
             env.fund(XRP(1000), alice, bob);
             env.close();
@@ -228,8 +228,8 @@ class Clawback_test : public beast::unit_test::suite
         {
             Env env(*this, features);
 
-            Account alice{"alice"};
-            Account bob{"bob"};
+            Account const alice{"alice"};
+            Account const bob{"bob"};
 
             env.fund(XRP(1000), alice, bob);
             env.close();
@@ -310,8 +310,8 @@ class Clawback_test : public beast::unit_test::suite
         {
             Env env(*this, features);
 
-            Account alice{"alice"};
-            Account bob{"bob"};
+            Account const alice{"alice"};
+            Account const bob{"bob"};
 
             // bob's account is not funded and does not exist
             env.fund(XRP(1000), alice);
@@ -332,9 +332,9 @@ class Clawback_test : public beast::unit_test::suite
         {
             Env env(*this, features);
 
-            Account alice{"alice"};
-            Account bob{"bob"};
-            Account cindy{"cindy"};
+            Account const alice{"alice"};
+            Account const bob{"bob"};
+            Account const cindy{"cindy"};
 
             env.fund(XRP(1000), alice, bob, cindy);
             env.close();
@@ -375,8 +375,8 @@ class Clawback_test : public beast::unit_test::suite
         {
             Env env(*this, features);
 
-            Account alice{"alice"};
-            Account bob{"bob"};
+            Account const alice{"alice"};
+            Account const bob{"bob"};
 
             env.fund(XRP(1000), alice, bob);
             env.close();
@@ -445,8 +445,8 @@ class Clawback_test : public beast::unit_test::suite
         // Test that alice is able to successfully clawback tokens from bob
         Env env(*this, features);
 
-        Account alice{"alice"};
-        Account bob{"bob"};
+        Account const alice{"alice"};
+        Account const bob{"bob"};
 
         env.fund(XRP(1000), alice, bob);
         env.close();
@@ -496,9 +496,9 @@ class Clawback_test : public beast::unit_test::suite
         {
             Env env(*this, features);
 
-            Account alice{"alice"};
-            Account bob{"bob"};
-            Account cindy{"cindy"};
+            Account const alice{"alice"};
+            Account const bob{"bob"};
+            Account const cindy{"cindy"};
 
             env.fund(XRP(1000), alice, bob, cindy);
             env.close();
@@ -554,9 +554,9 @@ class Clawback_test : public beast::unit_test::suite
         {
             Env env(*this, features);
 
-            Account alice{"alice"};
-            Account bob{"bob"};
-            Account cindy{"cindy"};
+            Account const alice{"alice"};
+            Account const bob{"bob"};
+            Account const cindy{"cindy"};
 
             env.fund(XRP(1000), alice, bob, cindy);
             env.close();
@@ -624,8 +624,8 @@ class Clawback_test : public beast::unit_test::suite
         // perspective is allowed to clawback
         Env env(*this, features);
 
-        Account alice{"alice"};
-        Account bob{"bob"};
+        Account const alice{"alice"};
+        Account const bob{"bob"};
 
         env.fund(XRP(1000), alice, bob);
         env.close();
@@ -711,8 +711,8 @@ class Clawback_test : public beast::unit_test::suite
         // If clawback results the trustline to be default,
         // trustline should be automatically deleted
         Env env(*this, features);
-        Account alice{"alice"};
-        Account bob{"bob"};
+        Account const alice{"alice"};
+        Account const bob{"bob"};
 
         env.fund(XRP(1000), alice, bob);
         env.close();
@@ -761,8 +761,8 @@ class Clawback_test : public beast::unit_test::suite
         // Claws back from frozen trustline
         // and the trustline should remain frozen
         Env env(*this, features);
-        Account alice{"alice"};
-        Account bob{"bob"};
+        Account const alice{"alice"};
+        Account const bob{"bob"};
 
         env.fund(XRP(1000), alice, bob);
         env.close();
@@ -807,8 +807,8 @@ class Clawback_test : public beast::unit_test::suite
         // When alice tries to claw back an amount that is greater
         // than what bob holds, only the max available balance is clawed
         Env env(*this, features);
-        Account alice{"alice"};
-        Account bob{"bob"};
+        Account const alice{"alice"};
+        Account const bob{"bob"};
 
         env.fund(XRP(1000), alice, bob);
         env.close();
@@ -859,8 +859,8 @@ class Clawback_test : public beast::unit_test::suite
 
         // Tests clawback with tickets
         Env env(*this, features);
-        Account alice{"alice"};
-        Account bob{"bob"};
+        Account const alice{"alice"};
+        Account const bob{"bob"};
 
         env.fund(XRP(1000), alice, bob);
         env.close();
diff --git a/src/test/app/DNS_test.cpp b/src/test/app/DNS_test.cpp
index 9b75e66b85..2273a77e09 100644
--- a/src/test/app/DNS_test.cpp
+++ b/src/test/app/DNS_test.cpp
@@ -62,7 +62,7 @@ public:
     {
         using boost::asio::ip::tcp;
         tcp::resolver resolver(env_.app().getIOContext());
-        std::string port = pUrl_.port ? std::to_string(*pUrl_.port) : "443";
+        std::string const port = pUrl_.port ? std::to_string(*pUrl_.port) : "443";
         auto results = resolver.resolve(pUrl_.domain, port);
         auto it = results.begin();
         auto end = results.end();
diff --git a/src/test/app/Delegate_test.cpp b/src/test/app/Delegate_test.cpp
index 2618a95d0d..3f6d5e6b47 100644
--- a/src/test/app/Delegate_test.cpp
+++ b/src/test/app/Delegate_test.cpp
@@ -16,9 +16,9 @@ class Delegate_test : public beast::unit_test::suite
         using namespace jtx;
 
         Env env{*this, features};
-        Account gw{"gateway"};
-        Account alice{"alice"};
-        Account bob{"bob"};
+        Account const gw{"gateway"};
+        Account const alice{"alice"};
+        Account const bob{"bob"};
         env.fund(XRP(1000000), gw, alice, bob);
         env.close();
 
@@ -39,8 +39,8 @@ class Delegate_test : public beast::unit_test::suite
         using namespace jtx;
 
         Env env(*this);
-        Account gw{"gateway"};
-        Account alice{"alice"};
+        Account const gw{"gateway"};
+        Account const alice{"alice"};
         env.fund(XRP(100000), gw, alice);
         env.close();
 
@@ -112,9 +112,9 @@ class Delegate_test : public beast::unit_test::suite
         using namespace jtx;
 
         Env env(*this, features);
-        Account gw{"gateway"};
-        Account alice{"alice"};
-        Account bob{"bob"};
+        Account const gw{"gateway"};
+        Account const alice{"alice"};
+        Account const bob{"bob"};
         env.fund(XRP(100000), gw, alice, bob);
         env.close();
 
@@ -203,8 +203,8 @@ class Delegate_test : public beast::unit_test::suite
         // reserve requirement not met
         {
             Env env(*this);
-            Account alice{"alice"};
-            Account bob{"bob"};
+            Account const alice{"alice"};
+            Account const bob{"bob"};
 
             auto const txFee = env.current()->fees().base;
             env.fund(env.current()->fees().accountReserve(0) + txFee, alice);
@@ -218,9 +218,9 @@ class Delegate_test : public beast::unit_test::suite
         // reserve recovered after deleting delegation object
         {
             Env env(*this);
-            Account bob{"bob"};
-            Account alice{"alice"};
-            Account carol{"carol"};
+            Account const bob{"bob"};
+            Account const alice{"alice"};
+            Account const carol{"carol"};
 
             auto const txFee = env.current()->fees().base;
 
@@ -247,8 +247,8 @@ class Delegate_test : public beast::unit_test::suite
         // test reserve when sending transaction on behalf of other account
         {
             Env env(*this);
-            Account alice{"alice"};
-            Account bob{"bob"};
+            Account const alice{"alice"};
+            Account const bob{"bob"};
 
             env.fund(drops(env.current()->fees().accountReserve(1)), alice);
             env.fund(drops(env.current()->fees().accountReserve(2)), bob);
@@ -275,9 +275,9 @@ class Delegate_test : public beast::unit_test::suite
         using namespace jtx;
 
         Env env(*this);
-        Account alice{"alice"};
-        Account bob{"bob"};
-        Account carol{"carol"};
+        Account const alice{"alice"};
+        Account const bob{"bob"};
+        Account const carol{"carol"};
         env.fund(XRP(10000), alice, carol);
         env.fund(XRP(1000), bob);
         env.close();
@@ -357,9 +357,9 @@ class Delegate_test : public beast::unit_test::suite
         using namespace jtx;
 
         Env env(*this);
-        Account alice{"alice"};
-        Account bob{"bob"};
-        Account carol{"carol"};
+        Account const alice{"alice"};
+        Account const bob{"bob"};
+        Account const carol{"carol"};
         env.fund(XRP(10000), alice, bob, carol);
         env.close();
 
@@ -410,8 +410,8 @@ class Delegate_test : public beast::unit_test::suite
         using namespace jtx;
 
         Env env(*this);
-        Account alice{"alice"};
-        Account bob{"bob"};
+        Account const alice{"alice"};
+        Account const bob{"bob"};
         env.fund(XRP(100000), alice, bob);
         env.close();
 
@@ -444,9 +444,9 @@ class Delegate_test : public beast::unit_test::suite
         using namespace jtx;
 
         Env env(*this);
-        Account alice{"alice"};
-        Account bob{"bob"};
-        Account carol{"carol"};
+        Account const alice{"alice"};
+        Account const bob{"bob"};
+        Account const carol{"carol"};
 
         XRPAmount const baseFee{env.current()->fees().base};
 
@@ -510,10 +510,10 @@ class Delegate_test : public beast::unit_test::suite
         // test PaymentMint and PaymentBurn
         {
             Env env(*this);
-            Account alice{"alice"};
-            Account bob{"bob"};
-            Account gw{"gateway"};
-            Account gw2{"gateway2"};
+            Account const alice{"alice"};
+            Account const bob{"bob"};
+            Account const gw{"gateway"};
+            Account const gw2{"gateway2"};
             auto const USD = gw["USD"];
             auto const EUR = gw2["EUR"];
 
@@ -615,9 +615,9 @@ class Delegate_test : public beast::unit_test::suite
         // test PaymentMint won't affect Payment transaction level delegation.
         {
             Env env(*this);
-            Account alice{"alice"};
-            Account bob{"bob"};
-            Account gw{"gateway"};
+            Account const alice{"alice"};
+            Account const bob{"bob"};
+            Account const gw{"gateway"};
             auto const USD = gw["USD"];
 
             env.fund(XRP(10000), alice);
@@ -805,9 +805,9 @@ class Delegate_test : public beast::unit_test::suite
         // test TrustlineUnfreeze, TrustlineFreeze and TrustlineAuthorize
         {
             Env env(*this);
-            Account gw{"gw"};
-            Account alice{"alice"};
-            Account bob{"bob"};
+            Account const gw{"gw"};
+            Account const alice{"alice"};
+            Account const bob{"bob"};
             env.fund(XRP(10000), gw, alice, bob);
             env(fset(gw, asfRequireAuth));
             env.close();
@@ -917,9 +917,9 @@ class Delegate_test : public beast::unit_test::suite
         // test mix of transaction level delegation and granular delegation
         {
             Env env(*this);
-            Account gw{"gw"};
-            Account alice{"alice"};
-            Account bob{"bob"};
+            Account const gw{"gw"};
+            Account const alice{"alice"};
+            Account const bob{"bob"};
             env.fund(XRP(10000), gw, alice, bob);
             env(fset(gw, asfRequireAuth));
             env.close();
@@ -962,9 +962,9 @@ class Delegate_test : public beast::unit_test::suite
         // tfFullyCanonicalSig won't block delegated transaction
         {
             Env env(*this);
-            Account gw{"gw"};
-            Account alice{"alice"};
-            Account bob{"bob"};
+            Account const gw{"gw"};
+            Account const alice{"alice"};
+            Account const bob{"bob"};
             env.fund(XRP(10000), gw, alice, bob);
             env(fset(gw, asfRequireAuth));
             env.close();
@@ -1210,8 +1210,8 @@ class Delegate_test : public beast::unit_test::suite
         // tfFullyCanonicalSig won't block delegated transaction
         {
             Env env(*this);
-            Account alice{"alice"};
-            Account bob{"bob"};
+            Account const alice{"alice"};
+            Account const bob{"bob"};
             env.fund(XRP(10000), alice, bob);
             env.close();
 
@@ -1356,9 +1356,9 @@ class Delegate_test : public beast::unit_test::suite
         using namespace jtx;
 
         Env env(*this);
-        Account alice{"alice"};
-        Account bob{"bob"};
-        Account carol{"carol"};
+        Account const alice{"alice"};
+        Account const bob{"bob"};
+        Account const carol{"carol"};
         env.fund(XRP(100000), alice, bob, carol);
         env.close();
 
@@ -1384,9 +1384,9 @@ class Delegate_test : public beast::unit_test::suite
 
         {
             Env env(*this);
-            Account alice{"alice"};
-            Account bob{"bob"};
-            Account carol{"carol"};
+            Account const alice{"alice"};
+            Account const bob{"bob"};
+            Account const carol{"carol"};
             env.fund(XRP(100000), alice, bob, carol);
             env.close();
 
@@ -1410,7 +1410,11 @@ class Delegate_test : public beast::unit_test::suite
 
         {
             Env env(*this);
-            Account alice{"alice"}, bob{"bob"}, carol{"carol"};
+
+            Account const alice{"alice"};
+            Account const bob{"bob"};
+            Account const carol{"carol"};
+
             env.fund(XRP(100000), alice, bob, carol);
             env.close();
 
@@ -1444,7 +1448,11 @@ class Delegate_test : public beast::unit_test::suite
 
         {
             Env env(*this);
-            Account alice{"alice"}, bob{"bob"}, carol{"carol"};
+
+            Account const alice{"alice"};
+            Account const bob{"bob"};
+            Account const carol{"carol"};
+
             env.fund(XRP(100000), alice, bob, carol);
             env.close();
 
@@ -1481,9 +1489,9 @@ class Delegate_test : public beast::unit_test::suite
         using namespace jtx;
 
         Env env(*this);
-        Account alice{"alice"};
-        Account bob{"bob"};
-        Account carol{"carol"};
+        Account const alice{"alice"};
+        Account const bob{"bob"};
+        Account const carol{"carol"};
         Account daria{"daria"};
         Account edward{"edward"};
         env.fund(XRP(100000), alice, bob, carol, daria, edward);
@@ -1517,9 +1525,9 @@ class Delegate_test : public beast::unit_test::suite
         using namespace jtx;
 
         Env env(*this);
-        Account alice{"alice"};
-        Account bob{"bob"};
-        Account carol{"carol"};
+        Account const alice{"alice"};
+        Account const bob{"bob"};
+        Account const carol{"carol"};
         Account daria = Account{"daria"};
         Account edward = Account{"edward"};
         Account fred = Account{"fred"};
diff --git a/src/test/app/Discrepancy_test.cpp b/src/test/app/Discrepancy_test.cpp
index 3f808b37d8..d8c14df64e 100644
--- a/src/test/app/Discrepancy_test.cpp
+++ b/src/test/app/Discrepancy_test.cpp
@@ -24,13 +24,13 @@ class Discrepancy_test : public beast::unit_test::suite
         using namespace test::jtx;
         Env env{*this, features};
 
-        Account A1{"A1"};
-        Account A2{"A2"};
-        Account A3{"A3"};
-        Account A4{"A4"};
-        Account A5{"A5"};
-        Account A6{"A6"};
-        Account A7{"A7"};
+        Account const A1{"A1"};
+        Account const A2{"A2"};
+        Account const A3{"A3"};
+        Account const A4{"A4"};
+        Account const A5{"A5"};
+        Account const A6{"A6"};
+        Account const A7{"A7"};
 
         env.fund(XRP(2000), A1);
         env.fund(XRP(1000), A2, A6, A7);
@@ -68,7 +68,7 @@ class Discrepancy_test : public beast::unit_test::suite
         env(offer(A7, XRP(1233), A6["CNY"](25)));
         env.close();
 
-        test::PathSet payPaths{
+        test::PathSet const payPaths{
             test::Path{A2["JPY"], A2},
             test::Path{XRP, A2["JPY"], A2},
             test::Path{A6, XRP, A2["JPY"], A2}};
@@ -84,7 +84,7 @@ class Discrepancy_test : public beast::unit_test::suite
         jrq2[jss::transaction] = env.tx()->getJson(JsonOptions::none)[jss::hash];
         jrq2[jss::id] = 3;
         auto jrr = env.rpc("json", "tx", to_string(jrq2))[jss::result];
-        uint64_t fee{jrr[jss::Fee].asUInt()};
+        uint64_t const fee{jrr[jss::Fee].asUInt()};
         auto meta = jrr[jss::meta];
         uint64_t sumPrev{0};
         uint64_t sumFinal{0};
diff --git a/src/test/app/EscrowToken_test.cpp b/src/test/app/EscrowToken_test.cpp
index 619b584ddb..6e08c3eddf 100644
--- a/src/test/app/EscrowToken_test.cpp
+++ b/src/test/app/EscrowToken_test.cpp
@@ -983,13 +983,13 @@ struct EscrowToken_test : public beast::unit_test::suite
             auto const aa = env.le(keylet::escrow(alice.id(), aseq));
             BEAST_EXPECT(aa);
             {
-                xrpl::Dir aod(*env.current(), keylet::ownerDir(alice.id()));
+                xrpl::Dir const aod(*env.current(), keylet::ownerDir(alice.id()));
                 BEAST_EXPECT(std::distance(aod.begin(), aod.end()) == 2);
                 BEAST_EXPECT(std::find(aod.begin(), aod.end(), aa) != aod.end());
             }
 
             {
-                xrpl::Dir iod(*env.current(), keylet::ownerDir(gw.id()));
+                xrpl::Dir const iod(*env.current(), keylet::ownerDir(gw.id()));
                 BEAST_EXPECT(std::distance(iod.begin(), iod.end()) == 4);
                 BEAST_EXPECT(std::find(iod.begin(), iod.end(), aa) != iod.end());
             }
@@ -1004,13 +1004,13 @@ struct EscrowToken_test : public beast::unit_test::suite
             BEAST_EXPECT(bb);
 
             {
-                xrpl::Dir bod(*env.current(), keylet::ownerDir(bob.id()));
+                xrpl::Dir const bod(*env.current(), keylet::ownerDir(bob.id()));
                 BEAST_EXPECT(std::distance(bod.begin(), bod.end()) == 2);
                 BEAST_EXPECT(std::find(bod.begin(), bod.end(), bb) != bod.end());
             }
 
             {
-                xrpl::Dir iod(*env.current(), keylet::ownerDir(gw.id()));
+                xrpl::Dir const iod(*env.current(), keylet::ownerDir(gw.id()));
                 BEAST_EXPECT(std::distance(iod.begin(), iod.end()) == 5);
                 BEAST_EXPECT(std::find(iod.begin(), iod.end(), bb) != iod.end());
             }
@@ -1022,15 +1022,15 @@ struct EscrowToken_test : public beast::unit_test::suite
                 BEAST_EXPECT(
                     (*env.meta())[sfTransactionResult] == static_cast<std::uint8_t>(tesSUCCESS));
 
-                xrpl::Dir aod(*env.current(), keylet::ownerDir(alice.id()));
+                xrpl::Dir const aod(*env.current(), keylet::ownerDir(alice.id()));
                 BEAST_EXPECT(std::distance(aod.begin(), aod.end()) == 1);
                 BEAST_EXPECT(std::find(aod.begin(), aod.end(), aa) == aod.end());
 
-                xrpl::Dir bod(*env.current(), keylet::ownerDir(bob.id()));
+                xrpl::Dir const bod(*env.current(), keylet::ownerDir(bob.id()));
                 BEAST_EXPECT(std::distance(bod.begin(), bod.end()) == 2);
                 BEAST_EXPECT(std::find(bod.begin(), bod.end(), bb) != bod.end());
 
-                xrpl::Dir iod(*env.current(), keylet::ownerDir(gw.id()));
+                xrpl::Dir const iod(*env.current(), keylet::ownerDir(gw.id()));
                 BEAST_EXPECT(std::distance(iod.begin(), iod.end()) == 4);
                 BEAST_EXPECT(std::find(iod.begin(), iod.end(), bb) != iod.end());
             }
@@ -1042,11 +1042,11 @@ struct EscrowToken_test : public beast::unit_test::suite
                 BEAST_EXPECT(
                     (*env.meta())[sfTransactionResult] == static_cast<std::uint8_t>(tesSUCCESS));
 
-                xrpl::Dir bod(*env.current(), keylet::ownerDir(bob.id()));
+                xrpl::Dir const bod(*env.current(), keylet::ownerDir(bob.id()));
                 BEAST_EXPECT(std::distance(bod.begin(), bod.end()) == 1);
                 BEAST_EXPECT(std::find(bod.begin(), bod.end(), bb) == bod.end());
 
-                xrpl::Dir iod(*env.current(), keylet::ownerDir(gw.id()));
+                xrpl::Dir const iod(*env.current(), keylet::ownerDir(gw.id()));
                 BEAST_EXPECT(std::distance(iod.begin(), iod.end()) == 3);
                 BEAST_EXPECT(std::find(iod.begin(), iod.end(), bb) == iod.end());
             }
@@ -1085,20 +1085,20 @@ struct EscrowToken_test : public beast::unit_test::suite
             BEAST_EXPECT(bc);
 
             {
-                xrpl::Dir aod(*env.current(), keylet::ownerDir(alice.id()));
+                xrpl::Dir const aod(*env.current(), keylet::ownerDir(alice.id()));
                 BEAST_EXPECT(std::distance(aod.begin(), aod.end()) == 2);
                 BEAST_EXPECT(std::find(aod.begin(), aod.end(), ab) != aod.end());
 
-                xrpl::Dir bod(*env.current(), keylet::ownerDir(bob.id()));
+                xrpl::Dir const bod(*env.current(), keylet::ownerDir(bob.id()));
                 BEAST_EXPECT(std::distance(bod.begin(), bod.end()) == 3);
                 BEAST_EXPECT(std::find(bod.begin(), bod.end(), ab) != bod.end());
                 BEAST_EXPECT(std::find(bod.begin(), bod.end(), bc) != bod.end());
 
-                xrpl::Dir cod(*env.current(), keylet::ownerDir(carol.id()));
+                xrpl::Dir const cod(*env.current(), keylet::ownerDir(carol.id()));
                 BEAST_EXPECT(std::distance(cod.begin(), cod.end()) == 2);
                 BEAST_EXPECT(std::find(cod.begin(), cod.end(), bc) != cod.end());
 
-                xrpl::Dir iod(*env.current(), keylet::ownerDir(gw.id()));
+                xrpl::Dir const iod(*env.current(), keylet::ownerDir(gw.id()));
                 BEAST_EXPECT(std::distance(iod.begin(), iod.end()) == 5);
                 BEAST_EXPECT(std::find(iod.begin(), iod.end(), ab) != iod.end());
                 BEAST_EXPECT(std::find(iod.begin(), iod.end(), bc) != iod.end());
@@ -1110,19 +1110,19 @@ struct EscrowToken_test : public beast::unit_test::suite
                 BEAST_EXPECT(!env.le(keylet::escrow(alice.id(), aseq)));
                 BEAST_EXPECT(env.le(keylet::escrow(bob.id(), bseq)));
 
-                xrpl::Dir aod(*env.current(), keylet::ownerDir(alice.id()));
+                xrpl::Dir const aod(*env.current(), keylet::ownerDir(alice.id()));
                 BEAST_EXPECT(std::distance(aod.begin(), aod.end()) == 1);
                 BEAST_EXPECT(std::find(aod.begin(), aod.end(), ab) == aod.end());
 
-                xrpl::Dir bod(*env.current(), keylet::ownerDir(bob.id()));
+                xrpl::Dir const bod(*env.current(), keylet::ownerDir(bob.id()));
                 BEAST_EXPECT(std::distance(bod.begin(), bod.end()) == 2);
                 BEAST_EXPECT(std::find(bod.begin(), bod.end(), ab) == bod.end());
                 BEAST_EXPECT(std::find(bod.begin(), bod.end(), bc) != bod.end());
 
-                xrpl::Dir cod(*env.current(), keylet::ownerDir(carol.id()));
+                xrpl::Dir const cod(*env.current(), keylet::ownerDir(carol.id()));
                 BEAST_EXPECT(std::distance(cod.begin(), cod.end()) == 2);
 
-                xrpl::Dir iod(*env.current(), keylet::ownerDir(gw.id()));
+                xrpl::Dir const iod(*env.current(), keylet::ownerDir(gw.id()));
                 BEAST_EXPECT(std::distance(iod.begin(), iod.end()) == 4);
                 BEAST_EXPECT(std::find(iod.begin(), iod.end(), ab) == iod.end());
                 BEAST_EXPECT(std::find(iod.begin(), iod.end(), bc) != iod.end());
@@ -1134,19 +1134,19 @@ struct EscrowToken_test : public beast::unit_test::suite
                 BEAST_EXPECT(!env.le(keylet::escrow(alice.id(), aseq)));
                 BEAST_EXPECT(!env.le(keylet::escrow(bob.id(), bseq)));
 
-                xrpl::Dir aod(*env.current(), keylet::ownerDir(alice.id()));
+                xrpl::Dir const aod(*env.current(), keylet::ownerDir(alice.id()));
                 BEAST_EXPECT(std::distance(aod.begin(), aod.end()) == 1);
                 BEAST_EXPECT(std::find(aod.begin(), aod.end(), ab) == aod.end());
 
-                xrpl::Dir bod(*env.current(), keylet::ownerDir(bob.id()));
+                xrpl::Dir const bod(*env.current(), keylet::ownerDir(bob.id()));
                 BEAST_EXPECT(std::distance(bod.begin(), bod.end()) == 1);
                 BEAST_EXPECT(std::find(bod.begin(), bod.end(), ab) == bod.end());
                 BEAST_EXPECT(std::find(bod.begin(), bod.end(), bc) == bod.end());
 
-                xrpl::Dir cod(*env.current(), keylet::ownerDir(carol.id()));
+                xrpl::Dir const cod(*env.current(), keylet::ownerDir(carol.id()));
                 BEAST_EXPECT(std::distance(cod.begin(), cod.end()) == 1);
 
-                xrpl::Dir iod(*env.current(), keylet::ownerDir(gw.id()));
+                xrpl::Dir const iod(*env.current(), keylet::ownerDir(gw.id()));
                 BEAST_EXPECT(std::distance(iod.begin(), iod.end()) == 3);
                 BEAST_EXPECT(std::find(iod.begin(), iod.end(), ab) == iod.end());
                 BEAST_EXPECT(std::find(iod.begin(), iod.end(), bc) == iod.end());
@@ -1182,14 +1182,14 @@ struct EscrowToken_test : public beast::unit_test::suite
             BEAST_EXPECT(ag);
 
             {
-                xrpl::Dir aod(*env.current(), keylet::ownerDir(alice.id()));
+                xrpl::Dir const aod(*env.current(), keylet::ownerDir(alice.id()));
                 BEAST_EXPECT(std::distance(aod.begin(), aod.end()) == 2);
                 BEAST_EXPECT(std::find(aod.begin(), aod.end(), ag) != aod.end());
 
-                xrpl::Dir cod(*env.current(), keylet::ownerDir(carol.id()));
+                xrpl::Dir const cod(*env.current(), keylet::ownerDir(carol.id()));
                 BEAST_EXPECT(std::distance(cod.begin(), cod.end()) == 1);
 
-                xrpl::Dir iod(*env.current(), keylet::ownerDir(gw.id()));
+                xrpl::Dir const iod(*env.current(), keylet::ownerDir(gw.id()));
                 BEAST_EXPECT(std::distance(iod.begin(), iod.end()) == 3);
                 BEAST_EXPECT(std::find(iod.begin(), iod.end(), ag) != iod.end());
             }
@@ -1199,14 +1199,14 @@ struct EscrowToken_test : public beast::unit_test::suite
             {
                 BEAST_EXPECT(!env.le(keylet::escrow(alice.id(), aseq)));
 
-                xrpl::Dir aod(*env.current(), keylet::ownerDir(alice.id()));
+                xrpl::Dir const aod(*env.current(), keylet::ownerDir(alice.id()));
                 BEAST_EXPECT(std::distance(aod.begin(), aod.end()) == 1);
                 BEAST_EXPECT(std::find(aod.begin(), aod.end(), ag) == aod.end());
 
-                xrpl::Dir cod(*env.current(), keylet::ownerDir(carol.id()));
+                xrpl::Dir const cod(*env.current(), keylet::ownerDir(carol.id()));
                 BEAST_EXPECT(std::distance(cod.begin(), cod.end()) == 1);
 
-                xrpl::Dir iod(*env.current(), keylet::ownerDir(gw.id()));
+                xrpl::Dir const iod(*env.current(), keylet::ownerDir(gw.id()));
                 BEAST_EXPECT(std::distance(iod.begin(), iod.end()) == 2);
                 BEAST_EXPECT(std::find(iod.begin(), iod.end(), ag) == iod.end());
             }
@@ -1229,7 +1229,7 @@ struct EscrowToken_test : public beast::unit_test::suite
             bool negative;
         };
 
-        std::array<TestAccountData, 8> tests = {{
+        std::array<TestAccountData, 8> const tests = {{
             // src > dst && src > issuer && dst no trustline
             {Account("alice2"), Account("bob0"), Account{"gw0"}, false, true},
             // src < dst && src < issuer && dst no trustline
@@ -1335,7 +1335,7 @@ struct EscrowToken_test : public beast::unit_test::suite
             env.close();
         }
 
-        std::array<TestAccountData, 4> gwDstTests = {{
+        std::array<TestAccountData, 4> const gwDstTests = {{
             // src > dst && src > issuer && dst has trustline
             {Account("alice2"), Account{"gw0"}, true},
             // src < dst && src < issuer && dst has trustline
@@ -2522,7 +2522,7 @@ struct EscrowToken_test : public beast::unit_test::suite
                 Sandbox sb(&view, tapNONE);
                 auto sleNew = std::make_shared<SLE>(keylet::escrow(alice, seq1));
                 MPTIssue const mpt{MPTIssue{makeMptID(1, AccountID(0x4985601))}};
-                STAmount amt(mpt, 10);
+                STAmount const amt(mpt, 10);
                 sleNew->setAccountID(sfDestination, bob);
                 sleNew->setFieldAmount(sfAmount, amt);
                 sb.insert(sleNew);
@@ -2749,7 +2749,7 @@ struct EscrowToken_test : public beast::unit_test::suite
                 Sandbox sb(&view, tapNONE);
                 auto sleNew = std::make_shared<SLE>(keylet::escrow(alice, seq1));
                 MPTIssue const mpt{MPTIssue{makeMptID(1, AccountID(0x4985601))}};
-                STAmount amt(mpt, 10);
+                STAmount const amt(mpt, 10);
                 sleNew->setAccountID(sfDestination, bob);
                 sleNew->setFieldAmount(sfAmount, amt);
                 sb.insert(sleNew);
@@ -3100,13 +3100,13 @@ struct EscrowToken_test : public beast::unit_test::suite
             auto const aa = env.le(keylet::escrow(alice.id(), aseq));
             BEAST_EXPECT(aa);
             {
-                xrpl::Dir aod(*env.current(), keylet::ownerDir(alice.id()));
+                xrpl::Dir const aod(*env.current(), keylet::ownerDir(alice.id()));
                 BEAST_EXPECT(std::distance(aod.begin(), aod.end()) == 2);
                 BEAST_EXPECT(std::find(aod.begin(), aod.end(), aa) != aod.end());
             }
 
             {
-                xrpl::Dir iod(*env.current(), keylet::ownerDir(gw.id()));
+                xrpl::Dir const iod(*env.current(), keylet::ownerDir(gw.id()));
                 BEAST_EXPECT(std::distance(iod.begin(), iod.end()) == 1);
                 BEAST_EXPECT(std::find(iod.begin(), iod.end(), aa) == iod.end());
             }
@@ -3121,7 +3121,7 @@ struct EscrowToken_test : public beast::unit_test::suite
             BEAST_EXPECT(bb);
 
             {
-                xrpl::Dir bod(*env.current(), keylet::ownerDir(bob.id()));
+                xrpl::Dir const bod(*env.current(), keylet::ownerDir(bob.id()));
                 BEAST_EXPECT(std::distance(bod.begin(), bod.end()) == 2);
                 BEAST_EXPECT(std::find(bod.begin(), bod.end(), bb) != bod.end());
             }
@@ -3133,11 +3133,11 @@ struct EscrowToken_test : public beast::unit_test::suite
                 BEAST_EXPECT(
                     (*env.meta())[sfTransactionResult] == static_cast<std::uint8_t>(tesSUCCESS));
 
-                xrpl::Dir aod(*env.current(), keylet::ownerDir(alice.id()));
+                xrpl::Dir const aod(*env.current(), keylet::ownerDir(alice.id()));
                 BEAST_EXPECT(std::distance(aod.begin(), aod.end()) == 1);
                 BEAST_EXPECT(std::find(aod.begin(), aod.end(), aa) == aod.end());
 
-                xrpl::Dir bod(*env.current(), keylet::ownerDir(bob.id()));
+                xrpl::Dir const bod(*env.current(), keylet::ownerDir(bob.id()));
                 BEAST_EXPECT(std::distance(bod.begin(), bod.end()) == 2);
                 BEAST_EXPECT(std::find(bod.begin(), bod.end(), bb) != bod.end());
             }
@@ -3149,7 +3149,7 @@ struct EscrowToken_test : public beast::unit_test::suite
                 BEAST_EXPECT(
                     (*env.meta())[sfTransactionResult] == static_cast<std::uint8_t>(tesSUCCESS));
 
-                xrpl::Dir bod(*env.current(), keylet::ownerDir(bob.id()));
+                xrpl::Dir const bod(*env.current(), keylet::ownerDir(bob.id()));
                 BEAST_EXPECT(std::distance(bod.begin(), bod.end()) == 1);
                 BEAST_EXPECT(std::find(bod.begin(), bod.end(), bb) == bod.end());
             }
@@ -3191,16 +3191,16 @@ struct EscrowToken_test : public beast::unit_test::suite
             BEAST_EXPECT(bc);
 
             {
-                xrpl::Dir aod(*env.current(), keylet::ownerDir(alice.id()));
+                xrpl::Dir const aod(*env.current(), keylet::ownerDir(alice.id()));
                 BEAST_EXPECT(std::distance(aod.begin(), aod.end()) == 2);
                 BEAST_EXPECT(std::find(aod.begin(), aod.end(), ab) != aod.end());
 
-                xrpl::Dir bod(*env.current(), keylet::ownerDir(bob.id()));
+                xrpl::Dir const bod(*env.current(), keylet::ownerDir(bob.id()));
                 BEAST_EXPECT(std::distance(bod.begin(), bod.end()) == 3);
                 BEAST_EXPECT(std::find(bod.begin(), bod.end(), ab) != bod.end());
                 BEAST_EXPECT(std::find(bod.begin(), bod.end(), bc) != bod.end());
 
-                xrpl::Dir cod(*env.current(), keylet::ownerDir(carol.id()));
+                xrpl::Dir const cod(*env.current(), keylet::ownerDir(carol.id()));
                 BEAST_EXPECT(std::distance(cod.begin(), cod.end()) == 2);
                 BEAST_EXPECT(std::find(cod.begin(), cod.end(), bc) != cod.end());
             }
@@ -3211,16 +3211,16 @@ struct EscrowToken_test : public beast::unit_test::suite
                 BEAST_EXPECT(!env.le(keylet::escrow(alice.id(), aseq)));
                 BEAST_EXPECT(env.le(keylet::escrow(bob.id(), bseq)));
 
-                xrpl::Dir aod(*env.current(), keylet::ownerDir(alice.id()));
+                xrpl::Dir const aod(*env.current(), keylet::ownerDir(alice.id()));
                 BEAST_EXPECT(std::distance(aod.begin(), aod.end()) == 1);
                 BEAST_EXPECT(std::find(aod.begin(), aod.end(), ab) == aod.end());
 
-                xrpl::Dir bod(*env.current(), keylet::ownerDir(bob.id()));
+                xrpl::Dir const bod(*env.current(), keylet::ownerDir(bob.id()));
                 BEAST_EXPECT(std::distance(bod.begin(), bod.end()) == 2);
                 BEAST_EXPECT(std::find(bod.begin(), bod.end(), ab) == bod.end());
                 BEAST_EXPECT(std::find(bod.begin(), bod.end(), bc) != bod.end());
 
-                xrpl::Dir cod(*env.current(), keylet::ownerDir(carol.id()));
+                xrpl::Dir const cod(*env.current(), keylet::ownerDir(carol.id()));
                 BEAST_EXPECT(std::distance(cod.begin(), cod.end()) == 2);
             }
 
@@ -3230,16 +3230,16 @@ struct EscrowToken_test : public beast::unit_test::suite
                 BEAST_EXPECT(!env.le(keylet::escrow(alice.id(), aseq)));
                 BEAST_EXPECT(!env.le(keylet::escrow(bob.id(), bseq)));
 
-                xrpl::Dir aod(*env.current(), keylet::ownerDir(alice.id()));
+                xrpl::Dir const aod(*env.current(), keylet::ownerDir(alice.id()));
                 BEAST_EXPECT(std::distance(aod.begin(), aod.end()) == 1);
                 BEAST_EXPECT(std::find(aod.begin(), aod.end(), ab) == aod.end());
 
-                xrpl::Dir bod(*env.current(), keylet::ownerDir(bob.id()));
+                xrpl::Dir const bod(*env.current(), keylet::ownerDir(bob.id()));
                 BEAST_EXPECT(std::distance(bod.begin(), bod.end()) == 1);
                 BEAST_EXPECT(std::find(bod.begin(), bod.end(), ab) == bod.end());
                 BEAST_EXPECT(std::find(bod.begin(), bod.end(), bc) == bod.end());
 
-                xrpl::Dir cod(*env.current(), keylet::ownerDir(carol.id()));
+                xrpl::Dir const cod(*env.current(), keylet::ownerDir(carol.id()));
                 BEAST_EXPECT(std::distance(cod.begin(), cod.end()) == 1);
             }
         }
diff --git a/src/test/app/Escrow_test.cpp b/src/test/app/Escrow_test.cpp
index 2e6ef718d6..05640cde01 100644
--- a/src/test/app/Escrow_test.cpp
+++ b/src/test/app/Escrow_test.cpp
@@ -1057,7 +1057,7 @@ struct Escrow_test : public beast::unit_test::suite
             Env env(*this, features);
             env.fund(XRP(5000), "alice", "bob");
 
-            std::array<std::uint8_t, 45> cb = {
+            std::array<std::uint8_t, 45> const cb = {
                 {0xA2, 0x2B, 0x80, 0x20, 0x42, 0x4A, 0x70, 0x49, 0x49, 0x52, 0x92, 0x67,
                  0xB6, 0x21, 0xB3, 0xD7, 0x91, 0x19, 0xD7, 0x29, 0xB2, 0x38, 0x2C, 0xED,
                  0x8B, 0x29, 0x6C, 0x3C, 0x02, 0x8F, 0xA9, 0x7D, 0x35, 0x0F, 0x6D, 0x07,
@@ -1100,7 +1100,7 @@ struct Escrow_test : public beast::unit_test::suite
             BEAST_EXPECT(aa);
 
             {
-                xrpl::Dir aod(*env.current(), keylet::ownerDir(alice.id()));
+                xrpl::Dir const aod(*env.current(), keylet::ownerDir(alice.id()));
                 BEAST_EXPECT(std::distance(aod.begin(), aod.end()) == 1);
                 BEAST_EXPECT(std::find(aod.begin(), aod.end(), aa) != aod.end());
             }
@@ -1115,7 +1115,7 @@ struct Escrow_test : public beast::unit_test::suite
             BEAST_EXPECT(bb);
 
             {
-                xrpl::Dir bod(*env.current(), keylet::ownerDir(bruce.id()));
+                xrpl::Dir const bod(*env.current(), keylet::ownerDir(bruce.id()));
                 BEAST_EXPECT(std::distance(bod.begin(), bod.end()) == 1);
                 BEAST_EXPECT(std::find(bod.begin(), bod.end(), bb) != bod.end());
             }
@@ -1127,11 +1127,11 @@ struct Escrow_test : public beast::unit_test::suite
                 BEAST_EXPECT(
                     (*env.meta())[sfTransactionResult] == static_cast<std::uint8_t>(tesSUCCESS));
 
-                xrpl::Dir aod(*env.current(), keylet::ownerDir(alice.id()));
+                xrpl::Dir const aod(*env.current(), keylet::ownerDir(alice.id()));
                 BEAST_EXPECT(std::distance(aod.begin(), aod.end()) == 0);
                 BEAST_EXPECT(std::find(aod.begin(), aod.end(), aa) == aod.end());
 
-                xrpl::Dir bod(*env.current(), keylet::ownerDir(bruce.id()));
+                xrpl::Dir const bod(*env.current(), keylet::ownerDir(bruce.id()));
                 BEAST_EXPECT(std::distance(bod.begin(), bod.end()) == 1);
                 BEAST_EXPECT(std::find(bod.begin(), bod.end(), bb) != bod.end());
             }
@@ -1143,7 +1143,7 @@ struct Escrow_test : public beast::unit_test::suite
                 BEAST_EXPECT(
                     (*env.meta())[sfTransactionResult] == static_cast<std::uint8_t>(tesSUCCESS));
 
-                xrpl::Dir bod(*env.current(), keylet::ownerDir(bruce.id()));
+                xrpl::Dir const bod(*env.current(), keylet::ownerDir(bruce.id()));
                 BEAST_EXPECT(std::distance(bod.begin(), bod.end()) == 0);
                 BEAST_EXPECT(std::find(bod.begin(), bod.end(), bb) == bod.end());
             }
@@ -1174,16 +1174,16 @@ struct Escrow_test : public beast::unit_test::suite
             BEAST_EXPECT(bc);
 
             {
-                xrpl::Dir aod(*env.current(), keylet::ownerDir(alice.id()));
+                xrpl::Dir const aod(*env.current(), keylet::ownerDir(alice.id()));
                 BEAST_EXPECT(std::distance(aod.begin(), aod.end()) == 1);
                 BEAST_EXPECT(std::find(aod.begin(), aod.end(), ab) != aod.end());
 
-                xrpl::Dir bod(*env.current(), keylet::ownerDir(bruce.id()));
+                xrpl::Dir const bod(*env.current(), keylet::ownerDir(bruce.id()));
                 BEAST_EXPECT(std::distance(bod.begin(), bod.end()) == 2);
                 BEAST_EXPECT(std::find(bod.begin(), bod.end(), ab) != bod.end());
                 BEAST_EXPECT(std::find(bod.begin(), bod.end(), bc) != bod.end());
 
-                xrpl::Dir cod(*env.current(), keylet::ownerDir(carol.id()));
+                xrpl::Dir const cod(*env.current(), keylet::ownerDir(carol.id()));
                 BEAST_EXPECT(std::distance(cod.begin(), cod.end()) == 1);
                 BEAST_EXPECT(std::find(cod.begin(), cod.end(), bc) != cod.end());
             }
@@ -1194,16 +1194,16 @@ struct Escrow_test : public beast::unit_test::suite
                 BEAST_EXPECT(!env.le(keylet::escrow(alice.id(), aseq)));
                 BEAST_EXPECT(env.le(keylet::escrow(bruce.id(), bseq)));
 
-                xrpl::Dir aod(*env.current(), keylet::ownerDir(alice.id()));
+                xrpl::Dir const aod(*env.current(), keylet::ownerDir(alice.id()));
                 BEAST_EXPECT(std::distance(aod.begin(), aod.end()) == 0);
                 BEAST_EXPECT(std::find(aod.begin(), aod.end(), ab) == aod.end());
 
-                xrpl::Dir bod(*env.current(), keylet::ownerDir(bruce.id()));
+                xrpl::Dir const bod(*env.current(), keylet::ownerDir(bruce.id()));
                 BEAST_EXPECT(std::distance(bod.begin(), bod.end()) == 1);
                 BEAST_EXPECT(std::find(bod.begin(), bod.end(), ab) == bod.end());
                 BEAST_EXPECT(std::find(bod.begin(), bod.end(), bc) != bod.end());
 
-                xrpl::Dir cod(*env.current(), keylet::ownerDir(carol.id()));
+                xrpl::Dir const cod(*env.current(), keylet::ownerDir(carol.id()));
                 BEAST_EXPECT(std::distance(cod.begin(), cod.end()) == 1);
             }
 
@@ -1213,16 +1213,16 @@ struct Escrow_test : public beast::unit_test::suite
                 BEAST_EXPECT(!env.le(keylet::escrow(alice.id(), aseq)));
                 BEAST_EXPECT(!env.le(keylet::escrow(bruce.id(), bseq)));
 
-                xrpl::Dir aod(*env.current(), keylet::ownerDir(alice.id()));
+                xrpl::Dir const aod(*env.current(), keylet::ownerDir(alice.id()));
                 BEAST_EXPECT(std::distance(aod.begin(), aod.end()) == 0);
                 BEAST_EXPECT(std::find(aod.begin(), aod.end(), ab) == aod.end());
 
-                xrpl::Dir bod(*env.current(), keylet::ownerDir(bruce.id()));
+                xrpl::Dir const bod(*env.current(), keylet::ownerDir(bruce.id()));
                 BEAST_EXPECT(std::distance(bod.begin(), bod.end()) == 0);
                 BEAST_EXPECT(std::find(bod.begin(), bod.end(), ab) == bod.end());
                 BEAST_EXPECT(std::find(bod.begin(), bod.end(), bc) == bod.end());
 
-                xrpl::Dir cod(*env.current(), keylet::ownerDir(carol.id()));
+                xrpl::Dir const cod(*env.current(), keylet::ownerDir(carol.id()));
                 BEAST_EXPECT(std::distance(cod.begin(), cod.end()) == 0);
             }
         }
diff --git a/src/test/app/FeeVote_test.cpp b/src/test/app/FeeVote_test.cpp
index 3c84f9e007..62f1058de5 100644
--- a/src/test/app/FeeVote_test.cpp
+++ b/src/test/app/FeeVote_test.cpp
@@ -189,7 +189,7 @@ class FeeVote_test : public beast::unit_test::suite
         FeeSetup const defaultSetup;
         {
             // defaults
-            Section config;
+            Section const config;
             auto setup = setup_FeeVote(config);
             BEAST_EXPECT(setup.reference_fee == defaultSetup.reference_fee);
             BEAST_EXPECT(setup.account_reserve == defaultSetup.account_reserve);
@@ -260,7 +260,7 @@ class FeeVote_test : public beast::unit_test::suite
 
             // Test successful fee transaction with legacy fields
 
-            FeeSettingsFields fields{
+            FeeSettingsFields const fields{
                 .baseFee = 10,
                 .reserveBase = 200000,
                 .reserveIncrement = 50000,
@@ -288,7 +288,7 @@ class FeeVote_test : public beast::unit_test::suite
             // Create the next ledger to apply transaction to
             ledger = std::make_shared<Ledger>(*ledger, env.app().getTimeKeeper().closeTime());
 
-            FeeSettingsFields fields{
+            FeeSettingsFields const fields{
                 .baseFeeDrops = XRPAmount{10},
                 .reserveBaseDrops = XRPAmount{200000},
                 .reserveIncrementDrops = XRPAmount{50000}};
@@ -408,7 +408,7 @@ class FeeVote_test : public beast::unit_test::suite
 
         ledger = std::make_shared<Ledger>(*ledger, env.app().getTimeKeeper().closeTime());
 
-        FeeSettingsFields fields1{
+        FeeSettingsFields const fields1{
             .baseFeeDrops = XRPAmount{10},
             .reserveBaseDrops = XRPAmount{200000},
             .reserveIncrementDrops = XRPAmount{50000}};
@@ -425,7 +425,7 @@ class FeeVote_test : public beast::unit_test::suite
         // Apply second fee transaction with different values
         ledger = std::make_shared<Ledger>(*ledger, env.app().getTimeKeeper().closeTime());
 
-        FeeSettingsFields fields2{
+        FeeSettingsFields const fields2{
             .baseFeeDrops = XRPAmount{20},
             .reserveBaseDrops = XRPAmount{300000},
             .reserveIncrementDrops = XRPAmount{75000}};
@@ -487,7 +487,7 @@ class FeeVote_test : public beast::unit_test::suite
 
         ledger = std::make_shared<Ledger>(*ledger, env.app().getTimeKeeper().closeTime());
 
-        FeeSettingsFields fields1{
+        FeeSettingsFields const fields1{
             .baseFeeDrops = XRPAmount{10},
             .reserveBaseDrops = XRPAmount{200000},
             .reserveIncrementDrops = XRPAmount{50000}};
@@ -504,7 +504,7 @@ class FeeVote_test : public beast::unit_test::suite
         ledger = std::make_shared<Ledger>(*ledger, env.app().getTimeKeeper().closeTime());
 
         // Apply partial update (only some fields)
-        FeeSettingsFields fields2{
+        FeeSettingsFields const fields2{
             .baseFeeDrops = XRPAmount{20}, .reserveBaseDrops = XRPAmount{200000}};
         auto feeTx2 = createFeeTx(ledger->rules(), ledger->seq(), fields2);
 
diff --git a/src/test/app/Flow_test.cpp b/src/test/app/Flow_test.cpp
index 25bcb4ee64..0bc5bd1727 100644
--- a/src/test/app/Flow_test.cpp
+++ b/src/test/app/Flow_test.cpp
@@ -437,7 +437,7 @@ struct Flow_test : public beast::unit_test::suite
 
             auto flowJournal = env.app().getJournal("Flow");
             auto const flowResult = [&] {
-                STAmount deliver(USD(51));
+                STAmount const deliver(USD(51));
                 STAmount smax(BTC(61));
                 PaymentSandbox sb(env.current().get(), tapNONE);
                 STPathSet paths;
@@ -450,10 +450,10 @@ struct Flow_test : public beast::unit_test::suite
                 };
                 {
                     // BTC -> USD
-                    STPath p1({IPE(USD.issue())});
+                    STPath const p1({IPE(USD.issue())});
                     paths.push_back(p1);
                     // BTC -> EUR -> USD
-                    STPath p2({IPE(EUR.issue()), IPE(USD.issue())});
+                    STPath const p2({IPE(EUR.issue()), IPE(USD.issue())});
                     paths.push_back(p2);
                 }
 
@@ -876,8 +876,10 @@ struct Flow_test : public beast::unit_test::suite
             env.close();
             env(trust(bob, USD(20)));
 
-            STAmount tinyAmt1{USD.issue(), 9000000000000000ll, -17, false, STAmount::unchecked{}};
-            STAmount tinyAmt3{USD.issue(), 9000000000000003ll, -17, false, STAmount::unchecked{}};
+            STAmount const tinyAmt1{
+                USD.issue(), 9000000000000000ll, -17, false, STAmount::unchecked{}};
+            STAmount const tinyAmt3{
+                USD.issue(), 9000000000000003ll, -17, false, STAmount::unchecked{}};
 
             env(offer(gw, drops(9000000000), tinyAmt3));
             env(pay(alice, bob, tinyAmt1),
@@ -900,8 +902,10 @@ struct Flow_test : public beast::unit_test::suite
             env.close();
             env(trust(alice, USD(20)));
 
-            STAmount tinyAmt1{USD.issue(), 9000000000000000ll, -17, false, STAmount::unchecked{}};
-            STAmount tinyAmt3{USD.issue(), 9000000000000003ll, -17, false, STAmount::unchecked{}};
+            STAmount const tinyAmt1{
+                USD.issue(), 9000000000000000ll, -17, false, STAmount::unchecked{}};
+            STAmount const tinyAmt3{
+                USD.issue(), 9000000000000003ll, -17, false, STAmount::unchecked{}};
 
             env(pay(gw, alice, tinyAmt1));
 
diff --git a/src/test/app/Freeze_test.cpp b/src/test/app/Freeze_test.cpp
index 1dd0de578b..ed5ee47578 100644
--- a/src/test/app/Freeze_test.cpp
+++ b/src/test/app/Freeze_test.cpp
@@ -19,9 +19,9 @@ class Freeze_test : public beast::unit_test::suite
         using namespace test::jtx;
         Env env(*this, features);
 
-        Account G1{"G1"};
-        Account alice{"alice"};
-        Account bob{"bob"};
+        Account const G1{"G1"};
+        Account const alice{"alice"};
+        Account const bob{"bob"};
 
         env.fund(XRP(1000), G1, alice, bob);
         env.close();
@@ -168,8 +168,8 @@ class Freeze_test : public beast::unit_test::suite
         using namespace test::jtx;
         Env env(*this, features);
 
-        Account G1{"G1"};
-        Account A1{"A1"};
+        Account const G1{"G1"};
+        Account const A1{"A1"};
 
         env.fund(XRP(10000), G1, A1);
         env.close();
@@ -259,8 +259,8 @@ class Freeze_test : public beast::unit_test::suite
         using namespace test::jtx;
         Env env(*this, features);
 
-        Account G1{"G1"};
-        Account A1{"A1"};
+        Account const G1{"G1"};
+        Account const A1{"A1"};
 
         env.fund(XRP(10000), G1, A1);
         env.close();
@@ -308,8 +308,8 @@ class Freeze_test : public beast::unit_test::suite
         using namespace test::jtx;
         Env env(*this, features);
 
-        Account G1{"G1"};
-        Account A1{"A1"};
+        Account const G1{"G1"};
+        Account const A1{"A1"};
 
         env.fund(XRP(10000), G1, A1);
         env.close();
@@ -347,11 +347,11 @@ class Freeze_test : public beast::unit_test::suite
         using namespace test::jtx;
         Env env(*this, features);
 
-        Account G1{"G1"};
-        Account A1{"A1"};
-        Account A2{"A2"};
-        Account A3{"A3"};
-        Account A4{"A4"};
+        Account const G1{"G1"};
+        Account const A1{"A1"};
+        Account const A2{"A2"};
+        Account const A3{"A3"};
+        Account const A4{"A4"};
 
         env.fund(XRP(12000), G1);
         env.fund(XRP(1000), A1);
@@ -497,10 +497,10 @@ class Freeze_test : public beast::unit_test::suite
         using namespace test::jtx;
         Env env(*this, features);
 
-        Account G1{"G1"};
-        Account A1{"A1"};
-        Account frozenAcc{"A2"};
-        Account deepFrozenAcc{"A3"};
+        Account const G1{"G1"};
+        Account const A1{"A1"};
+        Account const frozenAcc{"A2"};
+        Account const deepFrozenAcc{"A3"};
 
         env.fund(XRP(12000), G1);
         env.fund(XRP(1000), A1);
@@ -608,10 +608,10 @@ class Freeze_test : public beast::unit_test::suite
         using namespace test::jtx;
         Env env(*this, features);
 
-        Account G1{"G1"};
-        Account A2{"A2"};
-        Account A3{"A3"};
-        Account A4{"A4"};
+        Account const G1{"G1"};
+        Account const A2{"A2"};
+        Account const A3{"A3"};
+        Account const A4{"A4"};
 
         env.fund(XRP(1000), G1, A3, A4);
         env.fund(XRP(2000), A2);
@@ -705,10 +705,10 @@ class Freeze_test : public beast::unit_test::suite
         using namespace test::jtx;
         Env env(*this, features);
 
-        Account G1{"G1"};
-        Account A1{"A1"};
-        Account A2{"A2"};
-        Account A3{"A3"};
+        Account const G1{"G1"};
+        Account const A1{"A1"};
+        Account const A2{"A2"};
+        Account const A3{"A3"};
         auto const USD{G1["USD"]};
 
         env.fund(XRP(10000), G1, A1, A2, A3);
@@ -935,9 +935,9 @@ class Freeze_test : public beast::unit_test::suite
         using path = test::jtx::path;
 
         Env env(*this, features);
-        Account G1{"G1"};
-        Account A1{"A1"};
-        Account A2{"A2"};
+        Account const G1{"G1"};
+        Account const A1{"A1"};
+        Account const A2{"A2"};
         auto const USD{G1["USD"]};
 
         env.fund(XRP(10000), G1, A1, A2);
@@ -1161,9 +1161,9 @@ class Freeze_test : public beast::unit_test::suite
         using namespace test::jtx;
         Env env(*this, features);
 
-        Account G1{"G1"};
-        Account A1{"A1"};
-        Account A2{"A2"};
+        Account const G1{"G1"};
+        Account const A1{"A1"};
+        Account const A2{"A2"};
         auto const USD{G1["USD"]};
 
         env.fund(XRP(10000), G1, A1, A2);
@@ -1283,9 +1283,9 @@ class Freeze_test : public beast::unit_test::suite
         using namespace test::jtx;
         Env env(*this, features);
 
-        Account G1{"G1"};
-        Account A1{"A1"};
-        Account A2{"A2"};
+        Account const G1{"G1"};
+        Account const A1{"A1"};
+        Account const A2{"A2"};
         auto const USD{G1["USD"]};
 
         env.fund(XRP(10000), G1, A1, A2);
@@ -1578,9 +1578,9 @@ class Freeze_test : public beast::unit_test::suite
         using path = test::jtx::path;
 
         Env env(*this, features);
-        Account G1{"G1"};
-        Account A1{"A1"};
-        Account A2{"A2"};
+        Account const G1{"G1"};
+        Account const A1{"A1"};
+        Account const A2{"A2"};
         auto const USD{G1["USD"]};
 
         env.fund(XRP(10000), G1, A1, A2);
@@ -1593,7 +1593,7 @@ class Freeze_test : public beast::unit_test::suite
         env(pay(G1, A2, USD(1000)));
         env.close();
 
-        AMM ammG1(env, G1, XRP(1'000), USD(1'000));
+        AMM const ammG1(env, G1, XRP(1'000), USD(1'000));
         env.close();
 
         // Testing basic payment using AMM when freezing one of the trust lines.
@@ -1668,9 +1668,9 @@ class Freeze_test : public beast::unit_test::suite
         using namespace test::jtx;
 
         Env env(*this, features);
-        Account G1{"G1"};
-        Account A1{"A1"};
-        Account A2{"A2"};
+        Account const G1{"G1"};
+        Account const A1{"A1"};
+        Account const A2{"A2"};
         auto const USD{G1["USD"]};
 
         env.fund(XRP(10000), G1, A1, A2);
@@ -1829,7 +1829,7 @@ class Freeze_test : public beast::unit_test::suite
         // Testing brokered offer acceptance
         if (features[featureDeepFreeze] && features[fixEnforceNFTokenTrustlineV2])
         {
-            Account broker{"broker"};
+            Account const broker{"broker"};
             env.fund(XRP(10000), broker);
             env.close();
             env(trust(G1, broker["USD"](1000), tfSetFreeze | tfSetDeepFreeze));
@@ -1855,7 +1855,7 @@ class Freeze_test : public beast::unit_test::suite
         // Testing transfer fee
         if (features[featureDeepFreeze] && features[fixEnforceNFTokenTrustlineV2])
         {
-            Account minter{"minter"};
+            Account const minter{"minter"};
             env.fund(XRP(10000), minter);
             env.close();
             env(trust(G1, minter["USD"](1000)));
diff --git a/src/test/app/HashRouter_test.cpp b/src/test/app/HashRouter_test.cpp
index a1601914cf..e53515e421 100644
--- a/src/test/app/HashRouter_test.cpp
+++ b/src/test/app/HashRouter_test.cpp
@@ -27,9 +27,9 @@ class HashRouter_test : public beast::unit_test::suite
         TestStopwatch stopwatch;
         HashRouter router(getSetup(2s, 1s), stopwatch);
 
-        HashRouterFlags key1(HashRouterFlags::PRIVATE1);
-        HashRouterFlags key2(HashRouterFlags::PRIVATE2);
-        HashRouterFlags key3(HashRouterFlags::PRIVATE3);
+        HashRouterFlags const key1(HashRouterFlags::PRIVATE1);
+        HashRouterFlags const key2(HashRouterFlags::PRIVATE2);
+        HashRouterFlags const key3(HashRouterFlags::PRIVATE3);
 
         auto const ukey1 = uint256{static_cast<std::uint64_t>(key1)};
         auto const ukey2 = uint256{static_cast<std::uint64_t>(key2)};
@@ -69,10 +69,10 @@ class HashRouter_test : public beast::unit_test::suite
         TestStopwatch stopwatch;
         HashRouter router(getSetup(2s, 1s), stopwatch);
 
-        HashRouterFlags key1(HashRouterFlags::PRIVATE1);
-        HashRouterFlags key2(HashRouterFlags::PRIVATE2);
-        HashRouterFlags key3(HashRouterFlags::PRIVATE3);
-        HashRouterFlags key4(HashRouterFlags::PRIVATE4);
+        HashRouterFlags const key1(HashRouterFlags::PRIVATE1);
+        HashRouterFlags const key2(HashRouterFlags::PRIVATE2);
+        HashRouterFlags const key3(HashRouterFlags::PRIVATE3);
+        HashRouterFlags const key4(HashRouterFlags::PRIVATE4);
 
         auto const ukey1 = uint256{static_cast<std::uint64_t>(key1)};
         auto const ukey2 = uint256{static_cast<std::uint64_t>(key2)};
@@ -242,7 +242,7 @@ class HashRouter_test : public beast::unit_test::suite
         TestStopwatch stopwatch;
         HashRouter router(getSetup(5s, 1s), stopwatch);
         uint256 const key(1);
-        HashRouter::PeerShortID peer = 1;
+        HashRouter::PeerShortID const peer = 1;
         HashRouterFlags flags = HashRouterFlags::UNDEFINED;
 
         BEAST_EXPECT(router.shouldProcess(key, peer, flags, 1s));
@@ -259,7 +259,7 @@ class HashRouter_test : public beast::unit_test::suite
 
         using namespace std::chrono_literals;
         {
-            Config cfg;
+            Config const cfg;
             // default
             auto const setup = setup_HashRouter(cfg);
             BEAST_EXPECT(setup.holdTime == 300s);
@@ -298,7 +298,7 @@ class HashRouter_test : public beast::unit_test::suite
             }
             catch (std::exception const& e)
             {
-                std::string expected =
+                std::string const expected =
                     "HashRouter relay time must be less than or equal to hold "
                     "time";
                 BEAST_EXPECT(e.what() == expected);
@@ -317,7 +317,7 @@ class HashRouter_test : public beast::unit_test::suite
             }
             catch (std::exception const& e)
             {
-                std::string expected =
+                std::string const expected =
                     "HashRouter hold time must be at least 12 seconds (the "
                     "approximate validation time for three "
                     "ledgers).";
@@ -337,7 +337,7 @@ class HashRouter_test : public beast::unit_test::suite
             }
             catch (std::exception const& e)
             {
-                std::string expected =
+                std::string const expected =
                     "HashRouter relay time must be at least 8 seconds (the "
                     "approximate validation time for two ledgers).";
                 BEAST_EXPECT(e.what() == expected);
@@ -365,9 +365,9 @@ class HashRouter_test : public beast::unit_test::suite
         using HF = HashRouterFlags;
         using UHF = std::underlying_type_t<HF>;
 
-        HF f1 = HF::BAD;
-        HF f2 = HF::SAVED;
-        HF combined = f1 | f2;
+        HF const f1 = HF::BAD;
+        HF const f2 = HF::SAVED;
+        HF const combined = f1 | f2;
 
         BEAST_EXPECT(static_cast<UHF>(combined) == (static_cast<UHF>(f1) | static_cast<UHF>(f2)));
 
@@ -375,7 +375,7 @@ class HashRouter_test : public beast::unit_test::suite
         temp |= f2;
         BEAST_EXPECT(temp == combined);
 
-        HF intersect = combined & f1;
+        HF const intersect = combined & f1;
         BEAST_EXPECT(intersect == f1);
 
         HF temp2 = combined;
diff --git a/src/test/app/Invariants_test.cpp b/src/test/app/Invariants_test.cpp
index ca63a69bc4..ef0624b481 100644
--- a/src/test/app/Invariants_test.cpp
+++ b/src/test/app/Invariants_test.cpp
@@ -127,7 +127,7 @@ class Invariants_test : public beast::unit_test::suite
 
         OpenView ov{*env.current()};
         test::StreamSink sink{beast::severities::kWarning};
-        beast::Journal jlog{sink};
+        beast::Journal const jlog{sink};
         ApplyContext ac{env.app(), ov, tx, tesSUCCESS, env.current()->fees().base, tapNONE, jlog};
 
         BEAST_EXPECT(precheck(A1, A2, ac));
@@ -845,7 +845,7 @@ class Invariants_test : public beast::unit_test::suite
                 auto sleNew = std::make_shared<SLE>(keylet::escrow(A1, (*sle)[sfSequence] + 2));
 
                 Issue const usd{Currency(0x5553440000000000), AccountID(0x4985601)};
-                STAmount amt(usd, -1);
+                STAmount const amt(usd, -1);
                 sleNew->setFieldAmount(sfAmount, amt);
                 ac.view().insert(sleNew);
                 return true;
@@ -862,7 +862,7 @@ class Invariants_test : public beast::unit_test::suite
                 auto sleNew = std::make_shared<SLE>(keylet::escrow(A1, (*sle)[sfSequence] + 2));
 
                 Issue const bad{badCurrency(), AccountID(0x4985601)};
-                STAmount amt(bad, 1);
+                STAmount const amt(bad, 1);
                 sleNew->setFieldAmount(sfAmount, amt);
                 ac.view().insert(sleNew);
                 return true;
@@ -879,7 +879,7 @@ class Invariants_test : public beast::unit_test::suite
                 auto sleNew = std::make_shared<SLE>(keylet::escrow(A1, (*sle)[sfSequence] + 2));
 
                 MPTIssue const mpt{MPTIssue{makeMptID(1, AccountID(0x4985601))}};
-                STAmount amt(mpt, -1);
+                STAmount const amt(mpt, -1);
                 sleNew->setFieldAmount(sfAmount, amt);
                 ac.view().insert(sleNew);
                 return true;
@@ -1026,8 +1026,7 @@ class Invariants_test : public beast::unit_test::suite
                 auto const sleNew = std::make_shared<SLE>(acctKeylet);
                 sleNew->setFieldU32(sfSequence, 0);
                 sleNew->setFieldH256(sfAMMID, uint256(1));
-                sleNew->setFieldU32(
-                    sfFlags, lsfDisableMaster | lsfDefaultRipple | lsfDefaultRipple);
+                sleNew->setFieldU32(sfFlags, lsfDisableMaster | lsfDefaultRipple);
                 ac.view().insert(sleNew);
                 return true;
             },
@@ -1253,8 +1252,8 @@ class Invariants_test : public beast::unit_test::suite
         using namespace test::jtx;
 
         bool const fixPDEnabled = features[fixPermissionedDomainInvariant];
-        std::initializer_list<TER> badTers = {tecINVARIANT_FAILED, tecINVARIANT_FAILED};
-        std::initializer_list<TER> failTers = {tecINVARIANT_FAILED, tefINVARIANT_FAILED};
+        std::initializer_list<TER> const badTers = {tecINVARIANT_FAILED, tecINVARIANT_FAILED};
+        std::initializer_list<TER> const failTers = {tecINVARIANT_FAILED, tefINVARIANT_FAILED};
 
         testcase << "PermissionedDomain" + std::string(fixPDEnabled ? " fix" : "");
 
@@ -1338,7 +1337,7 @@ class Invariants_test : public beast::unit_test::suite
 
                 // update PD with empty rules
                 {
-                    STArray credentials(sfAcceptedCredentials, 2);
+                    STArray const credentials(sfAcceptedCredentials, 2);
                     slePd->setFieldArray(sfAcceptedCredentials, credentials);
                     ac.view().update(slePd);
                 }
@@ -1438,15 +1437,16 @@ class Invariants_test : public beast::unit_test::suite
             STTx{ttPERMISSIONED_DOMAIN_SET, [](STObject&) {}},
             fixPDEnabled ? failTers : badTers);
 
-        std::initializer_list<TER> goodTers = {tesSUCCESS, tesSUCCESS};
+        std::initializer_list<TER> const goodTers = {tesSUCCESS, tesSUCCESS};
 
-        std::vector<std::string> badMoreThan1{
+        std::vector<std::string> const badMoreThan1{
             {"transaction affected more than 1 permissioned domain entry."}};
-        std::vector<std::string> emptyV;
-        std::vector<std::string> badNoDomains{{"no domain objects affected by"}};
-        std::vector<std::string> badNotDeleted{{"domain object modified, but not deleted by "}};
-        std::vector<std::string> badDeleted{{"domain object deleted by"}};
-        std::vector<std::string> badTx{
+        std::vector<std::string> const emptyV;
+        std::vector<std::string> const badNoDomains{{"no domain objects affected by"}};
+        std::vector<std::string> const badNotDeleted{
+            {"domain object modified, but not deleted by "}};
+        std::vector<std::string> const badDeleted{{"domain object deleted by"}};
+        std::vector<std::string> const badTx{
             {"domain object(s) affected by an unauthorized transaction."}};
 
         {
@@ -1596,11 +1596,11 @@ class Invariants_test : public beast::unit_test::suite
         using namespace jtx;
 
         AccountID pseudoAccountID;
-        Preclose createPseudo = [&, this](Account const& a, Account const& b, Env& env) {
+        Preclose const createPseudo = [&, this](Account const& a, Account const& b, Env& env) {
             PrettyAsset const xrpAsset{xrpIssue(), 1'000'000};
 
             // Create vault
-            Vault vault{env};
+            Vault const vault{env};
             auto [tx, vKeylet] = vault.create({.owner = a, .asset = xrpAsset});
             env(tx);
             env.close();
@@ -1724,7 +1724,7 @@ class Invariants_test : public beast::unit_test::suite
 
         std::uint32_t const seq = env.seq(A1);
         env(pdomain::setTx(A1, credentials));
-        uint256 key = pdomain::getNewDomain(env.meta());
+        uint256 const key = pdomain::getNewDomain(env.meta());
 
         // std::cout << "PD, acc: " << A1.id() << ", seq: " << seq << ", k: " <<
         // key << std::endl;
@@ -1942,7 +1942,7 @@ class Invariants_test : public beast::unit_test::suite
 
         // Create vault
         uint256 vaultID;
-        Vault vault{env};
+        Vault const vault{env};
         auto [tx, vKeylet] = vault.create({.owner = a, .asset = asset});
         env(tx);
         BEAST_EXPECT(env.le(vKeylet));
@@ -1967,7 +1967,7 @@ class Invariants_test : public beast::unit_test::suite
 
         // Initialize with a placeholder value because there's no default ctor
         Keylet loanBrokerKeylet = keylet::amendments();
-        Preclose createLoanBroker = [&, this](Account const& a, Account const& b, Env& env) {
+        Preclose const createLoanBroker = [&, this](Account const& a, Account const& b, Env& env) {
             PrettyAsset const xrpAsset{xrpIssue(), 1'000'000};
 
             loanBrokerKeylet = this->createLoanBroker(a, env, xrpAsset);
@@ -2047,38 +2047,38 @@ class Invariants_test : public beast::unit_test::suite
             // Initialize with a placeholder value because there's no default
             // ctor
             Keylet loanBrokerKeylet = keylet::amendments();
-            Preclose createLoanBroker = [&, this](
-                                            Account const& alice, Account const& issuer, Env& env) {
-                PrettyAsset const asset = [&]() {
-                    switch (assetType)
-                    {
-                        case Asset::IOU: {
-                            PrettyAsset const iouAsset = issuer["IOU"];
-                            env(trust(alice, iouAsset(1000)));
-                            env(pay(issuer, alice, iouAsset(1000)));
-                            env.close();
-                            return iouAsset;
-                        }
+            Preclose const createLoanBroker =
+                [&, this](Account const& alice, Account const& issuer, Env& env) {
+                    PrettyAsset const asset = [&]() {
+                        switch (assetType)
+                        {
+                            case Asset::IOU: {
+                                PrettyAsset const iouAsset = issuer["IOU"];
+                                env(trust(alice, iouAsset(1000)));
+                                env(pay(issuer, alice, iouAsset(1000)));
+                                env.close();
+                                return iouAsset;
+                            }
 
-                        case Asset::MPT: {
-                            MPTTester mptt{env, issuer, mptInitNoFund};
-                            mptt.create(
-                                {.flags = tfMPTCanClawback | tfMPTCanTransfer | tfMPTCanLock});
-                            PrettyAsset const mptAsset = mptt.issuanceID();
-                            mptt.authorize({.account = alice});
-                            env(pay(issuer, alice, mptAsset(1000)));
-                            env.close();
-                            return mptAsset;
-                        }
+                            case Asset::MPT: {
+                                MPTTester mptt{env, issuer, mptInitNoFund};
+                                mptt.create(
+                                    {.flags = tfMPTCanClawback | tfMPTCanTransfer | tfMPTCanLock});
+                                PrettyAsset const mptAsset = mptt.issuanceID();
+                                mptt.authorize({.account = alice});
+                                env(pay(issuer, alice, mptAsset(1000)));
+                                env.close();
+                                return mptAsset;
+                            }
 
-                        case Asset::XRP:
-                        default:
-                            return PrettyAsset{xrpIssue(), 1'000'000};
-                    }
-                }();
-                loanBrokerKeylet = this->createLoanBroker(alice, env, asset);
-                return BEAST_EXPECT(env.le(loanBrokerKeylet));
-            };
+                            case Asset::XRP:
+                            default:
+                                return PrettyAsset{xrpIssue(), 1'000'000};
+                        }
+                    }();
+                    loanBrokerKeylet = this->createLoanBroker(alice, env, asset);
+                    return BEAST_EXPECT(env.le(loanBrokerKeylet));
+                };
 
             // Ensure the test scenarios are set up completely. The test cases
             // will need to recompute any of these values it needs for itself
@@ -2393,7 +2393,7 @@ class Invariants_test : public beast::unit_test::suite
         Account A4{"A4"};
         auto const precloseXrp = [&](Account const& A1, Account const& A2, Env& env) -> bool {
             env.fund(XRP(1000), A3, A4);
-            Vault vault{env};
+            Vault const vault{env};
             auto [tx, keylet] = vault.create({.owner = A1, .asset = xrpIssue()});
             env(tx);
             env(vault.deposit({.depositor = A1, .id = keylet.key, .amount = XRP(10)}));
@@ -2417,7 +2417,7 @@ class Invariants_test : public beast::unit_test::suite
             STTx{ttVAULT_DELETE, [](STObject&) {}},
             {tecINVARIANT_FAILED, tecINVARIANT_FAILED},
             [&](Account const& A1, Account const& A2, Env& env) {
-                Vault vault{env};
+                Vault const vault{env};
                 auto [tx, _] = vault.create({.owner = A1, .asset = xrpIssue()});
                 env(tx);
                 return true;
@@ -2437,7 +2437,7 @@ class Invariants_test : public beast::unit_test::suite
             STTx{ttPAYMENT, [](STObject&) {}},
             {tecINVARIANT_FAILED, tecINVARIANT_FAILED},
             [&](Account const& A1, Account const& A2, Env& env) {
-                Vault vault{env};
+                Vault const vault{env};
                 auto [tx, _] = vault.create({.owner = A1, .asset = xrpIssue()});
                 env(tx);
                 return true;
@@ -2457,7 +2457,7 @@ class Invariants_test : public beast::unit_test::suite
             STTx{ttPAYMENT, [](STObject&) {}},
             {tecINVARIANT_FAILED, tecINVARIANT_FAILED},
             [&](Account const& A1, Account const& A2, Env& env) {
-                Vault vault{env};
+                Vault const vault{env};
                 auto [tx, _] = vault.create({.owner = A1, .asset = xrpIssue()});
                 env(tx);
                 return true;
@@ -2493,7 +2493,7 @@ class Invariants_test : public beast::unit_test::suite
             STTx{ttVAULT_SET, [](STObject&) {}},
             {tecINVARIANT_FAILED, tecINVARIANT_FAILED},
             [&](Account const& A1, Account const& A2, Env& env) {
-                Vault vault{env};
+                Vault const vault{env};
                 auto [tx, _] = vault.create({.owner = A1, .asset = xrpIssue()});
                 env(tx);
                 return true;
@@ -2522,7 +2522,7 @@ class Invariants_test : public beast::unit_test::suite
             STTx{ttVAULT_DELETE, [](STObject&) {}},
             {tecINVARIANT_FAILED, tecINVARIANT_FAILED},
             [&](Account const& A1, Account const& A2, Env& env) {
-                Vault vault{env};
+                Vault const vault{env};
                 {
                     auto [tx, _] = vault.create({.owner = A1, .asset = xrpIssue()});
                     env(tx);
@@ -2568,7 +2568,7 @@ class Invariants_test : public beast::unit_test::suite
             STTx{ttVAULT_DELETE, [](STObject&) {}},
             {tecINVARIANT_FAILED, tecINVARIANT_FAILED},
             [&](Account const& A1, Account const& A2, Env& env) {
-                Vault vault{env};
+                Vault const vault{env};
                 auto [tx, _] = vault.create({.owner = A1, .asset = xrpIssue()});
                 env(tx);
                 return true;
@@ -2594,7 +2594,7 @@ class Invariants_test : public beast::unit_test::suite
             STTx{ttVAULT_DELETE, [](STObject&) {}},
             {tecINVARIANT_FAILED, tefINVARIANT_FAILED},
             [&](Account const& A1, Account const& A2, Env& env) {
-                Vault vault{env};
+                Vault const vault{env};
                 auto [tx, keylet] = vault.create({.owner = A1, .asset = xrpIssue()});
                 env(tx);
                 env(vault.deposit({.depositor = A1, .id = keylet.key, .amount = XRP(10)}));
@@ -2630,7 +2630,7 @@ class Invariants_test : public beast::unit_test::suite
             STTx{ttVAULT_CREATE, [](STObject&) {}},
             {tecINVARIANT_FAILED, tecINVARIANT_FAILED},
             [&](Account const& A1, Account const& A2, Env& env) {
-                Vault vault{env};
+                Vault const vault{env};
                 auto [tx, _] = vault.create({.owner = A1, .asset = xrpIssue()});
                 env(tx);
                 return true;
@@ -2643,7 +2643,7 @@ class Invariants_test : public beast::unit_test::suite
             STTx{ttVAULT_DEPOSIT, [](STObject&) {}},
             {tecINVARIANT_FAILED, tecINVARIANT_FAILED},
             [&](Account const& A1, Account const& A2, Env& env) {
-                Vault vault{env};
+                Vault const vault{env};
                 auto [tx, _] = vault.create({.owner = A1, .asset = xrpIssue()});
                 env(tx);
                 return true;
@@ -2656,7 +2656,7 @@ class Invariants_test : public beast::unit_test::suite
             STTx{ttVAULT_WITHDRAW, [](STObject&) {}},
             {tecINVARIANT_FAILED, tecINVARIANT_FAILED},
             [&](Account const& A1, Account const& A2, Env& env) {
-                Vault vault{env};
+                Vault const vault{env};
                 auto [tx, _] = vault.create({.owner = A1, .asset = xrpIssue()});
                 env(tx);
                 return true;
@@ -2669,7 +2669,7 @@ class Invariants_test : public beast::unit_test::suite
             STTx{ttVAULT_CLAWBACK, [](STObject&) {}},
             {tecINVARIANT_FAILED, tecINVARIANT_FAILED},
             [&](Account const& A1, Account const& A2, Env& env) {
-                Vault vault{env};
+                Vault const vault{env};
                 auto [tx, _] = vault.create({.owner = A1, .asset = xrpIssue()});
                 env(tx);
                 return true;
@@ -2682,7 +2682,7 @@ class Invariants_test : public beast::unit_test::suite
             STTx{ttVAULT_DELETE, [](STObject&) {}},
             {tecINVARIANT_FAILED, tecINVARIANT_FAILED},
             [&](Account const& A1, Account const& A2, Env& env) {
-                Vault vault{env};
+                Vault const vault{env};
                 auto [tx, _] = vault.create({.owner = A1, .asset = xrpIssue()});
                 env(tx);
                 return true;
@@ -2708,7 +2708,7 @@ class Invariants_test : public beast::unit_test::suite
             STTx{ttVAULT_SET, [](STObject&) {}},
             {tecINVARIANT_FAILED, tefINVARIANT_FAILED},
             [&](Account const& A1, Account const& A2, Env& env) {
-                Vault vault{env};
+                Vault const vault{env};
                 auto [tx, _] = vault.create({.owner = A1, .asset = xrpIssue()});
                 env(tx);
                 return true;
@@ -2730,7 +2730,7 @@ class Invariants_test : public beast::unit_test::suite
             STTx{ttVAULT_WITHDRAW, [](STObject&) {}},
             {tecINVARIANT_FAILED, tecINVARIANT_FAILED},
             [&](Account const& A1, Account const& A2, Env& env) {
-                Vault vault{env};
+                Vault const vault{env};
                 auto [tx, keylet] = vault.create({.owner = A1, .asset = xrpIssue()});
                 env(tx);
                 env(vault.deposit({.depositor = A1, .id = keylet.key, .amount = XRP(10)}));
@@ -2970,7 +2970,7 @@ class Invariants_test : public beast::unit_test::suite
             STTx{ttVAULT_CREATE, [](STObject&) {}},
             {tecINVARIANT_FAILED, tecINVARIANT_FAILED},
             [&](Account const& A1, Account const& A2, Env& env) {
-                Vault vault{env};
+                Vault const vault{env};
                 auto [tx, keylet] = vault.create({.owner = A1, .asset = xrpIssue()});
                 env(tx);
                 return true;
@@ -2996,7 +2996,7 @@ class Invariants_test : public beast::unit_test::suite
             STTx{ttVAULT_CREATE, [](STObject&) {}},
             {tecINVARIANT_FAILED, tecINVARIANT_FAILED},
             [&](Account const& A1, Account const& A2, Env& env) {
-                Vault vault{env};
+                Vault const vault{env};
                 auto [tx, keylet] = vault.create({.owner = A1, .asset = xrpIssue()});
                 env(tx);
                 return true;
@@ -3023,7 +3023,7 @@ class Invariants_test : public beast::unit_test::suite
             STTx{ttVAULT_CREATE, [](STObject&) {}},
             {tecINVARIANT_FAILED, tecINVARIANT_FAILED},
             [&](Account const& A1, Account const& A2, Env& env) {
-                Vault vault{env};
+                Vault const vault{env};
                 auto [tx, keylet] = vault.create({.owner = A1, .asset = xrpIssue()});
                 env(tx);
                 return true;
@@ -3051,7 +3051,7 @@ class Invariants_test : public beast::unit_test::suite
             STTx{ttVAULT_CREATE, [](STObject&) {}},
             {tecINVARIANT_FAILED, tecINVARIANT_FAILED},
             [&](Account const& A1, Account const& A2, Env& env) {
-                Vault vault{env};
+                Vault const vault{env};
                 auto [tx, keylet] = vault.create({.owner = A1, .asset = xrpIssue()});
                 env(tx);
                 return true;
@@ -3075,7 +3075,7 @@ class Invariants_test : public beast::unit_test::suite
             STTx{ttVAULT_CREATE, [](STObject&) {}},
             {tecINVARIANT_FAILED, tecINVARIANT_FAILED},
             [&](Account const& A1, Account const& A2, Env& env) {
-                Vault vault{env};
+                Vault const vault{env};
                 auto [tx, keylet] = vault.create({.owner = A1, .asset = xrpIssue()});
                 env(tx);
                 return true;
@@ -3103,7 +3103,7 @@ class Invariants_test : public beast::unit_test::suite
             STTx{ttVAULT_CREATE, [](STObject&) {}},
             {tecINVARIANT_FAILED, tecINVARIANT_FAILED},
             [&](Account const& A1, Account const& A2, Env& env) {
-                Vault vault{env};
+                Vault const vault{env};
                 auto [tx, keylet] = vault.create({.owner = A1, .asset = xrpIssue()});
                 env(tx);
                 return true;
@@ -3658,7 +3658,7 @@ class Invariants_test : public beast::unit_test::suite
             }
 
             auto const mptID = makeMptID(env.seq(A3) - 1, A3);
-            Asset asset = MPTIssue(mptID);
+            Asset const asset = MPTIssue(mptID);
             // Authorize A1 A2 A4
             {
                 Json::Value jv;
@@ -3681,7 +3681,7 @@ class Invariants_test : public beast::unit_test::suite
                 env.close();
             }
 
-            Vault vault{env};
+            Vault const vault{env};
             auto [tx, keylet] = vault.create({.owner = A1, .asset = asset});
             env(tx);
             env(vault.deposit({.depositor = A1, .id = keylet.key, .amount = asset(10)}));
diff --git a/src/test/app/LedgerHistory_test.cpp b/src/test/app/LedgerHistory_test.cpp
index dbc20fe8f2..453c424251 100644
--- a/src/test/app/LedgerHistory_test.cpp
+++ b/src/test/app/LedgerHistory_test.cpp
@@ -138,17 +138,17 @@ public:
             Env env{*this, envconfig(), std::make_unique<CheckMessageLogs>(msg, &found)};
             LedgerHistory lh{beast::insight::NullCollector::New(), env.app()};
 
-            Account alice{"A1"};
-            Account bob{"A2"};
+            Account const alice{"A1"};
+            Account const bob{"A2"};
             env.fund(XRP(1000), alice, bob);
             env.close();
 
             auto const ledgerBase = env.app().getLedgerMaster().getClosedLedger();
 
-            JTx txAlice = env.jt(noop(alice));
+            JTx const txAlice = env.jt(noop(alice));
             auto const ledgerA = makeLedger(ledgerBase, env, lh, 4s, txAlice.stx);
 
-            JTx txBob = env.jt(noop(bob));
+            JTx const txBob = env.jt(noop(bob));
             auto const ledgerB = makeLedger(ledgerBase, env, lh, 4s, txBob.stx);
 
             lh.builtLedger(ledgerA, txAlice.stx->getTransactionID(), {});
diff --git a/src/test/app/LedgerLoad_test.cpp b/src/test/app/LedgerLoad_test.cpp
index 2fa1193921..1df41671fe 100644
--- a/src/test/app/LedgerLoad_test.cpp
+++ b/src/test/app/LedgerLoad_test.cpp
@@ -127,7 +127,7 @@ class LedgerLoad_test : public beast::unit_test::suite
 
         // empty path
         except([&] {
-            Env env(
+            Env const env(
                 *this,
                 envconfig(ledgerConfig, sd.dbPath, "", StartUpType::LoadFile, std::nullopt),
                 nullptr,
@@ -136,7 +136,7 @@ class LedgerLoad_test : public beast::unit_test::suite
 
         // file does not exist
         except([&] {
-            Env env(
+            Env const env(
                 *this,
                 envconfig(
                     ledgerConfig, sd.dbPath, "badfile.json", StartUpType::LoadFile, std::nullopt),
@@ -158,7 +158,7 @@ class LedgerLoad_test : public beast::unit_test::suite
             return;
 
         except([&] {
-            Env env(
+            Env const env(
                 *this,
                 envconfig(
                     ledgerConfig,
@@ -257,7 +257,7 @@ class LedgerLoad_test : public beast::unit_test::suite
         {
             // will throw an exception, because we cannot load a ledger for
             // replay when trapTxHash is set to an invalid transaction
-            Env env(
+            Env const env(
                 *this,
                 envconfig(ledgerConfig, sd.dbPath, ledgerHash, StartUpType::Replay, ~sd.trapTxHash),
                 nullptr,
@@ -314,7 +314,7 @@ public:
     void
     run() override
     {
-        beast::temp_dir td;
+        beast::temp_dir const td;
         auto sd = setupLedger(td);
 
         // test cases
diff --git a/src/test/app/LedgerMaster_test.cpp b/src/test/app/LedgerMaster_test.cpp
index 3ea16b63eb..7a8904dbd7 100644
--- a/src/test/app/LedgerMaster_test.cpp
+++ b/src/test/app/LedgerMaster_test.cpp
@@ -51,14 +51,14 @@ class LedgerMaster_test : public beast::unit_test::suite
 
         // test invalid range
         {
-            std::uint32_t ledgerSeq = -1;
-            std::uint32_t txnIndex = 0;
+            std::uint32_t const ledgerSeq = -1;
+            std::uint32_t const txnIndex = 0;
             auto result = env.app().getLedgerMaster().txnIdFromIndex(ledgerSeq, txnIndex);
             BEAST_EXPECT(!result);
         }
         // test not in ledger
         {
-            uint32_t txnIndex = metas[0]->getFieldU32(sfTransactionIndex);
+            uint32_t const txnIndex = metas[0]->getFieldU32(sfTransactionIndex);
             auto result = env.app().getLedgerMaster().txnIdFromIndex(0, txnIndex);
             BEAST_EXPECT(!result);
         }
@@ -69,13 +69,13 @@ class LedgerMaster_test : public beast::unit_test::suite
         }
         // ended without result
         {
-            uint32_t txnIndex = metas[0]->getFieldU32(sfTransactionIndex);
+            uint32_t const txnIndex = metas[0]->getFieldU32(sfTransactionIndex);
             auto result = env.app().getLedgerMaster().txnIdFromIndex(endLegSeq + 1, txnIndex);
             BEAST_EXPECT(!result);
         }
         // success (first tx)
         {
-            uint32_t txnIndex = metas[0]->getFieldU32(sfTransactionIndex);
+            uint32_t const txnIndex = metas[0]->getFieldU32(sfTransactionIndex);
             auto result = env.app().getLedgerMaster().txnIdFromIndex(startLegSeq, txnIndex);
             BEAST_EXPECT(
                 // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
@@ -86,7 +86,7 @@ class LedgerMaster_test : public beast::unit_test::suite
         }
         // success (second tx)
         {
-            uint32_t txnIndex = metas[1]->getFieldU32(sfTransactionIndex);
+            uint32_t const txnIndex = metas[1]->getFieldU32(sfTransactionIndex);
             auto result = env.app().getLedgerMaster().txnIdFromIndex(startLegSeq + 1, txnIndex);
             BEAST_EXPECT(
                 // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
diff --git a/src/test/app/LedgerReplay_test.cpp b/src/test/app/LedgerReplay_test.cpp
index 93811d33b0..b30dce4756 100644
--- a/src/test/app/LedgerReplay_test.cpp
+++ b/src/test/app/LedgerReplay_test.cpp
@@ -246,7 +246,7 @@ public:
     uint256 const&
     getClosedLedgerHash() const override
     {
-        static uint256 hash{};
+        static uint256 const hash{};
         return hash;
     }
     bool
@@ -398,7 +398,7 @@ struct TestPeerSet : public PeerSet
     std::set<Peer::id_t> const&
     getPeerIds() const override
     {
-        static std::set<Peer::id_t> emptyPeers;
+        static std::set<Peer::id_t> const emptyPeers;
         return emptyPeers;
     }
 
@@ -605,7 +605,7 @@ public:
     bool
     waitForLedgers(uint256 const& finishLedgerHash, int totalReplay)
     {
-        int totalRound = 100;
+        int const totalRound = 100;
         for (int i = 0; i < totalRound; ++i)
         {
             if (haveLedgers(finishLedgerHash, totalReplay))
@@ -619,12 +619,12 @@ public:
     bool
     waitForDone()
     {
-        int totalRound = 100;
+        int const totalRound = 100;
         for (int i = 0; i < totalRound; ++i)
         {
             bool allDone = true;
             {
-                std::unique_lock<std::mutex> lock(replayer.mtx_);
+                std::unique_lock<std::mutex> const lock(replayer.mtx_);
                 for (auto const& t : replayer.tasks_)
                 {
                     if (!t->finished())
@@ -645,14 +645,14 @@ public:
     std::vector<std::shared_ptr<LedgerReplayTask>>
     getTasks()
     {
-        std::unique_lock<std::mutex> lock(replayer.mtx_);
+        std::unique_lock<std::mutex> const lock(replayer.mtx_);
         return replayer.tasks_;
     }
 
     std::shared_ptr<LedgerReplayTask>
     findTask(uint256 const& hash, int totalReplay)
     {
-        std::unique_lock<std::mutex> lock(replayer.mtx_);
+        std::unique_lock<std::mutex> const lock(replayer.mtx_);
         auto i = std::find_if(replayer.tasks_.begin(), replayer.tasks_.end(), [&](auto const& t) {
             return t->parameter_.finishHash_ == hash && t->parameter_.totalLedgers_ == totalReplay;
         });
@@ -664,21 +664,21 @@ public:
     std::size_t
     countDeltas()
     {
-        std::unique_lock<std::mutex> lock(replayer.mtx_);
+        std::unique_lock<std::mutex> const lock(replayer.mtx_);
         return replayer.deltas_.size();
     }
 
     std::size_t
     countSkipLists()
     {
-        std::unique_lock<std::mutex> lock(replayer.mtx_);
+        std::unique_lock<std::mutex> const lock(replayer.mtx_);
         return replayer.skipLists_.size();
     }
 
     bool
     countsAsExpected(std::size_t tasks, std::size_t skipLists, std::size_t deltas)
     {
-        std::unique_lock<std::mutex> lock(replayer.mtx_);
+        std::unique_lock<std::mutex> const lock(replayer.mtx_);
         return replayer.tasks_.size() == tasks && replayer.skipLists_.size() == skipLists &&
             replayer.deltas_.size() == deltas;
     }
@@ -686,7 +686,7 @@ public:
     std::shared_ptr<SkipListAcquire>
     findSkipListAcquire(uint256 const& hash)
     {
-        std::unique_lock<std::mutex> lock(replayer.mtx_);
+        std::unique_lock<std::mutex> const lock(replayer.mtx_);
         auto i = replayer.skipLists_.find(hash);
         if (i == replayer.skipLists_.end())
             return {};
@@ -696,7 +696,7 @@ public:
     std::shared_ptr<LedgerDeltaAcquire>
     findLedgerDeltaAcquire(uint256 const& hash)
     {
-        std::unique_lock<std::mutex> lock(replayer.mtx_);
+        std::unique_lock<std::mutex> const lock(replayer.mtx_);
         auto i = replayer.deltas_.find(hash);
         if (i == replayer.deltas_.end())
             return {};
@@ -1017,13 +1017,13 @@ struct LedgerReplayer_test : public beast::unit_test::suite
     {
         testcase("config test");
         {
-            Config c;
+            Config const c;
             BEAST_EXPECT(c.LEDGER_REPLAY == false);
         }
 
         {
             Config c;
-            std::string toLoad(R"rippleConfig(
+            std::string const toLoad(R"rippleConfig(
 [ledger_replay]
 1
 )rippleConfig");
@@ -1033,7 +1033,7 @@ struct LedgerReplayer_test : public beast::unit_test::suite
 
         {
             Config c;
-            std::string toLoad = (R"rippleConfig(
+            std::string const toLoad = (R"rippleConfig(
 [ledger_replay]
 0
 )rippleConfig");
@@ -1051,11 +1051,12 @@ struct LedgerReplayer_test : public beast::unit_test::suite
             http_request_type http_request;
             http_request.version(request.version());
             http_request.base() = request.base();
-            bool serverResult = peerFeatureEnabled(http_request, FEATURE_LEDGER_REPLAY, server);
+            bool const serverResult =
+                peerFeatureEnabled(http_request, FEATURE_LEDGER_REPLAY, server);
             if (serverResult != expecting)
                 return false;
 
-            beast::IP::Address addr = boost::asio::ip::make_address("172.1.1.100");
+            beast::IP::Address const addr = boost::asio::ip::make_address("172.1.1.100");
             jtx::Env serverEnv(*this);
             serverEnv.app().config().LEDGER_REPLAY = server;
             auto http_resp = xrpl::makeResponse(
@@ -1081,7 +1082,7 @@ struct LedgerReplayer_test : public beast::unit_test::suite
         NetworkOfTwo net(*this, {totalReplay + 1}, psBhvr, ilBhvr, peerFeature);
 
         auto l = net.server.ledgerMaster.getClosedLedger();
-        uint256 finalHash = l->header().hash;
+        uint256 const finalHash = l->header().hash;
         for (int i = 0; i < totalReplay; ++i)
         {
             BEAST_EXPECT(l);
@@ -1098,7 +1099,7 @@ struct LedgerReplayer_test : public beast::unit_test::suite
 
         net.client.replayer.replay(InboundLedger::Reason::GENERIC, finalHash, totalReplay);
 
-        std::vector<TaskStatus> deltaStatuses(totalReplay - 1, TaskStatus::Completed);
+        std::vector<TaskStatus> const deltaStatuses(totalReplay - 1, TaskStatus::Completed);
         BEAST_EXPECT(net.client.waitAndCheckStatus(
             finalHash, totalReplay, TaskStatus::Completed, TaskStatus::Completed, deltaStatuses));
 
@@ -1119,10 +1120,10 @@ struct LedgerReplayer_test : public beast::unit_test::suite
             PeerFeature::None);
 
         auto l = net.server.ledgerMaster.getClosedLedger();
-        uint256 finalHash = l->header().hash;
+        uint256 const finalHash = l->header().hash;
         net.client.replayer.replay(InboundLedger::Reason::GENERIC, finalHash, totalReplay);
 
-        std::vector<TaskStatus> deltaStatuses(totalReplay - 1, TaskStatus::Completed);
+        std::vector<TaskStatus> const deltaStatuses(totalReplay - 1, TaskStatus::Completed);
         BEAST_EXPECT(net.client.waitAndCheckStatus(
             finalHash, totalReplay, TaskStatus::Completed, TaskStatus::Completed, deltaStatuses));
 
@@ -1176,7 +1177,7 @@ struct LedgerReplayer_test : public beast::unit_test::suite
 
         // feed client with start ledger since InboundLedgers drops all
         auto l = net.server.ledgerMaster.getClosedLedger();
-        uint256 finalHash = l->header().hash;
+        uint256 const finalHash = l->header().hash;
         for (int i = 0; i < totalReplay - 1; ++i)
         {
             l = net.server.ledgerMaster.getLedgerByHash(l->header().parentHash);
@@ -1185,7 +1186,7 @@ struct LedgerReplayer_test : public beast::unit_test::suite
 
         net.client.replayer.replay(InboundLedger::Reason::GENERIC, finalHash, totalReplay);
 
-        std::vector<TaskStatus> deltaStatuses(totalReplay - 1, TaskStatus::Completed);
+        std::vector<TaskStatus> const deltaStatuses(totalReplay - 1, TaskStatus::Completed);
         BEAST_EXPECT(net.client.waitAndCheckStatus(
             finalHash, totalReplay, TaskStatus::Completed, TaskStatus::Completed, deltaStatuses));
         BEAST_EXPECT(net.client.waitForLedgers(finalHash, totalReplay));
@@ -1199,7 +1200,7 @@ struct LedgerReplayer_test : public beast::unit_test::suite
     testStop()
     {
         testcase("stop before timeout");
-        int totalReplay = 3;
+        int const totalReplay = 3;
         NetworkOfTwo net(
             *this,
             {totalReplay + 1},
@@ -1208,10 +1209,10 @@ struct LedgerReplayer_test : public beast::unit_test::suite
             PeerFeature::LedgerReplayEnabled);
 
         auto l = net.server.ledgerMaster.getClosedLedger();
-        uint256 finalHash = l->header().hash;
+        uint256 const finalHash = l->header().hash;
         net.client.replayer.replay(InboundLedger::Reason::GENERIC, finalHash, totalReplay);
 
-        std::vector<TaskStatus> deltaStatuses;
+        std::vector<TaskStatus> const deltaStatuses;
         BEAST_EXPECT(net.client.checkStatus(
             finalHash, totalReplay, TaskStatus::NotDone, TaskStatus::NotDone, deltaStatuses));
 
@@ -1224,7 +1225,7 @@ struct LedgerReplayer_test : public beast::unit_test::suite
     testSkipListBadReply()
     {
         testcase("SkipListAcquire bad reply");
-        int totalReplay = 3;
+        int const totalReplay = 3;
         NetworkOfTwo net(
             *this,
             {totalReplay + 1 + 1},
@@ -1233,7 +1234,7 @@ struct LedgerReplayer_test : public beast::unit_test::suite
             PeerFeature::LedgerReplayEnabled);
 
         auto l = net.server.ledgerMaster.getClosedLedger();
-        uint256 finalHash = l->header().hash;
+        uint256 const finalHash = l->header().hash;
         net.client.replayer.replay(InboundLedger::Reason::GENERIC, finalHash, totalReplay);
 
         auto skipList = net.client.findSkipListAcquire(finalHash);
@@ -1242,7 +1243,7 @@ struct LedgerReplayer_test : public beast::unit_test::suite
         auto item = make_shamapitem(uint256(12345), Slice(payload, sizeof(payload)));
         skipList->processData(l->seq(), item);
 
-        std::vector<TaskStatus> deltaStatuses;
+        std::vector<TaskStatus> const deltaStatuses;
         BEAST_EXPECT(net.client.waitAndCheckStatus(
             finalHash, totalReplay, TaskStatus::Failed, TaskStatus::Failed, deltaStatuses));
 
@@ -1257,7 +1258,7 @@ struct LedgerReplayer_test : public beast::unit_test::suite
     testLedgerDeltaBadReply()
     {
         testcase("LedgerDeltaAcquire bad reply");
-        int totalReplay = 3;
+        int const totalReplay = 3;
         NetworkOfTwo net(
             *this,
             {totalReplay + 1},
@@ -1266,7 +1267,7 @@ struct LedgerReplayer_test : public beast::unit_test::suite
             PeerFeature::LedgerReplayEnabled);
 
         auto l = net.server.ledgerMaster.getClosedLedger();
-        uint256 finalHash = l->header().hash;
+        uint256 const finalHash = l->header().hash;
         net.client.ledgerMaster.storeLedger(l);
         net.client.replayer.replay(InboundLedger::Reason::GENERIC, finalHash, totalReplay);
 
@@ -1290,7 +1291,7 @@ struct LedgerReplayer_test : public beast::unit_test::suite
     testLedgerReplayOverlap()
     {
         testcase("Overlap tasks");
-        int totalReplay = 5;
+        int const totalReplay = 5;
         NetworkOfTwo net(
             *this,
             {(totalReplay * 3) + 1},
@@ -1298,7 +1299,7 @@ struct LedgerReplayer_test : public beast::unit_test::suite
             InboundLedgersBehavior::Good,
             PeerFeature::LedgerReplayEnabled);
         auto l = net.server.ledgerMaster.getClosedLedger();
-        uint256 finalHash = l->header().hash;
+        uint256 const finalHash = l->header().hash;
         net.client.replayer.replay(InboundLedger::Reason::GENERIC, finalHash, totalReplay);
         std::vector<TaskStatus> deltaStatuses(totalReplay - 1, TaskStatus::Completed);
         BEAST_EXPECT(net.client.waitAndCheckStatus(
@@ -1388,7 +1389,7 @@ struct LedgerReplayerTimeout_test : public beast::unit_test::suite
     testSkipListTimeout()
     {
         testcase("SkipListAcquire timeout");
-        int totalReplay = 3;
+        int const totalReplay = 3;
         NetworkOfTwo net(
             *this,
             {totalReplay + 1},
@@ -1397,10 +1398,10 @@ struct LedgerReplayerTimeout_test : public beast::unit_test::suite
             PeerFeature::LedgerReplayEnabled);
 
         auto l = net.server.ledgerMaster.getClosedLedger();
-        uint256 finalHash = l->header().hash;
+        uint256 const finalHash = l->header().hash;
         net.client.replayer.replay(InboundLedger::Reason::GENERIC, finalHash, totalReplay);
 
-        std::vector<TaskStatus> deltaStatuses;
+        std::vector<TaskStatus> const deltaStatuses;
         BEAST_EXPECT(net.client.waitAndCheckStatus(
             finalHash, totalReplay, TaskStatus::Failed, TaskStatus::Failed, deltaStatuses));
 
@@ -1414,7 +1415,7 @@ struct LedgerReplayerTimeout_test : public beast::unit_test::suite
     testLedgerDeltaTimeout()
     {
         testcase("LedgerDeltaAcquire timeout");
-        int totalReplay = 3;
+        int const totalReplay = 3;
         NetworkOfTwo net(
             *this,
             {totalReplay + 1},
@@ -1423,7 +1424,7 @@ struct LedgerReplayerTimeout_test : public beast::unit_test::suite
             PeerFeature::LedgerReplayEnabled);
 
         auto l = net.server.ledgerMaster.getClosedLedger();
-        uint256 finalHash = l->header().hash;
+        uint256 const finalHash = l->header().hash;
         net.client.ledgerMaster.storeLedger(l);
         net.client.replayer.replay(InboundLedger::Reason::GENERIC, finalHash, totalReplay);
 
@@ -1452,8 +1453,8 @@ struct LedgerReplayerLong_test : public beast::unit_test::suite
     run() override
     {
         testcase("Acquire 1000 ledgers");
-        int totalReplay = 250;
-        int rounds = 4;
+        int const totalReplay = 250;
+        int const rounds = 4;
         NetworkOfTwo net(
             *this,
             {(totalReplay * rounds) + 1},
@@ -1479,7 +1480,7 @@ struct LedgerReplayerLong_test : public beast::unit_test::suite
                 InboundLedger::Reason::GENERIC, finishHashes[i], totalReplay);
         }
 
-        std::vector<TaskStatus> deltaStatuses(totalReplay - 1, TaskStatus::Completed);
+        std::vector<TaskStatus> const deltaStatuses(totalReplay - 1, TaskStatus::Completed);
         for (int i = 0; i < rounds; ++i)
         {
             BEAST_EXPECT(net.client.waitAndCheckStatus(
diff --git a/src/test/app/LendingHelpers_test.cpp b/src/test/app/LendingHelpers_test.cpp
index 24661c18fb..56db553583 100644
--- a/src/test/app/LendingHelpers_test.cpp
+++ b/src/test/app/LendingHelpers_test.cpp
@@ -593,7 +593,7 @@ class LendingHelpers_test : public beast::unit_test::suite
         using namespace jtx;
         using namespace xrpl::detail;
 
-        Env env{*this};
+        Env const env{*this};
         Account const issuer{"issuer"};
         PrettyAsset const asset = issuer["USD"];
         std::int32_t const loanScale = -5;
@@ -680,7 +680,7 @@ class LendingHelpers_test : public beast::unit_test::suite
         using namespace jtx;
         using namespace xrpl::detail;
 
-        Env env{*this};
+        Env const env{*this};
         Account const issuer{"issuer"};
         PrettyAsset const asset = issuer["USD"];
         std::int32_t const loanScale = -5;
@@ -773,7 +773,7 @@ class LendingHelpers_test : public beast::unit_test::suite
         using namespace jtx;
         using namespace xrpl::detail;
 
-        Env env{*this};
+        Env const env{*this};
         Account const issuer{"issuer"};
         PrettyAsset const asset = issuer["USD"];
         std::int32_t const loanScale = -5;
@@ -872,7 +872,7 @@ class LendingHelpers_test : public beast::unit_test::suite
         using namespace jtx;
         using namespace xrpl::detail;
 
-        Env env{*this};
+        Env const env{*this};
         Account const issuer{"issuer"};
         PrettyAsset const asset = issuer["USD"];
         std::int32_t const loanScale = -5;
@@ -979,7 +979,7 @@ class LendingHelpers_test : public beast::unit_test::suite
         using namespace jtx;
         using namespace xrpl::detail;
 
-        Env env{*this};
+        Env const env{*this};
         Account const issuer{"issuer"};
         PrettyAsset const asset = issuer["USD"];
         std::int32_t const loanScale = -5;
@@ -1086,7 +1086,7 @@ class LendingHelpers_test : public beast::unit_test::suite
         using namespace jtx;
         using namespace xrpl::detail;
 
-        Env env{*this};
+        Env const env{*this};
         Account const issuer{"issuer"};
         PrettyAsset const asset = issuer["USD"];
         std::int32_t const loanScale = -5;
diff --git a/src/test/app/LoadFeeTrack_test.cpp b/src/test/app/LoadFeeTrack_test.cpp
index fed76288ef..68ebcc70a1 100644
--- a/src/test/app/LoadFeeTrack_test.cpp
+++ b/src/test/app/LoadFeeTrack_test.cpp
@@ -13,7 +13,7 @@ public:
     run() override
     {
         Config d;  // get a default configuration object
-        LoadFeeTrack l;
+        LoadFeeTrack const l;
         {
             Fees const fees = [&]() {
                 Fees f;
diff --git a/src/test/app/LoanBroker_test.cpp b/src/test/app/LoanBroker_test.cpp
index 361f70209f..f7222aa61a 100644
--- a/src/test/app/LoanBroker_test.cpp
+++ b/src/test/app/LoanBroker_test.cpp
@@ -31,7 +31,7 @@ class LoanBroker_test : public beast::unit_test::suite
 
             // Try to create a vault
             PrettyAsset const asset{xrpIssue(), 1'000'000};
-            Vault vault{env};
+            Vault const vault{env};
             auto const [tx, keylet] = vault.create({.owner = alice, .asset = asset});
             env(tx, ter(goodVault ? ter(tesSUCCESS) : ter(temDISABLED)));
             env.close();
@@ -493,14 +493,14 @@ class LoanBroker_test : public beast::unit_test::suite
         // MPT. That'll require three corresponding SAVs.
         Env env(*this, all);
 
-        Account issuer{"issuer"};
+        Account const issuer{"issuer"};
         // For simplicity, alice will be the sole actor for the vault & brokers.
         Account alice{"alice"};
         // Evan will attempt to be naughty
         Account evan{"evan"};
         // Bystander doesn't have anything to do with the SAV or Broker, or any
         // of the relevant tokens
-        Account bystander{"bystander"};
+        Account const bystander{"bystander"};
         Vault vault{env};
 
         // Fund the accounts and trust lines with the same amount so that tests
@@ -807,7 +807,7 @@ class LoanBroker_test : public beast::unit_test::suite
         Account const issuer{"issuer"};
         Account const alice{"alice"};
         Env env(*this);
-        Vault vault{env};
+        Vault const vault{env};
 
         env.fund(XRP(100'000), issuer, alice);
         env.close();
@@ -1070,7 +1070,7 @@ class LoanBroker_test : public beast::unit_test::suite
             env(jtx, ter(temINVALID));
 
             // holder == beast::zero
-            STAmount bad(Issue{USD.currency, beast::zero}, 100);
+            STAmount const bad(Issue{USD.currency, beast::zero}, 100);
             jtx.jv[sfAmount] = bad.getJson();
             jtx.stx = env.ust(jtx);
             Serializer s;
@@ -1091,7 +1091,7 @@ class LoanBroker_test : public beast::unit_test::suite
         // MPTCanClawback is not set
         testLoanBroker(
             [&](Env& env, Account const& issuer, Account const& alice) -> MPT {
-                MPTTester mpt({.env = env, .issuer = issuer, .holders = {alice}});
+                MPTTester const mpt({.env = env, .issuer = issuer, .holders = {alice}});
                 return mpt;
             },
             CoverClawback);
@@ -1171,7 +1171,7 @@ class LoanBroker_test : public beast::unit_test::suite
 
         // Create a Vault owned by alice with an XRP asset
         PrettyAsset const asset{xrpIssue(), 1};
-        Vault vault{env};
+        Vault const vault{env};
         auto const [createTx, vaultKeylet] = vault.create({.owner = alice, .asset = asset});
         env(createTx);
         env.close();
@@ -1193,7 +1193,7 @@ class LoanBroker_test : public beast::unit_test::suite
         // vault SLE
         OpenView ov{*env.current()};
         test::StreamSink sink{beast::severities::kWarning};
-        beast::Journal jlog{sink};
+        beast::Journal const jlog{sink};
         ApplyContext ac{env.app(), ov, tx, tesSUCCESS, env.current()->fees().base, tapNONE, jlog};
 
         if (auto sleBroker = ac.view().peek(keylet::loanbroker(brokerKeylet.key)))
@@ -1207,7 +1207,7 @@ class LoanBroker_test : public beast::unit_test::suite
 
         // Invoke preclaim against the mutated (ApplyView) view; triggers
         // nullptr deref
-        PreclaimContext pctx{env.app(), ac.view(), tesSUCCESS, tx, tapNONE, jlog};
+        PreclaimContext const pctx{env.app(), ac.view(), tesSUCCESS, tx, tapNONE, jlog};
         (void)LoanBrokerCoverDeposit::preclaim(pctx);
     }
 
@@ -1326,7 +1326,7 @@ class LoanBroker_test : public beast::unit_test::suite
         Account const issuer{"issuer"};
         Account const alice{"alice"};
         Env env(*this);
-        Vault vault{env};
+        Vault const vault{env};
 
         env.fund(XRP(100'000), issuer, alice);
         env.close();
@@ -1348,7 +1348,7 @@ class LoanBroker_test : public beast::unit_test::suite
         env(tx);
         env.close();
         auto const le = env.le(vaultKeylet);
-        VaultInfo vaultInfo = [&]() {
+        VaultInfo const vaultInfo = [&]() {
             if (BEAST_EXPECT(le))
                 return VaultInfo{asset, vaultKeylet.key, le->at(sfAccount)};
             return VaultInfo{asset, {}, {}};
@@ -1438,7 +1438,7 @@ class LoanBroker_test : public beast::unit_test::suite
 
             auto const [token, deposit, err] = getToken(env);
 
-            Vault vault(env);
+            Vault const vault(env);
             auto const [tx, keylet] = vault.create({.owner = broker, .asset = token.asset()});
             env(tx);
             env.close();
@@ -1466,7 +1466,7 @@ class LoanBroker_test : public beast::unit_test::suite
             std::optional<std::uint64_t>,  // max amount
             std::uint64_t,                 // deposit amount
             TER>>                          // expected error
-            mptTests = {
+            const mptTests = {
                 // issuer can issue up to 2'000 tokens
                 {2'000, 4'000, 1'000, tesSUCCESS},
                 // issuer can issue 500 tokens (250 VaultDeposit +
@@ -1509,7 +1509,7 @@ class LoanBroker_test : public beast::unit_test::suite
         env.fund(XRP(20'000), issuer, lender, borrower);
         auto const IOU = issuer["IOU"];
 
-        Vault vault{env};
+        Vault const vault{env};
         auto [tx, vaultKeylet] = vault.create({.owner = lender, .asset = IOU.asset()});
         env(tx);
         env.close();
@@ -1597,7 +1597,7 @@ class LoanBroker_test : public beast::unit_test::suite
             env(pay(issuer, broker, token(2'000)));
             env.close();
 
-            Vault vault(env);
+            Vault const vault(env);
             auto const [tx, keylet] = vault.create({.owner = broker, .asset = token.asset()});
             env(tx);
             env.close();
@@ -1718,7 +1718,7 @@ class LoanBroker_test : public beast::unit_test::suite
 
             auto const& token = *maybeToken;
 
-            Vault vault(env);
+            Vault const vault(env);
             auto const [tx, keylet] = vault.create({.owner = broker, .asset = token.asset()});
             env(tx);
             env.close();
diff --git a/src/test/app/Loan_test.cpp b/src/test/app/Loan_test.cpp
index 4cdc62853c..a63d31f030 100644
--- a/src/test/app/Loan_test.cpp
+++ b/src/test/app/Loan_test.cpp
@@ -87,7 +87,7 @@ protected:
         Number
         maxCoveredLoanValue(Number const& currentDebt) const
         {
-            NumberRoundModeGuard mg(Number::downward);
+            NumberRoundModeGuard const mg(Number::downward);
             auto debtLimit = coverDeposit * tenthBipsPerUnity.value() / coverRateMin.value();
 
             return debtLimit - currentDebt;
@@ -429,7 +429,7 @@ protected:
     {
         using namespace jtx;
 
-        Vault vault{env};
+        Vault const vault{env};
 
         auto const deposit = asset(params.vaultDeposit);
         auto const debtMaximumValue = asset(params.debtMax).value();
@@ -520,7 +520,7 @@ protected:
                  : std::max(broker.vaultScale(env), state.principalOutstanding.exponent())));
         BEAST_EXPECT(state.paymentInterval == 600);
         {
-            NumberRoundModeGuard mg(Number::upward);
+            NumberRoundModeGuard const mg(Number::upward);
             BEAST_EXPECT(
                 state.totalValue ==
                 roundToAsset(
@@ -1149,7 +1149,7 @@ protected:
         auto loanKeylet = std::get<Keylet>(*loanResult);
         auto pseudoAcct = std::get<Account>(*loanResult);
 
-        VerifyLoanStatus verifyLoanStatus(env, broker, pseudoAcct, loanKeylet);
+        VerifyLoanStatus const verifyLoanStatus(env, broker, pseudoAcct, loanKeylet);
 
         makeLoanPayments(
             env,
@@ -1822,7 +1822,7 @@ protected:
                           std::function<void(Account const& holder)>,
                           TER> {
                 // Freeze / lock the asset
-                std::function<void(Account const& holder)> empty;
+                std::function<void(Account const& holder)> const empty;
                 if (broker.asset.native())
                 {
                     // XRP can't be frozen
@@ -1943,7 +1943,7 @@ protected:
                          ? 0
                          : std::max(
                                broker.vaultScale(env), state.principalOutstanding.exponent())));
-                NumberRoundModeGuard mg(Number::upward);
+                NumberRoundModeGuard const mg(Number::upward);
                 auto const defaultAmount = roundToAsset(
                     broker.asset,
                     std::min(
@@ -2235,7 +2235,7 @@ protected:
                     // service fee is 2
                     auto const startingPayments = state.paymentRemaining;
                     STAmount const payoffAmount = [&]() {
-                        NumberRoundModeGuard mg(Number::upward);
+                        NumberRoundModeGuard const mg(Number::upward);
                         auto const rawPayoff =
                             startingPayments * (state.periodicPayment + broker.asset(2).value());
                         STAmount payoffAmount{broker.asset, rawPayoff};
@@ -2835,7 +2835,7 @@ protected:
                 {.flags = tfMPTCanTransfer | tfMPTCanLock |
                      (args.requireAuth ? tfMPTRequireAuth : none)});
             env.close();
-            PrettyAsset mptAsset = mptt.issuanceID();
+            PrettyAsset const mptAsset = mptt.issuanceID();
             mptt.authorize({.account = lender});
             mptt.authorize({.account = borrower});
             env.close();
@@ -2962,7 +2962,7 @@ protected:
             CaseArgs{.requireAuth = true});
 
         auto const [acctReserve, incReserve] = [this]() -> std::pair<int, int> {
-            Env env{*this, testable_amendments()};
+            Env const env{*this, testable_amendments()};
             return {
                 env.current()->fees().accountReserve(0).drops() / DROPS_PER_XRP.drops(),
                 env.current()->fees().increment.drops() / DROPS_PER_XRP.drops()};
@@ -3247,7 +3247,7 @@ protected:
         jtx::Account const alice{"alice"};
         jtx::Account const bella{"bella"};
         auto const msigSetup = [&](Env& env, Account const& account) {
-            Json::Value tx1 = signers(account, 2, {{alice, 1}, {bella, 1}});
+            Json::Value const tx1 = signers(account, 2, {{alice, 1}, {bella, 1}});
             env(tx1);
             env.close();
         };
@@ -3314,7 +3314,7 @@ protected:
             [&, this](Env& env, BrokerInfo const& broker, auto&) {
                 using namespace loan;
                 Number const principalRequest = broker.asset(1'000).value();
-                Vault vault{env};
+                Vault const vault{env};
                 auto tx = vault.set({.owner = lender, .id = broker.vaultID});
                 tx[sfAssetsMaximum] = BrokerParameters::defaults().vaultDeposit;
                 env(tx);
@@ -3334,7 +3334,7 @@ protected:
             [&, this](Env& env, BrokerInfo const& broker, auto&) {
                 using namespace loan;
                 Number const principalRequest = broker.asset(1'000).value();
-                Vault vault{env};
+                Vault const vault{env};
                 auto tx = vault.set({.owner = lender, .id = broker.vaultID});
                 tx[sfAssetsMaximum] =
                     BrokerParameters::defaults().vaultDeposit + broker.asset(1).number();
@@ -3601,13 +3601,13 @@ protected:
         Account const lender{"lender"};
         Account const borrower{"borrower"};
 
-        BrokerParameters brokerParams;
+        BrokerParameters const brokerParams;
         env.fund(XRP(brokerParams.vaultDeposit * 100), lender, borrower);
         env.close();
 
         PrettyAsset const xrpAsset{xrpIssue(), 1'000'000};
 
-        BrokerInfo broker{createVaultAndBroker(env, xrpAsset, lender, brokerParams)};
+        BrokerInfo const broker{createVaultAndBroker(env, xrpAsset, lender, brokerParams)};
 
         using namespace loan;
 
@@ -3664,13 +3664,13 @@ protected:
         Account const issuer{"issuer"};
         Account const lender{"lender"};
 
-        BrokerParameters brokerParams{.debtMax = 0};
+        BrokerParameters const brokerParams{.debtMax = 0};
         env.fund(XRP(brokerParams.vaultDeposit * 100), issuer, noripple(lender));
         env.close();
 
         PrettyAsset const xrpAsset{xrpIssue(), 1'000'000};
 
-        BrokerInfo broker{createVaultAndBroker(env, xrpAsset, lender, brokerParams)};
+        BrokerInfo const broker{createVaultAndBroker(env, xrpAsset, lender, brokerParams)};
 
         if (auto const brokerSle = env.le(keylet::loanbroker(broker.brokerID));
             BEAST_EXPECT(brokerSle))
@@ -3712,12 +3712,12 @@ protected:
         Account const lender{"lender"};
         Account const borrower{"borrower"};
 
-        BrokerParameters brokerParams;
+        BrokerParameters const brokerParams;
         env.fund(XRP(brokerParams.vaultDeposit * 100), issuer, lender, borrower);
         env.close();
 
         PrettyAsset const xrpAsset{xrpIssue(), 1'000'000};
-        BrokerInfo broker{createVaultAndBroker(env, xrpAsset, lender, brokerParams)};
+        BrokerInfo const broker{createVaultAndBroker(env, xrpAsset, lender, brokerParams)};
 
         using namespace loan;
 
@@ -3786,9 +3786,9 @@ protected:
 
         Account const alice{"alice"};
         std::string const borrowerPass = "borrower";
-        Account borrower{borrowerPass, KeyType::ed25519};
+        Account const borrower{borrowerPass, KeyType::ed25519};
         auto const lenderPass = "lender";
-        Account lender{lenderPass, KeyType::ed25519};
+        Account const lender{lenderPass, KeyType::ed25519};
 
         env.fund(XRP(1'000'000), alice, lender, borrower);
         env.close();
@@ -4169,7 +4169,8 @@ protected:
         env.fund(XRP(1'000), issuer, lender);
 
         std::int64_t constexpr issuerBalance = 10'000'000;
-        MPTTester asset({.env = env, .issuer = issuer, .holders = {lender}, .pay = issuerBalance});
+        MPTTester const asset(
+            {.env = env, .issuer = issuer, .holders = {lender}, .pay = issuerBalance});
 
         BrokerParameters const brokerParams{
             .debtMax = 200,
@@ -4319,7 +4320,7 @@ protected:
             env.fund(XRP(1'000), lender, issuer, borrower);
             env(trust(lender, IOU(10'000'000)));
             env(pay(issuer, lender, IOU(5'000'000)));
-            BrokerInfo brokerInfo{createVaultAndBroker(env, issuer["IOU"], lender)};
+            BrokerInfo const brokerInfo{createVaultAndBroker(env, issuer["IOU"], lender)};
 
             auto const loanSetFee = fee(env.current()->fees().base * 2);
             Number const debtMaximumRequest = brokerInfo.asset(1'000).value();
@@ -4381,7 +4382,7 @@ protected:
             // can it happen? the signature is checked before transactor
             // executes
 
-            JTx tx = env.jt(
+            JTx const tx = env.jt(
                 set(borrower, brokerInfo.brokerID, debtMaximumRequest),
                 sig(sfCounterpartySignature, lender),
                 loanSetFee);
@@ -4470,7 +4471,7 @@ protected:
         env(pay(issuer, borrower, mptAsset(1'000)));
         env.close();
 
-        BrokerInfo broker{createVaultAndBroker(env, mptAsset, lender)};
+        BrokerInfo const broker{createVaultAndBroker(env, mptAsset, lender)};
 
         using namespace loan;
 
@@ -4573,7 +4574,7 @@ protected:
             return Account("Broker pseudo-account", brokerPseudo);
         }();
 
-        VerifyLoanStatus verifyLoanStatus(env, broker, pseudoAcct, keylet);
+        VerifyLoanStatus const verifyLoanStatus(env, broker, pseudoAcct, keylet);
         auto const originalState = getCurrentState(env, broker, keylet);
         verifyLoanStatus(originalState);
 
@@ -4624,7 +4625,7 @@ protected:
         env(payIssuerTx);
         env.close();
 
-        BrokerInfo broker{createVaultAndBroker(env, iouAsset, lender)};
+        BrokerInfo const broker{createVaultAndBroker(env, iouAsset, lender)};
 
         using namespace loan;
 
@@ -4686,7 +4687,7 @@ protected:
         env(pay(issuer, borrower, iouAsset(1'000)));
         env.close();
 
-        BrokerInfo broker{createVaultAndBroker(env, iouAsset, lender)};
+        BrokerInfo const broker{createVaultAndBroker(env, iouAsset, lender)};
 
         using namespace loan;
 
@@ -4768,7 +4769,7 @@ protected:
         env(payIssuerTx);
         env.close();
 
-        BrokerInfo broker{createVaultAndBroker(env, iouAsset, lender)};
+        BrokerInfo const broker{createVaultAndBroker(env, iouAsset, lender)};
 
         using namespace loan;
 
@@ -4867,7 +4868,7 @@ protected:
         env(payIssuerTx);
         env.close();
 
-        BrokerInfo broker{createVaultAndBroker(env, iouAsset, lender)};
+        BrokerInfo const broker{createVaultAndBroker(env, iouAsset, lender)};
         {
             auto const coverDepositValue = broker.asset(broker.params.coverDeposit * 10).value();
             env(loanBroker::coverDeposit(lender, broker.brokerID, coverDepositValue));
@@ -5155,7 +5156,7 @@ protected:
 
             // pay all but the last payment
             {
-                NumberRoundModeGuard mg{Number::upward};
+                NumberRoundModeGuard const mg{Number::upward};
                 Number const payment = beforeState.periodicPayment * (total - 1);
                 XRPAmount const payFee{baseFee * ((total - 1) / loanPaymentsPerFeeIncrement + 1)};
                 STAmount const paymentAmount =
@@ -5259,7 +5260,7 @@ protected:
         env(pay(issuer, alice, asset(100)));
         env.close();
 
-        Vault vault{env};
+        Vault const vault{env};
         auto const [createTx, vaultKeylet] = vault.create({.owner = alice, .asset = asset});
         env(createTx);
         env.close();
@@ -5595,7 +5596,7 @@ protected:
         env.close();
 
         PrettyAsset const asset{xrpIssue(), 1'000'000};
-        BrokerParameters brokerParams{};
+        BrokerParameters const brokerParams{};
         auto const broker = createVaultAndBroker(env, asset, lender, brokerParams);
 
         // Create a 3-payment loan so full-payment path is enabled after 1
@@ -5792,10 +5793,10 @@ protected:
         Env env(*this, all);
 
         // Setup: Create accounts
-        Account issuer{"issuer"};
-        Account lender{"lender"};
-        Account borrower{"borrower"};
-        Account victim{"victim"};
+        Account const issuer{"issuer"};
+        Account const lender{"lender"};
+        Account const borrower{"borrower"};
+        Account const victim{"victim"};
 
         env.fund(XRP(1'000'000'00), issuer, lender, borrower, victim);
         env.close();
@@ -5810,7 +5811,7 @@ protected:
         env(pay(issuer, victim, asset(50000)));
         env.close();
 
-        BrokerParameters brokerParams{
+        BrokerParameters const brokerParams{
             .vaultDeposit = 10000,
             .debtMax = Number{0},
             .coverRateMin = TenthBips32{1000},
@@ -5838,8 +5839,8 @@ protected:
 
         {
             auto const vaultSle = env.le(vaultKeylet);
-            Number assetsTotal = vaultSle->at(sfAssetsTotal);
-            Number assetsAvail = vaultSle->at(sfAssetsAvailable);
+            Number const assetsTotal = vaultSle->at(sfAssetsTotal);
+            Number const assetsAvail = vaultSle->at(sfAssetsAvailable);
 
             log << "Before loan creation:" << std::endl;
             log << "  AssetsTotal: " << assetsTotal << std::endl;
@@ -5871,8 +5872,8 @@ protected:
 
         {
             auto const vaultSle = env.le(vaultKeylet);
-            Number assetsTotal = vaultSle->at(sfAssetsTotal);
-            Number assetsAvail = vaultSle->at(sfAssetsAvailable);
+            Number const assetsTotal = vaultSle->at(sfAssetsTotal);
+            Number const assetsAvail = vaultSle->at(sfAssetsAvailable);
 
             log << "After loan creation:" << std::endl;
             log << "  AssetsTotal: " << assetsTotal << std::endl;
@@ -5909,8 +5910,8 @@ protected:
         // Step 8: Verify phantom assets created
         {
             auto const vaultSle2 = env.le(vaultKeylet);
-            Number assetsTotal2 = vaultSle2->at(sfAssetsTotal);
-            Number assetsAvail2 = vaultSle2->at(sfAssetsAvailable);
+            Number const assetsTotal2 = vaultSle2->at(sfAssetsTotal);
+            Number const assetsAvail2 = vaultSle2->at(sfAssetsAvailable);
 
             log << "After default:" << std::endl;
             log << "  AssetsTotal: " << assetsTotal2 << std::endl;
@@ -6033,7 +6034,7 @@ protected:
         auto loanKeylet = std::get<Keylet>(*loanResult);
         auto pseudoAcct = std::get<Account>(*loanResult);
 
-        VerifyLoanStatus verifyLoanStatus(env, broker, pseudoAcct, loanKeylet);
+        VerifyLoanStatus const verifyLoanStatus(env, broker, pseudoAcct, loanKeylet);
 
         if (auto const brokerSle = env.le(broker.brokerKeylet()); BEAST_EXPECT(brokerSle))
         {
@@ -6077,7 +6078,7 @@ protected:
         auto const txfee = fee(XRP(100));
 
         Env env(*this);
-        Vault vault(env);
+        Vault const vault(env);
 
         env.fund(XRP(10'000), lender, issuer, borrower, depositor);
         env.close();
@@ -6137,7 +6138,7 @@ protected:
         env.close();
 
         // Vault with XRP asset
-        Vault vault{env};
+        Vault const vault{env};
         auto [vaultCreate, vaultKeylet] = vault.create({.owner = lender, .asset = xrpIssue()});
         env(vaultCreate);
         env.close();
@@ -6239,7 +6240,7 @@ protected:
         auto loanKeylet = std::get<Keylet>(*loanResult);
         auto pseudoAcct = std::get<Account>(*loanResult);
 
-        VerifyLoanStatus verifyLoanStatus(env, broker, pseudoAcct, loanKeylet);
+        VerifyLoanStatus const verifyLoanStatus(env, broker, pseudoAcct, loanKeylet);
 
         makeLoanPayments(
             env,
@@ -6266,7 +6267,7 @@ protected:
 
         auto testLoanAsset = [&](auto&& getMaxDebt, auto const& borrower) {
             Env env(*this);
-            Vault vault(env);
+            Vault const vault(env);
 
             if (borrower == broker)
             {
@@ -6359,7 +6360,7 @@ protected:
                 borrowerAcct);
             testLoanAsset(
                 [&](Env& env) -> STAmount {
-                    MPTTester mpt(
+                    MPTTester const mpt(
                         {.env = env,
                          .issuer = issuer,
                          .holders = {broker, depositor},
@@ -6403,7 +6404,7 @@ protected:
         auto loanKeylet = std::get<Keylet>(*loanResult);
         auto pseudoAcct = std::get<Account>(*loanResult);
 
-        VerifyLoanStatus verifyLoanStatus(env, broker, pseudoAcct, loanKeylet);
+        VerifyLoanStatus const verifyLoanStatus(env, broker, pseudoAcct, loanKeylet);
 
         makeLoanPayments(
             env,
@@ -6459,7 +6460,7 @@ protected:
         auto loanKeylet = std::get<Keylet>(*loanResult);
         auto pseudoAcct = std::get<Account>(*loanResult);
 
-        VerifyLoanStatus verifyLoanStatus(env, broker, pseudoAcct, loanKeylet);
+        VerifyLoanStatus const verifyLoanStatus(env, broker, pseudoAcct, loanKeylet);
 
         auto const state = getCurrentState(env, broker, loanKeylet);
 
@@ -6470,7 +6471,7 @@ protected:
             tfLoanOverpayment));
         env.close();
 
-        PaymentParameters paymentParams{
+        PaymentParameters const paymentParams{
             .showStepBalances = false,
             .validateBalances = true,
         };
@@ -7077,20 +7078,20 @@ protected:
         Account const borrower("borrower");
 
         // Determine all the random parameters at once
-        AssetType assetType = static_cast<AssetType>(assetDist(engine_));
+        AssetType const assetType = static_cast<AssetType>(assetDist(engine_));
         auto const principalRequest = principalDist(engine_);
-        TenthBips16 managementFeeRate{managementFeeRateDist(engine_)};
+        TenthBips16 const managementFeeRate{managementFeeRateDist(engine_)};
         auto const serviceFee = serviceFeeDist(engine_);
         TenthBips32 interest{interestRateDist(engine_)};
         auto const payTotal = paymentTotalDist(engine_);
         auto const payInterval = paymentIntervalDist(engine_);
 
-        BrokerParameters brokerParams{
+        BrokerParameters const brokerParams{
             .vaultDeposit = principalRequest * 10,
             .debtMax = 0,
             .coverRateMin = TenthBips32{0},
             .managementFeeRate = managementFeeRate};
-        LoanParameters loanParams{
+        LoanParameters const loanParams{
             .account = lender,
             .counter = borrower,
             .principalRequest = principalRequest,
@@ -7108,7 +7109,7 @@ public:
     run() override
     {
         auto const numIterations = [s = arg()]() -> int {
-            int defaultNum = 5;
+            int const defaultNum = 5;
             if (s.empty())
                 return defaultNum;
             try
diff --git a/src/test/app/MPToken_test.cpp b/src/test/app/MPToken_test.cpp
index 5a90a3a71e..6e94ffd9bc 100644
--- a/src/test/app/MPToken_test.cpp
+++ b/src/test/app/MPToken_test.cpp
@@ -827,7 +827,7 @@ class MPToken_test : public beast::unit_test::suite
 
             env.fund(XRP(1'000), alice);
             env.fund(XRP(1'000), bob);
-            STAmount mpt{MPTIssue{makeMptID(1, alice)}, UINT64_C(100)};
+            STAmount const mpt{MPTIssue{makeMptID(1, alice)}, UINT64_C(100)};
 
             env(pay(alice, bob, mpt), ter(temDISABLED));
         }
@@ -841,7 +841,7 @@ class MPToken_test : public beast::unit_test::suite
 
             env.fund(XRP(1'000), alice);
             env.fund(XRP(1'000), carol);
-            STAmount mpt{MPTIssue{makeMptID(1, alice)}, UINT64_C(100)};
+            STAmount const mpt{MPTIssue{makeMptID(1, alice)}, UINT64_C(100)};
 
             Json::Value jv;
             jv[jss::secret] = alice.name();
@@ -1457,7 +1457,7 @@ class MPToken_test : public beast::unit_test::suite
         {
             Env env{*this, features};
             env.fund(XRP(1'000), alice, bob);
-            STAmount mpt{MPTIssue{makeMptID(1, alice)}, UINT64_C(100)};
+            STAmount const mpt{MPTIssue{makeMptID(1, alice)}, UINT64_C(100)};
             Json::Value jv;
             jv[jss::secret] = alice.name();
             jv[jss::tx_json] = pay(alice, bob, mpt);
@@ -1805,7 +1805,7 @@ class MPToken_test : public beast::unit_test::suite
         Account const alice("alice");
         auto const USD = alice["USD"];
         Account const carol("carol");
-        MPTIssue issue(makeMptID(1, alice));
+        MPTIssue const issue(makeMptID(1, alice));
         STAmount mpt{issue, UINT64_C(100)};
         auto const jvb = bridge(alice, USD, alice, USD);
         for (auto const& feature : {features, features - featureMPTokensV1})
@@ -2876,7 +2876,7 @@ class MPToken_test : public beast::unit_test::suite
             mptAlice.create(
                 {.metadata = "test", .ownerCount = 1, .mutableFlags = tmfMPTCanMutateMetadata});
 
-            std::vector<std::string> metadatas = {
+            std::vector<std::string> const metadatas = {
                 "mutate metadata",
                 "mutate metadata 2",
                 "mutate metadata 3",
diff --git a/src/test/app/Manifest_test.cpp b/src/test/app/Manifest_test.cpp
index 92a10ef7fa..c2f789e80c 100644
--- a/src/test/app/Manifest_test.cpp
+++ b/src/test/app/Manifest_test.cpp
@@ -249,8 +249,9 @@ public:
             {
                 // save should store all trusted master keys to db
                 std::vector<std::string> s1;
-                std::vector<std::string> keys;
+                std::vector<std::string> const keys;
                 s1.reserve(inManifests.size());
+
                 for (auto const& man : inManifests)
                     s1.push_back(toBase58(TokenType::NodePublic, man->masterKey));
                 unl->load({}, s1, keys);
@@ -602,12 +603,12 @@ public:
                         BEAST_EXPECT(!deserializeManifest(toString(st)));
                     }
                     {  // invalid manifest (domain too long)
-                        std::string s(254, 'a');
+                        std::string const s(254, 'a');
                         auto const st = buildManifestObject(++sequence, s + ".example.com");
                         BEAST_EXPECT(!deserializeManifest(toString(st)));
                     }
                     {  // invalid manifest (domain component too long)
-                        std::string s(72, 'a');
+                        std::string const s(72, 'a');
                         auto const st = buildManifestObject(++sequence, s + ".example.com");
                         BEAST_EXPECT(!deserializeManifest(toString(st)));
                     }
diff --git a/src/test/app/MultiSign_test.cpp b/src/test/app/MultiSign_test.cpp
index 2bdfec2e9d..7a5a49ca9b 100644
--- a/src/test/app/MultiSign_test.cpp
+++ b/src/test/app/MultiSign_test.cpp
@@ -63,7 +63,7 @@ public:
 
         {
             // Attach a signer list to alice.  Should fail.
-            Json::Value signersList = signers(alice, 1, {{bogie, 1}});
+            Json::Value const signersList = signers(alice, 1, {{bogie, 1}});
             env(signersList, ter(tecINSUFFICIENT_RESERVE));
             env.close();
             env.require(owners(alice, 0));
@@ -81,7 +81,7 @@ public:
             env(pay(env.master, alice, fee - drops(1)));
 
             // Replace with the biggest possible signer list.  Should fail.
-            Json::Value bigSigners = signers(
+            Json::Value const bigSigners = signers(
                 alice,
                 1,
                 {{bogie, 1},
@@ -1012,7 +1012,7 @@ public:
         auto const baseFee = env.current()->fees().base;
         {
             // Single-sign, but leave an empty SigningPubKey.
-            JTx tx = env.jt(noop(alice), sig(alice));
+            JTx const tx = env.jt(noop(alice), sig(alice));
             STTx local = *(tx.stx);
             local.setFieldVL(sfSigningPubKey, Blob());  // Empty SigningPubKey
             auto const info = submitSTTx(local);
@@ -1022,7 +1022,7 @@ public:
         }
         {
             // Single-sign, but invalidate the signature.
-            JTx tx = env.jt(noop(alice), sig(alice));
+            JTx const tx = env.jt(noop(alice), sig(alice));
             STTx local = *(tx.stx);
             // Flip some bits in the signature.
             auto badSig = local.getFieldVL(sfTxnSignature);
@@ -1036,7 +1036,7 @@ public:
         }
         {
             // Single-sign, but invalidate the sequence number.
-            JTx tx = env.jt(noop(alice), sig(alice));
+            JTx const tx = env.jt(noop(alice), sig(alice));
             STTx local = *(tx.stx);
             // Flip some bits in the signature.
             auto seq = local.getFieldU32(sfSequence);
@@ -1049,7 +1049,7 @@ public:
         }
         {
             // Multisign, but leave a nonempty sfSigningPubKey.
-            JTx tx = env.jt(noop(alice), fee(2 * baseFee), msig(bogie));
+            JTx const tx = env.jt(noop(alice), fee(2 * baseFee), msig(bogie));
             STTx local = *(tx.stx);
             local[sfSigningPubKey] = alice.pk();  // Insert sfSigningPubKey
             auto const info = submitSTTx(local);
@@ -1059,7 +1059,7 @@ public:
         }
         {
             // Both multi- and single-sign with an empty SigningPubKey.
-            JTx tx = env.jt(noop(alice), fee(2 * baseFee), msig(bogie));
+            JTx const tx = env.jt(noop(alice), fee(2 * baseFee), msig(bogie));
             STTx local = *(tx.stx);
             local.sign(alice.pk(), alice.sk());
             local.setFieldVL(sfSigningPubKey, Blob());  // Empty SigningPubKey
@@ -1070,7 +1070,7 @@ public:
         }
         {
             // Multisign but invalidate one of the signatures.
-            JTx tx = env.jt(noop(alice), fee(2 * baseFee), msig(bogie));
+            JTx const tx = env.jt(noop(alice), fee(2 * baseFee), msig(bogie));
             STTx local = *(tx.stx);
             // Flip some bits in the signature.
             auto& signer = local.peekFieldArray(sfSigners).back();
@@ -1085,7 +1085,7 @@ public:
         }
         {
             // Multisign with an empty signers array should fail.
-            JTx tx = env.jt(noop(alice), fee(2 * baseFee), msig(bogie));
+            JTx const tx = env.jt(noop(alice), fee(2 * baseFee), msig(bogie));
             STTx local = *(tx.stx);
             local.peekFieldArray(sfSigners).clear();  // Empty Signers array.
             auto const info = submitSTTx(local);
@@ -1094,7 +1094,7 @@ public:
                 "fails local checks: Invalid Signers array size.");
         }
         {
-            JTx tx = env.jt(
+            JTx const tx = env.jt(
                 noop(alice),
                 fee(2 * baseFee),
 
@@ -1132,7 +1132,7 @@ public:
                     bogie,
                     bogie,
                     bogie));
-            STTx local = *(tx.stx);
+            STTx const local = *(tx.stx);
             auto const info = submitSTTx(local);
             BEAST_EXPECT(
                 info[jss::result][jss::error_exception] ==
@@ -1140,8 +1140,8 @@ public:
         }
         {
             // The account owner may not multisign for themselves.
-            JTx tx = env.jt(noop(alice), fee(2 * baseFee), msig(alice));
-            STTx local = *(tx.stx);
+            JTx const tx = env.jt(noop(alice), fee(2 * baseFee), msig(alice));
+            STTx const local = *(tx.stx);
             auto const info = submitSTTx(local);
             BEAST_EXPECT(
                 info[jss::result][jss::error_exception] ==
@@ -1149,8 +1149,8 @@ public:
         }
         {
             // No duplicate multisignatures allowed.
-            JTx tx = env.jt(noop(alice), fee(2 * baseFee), msig(bogie, bogie));
-            STTx local = *(tx.stx);
+            JTx const tx = env.jt(noop(alice), fee(2 * baseFee), msig(bogie, bogie));
+            STTx const local = *(tx.stx);
             auto const info = submitSTTx(local);
             BEAST_EXPECT(
                 info[jss::result][jss::error_exception] ==
@@ -1158,7 +1158,7 @@ public:
         }
         {
             // Multisignatures must be submitted in sorted order.
-            JTx tx = env.jt(noop(alice), fee(2 * baseFee), msig(bogie, demon));
+            JTx const tx = env.jt(noop(alice), fee(2 * baseFee), msig(bogie, demon));
             STTx local = *(tx.stx);
             // Unsort the Signers array.
             auto& signers = local.peekFieldArray(sfSigners);
diff --git a/src/test/app/NFTokenAuth_test.cpp b/src/test/app/NFTokenAuth_test.cpp
index 551882b51a..0e3fb24305 100644
--- a/src/test/app/NFTokenAuth_test.cpp
+++ b/src/test/app/NFTokenAuth_test.cpp
@@ -33,9 +33,9 @@ public:
         using namespace test::jtx;
 
         Env env(*this, features);
-        Account G1{"G1"};
-        Account A1{"A1"};
-        Account A2{"A2"};
+        Account const G1{"G1"};
+        Account const A1{"A1"};
+        Account const A2{"A2"};
         auto const USD{G1["USD"]};
 
         env.fund(XRP(10000), G1, A1, A2);
@@ -88,7 +88,7 @@ public:
         Env env(*this, features);
         Account G1{"G1"};
         Account A1{"A1"};
-        Account A2{"A2"};
+        Account const A2{"A2"};
         auto const USD{G1["USD"]};
 
         env.fund(XRP(10000), G1, A1, A2);
@@ -134,7 +134,7 @@ public:
         Env env(*this, features);
         Account G1{"G1"};
         Account A1{"A1"};
-        Account A2{"A2"};
+        Account const A2{"A2"};
         auto const USD{G1["USD"]};
 
         env.fund(XRP(10000), G1, A1, A2);
@@ -190,9 +190,9 @@ public:
         using namespace test::jtx;
 
         Env env(*this, features);
-        Account G1{"G1"};
-        Account A1{"A1"};
-        Account A2{"A2"};
+        Account const G1{"G1"};
+        Account const A1{"A1"};
+        Account const A2{"A2"};
         auto const USD{G1["USD"]};
 
         env.fund(XRP(10000), G1, A1, A2);
@@ -267,7 +267,7 @@ public:
         Env env(*this, features);
         Account G1{"G1"};
         Account A1{"A1"};
-        Account A2{"A2"};
+        Account const A2{"A2"};
         auto const USD{G1["USD"]};
 
         env.fund(XRP(10000), G1, A1, A2);
@@ -307,10 +307,10 @@ public:
         using namespace test::jtx;
 
         Env env(*this, features);
-        Account G1{"G1"};
-        Account A1{"A1"};
-        Account A2{"A2"};
-        Account broker{"broker"};
+        Account const G1{"G1"};
+        Account const A1{"A1"};
+        Account const A2{"A2"};
+        Account const broker{"broker"};
         auto const USD{G1["USD"]};
 
         env.fund(XRP(10000), G1, A1, A2, broker);
@@ -375,8 +375,8 @@ public:
         Env env(*this, features);
         Account G1{"G1"};
         Account A1{"A1"};
-        Account A2{"A2"};
-        Account broker{"broker"};
+        Account const A2{"A2"};
+        Account const broker{"broker"};
         auto const USD{G1["USD"]};
 
         env.fund(XRP(10000), G1, A1, A2, broker);
@@ -433,10 +433,10 @@ public:
         using namespace test::jtx;
 
         Env env(*this, features);
-        Account G1{"G1"};
-        Account A1{"A1"};
-        Account A2{"A2"};
-        Account broker{"broker"};
+        Account const G1{"G1"};
+        Account const A1{"A1"};
+        Account const A2{"A2"};
+        Account const broker{"broker"};
         auto const USD{G1["USD"]};
 
         env.fund(XRP(10000), G1, A1, A2, broker);
@@ -507,10 +507,10 @@ public:
         using namespace test::jtx;
 
         Env env(*this, features);
-        Account G1{"G1"};
-        Account minter{"minter"};
-        Account A1{"A1"};
-        Account A2{"A2"};
+        Account const G1{"G1"};
+        Account const minter{"minter"};
+        Account const A1{"A1"};
+        Account const A2{"A2"};
         auto const USD{G1["USD"]};
 
         env.fund(XRP(10000), G1, minter, A1, A2);
diff --git a/src/test/app/NFTokenBurn_test.cpp b/src/test/app/NFTokenBurn_test.cpp
index b91b245a7f..cd0df42c03 100644
--- a/src/test/app/NFTokenBurn_test.cpp
+++ b/src/test/app/NFTokenBurn_test.cpp
@@ -85,7 +85,7 @@ class NFTokenBurn_test : public beast::unit_test::suite
                 if (state[i].isMember(sfNFTokens.jsonName) &&
                     state[i][sfNFTokens.jsonName].isArray())
                 {
-                    std::uint32_t tokenCount = state[i][sfNFTokens.jsonName].size();
+                    std::uint32_t const tokenCount = state[i][sfNFTokens.jsonName].size();
                     std::cout << tokenCount << " NFtokens in page "
                               << state[i][jss::index].asString() << std::endl;
 
@@ -201,7 +201,7 @@ class NFTokenBurn_test : public beast::unit_test::suite
             {
                 // We do the same work on alice and minter, so make a lambda.
                 auto xferNFT = [&env, &becky](AcctStat& acct, auto& iter) {
-                    uint256 offerIndex = keylet::nftoffer(acct.acct, env.seq(acct.acct)).key;
+                    uint256 const offerIndex = keylet::nftoffer(acct.acct, env.seq(acct.acct)).key;
                     env(token::createOffer(acct, *iter, XRP(0)), txflags(tfSellNFToken));
                     env.close();
                     env(token::acceptSellOffer(becky, offerIndex));
@@ -225,7 +225,7 @@ class NFTokenBurn_test : public beast::unit_test::suite
         // Next we'll create offers for all of those NFTs.  This calls for
         // another lambda.
         auto addOffers = [&env](AcctStat& owner, AcctStat& other1, AcctStat& other2) {
-            for (uint256 nft : owner.nfts)
+            for (uint256 const nft : owner.nfts)
             {
                 // Create sell offers for owner.
                 env(token::createOffer(owner, nft, drops(1)),
@@ -277,7 +277,7 @@ class NFTokenBurn_test : public beast::unit_test::suite
             // Decide which of the accounts should burn the nft.  If the
             // owner is becky then any of the three accounts can burn.
             // Otherwise either alice or minter can burn.
-            AcctStat& burner = [&]() -> AcctStat& {
+            AcctStat const& burner = [&]() -> AcctStat& {
                 if (owner.acct == becky.acct)
                     return *(stats[acctDist(engine)]);
                 return mintDist(engine) ? alice : minter;
@@ -398,7 +398,7 @@ class NFTokenBurn_test : public beast::unit_test::suite
             // Generate three packed pages.  Then burn the tokens in order from
             // first to last.  This exercises specific cases where coalescing
             // pages is not possible.
-            std::vector<uint256> nfts = genPackedTokens();
+            std::vector<uint256> const nfts = genPackedTokens();
             BEAST_EXPECT(nftCount(env, alice) == 96);
             BEAST_EXPECT(ownerCount(env, alice) == 3);
 
@@ -736,9 +736,9 @@ class NFTokenBurn_test : public beast::unit_test::suite
                 // Create an ApplyContext we can use to run the invariant
                 // checks.  These variables must outlive the ApplyContext.
                 OpenView ov{*env.current()};
-                STTx tx{ttACCOUNT_SET, [](STObject&) {}};
+                STTx const tx{ttACCOUNT_SET, [](STObject&) {}};
                 test::StreamSink sink{beast::severities::kWarning};
-                beast::Journal jlog{sink};
+                beast::Journal const jlog{sink};
                 ApplyContext ac{
                     env.app(), ov, tx, tesSUCCESS, env.current()->fees().base, tapNONE, jlog};
 
@@ -769,9 +769,9 @@ class NFTokenBurn_test : public beast::unit_test::suite
                 // Create an ApplyContext we can use to run the invariant
                 // checks.  These variables must outlive the ApplyContext.
                 OpenView ov{*env.current()};
-                STTx tx{ttACCOUNT_SET, [](STObject&) {}};
+                STTx const tx{ttACCOUNT_SET, [](STObject&) {}};
                 test::StreamSink sink{beast::severities::kWarning};
-                beast::Journal jlog{sink};
+                beast::Journal const jlog{sink};
                 ApplyContext ac{
                     env.app(), ov, tx, tesSUCCESS, env.current()->fees().base, tapNONE, jlog};
 
@@ -1114,7 +1114,7 @@ class NFTokenBurn_test : public beast::unit_test::suite
         env.close();
 
         // minter sells the last 32 NFTs back to alice.
-        for (uint256 nftID : last32NFTs)
+        for (uint256 const nftID : last32NFTs)
         {
             // minter creates an offer for the NFToken.
             uint256 const minterOfferIndex = keylet::nftoffer(minter, env.seq(minter)).key;
diff --git a/src/test/app/NFTokenDir_test.cpp b/src/test/app/NFTokenDir_test.cpp
index 70514f497f..78765cb6c0 100644
--- a/src/test/app/NFTokenDir_test.cpp
+++ b/src/test/app/NFTokenDir_test.cpp
@@ -46,7 +46,7 @@ class NFTokenDir_test : public beast::unit_test::suite
                 if (state[i].isMember(sfNFTokens.jsonName) &&
                     state[i][sfNFTokens.jsonName].isArray())
                 {
-                    std::uint32_t tokenCount = state[i][sfNFTokens.jsonName].size();
+                    std::uint32_t const tokenCount = state[i][sfNFTokens.jsonName].size();
                     std::cout << tokenCount << " NFtokens in page "
                               << state[i][jss::index].asString() << std::endl;
 
@@ -104,7 +104,7 @@ class NFTokenDir_test : public beast::unit_test::suite
         nftIDs.reserve(nftCount);
         for (int i = 0; i < nftCount; ++i)
         {
-            std::uint32_t taxon = toUInt32(nft::cipheredTaxon(i, nft::toTaxon(0)));
+            std::uint32_t const taxon = toUInt32(nft::cipheredTaxon(i, nft::toTaxon(0)));
             nftIDs.emplace_back(token::getNextID(env, issuer, taxon, tfTransferable));
             env(token::mint(issuer, taxon), txflags(tfTransferable));
             env.close();
@@ -160,7 +160,7 @@ class NFTokenDir_test : public beast::unit_test::suite
             // Create accounts for all of the seeds and fund those accounts.
             std::vector<Account> accounts;
             accounts.reserve(seeds.size());
-            for (std::string_view seed : seeds)
+            for (std::string_view const seed : seeds)
             {
                 Account const& account =
                     accounts.emplace_back(Account::base58Seed, std::string(seed));
@@ -364,7 +364,7 @@ class NFTokenDir_test : public beast::unit_test::suite
             // Create accounts for all of the seeds and fund those accounts.
             std::vector<Account> accounts;
             accounts.reserve(seeds.size());
-            for (std::string_view seed : seeds)
+            for (std::string_view const seed : seeds)
             {
                 Account const& account =
                     accounts.emplace_back(Account::base58Seed, std::string(seed));
@@ -595,7 +595,7 @@ class NFTokenDir_test : public beast::unit_test::suite
         // Create accounts for all of the seeds and fund those accounts.
         std::vector<Account> accounts;
         accounts.reserve(seeds.size());
-        for (std::string_view seed : seeds)
+        for (std::string_view const seed : seeds)
         {
             Account const& account = accounts.emplace_back(Account::base58Seed, std::string(seed));
             env.fund(XRP(10000), account);
@@ -758,7 +758,7 @@ class NFTokenDir_test : public beast::unit_test::suite
         // Create accounts for all of the seeds and fund those accounts.
         std::vector<Account> accounts;
         accounts.reserve(seeds.size());
-        for (std::string_view seed : seeds)
+        for (std::string_view const seed : seeds)
         {
             Account const& account = accounts.emplace_back(Account::base58Seed, std::string(seed));
             env.fund(XRP(10000), account);
@@ -783,7 +783,7 @@ class NFTokenDir_test : public beast::unit_test::suite
             for (Account const& account : accounts)
             {
                 // Mint the NFT.  Tweak the taxon so zero is always stored.
-                std::uint32_t taxon = toUInt32(nft::cipheredTaxon(i, nft::toTaxon(0)));
+                std::uint32_t const taxon = toUInt32(nft::cipheredTaxon(i, nft::toTaxon(0)));
 
                 uint256 const& nftID = nftIDsByPage[i].emplace_back(
                     token::getNextID(env, account, taxon, tfTransferable));
@@ -831,7 +831,7 @@ class NFTokenDir_test : public beast::unit_test::suite
         // buyer accepts all of the offers that won't cause an overflow.
         // Fill the center and outsides first to exercise different boundary
         // cases.
-        for (int i : std::initializer_list<int>{3, 6, 0, 1, 2, 5, 4})
+        for (int const i : std::initializer_list<int>{3, 6, 0, 1, 2, 5, 4})
         {
             for (uint256 const& offer : offers[i])
             {
diff --git a/src/test/app/NFToken_test.cpp b/src/test/app/NFToken_test.cpp
index bd61c959fc..0d391147a8 100644
--- a/src/test/app/NFToken_test.cpp
+++ b/src/test/app/NFToken_test.cpp
@@ -580,7 +580,7 @@ class NFTokenBaseUtil_test : public beast::unit_test::suite
         env.close();
         BEAST_EXPECT(ownerCount(env, alice) == 1);
 
-        uint256 nftNoXferID = token::getNextID(env, alice, 0);
+        uint256 const nftNoXferID = token::getNextID(env, alice, 0);
         env(token::mint(alice, 0));
         env.close();
         BEAST_EXPECT(ownerCount(env, alice) == 1);
@@ -849,7 +849,7 @@ class NFTokenBaseUtil_test : public beast::unit_test::suite
 
         // List of tokens to delete is too long.
         {
-            std::vector<uint256> offers(maxTokenOfferCancelCount + 1, buyerOfferIndex);
+            std::vector<uint256> const offers(maxTokenOfferCancelCount + 1, buyerOfferIndex);
 
             env(token::cancelOffer(buyer, offers), ter(temMALFORMED));
             env.close();
@@ -936,7 +936,7 @@ class NFTokenBaseUtil_test : public beast::unit_test::suite
         env.close();
         BEAST_EXPECT(ownerCount(env, alice) == aliceCount);
 
-        uint256 nftNoXferID = token::getNextID(env, alice, 0);
+        uint256 const nftNoXferID = token::getNextID(env, alice, 0);
         env(token::mint(alice, 0));
         env.close();
         BEAST_EXPECT(ownerCount(env, alice) == aliceCount);
@@ -1515,7 +1515,7 @@ class NFTokenBaseUtil_test : public beast::unit_test::suite
 
             // An nft without flagCreateTrustLines but with a non-zero transfer
             // fee will not allow creating offers that use IOUs for payment.
-            for (std::uint32_t xferFee : {0, 1})
+            for (std::uint32_t const xferFee : {0, 1})
             {
                 uint256 const nftNoAutoTrustID{
                     token::getNextID(env, alice, 0u, tfTransferable, xferFee)};
@@ -1552,7 +1552,7 @@ class NFTokenBaseUtil_test : public beast::unit_test::suite
             // An nft with flagCreateTrustLines but with a non-zero transfer
             // fee allows transfers using IOUs for payment.
             {
-                std::uint16_t transferFee = 10000;  // 10%
+                std::uint16_t const transferFee = 10000;  // 10%
 
                 uint256 const nftAutoTrustID{
                     token::getNextID(env, alice, 0u, tfTransferable | tfTrustLine, transferFee)};
@@ -1606,7 +1606,7 @@ class NFTokenBaseUtil_test : public beast::unit_test::suite
             // Now that alice has trust lines preestablished, an nft without
             // flagCreateTrustLines will work for preestablished trust lines.
             {
-                std::uint16_t transferFee = 5000;  // 5%
+                std::uint16_t const transferFee = 5000;  // 5%
                 uint256 const nftNoAutoTrustID{
                     token::getNextID(env, alice, 0u, tfTransferable, transferFee)};
                 env(token::mint(alice, 0u), token::xferFee(transferFee), txflags(tfTransferable));
@@ -2261,7 +2261,7 @@ class NFTokenBaseUtil_test : public beast::unit_test::suite
             env.close();
 
             // Here is the smallest expressible gwXAU amount.
-            STAmount tinyXAU(gwXAU.issue(), STAmount::cMinValue, STAmount::cMinOffset);
+            STAmount const tinyXAU(gwXAU.issue(), STAmount::cMinValue, STAmount::cMinOffset);
 
             // minter buys the nft for tinyXAU.  Since the transfer involves
             // alice there should be no transfer fee.
@@ -3702,7 +3702,7 @@ class NFTokenBaseUtil_test : public beast::unit_test::suite
                     int line) {
                     for (Account const& acct : accounts)
                     {
-                        if (std::uint32_t ownerCount = test::jtx::ownerCount(env, acct);
+                        if (std::uint32_t const ownerCount = test::jtx::ownerCount(env, acct);
                             ownerCount != 1)
                         {
                             std::stringstream ss;
@@ -6596,7 +6596,7 @@ class NFTokenBaseUtil_test : public beast::unit_test::suite
             env.close();
 
             // issuer creates two NFTs: one with and one without AutoTrustLine.
-            std::uint16_t xferFee = 5000;  // 5%
+            std::uint16_t const xferFee = 5000;  // 5%
             uint256 const nftAutoTrustID{
                 token::getNextID(env, issuer, 0u, tfTransferable | tfTrustLine, xferFee)};
             env(token::mint(issuer, 0u),
@@ -6752,7 +6752,7 @@ class NFTokenBaseUtil_test : public beast::unit_test::suite
         env.close();
 
         // issuer creates two NFTs: one with and one without AutoTrustLine.
-        std::uint16_t xferFee = 5000;  // 5%
+        std::uint16_t const xferFee = 5000;  // 5%
         uint256 const nftAutoTrustID{
             token::getNextID(env, issuer, 0u, tfTransferable | tfTrustLine, xferFee)};
         env(token::mint(issuer, 0u),
diff --git a/src/test/app/Offer_test.cpp b/src/test/app/Offer_test.cpp
index 57f938e399..66e84360ef 100644
--- a/src/test/app/Offer_test.cpp
+++ b/src/test/app/Offer_test.cpp
@@ -93,7 +93,7 @@ public:
         // Offers for the good quality path
         env(offer(carol, BTC(1), USD(100)));
 
-        PathSet paths(Path(XRP, USD), Path(USD));
+        PathSet const paths(Path(XRP, USD), Path(USD));
 
         env(pay(alice, bob, USD(100)),
             json(paths.json()),
@@ -419,7 +419,7 @@ public:
         auto const EUR = gw["EUR"];
 
         auto tinyAmount = [&](IOU const& iou) -> PrettyAmount {
-            STAmount amt(
+            STAmount const amt(
                 iou.issue(),
                 /*mantissa*/ 1,
                 /*exponent*/ -81);
diff --git a/src/test/app/Oracle_test.cpp b/src/test/app/Oracle_test.cpp
index 9da0ee3a31..83b658ac41 100644
--- a/src/test/app/Oracle_test.cpp
+++ b/src/test/app/Oracle_test.cpp
@@ -23,7 +23,7 @@ private:
             Env env(*this);
             Account const bad("bad");
             env.memoize(bad);
-            Oracle oracle(
+            Oracle const oracle(
                 env,
                 {.owner = bad,
                  .seq = seq(1),
@@ -35,7 +35,7 @@ private:
         {
             Env env(*this);
             env.fund(env.current()->fees().accountReserve(0), owner);
-            Oracle oracle(
+            Oracle const oracle(
                 env,
                 {.owner = owner,
                  .fee = static_cast<int>(env.current()->fees().base.drops()),
@@ -302,7 +302,7 @@ private:
             Env env(*this);
             auto const baseFee = static_cast<int>(env.current()->fees().base.drops());
             env.fund(XRP(1'000), owner);
-            Oracle oracle(
+            Oracle const oracle(
                 env,
                 {.owner = owner,
                  .series = {{"USD", "USD", 740, 1}},
@@ -315,7 +315,7 @@ private:
             Env env(*this);
             auto const baseFee = static_cast<int>(env.current()->fees().base.drops());
             env.fund(XRP(1'000), owner);
-            Oracle oracle(
+            Oracle const oracle(
                 env,
                 {.owner = owner,
                  .series = {{"USD", "BTC", 740, maxPriceScale + 1}},
@@ -354,7 +354,7 @@ private:
             Env env(*this);
             env.fund(XRP(1'000), owner);
             Oracle oracle(env, {.owner = owner, .fee = -1, .err = ter(temBAD_FEE)});
-            Oracle oracle1(
+            Oracle const oracle1(
                 env, {.owner = owner, .fee = static_cast<int>(env.current()->fees().base.drops())});
             oracle.set(UpdateArg{.owner = owner, .fee = -1, .err = ter(temBAD_FEE)});
         }
@@ -371,7 +371,7 @@ private:
             auto const baseFee = static_cast<int>(env.current()->fees().base.drops());
             env.fund(XRP(1'000), owner);
             auto const count = ownerCount(env, owner);
-            Oracle oracle(env, {.owner = owner, .series = series, .fee = baseFee});
+            Oracle const oracle(env, {.owner = owner, .series = series, .fee = baseFee});
             BEAST_EXPECT(oracle.exists());
             BEAST_EXPECT(ownerCount(env, owner) == (count + adj));
             auto const entry = oracle.ledgerEntry();
@@ -506,9 +506,9 @@ private:
             auto const acctDelFee{drops(env.current()->fees().increment)};
             env.fund(XRP(1'000), owner);
             env.fund(XRP(1'000), alice);
-            Oracle oracle(
+            Oracle const oracle(
                 env, {.owner = owner, .series = {{"XRP", "USD", 740, 1}}, .fee = baseFee});
-            Oracle oracle1(
+            Oracle const oracle1(
                 env,
                 {.owner = owner,
                  .documentID = 2,
@@ -764,7 +764,7 @@ private:
 
         env.fund(XRP(1'000), owner);
         {
-            Oracle oracle(env, {.owner = owner, .fee = baseFee, .err = ter(temDISABLED)});
+            Oracle const oracle(env, {.owner = owner, .fee = baseFee, .err = ter(temDISABLED)});
         }
 
         {
diff --git a/src/test/app/Path_test.cpp b/src/test/app/Path_test.cpp
index 53da92ce1c..841847d183 100644
--- a/src/test/app/Path_test.cpp
+++ b/src/test/app/Path_test.cpp
@@ -100,7 +100,7 @@ public:
         void
         signal()
         {
-            std::lock_guard lk(mutex_);
+            std::lock_guard const lk(mutex_);
             signaled_ = true;
             cv_.notify_all();
         }
@@ -959,13 +959,13 @@ public:
             (domainEnabled ? " w/ " : " w/o ") + "domain");
         using namespace jtx;
         Env env = pathTestEnv();
-        Account A1{"A1"};
-        Account A2{"A2"};
-        Account A3{"A3"};
-        Account G1{"G1"};
-        Account G2{"G2"};
-        Account G3{"G3"};
-        Account M1{"M1"};
+        Account const A1{"A1"};
+        Account const A2{"A2"};
+        Account const A3{"A3"};
+        Account const G1{"G1"};
+        Account const G2{"G2"};
+        Account const G3{"G3"};
+        Account const M1{"M1"};
 
         env.fund(XRP(100000), A1);
         env.fund(XRP(10000), A2);
@@ -1060,10 +1060,10 @@ public:
             "domain");
         using namespace jtx;
         Env env = pathTestEnv();
-        Account A1{"A1"};
-        Account A2{"A2"};
-        Account G3{"G3"};
-        Account M1{"M1"};
+        Account const A1{"A1"};
+        Account const A2{"A2"};
+        Account const G3{"G3"};
+        Account const M1{"M1"};
 
         env.fund(XRP(1000), A1, A2, G3);
         env.fund(XRP(11000), M1);
@@ -1120,11 +1120,11 @@ public:
             (domainEnabled ? " w/ " : " w/o ") + "domain");
         using namespace jtx;
         Env env = pathTestEnv();
-        Account A1{"A1"};
-        Account A2{"A2"};
-        Account G1BS{"G1BS"};
-        Account G2SW{"G2SW"};
-        Account M1{"M1"};
+        Account const A1{"A1"};
+        Account const A2{"A2"};
+        Account const G1BS{"G1BS"};
+        Account const G2SW{"G2SW"};
+        Account const M1{"M1"};
 
         env.fund(XRP(1000), G1BS, G2SW, A1, A2);
         env.fund(XRP(11000), M1);
@@ -1206,16 +1206,16 @@ public:
             (domainEnabled ? " w/ " : " w/o ") + "domain");
         using namespace jtx;
         Env env = pathTestEnv();
-        Account A1{"A1"};
-        Account A2{"A2"};
-        Account A3{"A3"};
-        Account A4{"A4"};
-        Account G1{"G1"};
-        Account G2{"G2"};
-        Account G3{"G3"};
-        Account G4{"G4"};
-        Account M1{"M1"};
-        Account M2{"M2"};
+        Account const A1{"A1"};
+        Account const A2{"A2"};
+        Account const A3{"A3"};
+        Account const A4{"A4"};
+        Account const G1{"G1"};
+        Account const G2{"G2"};
+        Account const G3{"G3"};
+        Account const G4{"G4"};
+        Account const M1{"M1"};
+        Account const M2{"M2"};
 
         env.fund(XRP(1000), A1, A2, A3, G1, G2, G3, G4);
         env.fund(XRP(10000), A4);
@@ -1349,12 +1349,12 @@ public:
             (domainEnabled ? " w/ " : " w/o ") + "domain");
         using namespace jtx;
         Env env = pathTestEnv();
-        Account A1{"A1"};
-        Account A2{"A2"};
-        Account A3{"A3"};
-        Account G1{"G1"};
-        Account G2{"G2"};
-        Account M1{"M1"};
+        Account const A1{"A1"};
+        Account const A2{"A2"};
+        Account const A3{"A3"};
+        Account const G1{"G1"};
+        Account const G2{"G2"};
+        Account const M1{"M1"};
 
         env.fund(XRP(11000), M1);
         env.fund(XRP(1000), A1, A2, A3, G1, G2);
@@ -1539,16 +1539,16 @@ public:
         // lambda param that creates different types of offers
         auto testPathfind = [&](auto func, bool const domainEnabled = false) {
             Env env = pathTestEnv();
-            Account A1{"A1"};
-            Account A2{"A2"};
-            Account A3{"A3"};
-            Account A4{"A4"};
-            Account G1{"G1"};
-            Account G2{"G2"};
-            Account G3{"G3"};
-            Account G4{"G4"};
-            Account M1{"M1"};
-            Account M2{"M2"};
+            Account const A1{"A1"};
+            Account const A2{"A2"};
+            Account const A3{"A3"};
+            Account const A4{"A4"};
+            Account const G1{"G1"};
+            Account const G2{"G2"};
+            Account const G3{"G3"};
+            Account const G4{"G4"};
+            Account const M1{"M1"};
+            Account const M2{"M2"};
 
             env.fund(XRP(1000), A1, A2, A3, G1, G2, G3, G4);
             env.fund(XRP(10000), A4);
@@ -1815,9 +1815,9 @@ public:
         testcase("AMM not used in domain path");
         using namespace jtx;
         Env env = pathTestEnv();
-        PermissionedDEX permDex(env);
+        PermissionedDEX const permDex(env);
         auto const& [gw, domainOwner, alice, bob, carol, USD, domainID, credType] = permDex;
-        AMM amm(env, alice, XRP(10), USD(50));
+        AMM const amm(env, alice, XRP(10), USD(50));
 
         STPathSet st;
         STAmount sa, da;
diff --git a/src/test/app/PayChan_test.cpp b/src/test/app/PayChan_test.cpp
index 1150ae4d86..768031c3af 100644
--- a/src/test/app/PayChan_test.cpp
+++ b/src/test/app/PayChan_test.cpp
@@ -1504,7 +1504,7 @@ struct PayChan_test : public beast::unit_test::suite
         auto const settleDelay = 3600s;
         auto const channelFunds = XRP(1000);
 
-        std::optional<NetClock::time_point> cancelAfter;
+        std::optional<NetClock::time_point> const cancelAfter;
 
         {
             auto const chan = to_string(channel(alice, bob, env.seq(alice)));
diff --git a/src/test/app/PayStrand_test.cpp b/src/test/app/PayStrand_test.cpp
index 256c5ae716..222bc2ed07 100644
--- a/src/test/app/PayStrand_test.cpp
+++ b/src/test/app/PayStrand_test.cpp
@@ -559,7 +559,7 @@ struct ExistingElementPool
         result.reserve(resultSize);
         while (outer.next())
         {
-            StateGuard og{*this};
+            StateGuard const og{*this};
             outerResult = prefix;
             outer.emplace_into(
                 outerResult, accF, issF, currencyF, existingAcc, existingCur, existingIss);
@@ -567,7 +567,7 @@ struct ExistingElementPool
             ElementComboIter inner(prevInner);
             while (inner.next())
             {
-                StateGuard ig{*this};
+                StateGuard const ig{*this};
                 result = outerResult;
                 inner.emplace_into(
                     result, accF, issF, currencyF, existingAcc, existingCur, existingIss);
@@ -1006,7 +1006,7 @@ struct PayStrand_test : public beast::unit_test::suite
                 return result;
             }();
 
-            PathSet paths(p);
+            PathSet const paths(p);
 
             env(pay(alice, alice, EUR(1)),
                 json(paths.json()),
@@ -1125,12 +1125,12 @@ struct PayStrand_test : public beast::unit_test::suite
         Env env(*this, features);
         env.fund(XRP(10000), alice, bob, gw);
 
-        STAmount sendMax{USD.issue(), 100, 1};
-        STAmount noAccountAmount{Issue{USD.currency, noAccount()}, 100, 1};
-        STAmount deliver;
+        STAmount const sendMax{USD.issue(), 100, 1};
+        STAmount const noAccountAmount{Issue{USD.currency, noAccount()}, 100, 1};
+        STAmount const deliver;
         AccountID const srcAcc = alice.id();
-        AccountID dstAcc = bob.id();
-        STPathSet pathSet;
+        AccountID const dstAcc = bob.id();
+        STPathSet const pathSet;
         ::xrpl::path::RippleCalc::Input inputs;
         inputs.defaultPathsAllowed = true;
         try
diff --git a/src/test/app/PermissionedDEX_test.cpp b/src/test/app/PermissionedDEX_test.cpp
index 7b622a1256..58a041ff56 100644
--- a/src/test/app/PermissionedDEX_test.cpp
+++ b/src/test/app/PermissionedDEX_test.cpp
@@ -183,7 +183,7 @@ class PermissionedDEX_test : public beast::unit_test::suite
                 PermissionedDEX(env);
 
             // create devin account who is not part of the domain
-            Account devin("devin");
+            Account const devin("devin");
             env.fund(XRP(1000), devin);
             env.close();
             env.trust(USD(1000), devin);
@@ -216,7 +216,7 @@ class PermissionedDEX_test : public beast::unit_test::suite
                 PermissionedDEX(env);
 
             // create devin account who is not part of the domain
-            Account devin("devin");
+            Account const devin("devin");
             env.fund(XRP(1000), devin);
             env.close();
             env.trust(USD(1000), devin);
@@ -402,7 +402,7 @@ class PermissionedDEX_test : public beast::unit_test::suite
             env.close();
 
             // create devin account who is not part of the domain
-            Account devin("devin");
+            Account const devin("devin");
             env.fund(XRP(1000), devin);
             env.close();
             env.trust(USD(1000), devin);
@@ -448,7 +448,7 @@ class PermissionedDEX_test : public beast::unit_test::suite
             env.close();
 
             // create devin account who is not part of the domain
-            Account devin("devin");
+            Account const devin("devin");
             env.fund(XRP(1000), devin);
             env.close();
             env.trust(USD(1000), devin);
@@ -642,7 +642,7 @@ class PermissionedDEX_test : public beast::unit_test::suite
 
             // Fund devin and create USD trustline
             Account badDomainOwner("badDomainOwner");
-            Account devin("devin");
+            Account const devin("devin");
             env.fund(XRP(1000), badDomainOwner, devin);
             env.close();
             env.trust(USD(1000), devin);
@@ -651,7 +651,7 @@ class PermissionedDEX_test : public beast::unit_test::suite
             env.close();
 
             auto const badCredType = "badCred";
-            pdomain::Credentials credentials{{badDomainOwner, badCredType}};
+            pdomain::Credentials const credentials{{badDomainOwner, badCredType}};
             env(pdomain::setTx(badDomainOwner, credentials));
 
             auto objects = pdomain::getObjects(badDomainOwner, env);
@@ -698,7 +698,7 @@ class PermissionedDEX_test : public beast::unit_test::suite
             env.close();
 
             // fund devin but don't create a USD trustline with gateway
-            Account devin("devin");
+            Account const devin("devin");
             env.fund(XRP(1000), devin);
             env.close();
 
@@ -721,7 +721,7 @@ class PermissionedDEX_test : public beast::unit_test::suite
                 PermissionedDEX(env);
 
             // create devin account who is not part of the domain
-            Account devin("devin");
+            Account const devin("devin");
             env.fund(XRP(1000), devin);
             env.close();
             env.trust(USD(1000), devin);
@@ -920,7 +920,7 @@ class PermissionedDEX_test : public beast::unit_test::suite
         Env env(*this, features);
         auto const& [gw, domainOwner, alice, bob, carol, USD, domainID, credType] =
             PermissionedDEX(env);
-        AMM amm(env, alice, XRP(10), USD(50));
+        AMM const amm(env, alice, XRP(10), USD(50));
 
         // a domain payment isn't able to consume AMM
         env(pay(bob, carol, USD(5)),
@@ -1164,12 +1164,12 @@ class PermissionedDEX_test : public beast::unit_test::suite
 
             // Fund accounts
             Account badDomainOwner("badDomainOwner");
-            Account devin("devin");
+            Account const devin("devin");
             env.fund(XRP(1000), badDomainOwner, devin);
             env.close();
 
             auto const badCredType = "badCred";
-            pdomain::Credentials credentials{{badDomainOwner, badCredType}};
+            pdomain::Credentials const credentials{{badDomainOwner, badCredType}};
             env(pdomain::setTx(badDomainOwner, credentials));
 
             auto objects = pdomain::getObjects(badDomainOwner, env);
@@ -1297,8 +1297,8 @@ class PermissionedDEX_test : public beast::unit_test::suite
         std::vector<std::uint32_t> offerSeqs;
         offerSeqs.reserve(100);
 
-        Book domainBook{Issue(XRP), Issue(USD), domainID};
-        Book openBook{Issue(XRP), Issue(USD), std::nullopt};
+        Book const domainBook{Issue(XRP), Issue(USD), domainID};
+        Book const openBook{Issue(XRP), Issue(USD), std::nullopt};
 
         auto const domainDir = getBookDirKey(domainBook, XRP(10), USD(10));
         auto const openDir = getBookDirKey(openBook, XRP(10), USD(10));
diff --git a/src/test/app/PermissionedDomains_test.cpp b/src/test/app/PermissionedDomains_test.cpp
index c4bbd80e74..c4bde9831a 100644
--- a/src/test/app/PermissionedDomains_test.cpp
+++ b/src/test/app/PermissionedDomains_test.cpp
@@ -49,7 +49,7 @@ class PermissionedDomains_test : public beast::unit_test::suite
         Account const alice("alice");
         Env env(*this, features);
         env.fund(XRP(1000), alice);
-        pdomain::Credentials credentials{{alice, "first credential"}};
+        pdomain::Credentials const credentials{{alice, "first credential"}};
         env(pdomain::setTx(alice, credentials));
         BEAST_EXPECT(env.ownerCount(alice) == 1);
         auto objects = pdomain::getObjects(alice, env);
@@ -71,7 +71,7 @@ class PermissionedDomains_test : public beast::unit_test::suite
         Account const alice("alice");
         Env env(*this, amendments);
         env.fund(XRP(1000), alice);
-        pdomain::Credentials credentials{{alice, "first credential"}};
+        pdomain::Credentials const credentials{{alice, "first credential"}};
         env(pdomain::setTx(alice, credentials), ter(temDISABLED));
     }
 
@@ -83,7 +83,7 @@ class PermissionedDomains_test : public beast::unit_test::suite
         Account const alice("alice");
         Env env(*this, withoutFeature_);
         env.fund(XRP(1000), alice);
-        pdomain::Credentials credentials{{alice, "first credential"}};
+        pdomain::Credentials const credentials{{alice, "first credential"}};
         env(pdomain::setTx(alice, credentials), ter(temDISABLED));
         env(pdomain::deleteTx(alice, uint256(75)), ter(temDISABLED));
     }
@@ -391,7 +391,7 @@ class PermissionedDomains_test : public beast::unit_test::suite
         constexpr std::size_t deleteDelta = 255;
         {
             // Close enough ledgers to make it potentially deletable if empty.
-            std::size_t ownerSeq = env.seq(alice[0]);
+            std::size_t const ownerSeq = env.seq(alice[0]);
             while (deleteDelta + ownerSeq > env.current()->seq())
                 env.close();
             env(acctdelete(alice[0], alice[2]), fee(acctDelFee), ter(tecHAS_OBLIGATIONS));
@@ -402,7 +402,7 @@ class PermissionedDomains_test : public beast::unit_test::suite
             for (auto const& objs : pdomain::getObjects(alice[0], env))
                 env(pdomain::deleteTx(alice[0], objs.first));
             env.close();
-            std::size_t ownerSeq = env.seq(alice[0]);
+            std::size_t const ownerSeq = env.seq(alice[0]);
             while (deleteDelta + ownerSeq > env.current()->seq())
                 env.close();
             env(acctdelete(alice[0], alice[2]), fee(acctDelFee));
@@ -420,7 +420,7 @@ class PermissionedDomains_test : public beast::unit_test::suite
         env.fund(XRP(1000), alice);
         auto const setFee(drops(env.current()->fees().increment));
 
-        pdomain::Credentials credentials{{alice, "first credential"}};
+        pdomain::Credentials const credentials{{alice, "first credential"}};
         env(pdomain::setTx(alice, credentials));
         env.close();
 
@@ -484,7 +484,7 @@ class PermissionedDomains_test : public beast::unit_test::suite
         BEAST_EXPECT(env.ownerCount(alice) == 0);
 
         // alice does not have enough XRP to cover the reserve.
-        pdomain::Credentials credentials{{alice, "first credential"}};
+        pdomain::Credentials const credentials{{alice, "first credential"}};
         env(pdomain::setTx(alice, credentials), ter(tecINSUFFICIENT_RESERVE));
         BEAST_EXPECT(env.ownerCount(alice) == 0);
         BEAST_EXPECT(pdomain::getObjects(alice, env).empty());
diff --git a/src/test/app/RCLValidations_test.cpp b/src/test/app/RCLValidations_test.cpp
index 537563ecc4..32267cbf45 100644
--- a/src/test/app/RCLValidations_test.cpp
+++ b/src/test/app/RCLValidations_test.cpp
@@ -55,7 +55,7 @@ class RCLValidations_test : public beast::unit_test::suite
         std::vector<std::shared_ptr<Ledger const>> history;
 
         jtx::Env env(*this);
-        Config config;
+        Config const config;
         auto prev = std::make_shared<Ledger const>(
             create_genesis,
             Rules{config.features},
@@ -100,7 +100,7 @@ class RCLValidations_test : public beast::unit_test::suite
 
         // Empty ledger
         {
-            RCLValidatedLedger a{RCLValidatedLedger::MakeGenesis{}};
+            RCLValidatedLedger const a{RCLValidatedLedger::MakeGenesis{}};
             BEAST_EXPECT(a.seq() == Seq{0});
             BEAST_EXPECT(a[Seq{0}] == ID{0});
             BEAST_EXPECT(a.minSeq() == Seq{0});
@@ -108,8 +108,8 @@ class RCLValidations_test : public beast::unit_test::suite
 
         // Full history ledgers
         {
-            std::shared_ptr<Ledger const> ledger = history.back();
-            RCLValidatedLedger a{ledger, env.journal};
+            std::shared_ptr<Ledger const> const ledger = history.back();
+            RCLValidatedLedger const a{ledger, env.journal};
             BEAST_EXPECT(a.seq() == ledger->header().seq);
             BEAST_EXPECT(a.minSeq() == a.seq() - maxAncestors);
             // Ensure the ancestral 256 ledgers have proper ID
@@ -130,21 +130,21 @@ class RCLValidations_test : public beast::unit_test::suite
 
         // Empty with non-empty
         {
-            RCLValidatedLedger a{RCLValidatedLedger::MakeGenesis{}};
+            RCLValidatedLedger const a{RCLValidatedLedger::MakeGenesis{}};
 
             for (auto const& ledger : {history.back(), history[maxAncestors - 1]})
             {
-                RCLValidatedLedger b{ledger, env.journal};
+                RCLValidatedLedger const b{ledger, env.journal};
                 BEAST_EXPECT(mismatch(a, b) == 1);
                 BEAST_EXPECT(mismatch(b, a) == 1);
             }
         }
         // Same chains, different seqs
         {
-            RCLValidatedLedger a{history.back(), env.journal};
+            RCLValidatedLedger const a{history.back(), env.journal};
             for (Seq s = a.seq(); s > 0; s--)
             {
-                RCLValidatedLedger b{history[s - 1], env.journal};
+                RCLValidatedLedger const b{history[s - 1], env.journal};
                 if (s >= a.minSeq())
                 {
                     BEAST_EXPECT(mismatch(a, b) == b.seq() + 1);
@@ -162,8 +162,8 @@ class RCLValidations_test : public beast::unit_test::suite
             // Alt history diverged at history.size()/2
             for (Seq s = 1; s < history.size(); ++s)
             {
-                RCLValidatedLedger a{history[s - 1], env.journal};
-                RCLValidatedLedger b{altHistory[s - 1], env.journal};
+                RCLValidatedLedger const a{history[s - 1], env.journal};
+                RCLValidatedLedger const b{altHistory[s - 1], env.journal};
 
                 BEAST_EXPECT(a.seq() == b.seq());
                 if (s <= diverge)
@@ -183,10 +183,10 @@ class RCLValidations_test : public beast::unit_test::suite
         // Different chains, different seqs
         {
             // Compare around the divergence point
-            RCLValidatedLedger a{history[diverge], env.journal};
+            RCLValidatedLedger const a{history[diverge], env.journal};
             for (Seq offset = diverge / 2; offset < 3 * diverge / 2; ++offset)
             {
-                RCLValidatedLedger b{altHistory[offset - 1], env.journal};
+                RCLValidatedLedger const b{altHistory[offset - 1], env.journal};
                 if (offset <= diverge)
                 {
                     BEAST_EXPECT(mismatch(a, b) == b.seq() + 1);
@@ -221,7 +221,7 @@ class RCLValidations_test : public beast::unit_test::suite
         // Generate a chain of 256 + 10 ledgers
         jtx::Env env(*this);
         auto& j = env.journal;
-        Config config;
+        Config const config;
         auto prev = std::make_shared<Ledger const>(
             create_genesis,
             Rules{config.features},
diff --git a/src/test/app/ReducedOffer_test.cpp b/src/test/app/ReducedOffer_test.cpp
index 46193a1544..b19999fecd 100644
--- a/src/test/app/ReducedOffer_test.cpp
+++ b/src/test/app/ReducedOffer_test.cpp
@@ -160,12 +160,12 @@ public:
                  mantissaReduce <= 5'000'000'000ull;
                  mantissaReduce += 20'000'000ull)
             {
-                STAmount aliceUSD{
+                STAmount const aliceUSD{
                     bobOffer.out.issue(),
                     bobOffer.out.mantissa() - mantissaReduce,
                     bobOffer.out.exponent()};
-                STAmount aliceXRP{bobOffer.in.issue(), bobOffer.in.mantissa() - 1};
-                Amounts aliceOffer{aliceUSD, aliceXRP};
+                STAmount const aliceXRP{bobOffer.in.issue(), bobOffer.in.mantissa() - 1};
+                Amounts const aliceOffer{aliceUSD, aliceXRP};
                 blockedCount += exerciseOfferPair(aliceOffer, bobOffer);
             }
 
@@ -292,12 +292,12 @@ public:
                  mantissaReduce <= 4'000'000'000ull;
                  mantissaReduce += 20'000'000ull)
             {
-                STAmount bobUSD{
+                STAmount const bobUSD{
                     aliceOffer.out.issue(),
                     aliceOffer.out.mantissa() - mantissaReduce,
                     aliceOffer.out.exponent()};
-                STAmount bobXRP{aliceOffer.in.issue(), aliceOffer.in.mantissa() - 1};
-                Amounts bobOffer{bobUSD, bobXRP};
+                STAmount const bobXRP{aliceOffer.in.issue(), aliceOffer.in.mantissa() - 1};
+                Amounts const bobOffer{bobUSD, bobXRP};
 
                 blockedCount += exerciseOfferPair(aliceOffer, bobOffer);
             }
@@ -445,7 +445,7 @@ public:
                 // Examine the aftermath of alice's offer.
                 {
                     bool const bobOfferGone = !offerInLedger(env, bob, bobOfferSeq);
-                    STAmount aliceBalanceUSD = env.balance(alice, USD);
+                    STAmount const aliceBalanceUSD = env.balance(alice, USD);
 #if 0
                     std::cout
                         << "bob initial: " << initialBobUSD
@@ -580,7 +580,7 @@ public:
                 {
                     Json::Value aliceOffer = ledgerEntryOffer(env, alice, aliceOfferSeq);
 
-                    Amounts aliceReducedOffer = jsonOfferToAmounts(aliceOffer[jss::node]);
+                    Amounts const aliceReducedOffer = jsonOfferToAmounts(aliceOffer[jss::node]);
 
                     BEAST_EXPECT(aliceReducedOffer.in < aliceInitialOffer.in);
                     BEAST_EXPECT(aliceReducedOffer.out < aliceInitialOffer.out);
diff --git a/src/test/app/Regression_test.cpp b/src/test/app/Regression_test.cpp
index 55b4b9a87c..59ab0e427d 100644
--- a/src/test/app/Regression_test.cpp
+++ b/src/test/app/Regression_test.cpp
@@ -113,7 +113,8 @@ struct Regression_test : public beast::unit_test::suite
         auto test256r1key = [&env](Account const& acct) {
             auto const baseFee = env.current()->fees().base;
             std::uint32_t const acctSeq = env.seq(acct);
-            Json::Value jsonNoop = env.json(noop(acct), fee(baseFee), seq(acctSeq), sig(acct));
+            Json::Value const jsonNoop =
+                env.json(noop(acct), fee(baseFee), seq(acctSeq), sig(acct));
             JTx jt = env.jt(jsonNoop);
             jt.fill_sig = false;
 
@@ -237,8 +238,8 @@ struct Regression_test : public beast::unit_test::suite
         using namespace jtx;
         Env env(*this);
 
-        Account alice("alice");
-        Account bob("bob");
+        Account const alice("alice");
+        Account const bob("bob");
         env.fund(XRP(10'000), alice, bob);
         env.close();
 
diff --git a/src/test/app/TheoreticalQuality_test.cpp b/src/test/app/TheoreticalQuality_test.cpp
index 1a701b8954..d7e0882c3b 100644
--- a/src/test/app/TheoreticalQuality_test.cpp
+++ b/src/test/app/TheoreticalQuality_test.cpp
@@ -199,7 +199,7 @@ class TheoreticalQuality_test : public beast::unit_test::suite
     prettyQuality(Quality const& q)
     {
         std::stringstream sstr;
-        STAmount rate = q.rate();
+        STAmount const rate = q.rate();
         sstr << rate << " (" << q << ")";
         return sstr.str();
     };
@@ -220,7 +220,7 @@ class TheoreticalQuality_test : public beast::unit_test::suite
         std::shared_ptr<ReadView const> closed,
         std::optional<Quality> const& expectedQ = {})
     {
-        PaymentSandbox sb(closed.get(), tapNONE);
+        PaymentSandbox const sb(closed.get(), tapNONE);
         AMMContext ammContext(rcp.srcAccount, false);
 
         auto const sendMaxIssue = [&rcp]() -> std::optional<Issue> {
@@ -229,7 +229,7 @@ class TheoreticalQuality_test : public beast::unit_test::suite
             return std::nullopt;
         }();
 
-        beast::Journal dummyJ{beast::Journal::getNullSink()};
+        beast::Journal const dummyJ{beast::Journal::getNullSink()};
 
         auto sr = toStrands(
             sb,
@@ -366,7 +366,7 @@ public:
 
             // Accounts are set up, make the payment
             IOU const iou{accounts.back(), currency};
-            RippleCalcTestParams rcp{env.json(
+            RippleCalcTestParams const rcp{env.json(
                 pay(accounts.front(), accounts.back(), iou(paymentAmount)),
                 accountsPath,
                 txflags(tfNoRippleDirect))};
@@ -413,7 +413,7 @@ public:
             auto const USDB = bob["USD"];
             auto const EURC = carol["EUR"];
             constexpr std::size_t const numAccounts = 5;
-            std::array<Account, numAccounts> accounts{{alice, bob, carol, dan, oscar}};
+            std::array<Account, numAccounts> const accounts{{alice, bob, carol, dan, oscar}};
 
             // sendmax should be in USDB and delivered amount should be in EURC
             // normalized path should be:
@@ -445,7 +445,7 @@ public:
             // Accounts are set up, make the payment
             IOU const srcIOU{bob, usdCurrency};
             IOU const dstIOU{carol, eurCurrency};
-            RippleCalcTestParams rcp{env.json(
+            RippleCalcTestParams const rcp{env.json(
                 pay(alice, dan, dstIOU(paymentAmount)),
                 sendmax(srcIOU(100 * paymentAmount)),
                 bookPath,
diff --git a/src/test/app/Ticket_test.cpp b/src/test/app/Ticket_test.cpp
index 7d300f61ca..7f96caa05f 100644
--- a/src/test/app/Ticket_test.cpp
+++ b/src/test/app/Ticket_test.cpp
@@ -378,7 +378,7 @@ class Ticket_test : public beast::unit_test::suite
         {
             // Create tickets on a non-existent account.
             Env env{*this};
-            Account alice{"alice"};
+            Account const alice{"alice"};
             env.memoize(alice);
 
             env(ticket::create(alice, 1), json(jss::Sequence, 1), ter(terNO_ACCOUNT));
@@ -387,11 +387,11 @@ class Ticket_test : public beast::unit_test::suite
             // Exceed the threshold where tickets can no longer be
             // added to an account.
             Env env{*this};
-            Account alice{"alice"};
+            Account const alice{"alice"};
 
             env.fund(XRP(100000), alice);
 
-            std::uint32_t ticketSeq{env.seq(alice) + 1};
+            std::uint32_t const ticketSeq{env.seq(alice) + 1};
             env(ticket::create(alice, 250));
             checkTicketCreateMeta(env);
             env.close();
@@ -424,12 +424,12 @@ class Ticket_test : public beast::unit_test::suite
         {
             // Explore exceeding the ticket threshold from another angle.
             Env env{*this};
-            Account alice{"alice"};
+            Account const alice{"alice"};
 
             env.fund(XRP(100000), alice);
             env.close();
 
-            std::uint32_t ticketSeq_AB{env.seq(alice) + 1};
+            std::uint32_t const ticketSeq_AB{env.seq(alice) + 1};
             env(ticket::create(alice, 2));
             checkTicketCreateMeta(env);
             env.close();
@@ -462,7 +462,7 @@ class Ticket_test : public beast::unit_test::suite
 
         using namespace test::jtx;
         Env env{*this};
-        Account alice{"alice"};
+        Account const alice{"alice"};
 
         // Fund alice not quite enough to make the reserve for a Ticket.
         env.fund(env.current()->fees().accountReserve(1) - drops(1), alice);
@@ -515,7 +515,7 @@ class Ticket_test : public beast::unit_test::suite
 
         using namespace test::jtx;
         Env env{*this};
-        Account alice{"alice"};
+        Account const alice{"alice"};
 
         env.fund(XRP(10000), alice);
         env.close();
@@ -611,14 +611,14 @@ class Ticket_test : public beast::unit_test::suite
 
         using namespace test::jtx;
         Env env{*this};
-        Account alice{"alice"};
+        Account const alice{"alice"};
 
         env.fund(XRP(10000), alice);
         env.close();
 
         // Lambda that returns the hash of the most recent transaction.
         auto getTxID = [&env, this]() -> uint256 {
-            std::shared_ptr<STTx const> tx{env.tx()};
+            std::shared_ptr<STTx const> const tx{env.tx()};
             if (!BEAST_EXPECTS(tx, "Transaction not found"))
                 Throw<std::invalid_argument>("Invalid transaction ID");
 
@@ -689,7 +689,7 @@ class Ticket_test : public beast::unit_test::suite
             BEAST_EXPECT(txErrCode == rpcSUCCESS);
             if (auto txPtr = std::get_if<TxPair>(&maybeTx))
             {
-                std::shared_ptr<Transaction>& tx = txPtr->first;
+                std::shared_ptr<Transaction> const& tx = txPtr->first;
                 BEAST_EXPECT(tx->getLedger() == ledgerSeq);
                 std::shared_ptr<STTx const> const& sttx = tx->getSTransaction();
                 BEAST_EXPECT((*sttx)[sfSequence] == txSeq);
@@ -726,7 +726,7 @@ class Ticket_test : public beast::unit_test::suite
 
         using namespace test::jtx;
         Env env{*this};
-        Account alice{"alice"};
+        Account const alice{"alice"};
 
         env.fund(XRP(10000), alice);
         env.close();
@@ -812,7 +812,7 @@ class Ticket_test : public beast::unit_test::suite
         testcase("Fix both Seq and Ticket");
 
         Env env{*this, testable_amendments()};
-        Account alice{"alice"};
+        Account const alice{"alice"};
 
         env.fund(XRP(10000), alice);
         env.close();
diff --git a/src/test/app/TrustAndBalance_test.cpp b/src/test/app/TrustAndBalance_test.cpp
index 3a2aa8e7c9..a71ddb140e 100644
--- a/src/test/app/TrustAndBalance_test.cpp
+++ b/src/test/app/TrustAndBalance_test.cpp
@@ -28,7 +28,7 @@ class TrustAndBalance_test : public beast::unit_test::suite
         using namespace test::jtx;
 
         Env env{*this};
-        Account alice{"alice"};
+        Account const alice{"alice"};
 
         env(trust(env.master, alice["USD"](100)), ter(tecNO_DST));
     }
@@ -40,9 +40,9 @@ class TrustAndBalance_test : public beast::unit_test::suite
         using namespace test::jtx;
 
         Env env{*this};
-        Account gw{"gateway"};
-        Account alice{"alice"};
-        Account bob{"bob"};
+        Account const gw{"gateway"};
+        Account const alice{"alice"};
+        Account const bob{"bob"};
 
         env.fund(XRP(10000), gw, alice, bob);
         env.close();
@@ -112,8 +112,8 @@ class TrustAndBalance_test : public beast::unit_test::suite
         using namespace test::jtx;
 
         Env env{*this, features};
-        Account alice{"alice"};
-        Account bob{"bob"};
+        Account const alice{"alice"};
+        Account const bob{"bob"};
 
         env.fund(XRP(10000), alice, bob);
         env.close();
@@ -156,9 +156,9 @@ class TrustAndBalance_test : public beast::unit_test::suite
 
         Env env{*this, features};
         auto wsc = test::makeWSClient(env.app().config());
-        Account gw{"gateway"};
-        Account alice{"alice"};
-        Account bob{"bob"};
+        Account const gw{"gateway"};
+        Account const alice{"alice"};
+        Account const bob{"bob"};
 
         env.fund(XRP(10000), gw, alice, bob);
         env.close();
@@ -229,9 +229,9 @@ class TrustAndBalance_test : public beast::unit_test::suite
         using namespace test::jtx;
 
         Env env{*this, features};
-        Account gw{"gateway"};
-        Account alice{"alice"};
-        Account bob{"bob"};
+        Account const gw{"gateway"};
+        Account const alice{"alice"};
+        Account const bob{"bob"};
 
         env.fund(XRP(10000), gw, alice, bob);
         env.close();
@@ -276,9 +276,9 @@ class TrustAndBalance_test : public beast::unit_test::suite
         using namespace test::jtx;
 
         Env env{*this, features};
-        Account gw{"gateway"};
-        Account alice{"alice"};
-        Account bob{"bob"};
+        Account const gw{"gateway"};
+        Account const alice{"alice"};
+        Account const bob{"bob"};
 
         env.fund(XRP(10000), gw, alice, bob);
         env.close();
@@ -319,11 +319,11 @@ class TrustAndBalance_test : public beast::unit_test::suite
         using namespace test::jtx;
 
         Env env{*this, features};
-        Account gw{"gateway"};
-        Account amazon{"amazon"};
-        Account alice{"alice"};
-        Account bob{"bob"};
-        Account carol{"carol"};
+        Account const gw{"gateway"};
+        Account const amazon{"amazon"};
+        Account const alice{"alice"};
+        Account const bob{"bob"};
+        Account const carol{"carol"};
 
         env.fund(XRP(10000), gw, amazon, alice, bob, carol);
         env.close();
@@ -379,7 +379,7 @@ class TrustAndBalance_test : public beast::unit_test::suite
         using namespace test::jtx;
 
         Env env{*this, features};
-        Account alice{"alice"};
+        Account const alice{"alice"};
         auto wsc = test::makeWSClient(env.app().config());
 
         env.fund(XRP(10000), alice);
diff --git a/src/test/app/TxQ_test.cpp b/src/test/app/TxQ_test.cpp
index 11bbd62bd5..6f13f9d419 100644
--- a/src/test/app/TxQ_test.cpp
+++ b/src/test/app/TxQ_test.cpp
@@ -500,7 +500,7 @@ public:
 
         // We haven't yet shown that ticket-based transactions can be added
         // to the queue in any order.  We should do that...
-        std::uint32_t tkt250 = tkt1 + 249;
+        std::uint32_t const tkt250 = tkt1 + 249;
         env(noop(alice), ticket::use(tkt250 - 0), fee(baseFee * 3.0), queued);
         env(noop(alice), ticket::use(tkt1 + 14), fee(baseFee * 2.9), queued);
         env(noop(alice), ticket::use(tkt250 - 1), fee(baseFee * 2.8), queued);
@@ -1520,7 +1520,7 @@ public:
 
         try
         {
-            Env env(
+            Env const env(
                 *this,
                 makeConfig(
                     {{"minimum_txn_in_ledger", "200"},
@@ -1541,7 +1541,7 @@ public:
         }
         try
         {
-            Env env(
+            Env const env(
                 *this,
                 makeConfig(
                     {{"minimum_txn_in_ledger", "200"},
@@ -1562,7 +1562,7 @@ public:
         }
         try
         {
-            Env env(
+            Env const env(
                 *this,
                 makeConfig(
                     {{"minimum_txn_in_ledger", "2"},
@@ -3387,6 +3387,7 @@ public:
             BEAST_EXPECT(jv[jss::status] == "success");
         }
 
+        // NOLINTNEXTLINE(misc-const-correctness)
         Account a{"a"}, b{"b"}, c{"c"}, d{"d"}, e{"e"}, f{"f"}, g{"g"}, h{"h"}, i{"i"};
 
         // Fund the first few accounts at non escalated fee
@@ -3528,7 +3529,8 @@ public:
             }
 
             auto const den = (metrics.txPerLedger * metrics.txPerLedger);
-            FeeLevel64 feeLevel = (metrics.medFeeLevel * totalFactor + FeeLevel64{den - 1}) / den;
+            FeeLevel64 const feeLevel =
+                (metrics.medFeeLevel * totalFactor + FeeLevel64{den - 1}) / den;
 
             auto result = toDrops(feeLevel, env.current()->fees().base).drops();
 
diff --git a/src/test/app/ValidatorKeys_test.cpp b/src/test/app/ValidatorKeys_test.cpp
index 29876dea7c..3be6fcd028 100644
--- a/src/test/app/ValidatorKeys_test.cpp
+++ b/src/test/app/ValidatorKeys_test.cpp
@@ -59,7 +59,7 @@ public:
         // We're only using Env for its Journal.  That Journal gives better
         // coverage in unit tests.
         test::jtx::Env env{*this, test::jtx::envconfig(), nullptr, beast::severities::kDisabled};
-        beast::Journal journal{env.app().getJournal("ValidatorKeys_test")};
+        beast::Journal const journal{env.app().getJournal("ValidatorKeys_test")};
 
         // Keys/ID when using [validation_seed]
         SecretKey const seedSecretKey =
@@ -82,8 +82,8 @@ public:
 
         {
             // No config -> no key but valid
-            Config c;
-            ValidatorKeys k{c, journal};
+            Config const c;
+            ValidatorKeys const k{c, journal};
             BEAST_EXPECT(!k.keys);
             BEAST_EXPECT(k.manifest.empty());
             BEAST_EXPECT(!k.configInvalid());
@@ -109,7 +109,7 @@ public:
             Config c;
             c.section(SECTION_VALIDATION_SEED).append("badseed");
 
-            ValidatorKeys k{c, journal};
+            ValidatorKeys const k{c, journal};
             BEAST_EXPECT(k.configInvalid());
             BEAST_EXPECT(!k.keys);
             BEAST_EXPECT(k.manifest.empty());
@@ -134,7 +134,7 @@ public:
             // invalid validator token
             Config c;
             c.section(SECTION_VALIDATOR_TOKEN).append("badtoken");
-            ValidatorKeys k{c, journal};
+            ValidatorKeys const k{c, journal};
             BEAST_EXPECT(k.configInvalid());
             BEAST_EXPECT(!k.keys);
             BEAST_EXPECT(k.manifest.empty());
@@ -145,7 +145,7 @@ public:
             Config c;
             c.section(SECTION_VALIDATION_SEED).append(seed);
             c.section(SECTION_VALIDATOR_TOKEN).append(tokenBlob);
-            ValidatorKeys k{c, journal};
+            ValidatorKeys const k{c, journal};
 
             BEAST_EXPECT(k.configInvalid());
             BEAST_EXPECT(!k.keys);
@@ -156,7 +156,7 @@ public:
             // Token manifest and private key must match
             Config c;
             c.section(SECTION_VALIDATOR_TOKEN).append(invalidTokenBlob);
-            ValidatorKeys k{c, journal};
+            ValidatorKeys const k{c, journal};
 
             BEAST_EXPECT(k.configInvalid());
             BEAST_EXPECT(!k.keys);
diff --git a/src/test/app/ValidatorList_test.cpp b/src/test/app/ValidatorList_test.cpp
index 3f1c20ee25..74b208e5e2 100644
--- a/src/test/app/ValidatorList_test.cpp
+++ b/src/test/app/ValidatorList_test.cpp
@@ -272,7 +272,7 @@ private:
             auto const masterNode1 = randomMasterKey();
             auto const masterNode2 = randomMasterKey();
 
-            std::vector<std::string> cfgMasterKeys(
+            std::vector<std::string> const cfgMasterKeys(
                 {format(masterNode1), format(masterNode2, " Comment")});
             BEAST_EXPECT(trustedKeys->load({}, cfgMasterKeys, emptyCfgPublishers));
             BEAST_EXPECT(trustedKeys->listed(masterNode1));
@@ -362,7 +362,8 @@ private:
 
             // load should reject validator list signing keys with invalid
             // encoding
-            std::vector<PublicKey> keys({randomMasterKey(), randomMasterKey(), randomMasterKey()});
+            std::vector<PublicKey> const keys(
+                {randomMasterKey(), randomMasterKey(), randomMasterKey()});
             badPublishers.clear();
             for (auto const& key : keys)
                 badPublishers.push_back(toBase58(TokenType::NodePublic, key));
@@ -391,7 +392,7 @@ private:
                 app.config().legacy("database_path"),
                 env.journal);
 
-            std::vector<PublicKey> keys(
+            std::vector<PublicKey> const keys(
                 {randomMasterKey(), randomMasterKey(), randomMasterKey(), randomMasterKey()});
             std::vector<std::string> cfgPublishers;
             cfgPublishers.reserve(keys.size());
@@ -433,7 +434,7 @@ private:
             auto legitKey1 = randomMasterKey();
             auto legitKey2 = randomMasterKey();
 
-            std::vector<std::string> cfgPublishers = {
+            std::vector<std::string> const cfgPublishers = {
                 strHex(pubRevokedPublic), strHex(legitKey1), strHex(legitKey2)};
             BEAST_EXPECT(trustedKeys->load({}, emptyCfgKeys, cfgPublishers));
 
@@ -471,7 +472,8 @@ private:
             // this one is not revoked (and not in the manifest cache at all.)
             auto legitKey = randomMasterKey();
 
-            std::vector<std::string> cfgPublishers = {strHex(pubRevokedPublic), strHex(legitKey)};
+            std::vector<std::string> const cfgPublishers = {
+                strHex(pubRevokedPublic), strHex(legitKey)};
             BEAST_EXPECT(trustedKeys->load({}, emptyCfgKeys, cfgPublishers, std::size_t(2)));
 
             BEAST_EXPECT(!trustedKeys->trustedPublisher(pubRevokedPublic));
@@ -563,8 +565,8 @@ private:
         auto const manifest1 = base64_encode(makeManifestString(
             publisherPublic, publisherSecret, pubSigningKeys1.first, pubSigningKeys1.second, 1));
 
-        std::vector<std::string> cfgPublisherKeys({strHex(publisherPublic)});
-        std::vector<std::string> emptyCfgKeys;
+        std::vector<std::string> const cfgPublisherKeys({strHex(publisherPublic)});
+        std::vector<std::string> const emptyCfgKeys;
 
         BEAST_EXPECT(trustedKeys->load({}, emptyCfgKeys, cfgPublisherKeys));
 
@@ -909,8 +911,8 @@ private:
         auto const manifest = base64_encode(makeManifestString(
             publisherPublic, publisherSecret, pubSigningKeys1.first, pubSigningKeys1.second, 1));
 
-        std::vector<std::string> cfgPublisherKeys({strHex(publisherPublic)});
-        std::vector<std::string> emptyCfgKeys;
+        std::vector<std::string> const cfgPublisherKeys({strHex(publisherPublic)});
+        std::vector<std::string> const emptyCfgKeys;
 
         BEAST_EXPECT(trustedKeys->load({}, emptyCfgKeys, cfgPublisherKeys));
 
@@ -1033,7 +1035,7 @@ private:
             app.config().legacy("database_path"),
             env.journal);
 
-        std::vector<std::string> cfgPublishersOuter;
+        std::vector<std::string> const cfgPublishersOuter;
         hash_set<NodeID> activeValidatorsOuter;
 
         std::size_t const maxKeys = 40;
@@ -1101,7 +1103,7 @@ private:
             auto const masterPrivate = randomSecretKey();
             auto const masterPublic = derivePublicKey(KeyType::ed25519, masterPrivate);
 
-            std::vector<std::string> cfgKeys({toBase58(TokenType::NodePublic, masterPublic)});
+            std::vector<std::string> const cfgKeys({toBase58(TokenType::NodePublic, masterPublic)});
 
             BEAST_EXPECT(trustedKeysOuter->load({}, cfgKeys, cfgPublishersOuter));
 
@@ -1201,12 +1203,12 @@ private:
             auto const publisherSecret = randomSecretKey();
             auto const publisherPublic = derivePublicKey(KeyType::ed25519, publisherSecret);
 
-            std::vector<std::string> cfgPublishers({strHex(publisherPublic)});
-            std::vector<std::string> emptyCfgKeys;
+            std::vector<std::string> const cfgPublishers({strHex(publisherPublic)});
+            std::vector<std::string> const emptyCfgKeys;
 
             BEAST_EXPECT(trustedKeys->load({}, emptyCfgKeys, cfgPublishers));
 
-            TrustChanges changes = trustedKeys->updateTrusted(
+            TrustChanges const changes = trustedKeys->updateTrusted(
                 activeValidatorsOuter,
                 env.timeKeeper().now(),
                 env.app().getOPs(),
@@ -1227,18 +1229,18 @@ private:
                 env.journal);
             auto const masterPrivate = randomSecretKey();
             auto const masterPublic = derivePublicKey(KeyType::ed25519, masterPrivate);
-            std::vector<std::string> cfgKeys({toBase58(TokenType::NodePublic, masterPublic)});
+            std::vector<std::string> const cfgKeys({toBase58(TokenType::NodePublic, masterPublic)});
 
             auto const publisher1Secret = randomSecretKey();
             auto const publisher1Public = derivePublicKey(KeyType::ed25519, publisher1Secret);
             auto const publisher2Secret = randomSecretKey();
             auto const publisher2Public = derivePublicKey(KeyType::ed25519, publisher2Secret);
-            std::vector<std::string> cfgPublishers(
+            std::vector<std::string> const cfgPublishers(
                 {strHex(publisher1Public), strHex(publisher2Public)});
 
             BEAST_EXPECT(trustedKeys->load({}, cfgKeys, cfgPublishers, std::size_t(2)));
 
-            TrustChanges changes = trustedKeys->updateTrusted(
+            TrustChanges const changes = trustedKeys->updateTrusted(
                 activeValidatorsOuter,
                 env.timeKeeper().now(),
                 env.app().getOPs(),
@@ -1261,7 +1263,7 @@ private:
                 env.journal,
                 minQuorum);
 
-            std::size_t n = 10;
+            std::size_t const n = 10;
             std::vector<std::string> cfgKeys;
             cfgKeys.reserve(n);
             hash_set<NodeID> expectedTrusted;
@@ -1316,7 +1318,7 @@ private:
                 app.config().legacy("database_path"),
                 env.journal);
 
-            std::vector<std::string> emptyCfgKeys;
+            std::vector<std::string> const emptyCfgKeys;
             auto const publisherKeys = randomKeyPair(KeyType::secp256k1);
             auto const pubSigningKeys = randomKeyPair(KeyType::secp256k1);
             auto const manifest = base64_encode(makeManifestString(
@@ -1326,7 +1328,7 @@ private:
                 pubSigningKeys.second,
                 1));
 
-            std::vector<std::string> cfgPublisherKeys({strHex(publisherKeys.first)});
+            std::vector<std::string> const cfgPublisherKeys({strHex(publisherKeys.first)});
 
             BEAST_EXPECT(trustedKeys->load({}, emptyCfgKeys, cfgPublisherKeys));
 
@@ -1415,7 +1417,7 @@ private:
                 app.config().legacy("database_path"),
                 env.journal);
 
-            std::vector<std::string> cfgPublishers;
+            std::vector<std::string> const cfgPublishers;
             hash_set<NodeID> activeValidators;
             hash_set<PublicKey> activeKeys;
 
@@ -1429,7 +1431,7 @@ private:
                 activeValidators.emplace(calcNodeID(valKey));
                 activeKeys.emplace(valKey);
                 BEAST_EXPECT(trustedKeys->load({}, cfgKeys, cfgPublishers));
-                TrustChanges changes = trustedKeys->updateTrusted(
+                TrustChanges const changes = trustedKeys->updateTrusted(
                     activeValidators,
                     env.timeKeeper().now(),
                     env.app().getOPs(),
@@ -1452,7 +1454,7 @@ private:
                 env.journal);
 
             auto const localKey = randomNode();
-            std::vector<std::string> cfgPublishers;
+            std::vector<std::string> const cfgPublishers;
             hash_set<NodeID> activeValidators;
             hash_set<PublicKey> activeKeys;
             std::vector<std::string> cfgKeys{toBase58(TokenType::NodePublic, localKey)};
@@ -1466,7 +1468,7 @@ private:
                 activeKeys.emplace(valKey);
 
                 BEAST_EXPECT(trustedKeys->load(localKey, cfgKeys, cfgPublishers));
-                TrustChanges changes = trustedKeys->updateTrusted(
+                TrustChanges const changes = trustedKeys->updateTrusted(
                     activeValidators,
                     env.timeKeeper().now(),
                     env.app().getOPs(),
@@ -1532,8 +1534,8 @@ private:
                     pubSigningKeys.second,
                     1));
 
-                std::vector<std::string> cfgPublishers({strHex(publisherPublic)});
-                std::vector<std::string> emptyCfgKeys;
+                std::vector<std::string> const cfgPublishers({strHex(publisherPublic)});
+                std::vector<std::string> const emptyCfgKeys;
 
                 // Threshold of 1 will result in a union of all the lists
                 BEAST_EXPECT(trustedKeys->load({}, emptyCfgKeys, cfgPublishers, std::size_t(1)));
@@ -1542,7 +1544,7 @@ private:
                 auto const sequence = 1;
                 using namespace std::chrono_literals;
                 NetClock::time_point const validUntil = env.timeKeeper().now() + 3600s;
-                std::vector<Validator> localKeys{locals[i].first, locals[i].second};
+                std::vector<Validator> const localKeys{locals[i].first, locals[i].second};
                 auto const blob =
                     makeList(localKeys, sequence, validUntil.time_since_epoch().count());
                 auto const sig = signList(blob, pubSigningKeys);
@@ -1558,7 +1560,7 @@ private:
                 addPublishedList(i);
             BEAST_EXPECT(trustedKeys->getListThreshold() == 1);
 
-            TrustChanges changes = trustedKeys->updateTrusted(
+            TrustChanges const changes = trustedKeys->updateTrusted(
                 activeValidators,
                 env.timeKeeper().now(),
                 env.app().getOPs(),
@@ -1624,8 +1626,8 @@ private:
                         pubSigningKeys.second,
                         1));
 
-                    std::vector<std::string> cfgPublishers({strHex(publisherPublic)});
-                    std::vector<std::string> emptyCfgKeys;
+                    std::vector<std::string> const cfgPublishers({strHex(publisherPublic)});
+                    std::vector<std::string> const emptyCfgKeys;
 
                     BEAST_EXPECT(trustedKeys->load({}, emptyCfgKeys, cfgPublishers));
 
@@ -1655,7 +1657,7 @@ private:
                     {
                         validUntil2 = validUntil;
                     }
-                    std::vector<Validator> localKeys{locals[i].first, locals[i].second};
+                    std::vector<Validator> const localKeys{locals[i].first, locals[i].second};
                     auto const blob =
                         makeList(localKeys, sequence, validUntil.time_since_epoch().count());
                     auto const sig = signList(blob, pubSigningKeys);
@@ -1797,7 +1799,7 @@ private:
             BEAST_EXPECT(trustedKeys->expires() == std::nullopt);
 
             // Config listed keys have maximum expiry
-            PublicKey localCfgListed = randomNode();
+            PublicKey const localCfgListed = randomNode();
             trustedKeys->load({}, {toStr(localCfgListed)}, {});
             BEAST_EXPECT(
                 trustedKeys->expires() &&
@@ -1841,8 +1843,8 @@ private:
                     pubSigningKeys.second,
                     1));
 
-                std::vector<std::string> cfgPublishers({strHex(publisherPublic)});
-                std::vector<std::string> emptyCfgKeys;
+                std::vector<std::string> const cfgPublishers({strHex(publisherPublic)});
+                std::vector<std::string> const emptyCfgKeys;
 
                 BEAST_EXPECT(trustedKeys->load({}, emptyCfgKeys, cfgPublishers));
 
@@ -1874,7 +1876,7 @@ private:
             // Configure two publishers and prepare 2 lists
             PreparedList prep1 = addPublishedList();
             env.timeKeeper().set(env.timeKeeper().now() + 200s);
-            PreparedList prep2 = addPublishedList();
+            PreparedList const prep2 = addPublishedList();
 
             // Initially, no list has been published, so no known expiration
             BEAST_EXPECT(trustedKeys->expires() == std::nullopt);
@@ -1955,7 +1957,7 @@ private:
                 env.journal,
                 minimumQuorum);
 
-            std::vector<std::string> cfgPublishers;
+            std::vector<std::string> const cfgPublishers;
             std::vector<std::string> cfgKeys;
             hash_set<NodeID> activeValidators;
             cfgKeys.reserve(vlSize);
@@ -1995,10 +1997,10 @@ private:
          */
 
         {
-            hash_set<NodeID> activeValidators;
+            hash_set<NodeID> const activeValidators;
             //== Combinations ==
-            std::array<std::uint32_t, 4> unlSizes = {34, 35, 39, 60};
-            std::array<std::uint32_t, 4> nUnlPercent = {0, 20, 30, 50};
+            std::array<std::uint32_t, 4> const unlSizes = {34, 35, 39, 60};
+            std::array<std::uint32_t, 4> const nUnlPercent = {0, 20, 30, 50};
             for (auto us : unlSizes)
             {
                 for (auto np : nUnlPercent)
@@ -2007,7 +2009,7 @@ private:
                     BEAST_EXPECT(validators);
                     if (validators)
                     {
-                        std::uint32_t nUnlSize = us * np / 100;
+                        std::uint32_t const nUnlSize = us * np / 100;
                         auto unl = validators->getTrustedMasterKeys();
                         hash_set<PublicKey> nUnl;
                         auto it = unl.begin();
@@ -2082,12 +2084,12 @@ private:
                     // 18
                     auto nUnl = validators->getNegativeUNL();
                     BEAST_EXPECT(nUnl.size() == 12);
-                    std::size_t ss = 33;
+                    std::size_t const ss = 33;
                     std::vector<uint8_t> data(ss, 0);
                     data[0] = 0xED;
                     for (int i = 0; i < 6; ++i)
                     {
-                        Slice s(data.data(), ss);
+                        Slice const s(data.data(), ss);
                         data[1]++;
                         nUnl.emplace(s);
                     }
@@ -2167,7 +2169,7 @@ private:
         BEAST_EXPECT(global != sha512Half(signature, blobVector, version));
 
         {
-            std::map<std::size_t, ValidatorBlobInfo> blobMap{{99, blobVector[0]}};
+            std::map<std::size_t, ValidatorBlobInfo> const blobMap{{99, blobVector[0]}};
             BEAST_EXPECT(global == sha512Half(manifest, blobMap, version));
             BEAST_EXPECT(global != sha512Half(blob, blobMap, version));
         }
@@ -3698,7 +3700,7 @@ private:
             for (auto const& p : publishers)
                 BEAST_EXPECT(trustedKeys->trustedPublisher(p.pubKey));
 
-            TrustChanges changes = trustedKeys->updateTrusted(
+            TrustChanges const changes = trustedKeys->updateTrusted(
                 activeValidators,
                 env.timeKeeper().now(),
                 env.app().getOPs(),
@@ -3736,7 +3738,7 @@ private:
             for (auto const& p : publishers)
                 BEAST_EXPECT(trustedKeys->trustedPublisher(p.pubKey));
 
-            TrustChanges changes = trustedKeys->updateTrusted(
+            TrustChanges const changes = trustedKeys->updateTrusted(
                 activeValidators,
                 env.timeKeeper().now(),
                 env.app().getOPs(),
diff --git a/src/test/app/ValidatorSite_test.cpp b/src/test/app/ValidatorSite_test.cpp
index ee28410d9e..004c59609c 100644
--- a/src/test/app/ValidatorSite_test.cpp
+++ b/src/test/app/ValidatorSite_test.cpp
@@ -53,11 +53,11 @@ private:
         auto trustedSites = std::make_unique<ValidatorSite>(env.app(), env.journal);
 
         // load should accept empty sites list
-        std::vector<std::string> emptyCfgSites;
+        std::vector<std::string> const emptyCfgSites;
         BEAST_EXPECT(trustedSites->load(emptyCfgSites));
 
         // load should accept valid validator site uris
-        std::vector<std::string> cfgSites(
+        std::vector<std::string> const cfgSites(
             {"http://ripple.com/",
              "http://ripple.com/validators",
              "http://ripple.com:8080/validators",
@@ -145,7 +145,7 @@ private:
         test::StreamSink sink;
         beast::Journal journal{sink};
 
-        std::vector<std::string> emptyCfgKeys;
+        std::vector<std::string> const emptyCfgKeys;
         struct publisher
         {
             publisher(FetchListConfig const& c) : cfg{c}
@@ -181,7 +181,7 @@ private:
                 {{effective2, expires2}},
                 cfg.ssl,
                 cfg.serverVersion);
-            std::string pubHex = strHex(item.server->publisherPublic());
+            std::string const pubHex = strHex(item.server->publisherPublic());
             cfgPublishers.push_back(pubHex);
 
             if (item.cfg.failFetch)
@@ -337,11 +337,12 @@ private:
         };
         {
             // Create a file with a real validator list
-            detail::FileDirGuard good(*this, "test_val", "vl.txt", detail::realValidatorContents());
+            detail::FileDirGuard const good(
+                *this, "test_val", "vl.txt", detail::realValidatorContents());
             // Create a file with arbitrary content
-            detail::FileDirGuard hello(*this, "test_val", "helloworld.txt", "Hello, world!");
+            detail::FileDirGuard const hello(*this, "test_val", "helloworld.txt", "Hello, world!");
             // Create a file with malformed Json
-            detail::FileDirGuard json(
+            detail::FileDirGuard const json(
                 *this, "test_val", "json.txt", R"json({ "version": 2, "extra" : "value" })json");
             auto const goodPath = fullPath(good);
             auto const helloPath = fullPath(hello);
@@ -362,7 +363,7 @@ public:
     {
         testConfigLoad();
 
-        detail::DirGuard good(*this, "test_fetch");
+        detail::DirGuard const good(*this, "test_fetch");
         for (auto ssl : {true, false})
         {
             // fetch single site
diff --git a/src/test/app/Vault_test.cpp b/src/test/app/Vault_test.cpp
index 54cc6646b1..50417305b4 100644
--- a/src/test/app/Vault_test.cpp
+++ b/src/test/app/Vault_test.cpp
@@ -90,8 +90,8 @@ class Vault_test : public beast::unit_test::suite
             env.memoize(vaultAccount);
 
             // Several 3rd party accounts which cannot receive funds
-            Account alice{"alice"};
-            Account erin{"erin"};  // not authorized by issuer
+            Account const alice{"alice"};
+            Account const erin{"erin"};  // not authorized by issuer
             env.fund(XRP(1000), alice, erin);
             env(fset(alice, asfDepositAuth));
             env.close();
@@ -514,14 +514,14 @@ class Vault_test : public beast::unit_test::suite
             env.require(flags(issuer, asfAllowTrustLineClawback));
             env.require(flags(issuer, asfRequireAuth));
 
-            PrettyAsset asset = setup(env);
+            PrettyAsset const asset = setup(env);
             testSequence(prefix, env, vault, asset);
         };
 
         testCases("XRP", [&](Env& env) -> PrettyAsset { return {xrpIssue(), 1'000'000}; });
 
         testCases("IOU", [&](Env& env) -> Asset {
-            PrettyAsset asset = issuer["IOU"];
+            PrettyAsset const asset = issuer["IOU"];
             env(trust(owner, asset(1000)));
             env(trust(depositor, asset(1000)));
             env(trust(charlie, asset(1000)));
@@ -538,7 +538,7 @@ class Vault_test : public beast::unit_test::suite
         testCases("MPT", [&](Env& env) -> Asset {
             MPTTester mptt{env, issuer, mptInitNoFund};
             mptt.create({.flags = tfMPTCanClawback | tfMPTCanTransfer | tfMPTCanLock});
-            PrettyAsset asset = mptt.issuanceID();
+            PrettyAsset const asset = mptt.issuanceID();
             mptt.authorize({.account = depositor});
             mptt.authorize({.account = charlie});
             mptt.authorize({.account = dave});
@@ -567,8 +567,8 @@ class Vault_test : public beast::unit_test::suite
                                 Vault& vault)> test,
                             CaseArgs args = {}) {
             Env env{*this, args.features};
-            Account issuer{"issuer"};
-            Account owner{"owner"};
+            Account const issuer{"issuer"};
+            Account const owner{"owner"};
             Vault vault{env};
             env.fund(XRP(1000), issuer, owner);
             env.close();
@@ -577,7 +577,7 @@ class Vault_test : public beast::unit_test::suite
             env(fset(issuer, asfRequireAuth));
             env.close();
 
-            PrettyAsset asset = issuer["IOU"];
+            PrettyAsset const asset = issuer["IOU"];
             env(trust(owner, asset(1000)));
             env(trust(issuer, asset(0), owner, tfSetfAuth));
             env(pay(issuer, owner, asset(1000)));
@@ -1081,13 +1081,13 @@ class Vault_test : public beast::unit_test::suite
                                 Asset const& asset,
                                 Vault& vault)> test) {
             Env env{*this, testable_amendments() | featureSingleAssetVault};
-            Account issuer{"issuer"};
-            Account owner{"owner"};
-            Account depositor{"depositor"};
+            Account const issuer{"issuer"};
+            Account const owner{"owner"};
+            Account const depositor{"depositor"};
             env.fund(XRP(1000), issuer, owner, depositor);
             env.close();
             Vault vault{env};
-            Asset asset = xrpIssue();
+            Asset const asset = xrpIssue();
 
             test(env, issuer, owner, depositor, asset, vault);
         };
@@ -1246,13 +1246,13 @@ class Vault_test : public beast::unit_test::suite
                 testcase("IOU fail because MPT is disabled");
                 Env env{
                     *this, (testable_amendments() - featureMPTokensV1) | featureSingleAssetVault};
-                Account issuer{"issuer"};
-                Account owner{"owner"};
+                Account const issuer{"issuer"};
+                Account const owner{"owner"};
                 env.fund(XRP(1000), issuer, owner);
                 env.close();
 
-                Vault vault{env};
-                Asset asset = issuer["IOU"].asset();
+                Vault const vault{env};
+                Asset const asset = issuer["IOU"].asset();
                 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
 
                 env(tx, ter(temDISABLED));
@@ -1262,15 +1262,15 @@ class Vault_test : public beast::unit_test::suite
             {
                 testcase("IOU fail create frozen");
                 Env env{*this, testable_amendments() | featureSingleAssetVault};
-                Account issuer{"issuer"};
-                Account owner{"owner"};
+                Account const issuer{"issuer"};
+                Account const owner{"owner"};
                 env.fund(XRP(1000), issuer, owner);
                 env.close();
                 env(fset(issuer, asfGlobalFreeze));
                 env.close();
 
-                Vault vault{env};
-                Asset asset = issuer["IOU"].asset();
+                Vault const vault{env};
+                Asset const asset = issuer["IOU"].asset();
                 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
 
                 env(tx, ter(tecFROZEN));
@@ -1280,15 +1280,15 @@ class Vault_test : public beast::unit_test::suite
             {
                 testcase("IOU fail create no ripling");
                 Env env{*this, testable_amendments() | featureSingleAssetVault};
-                Account issuer{"issuer"};
-                Account owner{"owner"};
+                Account const issuer{"issuer"};
+                Account const owner{"owner"};
                 env.fund(XRP(1000), issuer, owner);
                 env.close();
                 env(fclear(issuer, asfDefaultRipple));
                 env.close();
 
-                Vault vault{env};
-                Asset asset = issuer["IOU"].asset();
+                Vault const vault{env};
+                Asset const asset = issuer["IOU"].asset();
                 auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
                 env(tx, ter(terNO_RIPPLE));
                 env.close();
@@ -1297,13 +1297,13 @@ class Vault_test : public beast::unit_test::suite
             {
                 testcase("IOU no issuer");
                 Env env{*this, testable_amendments() | featureSingleAssetVault};
-                Account issuer{"issuer"};
-                Account owner{"owner"};
+                Account const issuer{"issuer"};
+                Account const owner{"owner"};
                 env.fund(XRP(1000), owner);
                 env.close();
 
-                Vault vault{env};
-                Asset asset = issuer["IOU"].asset();
+                Vault const vault{env};
+                Asset const asset = issuer["IOU"].asset();
                 {
                     auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
                     env(tx, ter(terNO_ACCOUNT));
@@ -1351,12 +1351,12 @@ class Vault_test : public beast::unit_test::suite
                 fund(env, gw, {alice, carol}, toFund2, {toFund1}, Fund::All);
             }
 
-            AMM ammAlice(env, alice, asset1, asset2, CreateArg{.log = false, .tfee = 0});
+            AMM const ammAlice(env, alice, asset1, asset2, CreateArg{.log = false, .tfee = 0});
 
             Account const owner{"owner"};
             env.fund(XRP(1000000), owner);
 
-            Vault vault{env};
+            Vault const vault{env};
             auto [tx, k] = vault.create({.owner = owner, .asset = ammAlice.lptIssue()});
             env(tx, ter{tecWRONG_ASSET});
             env.close();
@@ -1377,16 +1377,16 @@ class Vault_test : public beast::unit_test::suite
                                 Asset const& asset,
                                 Vault& vault)> test) {
             Env env{*this, testable_amendments() | featureSingleAssetVault};
-            Account issuer{"issuer"};
-            Account owner{"owner"};
-            Account depositor{"depositor"};
+            Account const issuer{"issuer"};
+            Account const owner{"owner"};
+            Account const depositor{"depositor"};
             env.fund(XRP(1000), issuer, owner, depositor);
             env.close();
             Vault vault{env};
             MPTTester mptt{env, issuer, mptInitNoFund};
             // Locked because that is the default flag.
             mptt.create();
-            Asset asset = mptt.issuanceID();
+            Asset const asset = mptt.issuanceID();
 
             test(env, issuer, owner, depositor, asset, vault);
         };
@@ -1436,14 +1436,14 @@ class Vault_test : public beast::unit_test::suite
         using namespace test::jtx;
 
         Env env{*this, testable_amendments() | featureSingleAssetVault};
-        Account issuer{"issuer"};
-        Account owner{"owner"};
-        Account depositor{"depositor"};
+        Account const issuer{"issuer"};
+        Account const owner{"owner"};
+        Account const depositor{"depositor"};
         env.fund(XRP(1000), issuer, owner, depositor);
         env.close();
 
-        Vault vault{env};
-        PrettyAsset asset = issuer["IOU"];
+        Vault const vault{env};
+        PrettyAsset const asset = issuer["IOU"];
         env.trust(asset(1000), owner);
         env(pay(issuer, owner, asset(100)));
         env.trust(asset(1000), depositor);
@@ -1480,7 +1480,7 @@ class Vault_test : public beast::unit_test::suite
         }();
 
         auto const MptID = makeMptID(1, vaultAccount);
-        Asset shares = MptID;
+        Asset const shares = MptID;
 
         {
             testcase("nontransferable shares cannot be moved");
@@ -1563,7 +1563,7 @@ class Vault_test : public beast::unit_test::suite
                      (args.enableClawback ? tfMPTCanClawback : none) |
                      (args.requireAuth ? tfMPTRequireAuth : none),
                  .mutableFlags = tmfMPTCanMutateCanTransfer});
-            PrettyAsset asset = mptt.issuanceID();
+            PrettyAsset const asset = mptt.issuanceID();
             mptt.authorize({.account = owner});
             mptt.authorize({.account = depositor});
             if (args.requireAuth)
@@ -1654,10 +1654,10 @@ class Vault_test : public beast::unit_test::suite
             // accounts for the issued shares.
             auto v = env.le(keylet);
             BEAST_EXPECT(v);
-            MPTID share = (*v)[sfShareMPTID];
+            MPTID const share = (*v)[sfShareMPTID];
             auto issuance = env.le(keylet::mptIssuance(share));
             BEAST_EXPECT(issuance);
-            Number outstandingShares = issuance->at(sfOutstandingAmount);
+            Number const outstandingShares = issuance->at(sfOutstandingAmount);
             BEAST_EXPECT(outstandingShares == 100);
 
             mptt.set({.account = issuer, .flags = tfMPTLock});
@@ -1761,7 +1761,7 @@ class Vault_test : public beast::unit_test::suite
 
                 {
                     // Set destination to 3rd party without MPToken
-                    Account charlie{"charlie"};
+                    Account const charlie{"charlie"};
                     env.fund(XRP(1000), charlie);
                     env.close();
 
@@ -1838,7 +1838,7 @@ class Vault_test : public beast::unit_test::suite
             {.requireAuth = false});
 
         auto const [acctReserve, incReserve] = [this]() -> std::pair<int, int> {
-            Env env{*this, testable_amendments()};
+            Env const env{*this, testable_amendments()};
             return {
                 env.current()->fees().accountReserve(0).drops() / DROPS_PER_XRP.drops(),
                 env.current()->fees().increment.drops() / DROPS_PER_XRP.drops()};
@@ -1975,7 +1975,7 @@ class Vault_test : public beast::unit_test::suite
                 auto const vault = env.le(keylet);
                 return vault->at(sfShareMPTID);
             }(keylet);
-            PrettyAsset shares = MPTIssue(issuanceId);
+            PrettyAsset const shares = MPTIssue(issuanceId);
 
             {
                 // owner has MPToken for shares they did not explicitly create
@@ -2177,14 +2177,14 @@ class Vault_test : public beast::unit_test::suite
             Account issuer{"issuer"};
             env.fund(XRP(1000000), owner, issuer);
             env.close();
-            Vault vault{env};
+            Vault const vault{env};
 
             MPTTester mptt{env, issuer, mptInitNoFund};
             mptt.create(
                 {.flags = tfMPTCanTransfer | tfMPTCanLock | lsfMPTCanClawback | tfMPTRequireAuth});
             mptt.authorize({.account = owner});
             mptt.authorize({.account = issuer, .holder = owner});
-            PrettyAsset asset = mptt.issuanceID();
+            PrettyAsset const asset = mptt.issuanceID();
             env(pay(issuer, owner, asset(100)));
             auto [tx1, k1] = vault.create({.owner = owner, .asset = asset});
             env(tx1);
@@ -2650,7 +2650,7 @@ class Vault_test : public beast::unit_test::suite
                 }
 
                 {
-                    PrettyAsset shares = issuanceId(keylet);
+                    PrettyAsset const shares = issuanceId(keylet);
                     auto tx1 =
                         vault.deposit({.depositor = owner, .id = keylet.key, .amount = asset(100)});
                     env(tx1);
@@ -2761,7 +2761,7 @@ class Vault_test : public beast::unit_test::suite
             {.initialIOU = Number(11875, -2)});
 
         auto const [acctReserve, incReserve] = [this]() -> std::pair<int, int> {
-            Env env{*this, testable_amendments()};
+            Env const env{*this, testable_amendments()};
             return {
                 env.current()->fees().accountReserve(0).drops() / DROPS_PER_XRP.drops(),
                 env.current()->fees().increment.drops() / DROPS_PER_XRP.drops()};
@@ -2950,22 +2950,22 @@ class Vault_test : public beast::unit_test::suite
         testcase("private vault");
 
         Env env{*this, testable_amendments() | featureSingleAssetVault};
-        Account issuer{"issuer"};
-        Account owner{"owner"};
-        Account depositor{"depositor"};
-        Account charlie{"charlie"};
-        Account pdOwner{"pdOwner"};
-        Account credIssuer1{"credIssuer1"};
-        Account credIssuer2{"credIssuer2"};
+        Account const issuer{"issuer"};
+        Account const owner{"owner"};
+        Account const depositor{"depositor"};
+        Account const charlie{"charlie"};
+        Account const pdOwner{"pdOwner"};
+        Account const credIssuer1{"credIssuer1"};
+        Account const credIssuer2{"credIssuer2"};
         std::string const credType = "credential";
-        Vault vault{env};
+        Vault const vault{env};
         env.fund(XRP(1000), issuer, owner, depositor, charlie, pdOwner, credIssuer1, credIssuer2);
         env.close();
         env(fset(issuer, asfAllowTrustLineClawback));
         env.close();
         env.require(flags(issuer, asfAllowTrustLineClawback));
 
-        PrettyAsset asset = issuer["IOU"];
+        PrettyAsset const asset = issuer["IOU"];
         env.trust(asset(1000), owner);
         env(pay(issuer, owner, asset(500)));
         env.trust(asset(1000), depositor);
@@ -3198,15 +3198,15 @@ class Vault_test : public beast::unit_test::suite
         testcase("private XRP vault");
 
         Env env{*this, testable_amendments() | featureSingleAssetVault};
-        Account owner{"owner"};
-        Account depositor{"depositor"};
-        Account alice{"charlie"};
+        Account const owner{"owner"};
+        Account const depositor{"depositor"};
+        Account const alice{"charlie"};
         std::string const credType = "credential";
-        Vault vault{env};
+        Vault const vault{env};
         env.fund(XRP(100000), owner, depositor, alice);
         env.close();
 
-        PrettyAsset asset = xrpIssue();
+        PrettyAsset const asset = xrpIssue();
         auto [tx, keylet] = vault.create({.owner = owner, .asset = asset, .flags = tfVaultPrivate});
         env(tx);
         env.close();
@@ -3219,7 +3219,7 @@ class Vault_test : public beast::unit_test::suite
         }();
         BEAST_EXPECT(env.le(keylet::account(vaultAccount)));
         BEAST_EXPECT(env.le(keylet::mptIssuance(issuanceId)));
-        PrettyAsset shares{issuanceId};
+        PrettyAsset const shares{issuanceId};
 
         {
             testcase("private XRP vault owner can deposit");
@@ -3296,7 +3296,7 @@ class Vault_test : public beast::unit_test::suite
         testcase("fail pseudo-account allocation");
         Env env{*this, testable_amendments() | featureSingleAssetVault};
         Account const owner{"owner"};
-        Vault vault{env};
+        Vault const vault{env};
         env.fund(XRP(1000), owner);
 
         auto const keylet = keylet::vault(owner.id(), env.seq(owner));
@@ -3362,7 +3362,7 @@ class Vault_test : public beast::unit_test::suite
                 auto const vault = env.le(keylet);
                 return {Account("vault", vault->at(sfAccount)), vault->at(sfShareMPTID)};
             }(keylet);
-            MPTIssue shares(issuanceId);
+            MPTIssue const shares(issuanceId);
             env.memoize(vaultAccount);
 
             auto const peek = [keylet, &env, this](std::function<bool(SLE&, SLE&)> fn) -> bool {
@@ -4113,11 +4113,11 @@ class Vault_test : public beast::unit_test::suite
         Env env{*this, testable_amendments() | featureSingleAssetVault};
         Account const owner{"owner"};
         Account const issuer{"issuer"};
-        Vault vault{env};
+        Vault const vault{env};
         env.fund(XRP(1000), issuer, owner);
         env.close();
 
-        PrettyAsset asset = issuer["IOU"];
+        PrettyAsset const asset = issuer["IOU"];
         env.trust(asset(1000), owner);
         env(pay(issuer, owner, asset(200)));
         env.close();
@@ -4545,7 +4545,7 @@ class Vault_test : public beast::unit_test::suite
         auto const setupVault = [&](PrettyAsset const& asset,
                                     Account const& owner,
                                     Account const& depositor) -> std::pair<Vault, Keylet> {
-            Vault vault{env};
+            Vault const vault{env};
 
             auto const& [tx, vaultKeylet] = vault.create({.owner = owner, .asset = asset});
             env(tx, ter(tesSUCCESS));
@@ -4554,7 +4554,7 @@ class Vault_test : public beast::unit_test::suite
             auto const& vaultSle = env.le(vaultKeylet);
             BEAST_EXPECT(vaultSle != nullptr);
 
-            Asset share = vaultSle->at(sfShareMPTID);
+            Asset const share = vaultSle->at(sfShareMPTID);
 
             env(vault.deposit(
                     {.depositor = depositor, .id = vaultKeylet.key, .amount = asset(100)}),
@@ -4651,7 +4651,7 @@ class Vault_test : public beast::unit_test::suite
                 BEAST_EXPECT(vaultSle != nullptr);
                 if (!vaultSle)
                     return;
-                Asset share = vaultSle->at(sfShareMPTID);
+                Asset const share = vaultSle->at(sfShareMPTID);
                 env(vault.clawback({
                         .issuer = owner,
                         .id = vaultKeylet.key,
@@ -4687,7 +4687,7 @@ class Vault_test : public beast::unit_test::suite
                 BEAST_EXPECT(vaultSle != nullptr);
                 if (!vaultSle)
                     return;
-                Asset share = vaultSle->at(sfShareMPTID);
+                Asset const share = vaultSle->at(sfShareMPTID);
                 env(vault.clawback({
                         .issuer = owner,
                         .id = vaultKeylet.key,
@@ -4704,7 +4704,7 @@ class Vault_test : public beast::unit_test::suite
                 BEAST_EXPECT(vaultSle != nullptr);
                 if (!vaultSle)
                     return;
-                Asset share = vaultSle->at(sfShareMPTID);
+                Asset const share = vaultSle->at(sfShareMPTID);
                 env(vault.clawback({
                         .issuer = owner,
                         .id = vaultKeylet.key,
@@ -4721,7 +4721,7 @@ class Vault_test : public beast::unit_test::suite
                 auto const& vaultSle = env.le(vaultKeylet);
                 if (BEAST_EXPECT(vaultSle != nullptr))
                     return;
-                Asset share = vaultSle->at(sfShareMPTID);
+                Asset const share = vaultSle->at(sfShareMPTID);
                 env(vault.clawback({
                         .issuer = owner,
                         .id = vaultKeylet.key,
@@ -4743,18 +4743,18 @@ class Vault_test : public beast::unit_test::suite
 
         Account owner{"alice"};
         Account depositor{"bob"};
-        Account issuer{"issuer"};
+        Account const issuer{"issuer"};
 
         env.fund(XRP(10000), issuer, owner, depositor);
         env.close();
 
         // Test XRP
-        PrettyAsset xrp = xrpIssue();
+        PrettyAsset const xrp = xrpIssue();
         testCase(xrp, "XRP", owner, depositor);
         testCase(xrp, "XRP (depositor is owner)", owner, owner);
 
         // Test IOU
-        PrettyAsset IOU = issuer["IOU"];
+        PrettyAsset const IOU = issuer["IOU"];
         env(fset(issuer, asfAllowTrustLineClawback));
         env.close();
 
@@ -4769,7 +4769,7 @@ class Vault_test : public beast::unit_test::suite
         // Test MPT
         MPTTester mptt{env, issuer, mptInitNoFund};
         mptt.create({.flags = tfMPTCanClawback | tfMPTCanTransfer | tfMPTCanLock});
-        PrettyAsset MPT = mptt.issuanceID();
+        PrettyAsset const MPT = mptt.issuanceID();
         mptt.authorize({.account = owner});
         mptt.authorize({.account = depositor});
         env(pay(issuer, owner, MPT(1000)));
@@ -4791,7 +4791,7 @@ class Vault_test : public beast::unit_test::suite
                                     Account const& owner,
                                     Account const& depositor,
                                     Account const& issuer) -> std::pair<Vault, Keylet> {
-            Vault vault{env};
+            Vault const vault{env};
 
             auto const& [tx, vaultKeylet] = vault.create({.owner = owner, .asset = asset});
             env(tx, ter(tesSUCCESS));
@@ -4840,8 +4840,8 @@ class Vault_test : public beast::unit_test::suite
                     "VaultClawback (asset) - " + prefix + " clawback for different asset fails");
                 auto [vault, vaultKeylet] = setupVault(asset, owner, depositor, issuer);
 
-                Account issuer2{"issuer2"};
-                PrettyAsset asset2 = issuer2["FOO"];
+                Account const issuer2{"issuer2"};
+                PrettyAsset const asset2 = issuer2["FOO"];
                 env(vault.clawback({
                         .issuer = issuer,
                         .id = vaultKeylet.key,
@@ -4902,7 +4902,7 @@ class Vault_test : public beast::unit_test::suite
                 BEAST_EXPECT(vaultSle != nullptr);
                 if (!vaultSle)
                     return;
-                Asset share = vaultSle->at(sfShareMPTID);
+                Asset const share = vaultSle->at(sfShareMPTID);
 
                 env(vault.clawback({
                         .issuer = issuer,
@@ -4959,17 +4959,17 @@ class Vault_test : public beast::unit_test::suite
 
         Account owner{"alice"};
         Account depositor{"bob"};
-        Account issuer{"issuer"};
+        Account const issuer{"issuer"};
 
         env.fund(XRP(10000), issuer, owner, depositor);
         env.close();
 
         // Test XRP
-        PrettyAsset xrp = xrpIssue();
+        PrettyAsset const xrp = xrpIssue();
         testCase(xrp, "XRP", owner, depositor, issuer);
 
         // Test IOU
-        PrettyAsset IOU = issuer["IOU"];
+        PrettyAsset const IOU = issuer["IOU"];
         env(fset(issuer, asfAllowTrustLineClawback));
         env.close();
         env.trust(IOU(1000), owner);
@@ -4982,7 +4982,7 @@ class Vault_test : public beast::unit_test::suite
         // Test MPT
         MPTTester mptt{env, issuer, mptInitNoFund};
         mptt.create({.flags = tfMPTCanClawback | tfMPTCanTransfer | tfMPTCanLock});
-        PrettyAsset MPT = mptt.issuanceID();
+        PrettyAsset const MPT = mptt.issuanceID();
         mptt.authorize({.account = owner});
         mptt.authorize({.account = depositor});
         env(pay(issuer, depositor, MPT(1000)));
@@ -5001,7 +5001,7 @@ class Vault_test : public beast::unit_test::suite
         Account const owner{"owner"};
         Account const issuer{"issuer"};
 
-        Vault vault{env};
+        Vault const vault{env};
         env.fund(XRP(1'000'000), issuer, owner);
         env.close();
 
@@ -5116,7 +5116,7 @@ class Vault_test : public beast::unit_test::suite
             testcase("Assets Maximum: IOU");
 
             // Almost anything goes with IOUs
-            PrettyAsset iouAsset = issuer["IOU"];
+            PrettyAsset const iouAsset = issuer["IOU"];
             env.trust(iouAsset(1000), owner);
             env(pay(issuer, owner, iouAsset(200)));
             env.close();
diff --git a/src/test/app/XChain_test.cpp b/src/test/app/XChain_test.cpp
index 72f2597883..abaeccb4ff 100644
--- a/src/test/app/XChain_test.cpp
+++ b/src/test/app/XChain_test.cpp
@@ -130,7 +130,7 @@ struct SEnv
     std::shared_ptr<SLE const>
     bridge(Json::Value const& jvb)
     {
-        STXChainBridge b(jvb);
+        STXChainBridge const b(jvb);
 
         auto tryGet = [&](STXChainBridge::ChainType ct) -> std::shared_ptr<SLE const> {
             if (auto r = env_.le(keylet::bridge(b, ct)))
@@ -180,7 +180,7 @@ struct XEnv : public jtx::XChainBridgeObjects, public SEnv<T>
     XEnv(T& s, bool side = false) : SEnv<T>(s, jtx::envconfig(), features)
     {
         using namespace jtx;
-        STAmount xrp_funds{XRP(10000)};
+        STAmount const xrp_funds{XRP(10000)};
 
         if (!side)
         {
@@ -359,7 +359,7 @@ struct XChain_test : public beast::unit_test::suite, public jtx::XChainBridgeObj
         try
         {
             exceptionPresent = false;
-            [[maybe_unused]] STXChainBridge testBridge1(jBridge);
+            [[maybe_unused]] STXChainBridge const testBridge1(jBridge);
         }
         catch (std::exception& ec)
         {
@@ -372,7 +372,7 @@ struct XChain_test : public beast::unit_test::suite, public jtx::XChainBridgeObj
         {
             exceptionPresent = false;
             jBridge["Extra"] = 1;
-            [[maybe_unused]] STXChainBridge testBridge2(jBridge);
+            [[maybe_unused]] STXChainBridge const testBridge2(jBridge);
         }
         catch ([[maybe_unused]] std::exception& ec)
         {
@@ -385,7 +385,7 @@ struct XChain_test : public beast::unit_test::suite, public jtx::XChainBridgeObj
     void
     testXChainCreateBridge()
     {
-        XRPAmount res1 = reserve(1);
+        XRPAmount const res1 = reserve(1);
 
         using namespace jtx;
         testcase("Create Bridge");
@@ -807,12 +807,12 @@ struct XChain_test : public beast::unit_test::suite, public jtx::XChainBridgeObj
             auto const& expected = expected_result[test_result.size()];
 
             mcEnv.tx(create_bridge(a, bridge(a, ia, b, ib)), ter(TER::fromInt(expected.first)));
-            TER mcTER = mcEnv.env_.ter();
+            TER const mcTER = mcEnv.env_.ter();
 
             scEnv.tx(create_bridge(b, bridge(a, ia, b, ib)), ter(TER::fromInt(expected.second)));
-            TER scTER = scEnv.env_.ter();
+            TER const scTER = scEnv.env_.ter();
 
-            bool pass = isTesSuccess(mcTER) && isTesSuccess(scTER);
+            bool const pass = isTesSuccess(mcTER) && isTesSuccess(scTER);
 
             test_result.emplace_back(mcTER, scTER, pass);
         };
@@ -1155,8 +1155,8 @@ struct XChain_test : public beast::unit_test::suite, public jtx::XChainBridgeObj
     testXChainCreateClaimID()
     {
         using namespace jtx;
-        XRPAmount res1 = reserve(1);
-        XRPAmount tx_fee = txFee();
+        XRPAmount const res1 = reserve(1);
+        XRPAmount const tx_fee = txFee();
 
         testcase("Create ClaimID");
 
@@ -1173,7 +1173,7 @@ struct XChain_test : public beast::unit_test::suite, public jtx::XChainBridgeObj
         {
             XEnv xenv(*this, true);
 
-            Balance scAlice_bal(xenv, scAlice);
+            Balance const scAlice_bal(xenv, scAlice);
 
             xenv.tx(create_bridge(Account::master, jvb))
                 .tx(xchain_create_claim_id(scAlice, jvb, reward, mcAlice))
@@ -1240,8 +1240,8 @@ struct XChain_test : public beast::unit_test::suite, public jtx::XChainBridgeObj
     testXChainCommit()
     {
         using namespace jtx;
-        XRPAmount res0 = reserve(0);
-        XRPAmount tx_fee = txFee();
+        XRPAmount const res0 = reserve(0);
+        XRPAmount const tx_fee = txFee();
 
         testcase("Commit");
 
@@ -1252,7 +1252,7 @@ struct XChain_test : public beast::unit_test::suite, public jtx::XChainBridgeObj
         {
             XEnv xenv(*this);
 
-            Balance alice_bal(xenv, mcAlice);
+            Balance const alice_bal(xenv, mcAlice);
             auto const amt = XRP(1000);
 
             xenv.tx(create_bridge(mcDoor, jvb))
@@ -1260,7 +1260,7 @@ struct XChain_test : public beast::unit_test::suite, public jtx::XChainBridgeObj
                 .tx(xchain_commit(mcAlice, jvb, 1, amt, scBob))
                 .close();
 
-            STAmount claim_cost = amt;
+            STAmount const claim_cost = amt;
             BEAST_EXPECT(alice_bal.diff() == -(claim_cost + tx_fee));
         }
 
@@ -1369,7 +1369,7 @@ struct XChain_test : public beast::unit_test::suite, public jtx::XChainBridgeObj
         using namespace jtx;
 
         testcase("Add Attestation");
-        XRPAmount res0 = reserve(0);
+        XRPAmount const res0 = reserve(0);
         XRPAmount tx_fee = txFee();
 
         auto multiTtxFee = [&](std::uint32_t m) -> STAmount {
@@ -1457,7 +1457,7 @@ struct XChain_test : public beast::unit_test::suite, public jtx::XChainBridgeObj
             std::uint32_t const quorum_7 = 7;
             std::vector<signer> const signers_ = [] {
                 constexpr int numSigners = 4;
-                std::uint32_t weights[] = {1, 2, 4, 4};
+                std::uint32_t const weights[] = {1, 2, 4, 4};
 
                 std::vector<signer> result;
                 result.reserve(numSigners);
@@ -1515,7 +1515,7 @@ struct XChain_test : public beast::unit_test::suite, public jtx::XChainBridgeObj
             std::uint32_t const quorum_7 = 7;
             std::vector<signer> const signers_ = [] {
                 constexpr int numSigners = 4;
-                std::uint32_t weights[] = {1, 2, 4, 4};
+                std::uint32_t const weights[] = {1, 2, 4, 4};
 
                 std::vector<signer> result;
                 result.reserve(numSigners);
@@ -1575,7 +1575,7 @@ struct XChain_test : public beast::unit_test::suite, public jtx::XChainBridgeObj
             std::uint32_t const quorum_7 = 7;
             std::vector<signer> const signers_ = [] {
                 constexpr int numSigners = 4;
-                std::uint32_t weights[] = {1, 2, 4, 4};
+                std::uint32_t const weights[] = {1, 2, 4, 4};
 
                 std::vector<signer> result;
                 result.reserve(numSigners);
@@ -1634,7 +1634,7 @@ struct XChain_test : public beast::unit_test::suite, public jtx::XChainBridgeObj
             std::uint32_t const quorum_7 = 7;
             std::vector<signer> const signers_ = [] {
                 constexpr int numSigners = 4;
-                std::uint32_t weights[] = {1, 2, 4, 4};
+                std::uint32_t const weights[] = {1, 2, 4, 4};
 
                 std::vector<signer> result;
                 result.reserve(numSigners);
@@ -1697,8 +1697,8 @@ struct XChain_test : public beast::unit_test::suite, public jtx::XChainBridgeObj
             auto const amt_plus_reward = amt + reward;
 
             {
-                Balance door(mcEnv, mcDoor);
-                Balance carol(mcEnv, mcCarol);
+                Balance const door(mcEnv, mcDoor);
+                Balance const carol(mcEnv, mcCarol);
 
                 mcEnv.tx(create_bridge(mcDoor, jvb, reward, XRP(20)))
                     .close()
@@ -1719,8 +1719,8 @@ struct XChain_test : public beast::unit_test::suite, public jtx::XChainBridgeObj
             {
                 // send first batch of account create attest for all 3
                 // account create
-                Balance attester(scEnv, scAttester);
-                Balance door(scEnv, Account::master);
+                Balance const attester(scEnv, scAttester);
+                Balance const door(scEnv, Account::master);
 
                 scEnv.multiTx(att_create_acct_vec(1, amt, scuAlice, 2))
                     .multiTx(att_create_acct_vec(3, amt, scuCarol, 2))
@@ -1740,8 +1740,8 @@ struct XChain_test : public beast::unit_test::suite, public jtx::XChainBridgeObj
             {
                 // complete attestations for 2nd account create => should
                 // not complete
-                Balance attester(scEnv, scAttester);
-                Balance door(scEnv, Account::master);
+                Balance const attester(scEnv, scAttester);
+                Balance const door(scEnv, Account::master);
 
                 scEnv.multiTx(att_create_acct_vec(2, amt, scuBob, 3, 2)).close();
 
@@ -1756,8 +1756,8 @@ struct XChain_test : public beast::unit_test::suite, public jtx::XChainBridgeObj
             {
                 // complete attestations for 3rd account create => should
                 // not complete
-                Balance attester(scEnv, scAttester);
-                Balance door(scEnv, Account::master);
+                Balance const attester(scEnv, scAttester);
+                Balance const door(scEnv, Account::master);
 
                 scEnv.multiTx(att_create_acct_vec(3, amt, scuCarol, 3, 2)).close();
 
@@ -1772,8 +1772,8 @@ struct XChain_test : public beast::unit_test::suite, public jtx::XChainBridgeObj
             {
                 // complete attestations for 1st account create => account
                 // should be created
-                Balance attester(scEnv, scAttester);
-                Balance door(scEnv, Account::master);
+                Balance const attester(scEnv, scAttester);
+                Balance const door(scEnv, Account::master);
 
                 scEnv.multiTx(att_create_acct_vec(1, amt, scuAlice, 3, 1)).close();
 
@@ -1791,8 +1791,8 @@ struct XChain_test : public beast::unit_test::suite, public jtx::XChainBridgeObj
             {
                 // resend attestations for 3rd account create => still
                 // should not complete
-                Balance attester(scEnv, scAttester);
-                Balance door(scEnv, Account::master);
+                Balance const attester(scEnv, scAttester);
+                Balance const door(scEnv, Account::master);
 
                 scEnv.multiTx(att_create_acct_vec(3, amt, scuCarol, 3, 2)).close();
 
@@ -1808,8 +1808,8 @@ struct XChain_test : public beast::unit_test::suite, public jtx::XChainBridgeObj
             {
                 // resend attestations for 2nd account create => account
                 // should be created
-                Balance attester(scEnv, scAttester);
-                Balance door(scEnv, Account::master);
+                Balance const attester(scEnv, scAttester);
+                Balance const door(scEnv, Account::master);
 
                 scEnv.multiTx(att_create_acct_vec(2, amt, scuBob, 1)).close();
 
@@ -1824,8 +1824,8 @@ struct XChain_test : public beast::unit_test::suite, public jtx::XChainBridgeObj
             {
                 // resend attestations for 3rc account create => account
                 // should be created
-                Balance attester(scEnv, scAttester);
-                Balance door(scEnv, Account::master);
+                Balance const attester(scEnv, scAttester);
+                Balance const door(scEnv, Account::master);
 
                 scEnv.multiTx(att_create_acct_vec(3, amt, scuCarol, 1)).close();
 
@@ -1850,8 +1850,8 @@ struct XChain_test : public beast::unit_test::suite, public jtx::XChainBridgeObj
             mcEnv.tx(create_bridge(mcDoor, jvb, reward, XRP(20))).close();
 
             {
-                Balance door(mcEnv, mcDoor);
-                Balance carol(mcEnv, mcCarol);
+                Balance const door(mcEnv, mcDoor);
+                Balance const carol(mcEnv, mcCarol);
 
                 mcEnv.tx(sidechain_xchain_account_create(mcCarol, jvb, scuAlice, amt, reward))
                     .close();
@@ -1864,8 +1864,8 @@ struct XChain_test : public beast::unit_test::suite, public jtx::XChainBridgeObj
                 .tx(jtx::signers(Account::master, quorum, signers))
                 .close();
 
-            Balance attester(scEnv, scAttester);
-            Balance door(scEnv, Account::master);
+            Balance const attester(scEnv, scAttester);
+            Balance const door(scEnv, Account::master);
 
             scEnv.multiTx(att_create_acct_vec(1, amt, scuAlice, 2)).close();
             BEAST_EXPECT(!!scEnv.caClaimID(jvb, 1));   // claim id present
@@ -1892,8 +1892,8 @@ struct XChain_test : public beast::unit_test::suite, public jtx::XChainBridgeObj
             mcEnv.tx(create_bridge(mcDoor, jvb, reward, XRP(20))).close();
 
             {
-                Balance door(mcEnv, mcDoor);
-                Balance carol(mcEnv, mcCarol);
+                Balance const door(mcEnv, mcDoor);
+                Balance const carol(mcEnv, mcCarol);
 
                 mcEnv.tx(sidechain_xchain_account_create(mcCarol, jvb, scAlice, amt, reward))
                     .close();
@@ -1906,9 +1906,9 @@ struct XChain_test : public beast::unit_test::suite, public jtx::XChainBridgeObj
                 .tx(jtx::signers(Account::master, quorum, signers))
                 .close();
 
-            Balance attester(scEnv, scAttester);
-            Balance door(scEnv, Account::master);
-            Balance alice(scEnv, scAlice);
+            Balance const attester(scEnv, scAttester);
+            Balance const door(scEnv, Account::master);
+            Balance const alice(scEnv, scAlice);
 
             scEnv.multiTx(att_create_acct_vec(1, amt, scAlice, 2)).close();
             BEAST_EXPECT(!!scEnv.caClaimID(jvb, 1));   // claim id present
@@ -1935,8 +1935,8 @@ struct XChain_test : public beast::unit_test::suite, public jtx::XChainBridgeObj
             mcEnv.tx(create_bridge(mcDoor, jvb, reward, XRP(20))).close();
 
             {
-                Balance door(mcEnv, mcDoor);
-                Balance carol(mcEnv, mcCarol);
+                Balance const door(mcEnv, mcDoor);
+                Balance const carol(mcEnv, mcCarol);
 
                 mcEnv.tx(sidechain_xchain_account_create(mcCarol, jvb, scAlice, amt, reward))
                     .close();
@@ -1950,9 +1950,9 @@ struct XChain_test : public beast::unit_test::suite, public jtx::XChainBridgeObj
                 .tx(fset("scAlice", asfDepositAuth))  // set deposit auth
                 .close();
 
-            Balance attester(scEnv, scAttester);
-            Balance door(scEnv, Account::master);
-            Balance alice(scEnv, scAlice);
+            Balance const attester(scEnv, scAttester);
+            Balance const door(scEnv, Account::master);
+            Balance const alice(scEnv, scAlice);
 
             scEnv.multiTx(att_create_acct_vec(1, amt, scAlice, 2)).close();
             BEAST_EXPECT(!!scEnv.caClaimID(jvb, 1));   // claim id present
@@ -1979,8 +1979,8 @@ struct XChain_test : public beast::unit_test::suite, public jtx::XChainBridgeObj
             auto const amt_plus_reward = amt + reward;
 
             {
-                Balance door(mcEnv, mcDoor);
-                Balance carol(mcEnv, mcCarol);
+                Balance const door(mcEnv, mcDoor);
+                Balance const carol(mcEnv, mcCarol);
 
                 mcEnv.tx(create_bridge(mcDoor, jvb, reward, XRP(20)))
                     .close()
@@ -2002,8 +2002,8 @@ struct XChain_test : public beast::unit_test::suite, public jtx::XChainBridgeObj
                 .close();
 
             {
-                Balance attester(scEnv, scAttester);
-                Balance door(scEnv, Account::master);
+                Balance const attester(scEnv, scAttester);
+                Balance const door(scEnv, Account::master);
                 auto const bad_amt = XRP(10);
                 std::uint32_t txCount = 0;
 
@@ -2290,16 +2290,16 @@ struct XChain_test : public beast::unit_test::suite, public jtx::XChainBridgeObj
         XEnv mcEnv(*this);
         XEnv scEnv(*this, true);
 
-        XRPAmount tx_fee = mcEnv.txFee();
+        XRPAmount const tx_fee = mcEnv.txFee();
 
-        Account a{"a"};
-        Account doorA{"doorA"};
+        Account const a{"a"};
+        Account const doorA{"doorA"};
 
-        STAmount funds{XRP(10000)};
+        STAmount const funds{XRP(10000)};
         mcEnv.fund(funds, a);
         mcEnv.fund(funds, doorA);
 
-        Account ua{"ua"};  // unfunded account we want to create
+        Account const ua{"ua"};  // unfunded account we want to create
 
         BridgeDef xrp_b{
             doorA,
@@ -2317,8 +2317,8 @@ struct XChain_test : public beast::unit_test::suite, public jtx::XChainBridgeObj
         auto const amt = XRP(777);
         auto const amt_plus_reward = amt + xrp_b.reward;
         {
-            Balance bal_doorA(mcEnv, doorA);
-            Balance bal_a(mcEnv, a);
+            Balance const bal_doorA(mcEnv, doorA);
+            Balance const bal_a(mcEnv, a);
 
             mcEnv.tx(sidechain_xchain_account_create(a, xrp_b.jvb, ua, amt, xrp_b.reward)).close();
 
@@ -2360,8 +2360,8 @@ struct XChain_test : public beast::unit_test::suite, public jtx::XChainBridgeObj
     {
         using namespace jtx;
 
-        XRPAmount res0 = reserve(0);
-        XRPAmount tx_fee = txFee();
+        XRPAmount const res0 = reserve(0);
+        XRPAmount const tx_fee = txFee();
 
         testcase("Claim");
 
@@ -2436,7 +2436,7 @@ struct XChain_test : public beast::unit_test::suite, public jtx::XChainBridgeObj
             BalanceTransfer transfer(
                 scEnv, Account::master, scBob, scAlice, &payees[0], 1, withClaim);
 
-            jtx::signer master_signer(Account::master);
+            jtx::signer const master_signer(Account::master);
             scEnv
                 .tx(claim_attestation(
                         scAttester,
@@ -2481,7 +2481,7 @@ struct XChain_test : public beast::unit_test::suite, public jtx::XChainBridgeObj
             BalanceTransfer transfer(
                 scEnv, Account::master, scBob, scAlice, &payees[0], 1, withClaim);
 
-            jtx::signer master_signer(payees[0]);
+            jtx::signer const master_signer(payees[0]);
             scEnv
                 .tx(claim_attestation(
                         scAttester,
@@ -2861,7 +2861,7 @@ struct XChain_test : public beast::unit_test::suite, public jtx::XChainBridgeObj
             XEnv scEnv(*this, true);
 
             mcEnv.tx(create_bridge(mcDoor, jvb)).close();
-            STAmount huge_reward{XRP(20000)};
+            STAmount const huge_reward{XRP(20000)};
             BEAST_EXPECT(huge_reward > scEnv.balance(scAlice));
 
             scEnv.tx(create_bridge(Account::master, jvb, huge_reward))
@@ -3009,7 +3009,7 @@ struct XChain_test : public beast::unit_test::suite, public jtx::XChainBridgeObj
 
                 // the transfer failed, but check that we can still use the
                 // claimID with a different account
-                Balance scCarol_bal(scEnv, scCarol);
+                Balance const scCarol_bal(scEnv, scCarol);
 
                 scEnv.tx(xchain_claim(scAlice, jvb, claimID, amt, scCarol)).close();
                 BEAST_EXPECT(scCarol_bal.diff() == amt);
@@ -3026,7 +3026,7 @@ struct XChain_test : public beast::unit_test::suite, public jtx::XChainBridgeObj
                     .tx(fset("scBob", 0, asfDepositAuth))  // clear deposit auth
                     .close();
 
-                Balance scBob_bal(scEnv, scBob);
+                Balance const scBob_bal(scEnv, scBob);
                 scEnv.tx(txns.back()).close();
                 BEAST_EXPECT(scBob_bal.diff() == amt);
             }
@@ -3078,7 +3078,7 @@ struct XChain_test : public beast::unit_test::suite, public jtx::XChainBridgeObj
 
                 // the transfer failed, but check that we can still use the
                 // claimID with a different account
-                Balance scCarol_bal(scEnv, scCarol);
+                Balance const scCarol_bal(scEnv, scCarol);
 
                 scEnv.tx(xchain_claim(scAlice, jvb, claimID, amt, scCarol)).close();
                 BEAST_EXPECT(scCarol_bal.diff() == amt);
@@ -3095,7 +3095,7 @@ struct XChain_test : public beast::unit_test::suite, public jtx::XChainBridgeObj
                     .tx(fset("scBob", 0, asfRequireDest))  // clear dest tag
                     .close();
 
-                Balance scBob_bal(scEnv, scBob);
+                Balance const scBob_bal(scEnv, scBob);
 
                 scEnv.tx(txns.back()).close();
                 BEAST_EXPECT(scBob_bal.diff() == amt);
@@ -3126,7 +3126,7 @@ struct XChain_test : public beast::unit_test::suite, public jtx::XChainBridgeObj
 
             // we should be able to submit the attestations, but the transfer
             // should not occur because dest account has deposit auth set
-            Balance scBob_bal(scEnv, scBob);
+            Balance const scBob_bal(scEnv, scBob);
 
             scEnv.multiTx(claim_attestations(
                 scAttester, jvb, mcAlice, amt, payees, true, claimID, dst, signers));
@@ -3134,7 +3134,7 @@ struct XChain_test : public beast::unit_test::suite, public jtx::XChainBridgeObj
 
             // Check that check that we still can use the claimID to transfer
             // the amount to a different account
-            Balance scCarol_bal(scEnv, scCarol);
+            Balance const scCarol_bal(scEnv, scCarol);
 
             scEnv.tx(xchain_claim(scAlice, jvb, claimID, amt, scCarol)).close();
             BEAST_EXPECT(scCarol_bal.diff() == amt);
@@ -3213,7 +3213,7 @@ struct XChain_test : public beast::unit_test::suite, public jtx::XChainBridgeObj
                 &payees[0],
                 UT_XCHAIN_DEFAULT_QUORUM,
                 withClaim);
-            Balance scAlice_bal(scEnv, scAlice);
+            Balance const scAlice_bal(scEnv, scAlice);
             scEnv.multiTx(claim_attestations(
                 scAttester, jvb, mcAlice, amt, payees, true, claimID, dst, signers));
 
@@ -3261,7 +3261,7 @@ struct XChain_test : public beast::unit_test::suite, public jtx::XChainBridgeObj
                 &payees[0],
                 UT_XCHAIN_DEFAULT_QUORUM,
                 withClaim);
-            Balance scAlice_bal(scEnv, scAlice);
+            Balance const scAlice_bal(scEnv, scAlice);
             scEnv.multiTx(claim_attestations(
                 scAttester, jvb, mcAlice, amt, payees, true, claimID, dst, signers));
             STAmount claim_cost = tiny_reward;
@@ -3350,7 +3350,7 @@ struct XChain_test : public beast::unit_test::suite, public jtx::XChainBridgeObj
             mcEnv.tx(xchain_commit(mcAlice, jvb, claimID, amt, dst)).close();
 
             // balance of last signer should not change (has deposit auth)
-            Balance last_signer(scEnv, unpaid);
+            Balance const last_signer(scEnv, unpaid);
 
             // make sure all signers except the last one get the
             // split_reward
@@ -3414,7 +3414,7 @@ struct XChain_test : public beast::unit_test::suite, public jtx::XChainBridgeObj
         using namespace jtx;
 
         testcase("Bridge Create Account");
-        XRPAmount tx_fee = txFee();
+        XRPAmount const tx_fee = txFee();
 
         // coverage test: transferHelper() - dst == src
         {
@@ -3427,7 +3427,7 @@ struct XChain_test : public beast::unit_test::suite, public jtx::XChainBridgeObj
                 .tx(jtx::signers(Account::master, quorum, signers))
                 .close();
 
-            Balance door(scEnv, Account::master);
+            Balance const door(scEnv, Account::master);
 
             // scEnv.tx(att_create_acct_batch1(1, amt,
             // Account::master)).close();
@@ -3451,8 +3451,8 @@ struct XChain_test : public beast::unit_test::suite, public jtx::XChainBridgeObj
 
             mcEnv.tx(create_bridge(mcDoor, jvb, XRP(1), XRP(20))).close();
 
-            Balance door(mcEnv, mcDoor);
-            Balance carol(mcEnv, mcCarol);
+            Balance const door(mcEnv, mcDoor);
+            Balance const carol(mcEnv, mcCarol);
 
             mcEnv
                 .tx(sidechain_xchain_account_create(mcCarol, jvb, scuAlice, XRP(19), reward),
@@ -3469,7 +3469,7 @@ struct XChain_test : public beast::unit_test::suite, public jtx::XChainBridgeObj
 
             mcEnv.tx(create_bridge(mcDoor, jvb, XRP(1), XRP(20))).close();
 
-            Balance door(mcEnv, mcDoor);
+            Balance const door(mcEnv, mcDoor);
 
             mcEnv
                 .tx(sidechain_xchain_account_create(mcCarol, jvb, scuAlice, XRP(20), reward),
@@ -3487,7 +3487,7 @@ struct XChain_test : public beast::unit_test::suite, public jtx::XChainBridgeObj
 
             mcEnv.tx(create_bridge(mcDoor, jvb, XRP(1), XRP(20))).close();
 
-            Balance door(mcEnv, mcDoor);
+            Balance const door(mcEnv, mcDoor);
 
             mcEnv.disableFeature(featureXChainBridge)
                 .tx(sidechain_xchain_account_create(mcCarol, jvb, scuAlice, XRP(20), reward),
@@ -3503,7 +3503,7 @@ struct XChain_test : public beast::unit_test::suite, public jtx::XChainBridgeObj
 
             mcEnv.tx(create_bridge(mcDoor, jvb, XRP(1), XRP(20))).close();
 
-            Balance door(mcEnv, mcDoor);
+            Balance const door(mcEnv, mcDoor);
 
             mcEnv
                 .tx(sidechain_xchain_account_create(mcCarol, jvb, scuAlice, XRP(-20), reward),
@@ -3519,7 +3519,7 @@ struct XChain_test : public beast::unit_test::suite, public jtx::XChainBridgeObj
 
             mcEnv.tx(create_bridge(mcDoor, jvb, XRP(1), XRP(20))).close();
 
-            Balance door(mcEnv, mcDoor);
+            Balance const door(mcEnv, mcDoor);
 
             mcEnv
                 .tx(sidechain_xchain_account_create(mcCarol, jvb, scuAlice, XRP(20), XRP(-1)),
@@ -3535,7 +3535,7 @@ struct XChain_test : public beast::unit_test::suite, public jtx::XChainBridgeObj
 
             mcEnv.tx(create_bridge(mcDoor, jvb, XRP(1), XRP(20))).close();
 
-            Balance door(mcEnv, mcDoor);
+            Balance const door(mcEnv, mcDoor);
 
             mcEnv
                 .tx(sidechain_xchain_account_create(mcDoor, jvb, scuAlice, XRP(20), XRP(1)),
@@ -3551,7 +3551,7 @@ struct XChain_test : public beast::unit_test::suite, public jtx::XChainBridgeObj
 
             mcEnv.tx(create_bridge(mcDoor, jvb, XRP(1), XRP(20))).close();
 
-            Balance door(mcEnv, mcDoor);
+            Balance const door(mcEnv, mcDoor);
 
             mcEnv
                 .tx(sidechain_xchain_account_create(mcCarol, jvb, scuAlice, XRP(20), XRP(2)),
@@ -3566,8 +3566,8 @@ struct XChain_test : public beast::unit_test::suite, public jtx::XChainBridgeObj
     testFeeDipsIntoReserve()
     {
         using namespace jtx;
-        XRPAmount res0 = reserve(0);
-        XRPAmount tx_fee = txFee();
+        XRPAmount const res0 = reserve(0);
+        XRPAmount const tx_fee = txFee();
 
         testcase("Fee dips into reserve");
 
@@ -3660,7 +3660,7 @@ struct XChain_test : public beast::unit_test::suite, public jtx::XChainBridgeObj
             // Create a bridge and add an attestation with a bad public key
             XEnv scEnv(*this, true);
             std::uint32_t const claimID = 1;
-            std::optional<Account> dst{scBob};
+            std::optional<Account> const dst{scBob};
             auto const amt = XRP(1000);
             scEnv.tx(create_bridge(Account::master, jvb))
                 .tx(jtx::signers(Account::master, quorum, signers))
@@ -3689,7 +3689,7 @@ struct XChain_test : public beast::unit_test::suite, public jtx::XChainBridgeObj
             // public key
             XEnv scEnv(*this, true);
             std::uint32_t const createCount = 1;
-            Account dst{scBob};
+            Account const dst{scBob};
             auto const amt = XRP(1000);
             auto const rewardAmt = XRP(1);
             scEnv.tx(create_bridge(Account::master, jvb))
@@ -3789,8 +3789,8 @@ private:
         bool
         verify(ENV& env, jtx::Account const& acct) const
         {
-            STAmount diff{env.balance(acct) - startAmount};
-            bool check = diff == expectedDiff;
+            STAmount const diff{env.balance(acct) - startAmount};
+            bool const check = diff == expectedDiff;
             return check;
         }
     };
@@ -4093,7 +4093,7 @@ private:
             size_t i = 0;
             for (i = 0; i < num_signers; ++i)
             {
-                size_t signer_idx = (rnd + i) % num_signers;
+                size_t const signer_idx = (rnd + i) % num_signers;
 
                 if (!(cr.attested[signer_idx]))
                 {
@@ -4251,7 +4251,7 @@ private:
             // check all signers, but start at a random one
             for (size_t i = 0; i < num_signers; ++i)
             {
-                size_t signer_idx = (rnd + i) % num_signers;
+                size_t const signer_idx = (rnd + i) % num_signers;
                 if (!(xfer.attested[signer_idx]))
                 {
                     // enqueue one attestation for this signer
@@ -4275,7 +4275,7 @@ private:
             }
 
             // return true if quorum was reached, false otherwise
-            bool quorum =
+            bool const quorum =
                 std::count(xfer.attested.begin(), xfer.attested.end(), true) >= bridge_.quorum;
             if (quorum && xfer.with_claim == WithClaim::no)
             {
@@ -4380,7 +4380,7 @@ public:
             for (auto it = sm_.begin(); it != sm_.end();)
             {
                 auto vis = [&](auto& sm) {
-                    uint32_t rnd = distrib(gen);
+                    uint32_t const rnd = distrib(gen);
                     return sm.advance(time, rnd);
                 };
                 auto& [t, sm] = *it;
@@ -4446,14 +4446,14 @@ public:
 
         for (auto& acct : a)
         {
-            STAmount amt{XRP(100000)};
+            STAmount const amt{XRP(100000)};
 
             mcEnv.fund(amt, acct);
             scEnv.fund(amt, acct);
         }
-        Account USDLocking{"USDLocking"};
-        IOU usdLocking{USDLocking["USD"]};
-        IOU usdIssuing{doorUSDIssuing["USD"]};
+        Account const USDLocking{"USDLocking"};
+        IOU const usdLocking{USDLocking["USD"]};
+        IOU const usdIssuing{doorUSDIssuing["USD"]};
 
         mcEnv.fund(XRP(100000), USDLocking);
         mcEnv.close();
diff --git a/src/test/app/tx/apply_test.cpp b/src/test/app/tx/apply_test.cpp
index 10b0544f49..6d3efea5f3 100644
--- a/src/test/app/tx/apply_test.cpp
+++ b/src/test/app/tx/apply_test.cpp
@@ -37,7 +37,7 @@ public:
         {
             test::jtx::Env fully_canonical(*this, test::jtx::testable_amendments());
 
-            Validity valid =
+            Validity const valid =
                 checkValidity(
                     fully_canonical.app().getHashRouter(), tx, fully_canonical.current()->rules())
                     .first;
diff --git a/src/test/basics/Buffer_test.cpp b/src/test/basics/Buffer_test.cpp
index a329e527ba..95a8853975 100644
--- a/src/test/basics/Buffer_test.cpp
+++ b/src/test/basics/Buffer_test.cpp
@@ -26,7 +26,7 @@ struct Buffer_test : beast::unit_test::suite
                                      0xac, 0x2d, 0x89, 0x4d, 0x19, 0x9c, 0xf0, 0x2c,
                                      0x15, 0xd1, 0xf9, 0x9b, 0x66, 0xd2, 0x30, 0xd3};
 
-        Buffer b0;
+        Buffer const b0;
         BEAST_EXPECT(sane(b0));
         BEAST_EXPECT(b0.empty());
 
@@ -105,7 +105,7 @@ struct Buffer_test : beast::unit_test::suite
 
             {  // Move-construct from empty buf
                 Buffer x;
-                Buffer y{std::move(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));
@@ -115,7 +115,7 @@ struct Buffer_test : beast::unit_test::suite
 
             {  // Move-construct from non-empty buf
                 Buffer x{b1};
-                Buffer y{std::move(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));
diff --git a/src/test/basics/Expected_test.cpp b/src/test/basics/Expected_test.cpp
index 2caa15816f..fa35946624 100644
--- a/src/test/basics/Expected_test.cpp
+++ b/src/test/basics/Expected_test.cpp
@@ -46,7 +46,7 @@ struct Expected_test : beast::unit_test::suite
             BEAST_EXPECT(expected.value() == "Valid value");
             BEAST_EXPECT(*expected == "Valid value");
             BEAST_EXPECT(expected->at(0) == 'V');
-            std::string mv = std::move(*expected);
+            std::string const mv = std::move(*expected);
             BEAST_EXPECT(mv == "Valid value");
 
             bool throwOccurred = false;
diff --git a/src/test/basics/FileUtilities_test.cpp b/src/test/basics/FileUtilities_test.cpp
index 3d6f9b754b..b63f8baf0a 100644
--- a/src/test/basics/FileUtilities_test.cpp
+++ b/src/test/basics/FileUtilities_test.cpp
@@ -17,7 +17,7 @@ public:
 
         constexpr char const* expectedContents = "This file is very short. That's all we need.";
 
-        FileDirGuard file(
+        FileDirGuard const file(
             *this, "test_file", "test.txt", "This is temporary text that should get overwritten");
 
         error_code ec;
diff --git a/src/test/basics/IOUAmount_test.cpp b/src/test/basics/IOUAmount_test.cpp
index 73ab0343cd..d0e272c28b 100644
--- a/src/test/basics/IOUAmount_test.cpp
+++ b/src/test/basics/IOUAmount_test.cpp
@@ -55,7 +55,7 @@ public:
         using beast::zero;
 
         {
-            IOUAmount z(zero);
+            IOUAmount const z(zero);
             BEAST_EXPECT(z == zero);
             BEAST_EXPECT(z >= zero);
             BEAST_EXPECT(z <= zero);
@@ -94,9 +94,11 @@ public:
         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);
@@ -150,7 +152,7 @@ public:
 
         for (auto const mantissaSize : {MantissaRange::small, MantissaRange::large})
         {
-            NumberMantissaScaleGuard mg(mantissaSize);
+            NumberMantissaScaleGuard const mg(mantissaSize);
 
             test(IOUAmount(-2, 0), "-2");
             test(IOUAmount(0, 0), "0");
@@ -181,14 +183,14 @@ public:
         {
             // multiply by a number that would overflow the mantissa, then
             // divide by the same number, and check we didn't lose any value
-            IOUAmount bigMan(maxMantissa, 0);
+            IOUAmount const bigMan(maxMantissa, 0);
             BEAST_EXPECT(bigMan == mulRatio(bigMan, maxUInt, maxUInt, true));
             // rounding mode shouldn't matter as the result is exact
             BEAST_EXPECT(bigMan == mulRatio(bigMan, maxUInt, maxUInt, false));
         }
         {
             // Similar test as above, but for negative values
-            IOUAmount bigMan(-maxMantissa, 0);
+            IOUAmount const bigMan(-maxMantissa, 0);
             BEAST_EXPECT(bigMan == mulRatio(bigMan, maxUInt, maxUInt, true));
             // rounding mode shouldn't matter as the result is exact
             BEAST_EXPECT(bigMan == mulRatio(bigMan, maxUInt, maxUInt, false));
@@ -196,7 +198,7 @@ public:
 
         {
             // small amounts
-            IOUAmount tiny(minMantissa, minExponent);
+            IOUAmount const tiny(minMantissa, minExponent);
             // Round up should give the smallest allowable number
             BEAST_EXPECT(tiny == mulRatio(tiny, 1, maxUInt, true));
             BEAST_EXPECT(tiny == mulRatio(tiny, maxUInt - 1, maxUInt, true));
@@ -205,7 +207,7 @@ public:
             BEAST_EXPECT(beast::zero == mulRatio(tiny, maxUInt - 1, maxUInt, false));
 
             // tiny negative numbers
-            IOUAmount tinyNeg(-minMantissa, minExponent);
+            IOUAmount const tinyNeg(-minMantissa, minExponent);
             // Round up should give zero
             BEAST_EXPECT(beast::zero == mulRatio(tinyNeg, 1, maxUInt, true));
             BEAST_EXPECT(beast::zero == mulRatio(tinyNeg, maxUInt - 1, maxUInt, true));
@@ -216,20 +218,20 @@ public:
 
         {  // rounding
             {
-                IOUAmount one(1, 0);
+                IOUAmount const one(1, 0);
                 auto const rup = mulRatio(one, maxUInt - 1, maxUInt, true);
                 auto const rdown = mulRatio(one, maxUInt - 1, maxUInt, false);
                 BEAST_EXPECT(rup.mantissa() - rdown.mantissa() == 1);
             }
             {
-                IOUAmount big(maxMantissa, maxExponent);
+                IOUAmount const big(maxMantissa, maxExponent);
                 auto const rup = mulRatio(big, maxUInt - 1, maxUInt, true);
                 auto const rdown = mulRatio(big, maxUInt - 1, maxUInt, false);
                 BEAST_EXPECT(rup.mantissa() - rdown.mantissa() == 1);
             }
 
             {
-                IOUAmount negOne(-1, 0);
+                IOUAmount const negOne(-1, 0);
                 auto const rup = mulRatio(negOne, maxUInt - 1, maxUInt, true);
                 auto const rdown = mulRatio(negOne, maxUInt - 1, maxUInt, false);
                 BEAST_EXPECT(rup.mantissa() - rdown.mantissa() == 1);
diff --git a/src/test/basics/IntrusiveShared_test.cpp b/src/test/basics/IntrusiveShared_test.cpp
index 41ecf9a7a4..52cb8f5c1c 100644
--- a/src/test/basics/IntrusiveShared_test.cpp
+++ b/src/test/basics/IntrusiveShared_test.cpp
@@ -191,16 +191,16 @@ public:
         testcase("Basics");
 
         {
-            TIBase::ResetStatesGuard rsg{true};
+            TIBase::ResetStatesGuard const rsg{true};
 
-            TIBase b;
+            TIBase const b;
             BEAST_EXPECT(b.use_count() == 1);
             b.addWeakRef();
             BEAST_EXPECT(b.use_count() == 1);
             auto s = b.releaseStrongRef();
             BEAST_EXPECT(s == ReleaseStrongRefAction::partialDestroy);
             BEAST_EXPECT(b.use_count() == 0);
-            TIBase* pb = &b;
+            TIBase const* pb = &b;
             partialDestructorFinished(&pb);
             BEAST_EXPECT(!pb);
             auto w = b.releaseWeakRef();
@@ -210,7 +210,7 @@ public:
         std::vector<SharedIntrusive<TIBase>> strong;
         std::vector<WeakIntrusive<TIBase>> weak;
         {
-            TIBase::ResetStatesGuard rsg{true};
+            TIBase::ResetStatesGuard const rsg{true};
 
             using enum TrackedState;
             auto b = make_SharedIntrusive<TIBase>();
@@ -251,7 +251,7 @@ public:
             BEAST_EXPECT(TIBase::getState(id) == deleted);
         }
         {
-            TIBase::ResetStatesGuard rsg{true};
+            TIBase::ResetStatesGuard const rsg{true};
 
             using enum TrackedState;
             auto b = make_SharedIntrusive<TIBase>();
@@ -275,7 +275,7 @@ public:
             BEAST_EXPECT(TIBase::getState(id) == deleted);
         }
         {
-            TIBase::ResetStatesGuard rsg{true};
+            TIBase::ResetStatesGuard const rsg{true};
 
             using enum TrackedState;
             using swu = SharedWeakUnion<TIBase>;
@@ -309,7 +309,7 @@ public:
         {
             // Testing SharedWeakUnion assignment operator
 
-            TIBase::ResetStatesGuard rsg{true};
+            TIBase::ResetStatesGuard const rsg{true};
 
             auto strong1 = make_SharedIntrusive<TIBase>();
             auto strong2 = make_SharedIntrusive<TIBase>();
@@ -338,7 +338,7 @@ public:
             // 2) Test self-assignment
             BEAST_EXPECT(union1.isStrong());
             BEAST_EXPECT(TIBase::getState(id1) == TrackedState::alive);
-            int initialRefCount = strong1->use_count();
+            int const initialRefCount = strong1->use_count();
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wself-assign-overloaded"
             union1 = union1;  // Self-assignment
@@ -374,7 +374,7 @@ public:
 
         using enum TrackedState;
 
-        TIBase::ResetStatesGuard rsg{true};
+        TIBase::ResetStatesGuard const rsg{true};
 
         auto strong = make_SharedIntrusive<TIBase>();
         WeakIntrusive<TIBase> weak{strong};
@@ -441,7 +441,7 @@ public:
 
         using enum TrackedState;
 
-        TIBase::ResetStatesGuard rsg{true};
+        TIBase::ResetStatesGuard const rsg{true};
 
         auto strong = make_SharedIntrusive<TIBase>();
         WeakIntrusive<TIBase> weak{strong};
@@ -486,12 +486,12 @@ public:
         // and check that the invariants hold.
 
         using enum TrackedState;
-        TIBase::ResetStatesGuard rsg{true};
+        TIBase::ResetStatesGuard const rsg{true};
 
         std::atomic<int> destructionState{0};
         // returns destructorRan and partialDestructorRan (in that order)
         auto getDestructorState = [&]() -> std::pair<bool, bool> {
-            int s = destructionState.load(std::memory_order_relaxed);
+            int const s = destructionState.load(std::memory_order_relaxed);
             return {(s & 1) != 0, (s & 2) != 0};
         };
         auto setDestructorRan = [&]() -> void {
@@ -620,12 +620,12 @@ public:
 
         using enum TrackedState;
 
-        TIBase::ResetStatesGuard rsg{true};
+        TIBase::ResetStatesGuard const rsg{true};
 
         std::atomic<int> destructionState{0};
         // returns destructorRan and partialDestructorRan (in that order)
         auto getDestructorState = [&]() -> std::pair<bool, bool> {
-            int s = destructionState.load(std::memory_order_relaxed);
+            int const s = destructionState.load(std::memory_order_relaxed);
             return {(s & 1) != 0, (s & 2) != 0};
         };
         auto setDestructorRan = [&]() -> void {
@@ -761,12 +761,12 @@ public:
 
         using enum TrackedState;
 
-        TIBase::ResetStatesGuard rsg{true};
+        TIBase::ResetStatesGuard const rsg{true};
 
         std::atomic<int> destructionState{0};
         // returns destructorRan and partialDestructorRan (in that order)
         auto getDestructorState = [&]() -> std::pair<bool, bool> {
-            int s = destructionState.load(std::memory_order_relaxed);
+            int const s = destructionState.load(std::memory_order_relaxed);
             return {(s & 1) != 0, (s & 2) != 0};
         };
         auto setDestructorRan = [&]() -> void {
@@ -832,7 +832,7 @@ public:
 
                 // Multiple threads all create a weak pointer from the same
                 // strong pointer
-                WeakIntrusive weak{toLock[threadId]};
+                WeakIntrusive const weak{toLock[threadId]};
                 for (int wi = 0; wi < lockWeakLoopIters; ++wi)
                 {
                     BEAST_EXPECT(!weak.expired());
diff --git a/src/test/basics/Number_test.cpp b/src/test/basics/Number_test.cpp
index 4676884660..856b379533 100644
--- a/src/test/basics/Number_test.cpp
+++ b/src/test/basics/Number_test.cpp
@@ -37,7 +37,8 @@ public:
         auto const minMantissa = Number::minMantissa();
         try
         {
-            Number x = Number{false, minMantissa * 10, 32768, Number::normalized{}};
+            [[maybe_unused]] Number const x =
+                Number{false, minMantissa * 10, 32768, Number::normalized{}};
         }
         catch (std::overflow_error const&)
         {
@@ -86,7 +87,7 @@ public:
         try
         {
             [[maybe_unused]]
-            Number q = Number{false, minMantissa, 32767, Number::normalized{}} * 100;
+            Number const q = Number{false, minMantissa, 32767, Number::normalized{}} * 100;
         }
         catch (std::overflow_error const&)
         {
@@ -332,7 +333,7 @@ public:
         };
         auto const maxMantissa = Number::maxMantissa();
 
-        saveNumberRoundMode save{Number::setround(Number::to_nearest)};
+        saveNumberRoundMode const save{Number::setround(Number::to_nearest)};
         {
             auto const cSmall = std::to_array<Case>({
                 {Number{7}, Number{8}, Number{56}},
@@ -642,7 +643,7 @@ public:
                 test(cLarge);
             }
         };
-        saveNumberRoundMode save{Number::setround(Number::to_nearest)};
+        saveNumberRoundMode const save{Number::setround(Number::to_nearest)};
         {
             auto const cSmall = std::to_array<Case>(
                 {{Number{1}, Number{2}, Number{5, -1}},
@@ -857,7 +858,7 @@ public:
         test(cSmall);
         if (Number::getMantissaScale() != MantissaRange::small)
         {
-            NumberRoundModeGuard mg(Number::towards_zero);
+            NumberRoundModeGuard const mg(Number::towards_zero);
             test(cLarge);
         }
         bool caught = false;
@@ -928,7 +929,7 @@ public:
     {
         testcase << "test_power1 " << to_string(Number::getMantissaScale());
         using Case = std::tuple<Number, unsigned, Number>;
-        Case c[]{
+        Case const c[]{
             {Number{64}, 0, Number{1}},
             {Number{64}, 1, Number{64}},
             {Number{64}, 2, Number{4096}},
@@ -946,7 +947,7 @@ public:
     {
         testcase << "test_power2 " << to_string(Number::getMantissaScale());
         using Case = std::tuple<Number, unsigned, unsigned, Number>;
-        Case c[]{
+        Case const c[]{
             {Number{1}, 3, 7, Number{1}},
             {Number{-1}, 1, 0, Number{1}},
             {Number{-1, -1}, 1, 0, Number{0}},
@@ -992,24 +993,24 @@ public:
     {
         testcase << "testConversions " << to_string(Number::getMantissaScale());
 
-        IOUAmount x{5, 6};
-        Number y = x;
+        IOUAmount const x{5, 6};
+        Number const y = x;
         BEAST_EXPECT((y == Number{5, 6}));
-        IOUAmount z{y};
+        IOUAmount const z{y};
         BEAST_EXPECT(x == z);
-        XRPAmount xrp{500};
-        STAmount st = xrp;
-        Number n = st;
+        XRPAmount const xrp{500};
+        STAmount const st = xrp;
+        Number const n = st;
         BEAST_EXPECT(XRPAmount{n} == xrp);
-        IOUAmount x0{0, 0};
-        Number y0 = x0;
+        IOUAmount const x0{0, 0};
+        Number const y0 = x0;
         BEAST_EXPECT((y0 == Number{0}));
-        IOUAmount z0{y0};
+        IOUAmount const z0{y0};
         BEAST_EXPECT(x0 == z0);
-        XRPAmount xrp0{0};
-        Number n0 = xrp0;
+        XRPAmount const xrp0{0};
+        Number const n0 = xrp0;
         BEAST_EXPECT(n0 == Number{0});
-        XRPAmount xrp1{n0};
+        XRPAmount const xrp1{n0};
         BEAST_EXPECT(xrp1 == xrp0);
     }
 
@@ -1018,9 +1019,9 @@ public:
     {
         testcase << "test_to_integer " << to_string(Number::getMantissaScale());
         using Case = std::tuple<Number, std::int64_t>;
-        saveNumberRoundMode save{Number::setround(Number::to_nearest)};
+        saveNumberRoundMode const save{Number::setround(Number::to_nearest)};
         {
-            Case c[]{
+            Case const c[]{
                 {Number{0}, 0},
                 {Number{1}, 1},
                 {Number{2}, 2},
@@ -1058,7 +1059,7 @@ public:
         auto prev_mode = Number::setround(Number::towards_zero);
         BEAST_EXPECT(prev_mode == Number::to_nearest);
         {
-            Case c[]{
+            Case const c[]{
                 {Number{0}, 0},
                 {Number{1}, 1},
                 {Number{2}, 2},
@@ -1096,7 +1097,7 @@ public:
         prev_mode = Number::setround(Number::downward);
         BEAST_EXPECT(prev_mode == Number::towards_zero);
         {
-            Case c[]{
+            Case const c[]{
                 {Number{0}, 0},
                 {Number{1}, 1},
                 {Number{2}, 2},
@@ -1134,7 +1135,7 @@ public:
         prev_mode = Number::setround(Number::upward);
         BEAST_EXPECT(prev_mode == Number::downward);
         {
-            Case c[]{
+            Case const c[]{
                 {Number{0}, 0},
                 {Number{1}, 1},
                 {Number{2}, 2},
@@ -1185,7 +1186,7 @@ public:
     test_squelch()
     {
         testcase << "test_squelch " << to_string(Number::getMantissaScale());
-        Number limit{1, -6};
+        Number const limit{1, -6};
         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}));
@@ -1233,7 +1234,7 @@ public:
                 test(Number::max(), "9999999999999999e32768");
                 test(Number::lowest(), "-9999999999999999e32768");
                 {
-                    NumberRoundModeGuard mg(Number::towards_zero);
+                    NumberRoundModeGuard const mg(Number::towards_zero);
 
                     auto const maxMantissa = Number::maxMantissa();
                     BEAST_EXPECT(maxMantissa == 9'999'999'999'999'999);
@@ -1263,7 +1264,7 @@ public:
                 test(Number::max(), "9223372036854775807e32768");
                 test(Number::lowest(), "-9223372036854775807e32768");
                 {
-                    NumberRoundModeGuard mg(Number::towards_zero);
+                    NumberRoundModeGuard const mg(Number::towards_zero);
 
                     auto const maxMantissa = Number::maxMantissa();
                     BEAST_EXPECT(maxMantissa == 9'999'999'999'999'999'999ULL);
@@ -1314,7 +1315,7 @@ public:
     test_stream()
     {
         testcase << "test_stream " << to_string(Number::getMantissaScale());
-        Number x{100};
+        Number const x{100};
         std::ostringstream os;
         os << x;
         BEAST_EXPECT(os.str() == to_string(x));
@@ -1325,7 +1326,7 @@ public:
     {
         testcase << "test_inc_dec " << to_string(Number::getMantissaScale());
         Number x{100};
-        Number y = +x;
+        Number const y = +x;
         BEAST_EXPECT(x == y);
         BEAST_EXPECT(x++ == y);
         BEAST_EXPECT(x == Number{101});
@@ -1336,7 +1337,7 @@ public:
     void
     test_toSTAmount()
     {
-        NumberSO stNumberSO{true};
+        NumberSO const stNumberSO{true};
         Issue const issue;
         Number const n{7'518'783'80596, -5};
         saveNumberRoundMode const save{Number::setround(Number::to_nearest)};
@@ -1478,7 +1479,7 @@ public:
         {
             for (auto const& [mode, val] : roundings)
             {
-                NumberRoundModeGuard g{mode};
+                NumberRoundModeGuard const g{mode};
                 auto const res = static_cast<std::int64_t>(num);
                 BEAST_EXPECTS(
                     res == val,
@@ -1496,7 +1497,7 @@ public:
 
         // Control case
         BEAST_EXPECT(Number::maxMantissa() > 10);
-        Number ten{10};
+        Number const ten{10};
         BEAST_EXPECT(ten.exponent() <= 0);
 
         if (scale == MantissaRange::small)
@@ -1528,7 +1529,7 @@ public:
             // 85'070'591'730'234'615'847'396'907'784'232'501'249 - 38 digits
             BEAST_EXPECT((power(maxInt64, 2) == Number{85'070'591'730'234'615'85, 19}));
 
-            NumberRoundModeGuard mg(Number::towards_zero);
+            NumberRoundModeGuard const mg(Number::towards_zero);
 
             auto const maxMantissa = Number::maxMantissa();
             Number const max = Number{false, maxMantissa, 0, Number::normalized{}};
@@ -1546,7 +1547,7 @@ public:
     {
         for (auto const scale : {MantissaRange::small, MantissaRange::large})
         {
-            NumberMantissaScaleGuard sg(scale);
+            NumberMantissaScaleGuard const sg(scale);
             testZero();
             test_limits();
             testToString();
diff --git a/src/test/basics/StringUtilities_test.cpp b/src/test/basics/StringUtilities_test.cpp
index 78719e47c6..fb7cdb3d69 100644
--- a/src/test/basics/StringUtilities_test.cpp
+++ b/src/test/basics/StringUtilities_test.cpp
@@ -279,7 +279,7 @@ public:
         }
 
         {
-            std::string strUrl("s://" + std::string(8192, ':'));
+            std::string const strUrl("s://" + std::string(8192, ':'));
             parsedURL pUrl;
             BEAST_EXPECT(!parseUrl(pUrl, strUrl));
         }
diff --git a/src/test/basics/Units_test.cpp b/src/test/basics/Units_test.cpp
index 9693c6d181..6bb7f400cc 100644
--- a/src/test/basics/Units_test.cpp
+++ b/src/test/basics/Units_test.cpp
@@ -14,7 +14,7 @@ private:
         using FeeLevel32 = FeeLevel<std::uint32_t>;
 
         {
-            XRPAmount x{100};
+            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;
@@ -25,8 +25,8 @@ private:
             BEAST_EXPECT(z.value() == 1600);
             BEAST_EXPECT((std::is_same_v<decltype(z)::unit_type, unit::dropTag>));
 
-            FeeLevel32 f{10};
-            FeeLevel32 baseFee{100};
+            FeeLevel32 const f{10};
+            FeeLevel32 const baseFee{100};
 
             auto drops = mulDiv(baseFee, x, f);
 
@@ -39,15 +39,15 @@ private:
             BEAST_EXPECT((std::is_same_v<std::remove_reference_t<decltype(*drops)>, XRPAmount>));
         }
         {
-            XRPAmount x{100};
+            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 f{10};
-            FeeLevel64 baseFee{100};
+            FeeLevel64 const f{10};
+            FeeLevel64 const baseFee{100};
 
             auto drops = mulDiv(baseFee, x, f);
 
@@ -59,16 +59,16 @@ private:
             BEAST_EXPECT((std::is_same_v<std::remove_reference_t<decltype(*drops)>, XRPAmount>));
         }
         {
-            FeeLevel64 x{1024};
+            FeeLevel64 const x{1024};
             BEAST_EXPECT(x.value() == 1024);
             BEAST_EXPECT((std::is_same_v<decltype(x)::unit_type, unit::feelevelTag>));
-            std::uint64_t m = 4;
+            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 basefee{10};
-            FeeLevel64 referencefee{256};
+            XRPAmount const basefee{10};
+            FeeLevel64 const referencefee{256};
 
             auto drops = mulDiv(x, basefee, referencefee);
 
@@ -88,56 +88,56 @@ private:
         using FeeLevel32 = FeeLevel<std::uint32_t>;
 
         {
-            FeeLevel32 x{std::numeric_limits<std::uint32_t>::max()};
+            FeeLevel32 const x{std::numeric_limits<std::uint32_t>::max()};
             auto y = x.jsonClipped();
             BEAST_EXPECT(y.type() == Json::uintValue);
             BEAST_EXPECT(y == Json::Value{x.fee()});
         }
 
         {
-            FeeLevel32 x{std::numeric_limits<std::uint32_t>::min()};
+            FeeLevel32 const x{std::numeric_limits<std::uint32_t>::min()};
             auto y = x.jsonClipped();
             BEAST_EXPECT(y.type() == Json::uintValue);
             BEAST_EXPECT(y == Json::Value{x.fee()});
         }
 
         {
-            FeeLevel64 x{std::numeric_limits<std::uint64_t>::max()};
+            FeeLevel64 const x{std::numeric_limits<std::uint64_t>::max()};
             auto y = x.jsonClipped();
             BEAST_EXPECT(y.type() == Json::uintValue);
             BEAST_EXPECT(y == Json::Value{std::numeric_limits<std::uint32_t>::max()});
         }
 
         {
-            FeeLevel64 x{std::numeric_limits<std::uint64_t>::min()};
+            FeeLevel64 const x{std::numeric_limits<std::uint64_t>::min()};
             auto y = x.jsonClipped();
             BEAST_EXPECT(y.type() == Json::uintValue);
             BEAST_EXPECT(y == Json::Value{0});
         }
 
         {
-            FeeLevelDouble x{std::numeric_limits<double>::max()};
+            FeeLevelDouble const x{std::numeric_limits<double>::max()};
             auto y = x.jsonClipped();
             BEAST_EXPECT(y.type() == Json::realValue);
             BEAST_EXPECT(y == Json::Value{std::numeric_limits<double>::max()});
         }
 
         {
-            FeeLevelDouble x{std::numeric_limits<double>::min()};
+            FeeLevelDouble const x{std::numeric_limits<double>::min()};
             auto y = x.jsonClipped();
             BEAST_EXPECT(y.type() == Json::realValue);
             BEAST_EXPECT(y == Json::Value{std::numeric_limits<double>::min()});
         }
 
         {
-            XRPAmount x{std::numeric_limits<std::int64_t>::max()};
+            XRPAmount const x{std::numeric_limits<std::int64_t>::max()};
             auto y = x.jsonClipped();
             BEAST_EXPECT(y.type() == Json::intValue);
             BEAST_EXPECT(y == Json::Value{std::numeric_limits<std::int32_t>::max()});
         }
 
         {
-            XRPAmount x{std::numeric_limits<std::int64_t>::min()};
+            XRPAmount const x{std::numeric_limits<std::int64_t>::min()};
             auto y = x.jsonClipped();
             BEAST_EXPECT(y.type() == Json::intValue);
             BEAST_EXPECT(y == Json::Value{std::numeric_limits<std::int32_t>::min()});
@@ -156,7 +156,7 @@ private:
             auto explicitmake = [&](auto x) -> FeeLevel64 { return FeeLevel64{x}; };
 
             [[maybe_unused]]
-            FeeLevel64 defaulted;
+            FeeLevel64 const defaulted{};
             FeeLevel64 test{0};
             BEAST_EXPECT(test.fee() == 0);
 
@@ -241,7 +241,7 @@ private:
             auto explicitmake = [&](auto x) -> FeeLevelDouble { return FeeLevelDouble{x}; };
 
             [[maybe_unused]]
-            FeeLevelDouble defaulted;
+            FeeLevelDouble const defaulted{};
             FeeLevelDouble test{0};
             BEAST_EXPECT(test.fee() == 0);
 
diff --git a/src/test/basics/XRPAmount_test.cpp b/src/test/basics/XRPAmount_test.cpp
index 58b15b5d2d..ad81050558 100644
--- a/src/test/basics/XRPAmount_test.cpp
+++ b/src/test/basics/XRPAmount_test.cpp
@@ -127,7 +127,7 @@ public:
         // since some of them are templated, but not used anywhere else.
         auto make = [&](auto x) -> XRPAmount { return XRPAmount{x}; };
 
-        XRPAmount defaulted{};
+        XRPAmount const defaulted{};
         (void)defaulted;
         XRPAmount test{0};
         BEAST_EXPECT(test.drops() == 0);
@@ -230,7 +230,8 @@ public:
 
         {
             // Similar test as above, but for negative values
-            XRPAmount big(minXRP);
+            XRPAmount big(minXRP);  // NOLINT(misc-const-correctness): const breaks overflow check
+                                    // at end of this scope
             BEAST_EXPECT(big == mulRatio(big, maxUInt32, maxUInt32, true));
             // rounding mode shouldn't matter as the result is exact
             BEAST_EXPECT(big == mulRatio(big, maxUInt32, maxUInt32, false));
@@ -244,7 +245,7 @@ public:
 
         {
             // small amounts
-            XRPAmount tiny(1);
+            XRPAmount const tiny(1);
             // Round up should give the smallest allowable number
             BEAST_EXPECT(tiny == mulRatio(tiny, 1, maxUInt32, true));
             // rounding down should be zero
@@ -252,7 +253,7 @@ public:
             BEAST_EXPECT(beast::zero == mulRatio(tiny, maxUInt32 - 1, maxUInt32, false));
 
             // tiny negative numbers
-            XRPAmount tinyNeg(-1);
+            XRPAmount const tinyNeg(-1);
             // Round up should give zero
             BEAST_EXPECT(beast::zero == mulRatio(tinyNeg, 1, maxUInt32, true));
             BEAST_EXPECT(beast::zero == mulRatio(tinyNeg, maxUInt32 - 1, maxUInt32, true));
@@ -262,21 +263,21 @@ public:
 
         {  // rounding
             {
-                XRPAmount one(1);
+                XRPAmount const one(1);
                 auto const rup = mulRatio(one, maxUInt32 - 1, maxUInt32, true);
                 auto const rdown = mulRatio(one, maxUInt32 - 1, maxUInt32, false);
                 BEAST_EXPECT(rup.drops() - rdown.drops() == 1);
             }
 
             {
-                XRPAmount big(maxXRP);
+                XRPAmount const big(maxXRP);
                 auto const rup = mulRatio(big, maxUInt32 - 1, maxUInt32, true);
                 auto const rdown = mulRatio(big, maxUInt32 - 1, maxUInt32, false);
                 BEAST_EXPECT(rup.drops() - rdown.drops() == 1);
             }
 
             {
-                XRPAmount negOne(-1);
+                XRPAmount const negOne(-1);
                 auto const rup = mulRatio(negOne, maxUInt32 - 1, maxUInt32, true);
                 auto const rdown = mulRatio(negOne, maxUInt32 - 1, maxUInt32, false);
                 BEAST_EXPECT(rup.drops() - rdown.drops() == 1);
@@ -297,7 +298,7 @@ public:
 
         {
             // underflow
-            XRPAmount bigNegative(minXRP + 10);
+            XRPAmount const bigNegative(minXRP + 10);
             BEAST_EXPECT(mulRatio(bigNegative, 2, 1, true) == minXRP);
         }
     }  // namespace xrpl
diff --git a/src/test/basics/base_uint_test.cpp b/src/test/basics/base_uint_test.cpp
index c8f931e2b5..139c635e5f 100644
--- a/src/test/basics/base_uint_test.cpp
+++ b/src/test/basics/base_uint_test.cpp
@@ -120,7 +120,7 @@ struct base_uint_test : beast::unit_test::suite
         // used to verify set insertion (hashing required)
         std::unordered_set<test96, hardened_hash<>> uset;
 
-        Blob raw{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
+        Blob const raw{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
         BEAST_EXPECT(test96::bytes == raw.size());
 
         test96 u{raw};
@@ -144,7 +144,7 @@ struct base_uint_test : beast::unit_test::suite
         // back into another base_uint (w) for comparison with the original
         nonhash<96> h{};
         hash_append(h, u);
-        test96 w{std::vector<std::uint8_t>(h.data_.begin(), h.data_.end())};
+        test96 const w{std::vector<std::uint8_t>(h.data_.begin(), h.data_.end())};
         BEAST_EXPECT(w == u);
 
         test96 v{~u};
@@ -200,7 +200,7 @@ struct base_uint_test : beast::unit_test::suite
         zp1++;
         test96 zm1{z};
         zm1--;
-        test96 x{zm1 ^ zp1};
+        test96 const x{zm1 ^ zp1};
         uset.insert(x);
         BEAST_EXPECTS(to_string(x) == "FFFFFFFFFFFFFFFFFFFFFFFE", to_string(x));
         BEAST_EXPECTS(to_short_string(x) == "FFFFFFFF...", to_short_string(x));
@@ -285,8 +285,8 @@ struct base_uint_test : beast::unit_test::suite
                 {
                     // Try to prevent constant evaluation.
                     std::vector<char> str(23, '7');
-                    std::string_view sView(str.data(), str.size());
-                    [[maybe_unused]] test96 t96(sView);
+                    std::string_view const sView(str.data(), str.size());
+                    [[maybe_unused]] test96 const t96(sView);
                 }
                 catch (std::invalid_argument const& e)
                 {
@@ -303,8 +303,8 @@ struct base_uint_test : beast::unit_test::suite
                     // Try to prevent constant evaluation.
                     std::vector<char> str(23, '7');
                     str.push_back('G');
-                    std::string_view sView(str.data(), str.size());
-                    [[maybe_unused]] test96 t96(sView);
+                    std::string_view const sView(str.data(), str.size());
+                    [[maybe_unused]] test96 const t96(sView);
                 }
                 catch (std::range_error const& e)
                 {
diff --git a/src/test/basics/hardened_hash_test.cpp b/src/test/basics/hardened_hash_test.cpp
index 1a6609ac29..3910e5e414 100644
--- a/src/test/basics/hardened_hash_test.cpp
+++ b/src/test/basics/hardened_hash_test.cpp
@@ -189,13 +189,13 @@ public:
     check_container()
     {
         {
-            C<detail::test_user_type_member<std::string>> c;
+            C<detail::test_user_type_member<std::string>> const c;
         }
 
         pass();
 
         {
-            C<detail::test_user_type_free<std::string>> c;
+            C<detail::test_user_type_free<std::string>> const c;
         }
 
         pass();
diff --git a/src/test/beast/IPEndpoint_test.cpp b/src/test/beast/IPEndpoint_test.cpp
index 6276f7cd96..ce01743896 100644
--- a/src/test/beast/IPEndpoint_test.cpp
+++ b/src/test/beast/IPEndpoint_test.cpp
@@ -51,7 +51,7 @@ public:
         BEAST_EXPECT(AddressV4{0x01020304}.to_uint() == 0x01020304);
 
         {
-            AddressV4::bytes_type d = {{1, 2, 3, 4}};
+            AddressV4::bytes_type const d = {{1, 2, 3, 4}};
             BEAST_EXPECT(AddressV4{d}.to_uint() == 0x01020304);
 
             unexpected(is_unspecified(AddressV4{d}));
@@ -110,7 +110,7 @@ public:
     {
         testcase("AddressV4::Bytes");
 
-        AddressV4::bytes_type d1 = {{10, 0, 0, 1}};
+        AddressV4::bytes_type const d1 = {{10, 0, 0, 1}};
         AddressV4 v4{d1};
         BEAST_EXPECT(v4.to_bytes()[0] == 10);
         BEAST_EXPECT(v4.to_bytes()[1] == 0);
@@ -136,8 +136,8 @@ public:
         testcase("Address");
 
         boost::system::error_code ec;
-        Address result{boost::asio::ip::make_address("1.2.3.4", ec)};
-        AddressV4::bytes_type d = {{1, 2, 3, 4}};
+        Address const result{boost::asio::ip::make_address("1.2.3.4", ec)};
+        AddressV4::bytes_type const d = {{1, 2, 3, 4}};
         BEAST_EXPECT(!ec);
         BEAST_EXPECT(result.is_v4() && result.to_v4() == AddressV4{d});
     }
@@ -286,7 +286,7 @@ public:
         BEAST_EXPECTS(to_string(ep) == "::ffff:166.78.151.147", to_string(ep));
 
         // a private IPv6
-        AddressV6::bytes_type d2 = {{253, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1}};
+        AddressV6::bytes_type const d2 = {{253, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1}};
         ep = Endpoint(AddressV6{d2});
         BEAST_EXPECT(!is_unspecified(ep));
         BEAST_EXPECT(!is_public(ep));
diff --git a/src/test/beast/LexicalCast_test.cpp b/src/test/beast/LexicalCast_test.cpp
index 5cfc73a6f6..aa3ccfe64e 100644
--- a/src/test/beast/LexicalCast_test.cpp
+++ b/src/test/beast/LexicalCast_test.cpp
@@ -224,7 +224,7 @@ public:
 
         while (i <= std::numeric_limits<std::int16_t>::max())
         {
-            std::int16_t 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 1578ffceca..c47b41478b 100644
--- a/src/test/beast/aged_associative_container_test.cpp
+++ b/src/test/beast/aged_associative_container_test.cpp
@@ -915,7 +915,7 @@ typename std::enable_if<!IsUnordered>::type
 aged_associative_container_test_base::testConstructInitList()
 {
     using Traits = TestTraits<IsUnordered, IsMulti, IsMap>;
-    typename Traits::ManualClock clock;
+    typename Traits::ManualClock const clock;
 
     // testcase (Traits::name() + " init-list");
     testcase("init-list");
@@ -931,7 +931,7 @@ typename std::enable_if<IsUnordered>::type
 aged_associative_container_test_base::testConstructInitList()
 {
     using Traits = TestTraits<IsUnordered, IsMulti, IsMap>;
-    typename Traits::ManualClock clock;
+    typename Traits::ManualClock const clock;
 
     // testcase (Traits::name() + " init-list");
     testcase("init-list");
@@ -1033,8 +1033,8 @@ aged_associative_container_test_base::testIterator()
     using const_iterator = decltype(c.cbegin());
 
     // Should be able to construct or assign an iterator from an iterator.
-    iterator nnIt_0{c.begin()};
-    iterator nnIt_1{nnIt_0};
+    iterator const nnIt_0{c.begin()};
+    iterator const nnIt_1{nnIt_0};
     BEAST_EXPECT(nnIt_0 == nnIt_1);
     iterator nnIt_2;
     nnIt_2 = nnIt_1;
@@ -1042,8 +1042,8 @@ aged_associative_container_test_base::testIterator()
 
     // Should be able to construct or assign a const_iterator from a
     // const_iterator.
-    const_iterator ccIt_0{c.cbegin()};
-    const_iterator ccIt_1{ccIt_0};
+    const_iterator const ccIt_0{c.cbegin()};
+    const_iterator const ccIt_1{ccIt_0};
     BEAST_EXPECT(ccIt_0 == ccIt_1);
     const_iterator ccIt_2;
     ccIt_2 = ccIt_1;
@@ -1054,8 +1054,8 @@ aged_associative_container_test_base::testIterator()
     BEAST_EXPECT(ccIt_1 == nnIt_1);
 
     // Should be able to construct a const_iterator from an iterator.
-    const_iterator ncIt_3{c.begin()};
-    const_iterator ncIt_4{nnIt_0};
+    const_iterator const ncIt_3{c.begin()};
+    const_iterator const ncIt_4{nnIt_0};
     BEAST_EXPECT(ncIt_3 == ncIt_4);
     const_iterator ncIt_5;
     ncIt_5 = nnIt_2;
@@ -1098,8 +1098,8 @@ aged_associative_container_test_base::testReverseIterator()
 
     // Should be able to construct or assign a reverse_iterator from a
     // reverse_iterator.
-    reverse_iterator rNrNit_0{c.rbegin()};
-    reverse_iterator rNrNit_1{rNrNit_0};
+    reverse_iterator const rNrNit_0{c.rbegin()};
+    reverse_iterator const rNrNit_1{rNrNit_0};
     BEAST_EXPECT(rNrNit_0 == rNrNit_1);
     reverse_iterator xXrNit_2;
     xXrNit_2 = rNrNit_1;
@@ -1107,8 +1107,8 @@ aged_associative_container_test_base::testReverseIterator()
 
     // Should be able to construct or assign a const_reverse_iterator from a
     // const_reverse_iterator
-    const_reverse_iterator rCrCit_0{c.crbegin()};
-    const_reverse_iterator rCrCit_1{rCrCit_0};
+    const_reverse_iterator const rCrCit_0{c.crbegin()};
+    const_reverse_iterator const rCrCit_1{rCrCit_0};
     BEAST_EXPECT(rCrCit_0 == rCrCit_1);
     const_reverse_iterator xXrCit_2;
     xXrCit_2 = rCrCit_1;
@@ -1120,8 +1120,8 @@ aged_associative_container_test_base::testReverseIterator()
 
     // Should be able to construct or assign a const_reverse_iterator from a
     // reverse_iterator
-    const_reverse_iterator rNrCit_0{c.rbegin()};
-    const_reverse_iterator rNrCit_1{rNrNit_0};
+    const_reverse_iterator const rNrCit_0{c.rbegin()};
+    const_reverse_iterator const rNrCit_1{rNrNit_0};
     BEAST_EXPECT(rNrCit_0 == rNrCit_1);
     xXrCit_2 = rNrNit_1;
     BEAST_EXPECT(rNrCit_1 == xXrCit_2);
@@ -1132,10 +1132,10 @@ aged_associative_container_test_base::testReverseIterator()
     //  const_iterator.
     // Should be able to construct or assign reverse_iterators from
     // non-reverse iterators.
-    reverse_iterator fNrNit_0{c.begin()};
-    const_reverse_iterator fNrCit_0{c.begin()};
+    reverse_iterator const fNrNit_0{c.begin()};
+    const_reverse_iterator const fNrCit_0{c.begin()};
     BEAST_EXPECT(fNrNit_0 == fNrCit_0);
-    const_reverse_iterator fCrCit_0{c.cbegin()};
+    const_reverse_iterator const fCrCit_0{c.cbegin()};
     BEAST_EXPECT(fNrCit_0 == fCrCit_0);
 
     // None of these should compile because they construct a non-reverse
@@ -1146,7 +1146,7 @@ aged_associative_container_test_base::testReverseIterator()
 
     // You should not be able to assign an iterator to a reverse_iterator or
     // vise-versa.  So the following lines should not compile.
-    iterator xXfNit_0;
+    iterator const xXfNit_0;
     //  xXfNit_0 = xXrNit_2;
     //  xXrNit_2 = xXfNit_0;
 }
@@ -1297,7 +1297,7 @@ aged_associative_container_test_base::testChronological()
     for (auto iter(v.crbegin()); iter != v.crend(); ++iter)
     {
         using iterator = typename decltype(c)::iterator;
-        iterator found(c.find(Traits::extract(*iter)));
+        iterator const found(c.find(Traits::extract(*iter)));
 
         BEAST_EXPECT(found != c.cend());
         if (found == c.cend())
@@ -1317,7 +1317,7 @@ aged_associative_container_test_base::testChronological()
     for (auto iter(v.cbegin()); iter != v.cend(); ++iter)
     {
         using const_iterator = typename decltype(c)::const_iterator;
-        const_iterator found(c.find(Traits::extract(*iter)));
+        const_iterator const found(c.find(Traits::extract(*iter)));
 
         BEAST_EXPECT(found != c.cend());
         if (found == c.cend())
@@ -1642,7 +1642,7 @@ aged_associative_container_test_base::testCompare()
     // testcase (Traits::name() + " array create");
     testcase("array create");
 
-    typename Traits::template Cont<> c1(v.begin(), v.end(), clock);
+    typename Traits::template Cont<> const c1(v.begin(), v.end(), clock);
 
     typename Traits::template Cont<> c2(v.begin(), v.end(), clock);
     c2.erase(c2.cbegin());
@@ -1672,7 +1672,7 @@ aged_associative_container_test_base::testObservers()
     // testcase (Traits::name() + " observers");
     testcase("observers");
 
-    typename Traits::template Cont<> c(clock);
+    typename Traits::template Cont<> const c(clock);
     c.key_comp();
     c.value_comp();
 
@@ -1690,7 +1690,7 @@ aged_associative_container_test_base::testObservers()
     // testcase (Traits::name() + " observers");
     testcase("observers");
 
-    typename Traits::template Cont<> c(clock);
+    typename Traits::template Cont<> const c(clock);
     c.hash_function();
     c.key_eq();
 
diff --git a/src/test/beast/beast_Journal_test.cpp b/src/test/beast/beast_Journal_test.cpp
index cb190e57a0..35ab3640bd 100644
--- a/src/test/beast/beast_Journal_test.cpp
+++ b/src/test/beast/beast_Journal_test.cpp
@@ -50,7 +50,7 @@ public:
         using namespace beast::severities;
         sink.threshold(kInfo);
 
-        Journal j(sink);
+        Journal const j(sink);
 
         j.trace() << " ";
         BEAST_EXPECT(sink.count() == 0);
diff --git a/src/test/beast/beast_PropertyStream_test.cpp b/src/test/beast/beast_PropertyStream_test.cpp
index 35aa91d18e..9e76749218 100644
--- a/src/test/beast/beast_PropertyStream_test.cpp
+++ b/src/test/beast/beast_PropertyStream_test.cpp
@@ -67,7 +67,7 @@ public:
     {
         try
         {
-            Source* source(root.find_one(name));
+            Source const* source(root.find_one(name));
             BEAST_EXPECT(source == expected);
         }
         catch (...)
@@ -82,7 +82,7 @@ public:
     {
         try
         {
-            Source* source(root.find_path(path));
+            Source const* source(root.find_path(path));
             BEAST_EXPECT(source == expected);
         }
         catch (...)
@@ -97,7 +97,7 @@ public:
     {
         try
         {
-            Source* source(root.find_one_deep(name));
+            Source const* source(root.find_one_deep(name));
             BEAST_EXPECT(source == expected);
         }
         catch (...)
diff --git a/src/test/beast/beast_io_latency_probe_test.cpp b/src/test/beast/beast_io_latency_probe_test.cpp
index b2163f2630..dfa18e6770 100644
--- a/src/test/beast/beast_io_latency_probe_test.cpp
+++ b/src/test/beast/beast_io_latency_probe_test.cpp
@@ -60,7 +60,7 @@ class io_latency_probe_test : public beast::unit_test::suite, public beast::test
                         wait_err = ec;
                     auto const end{MeasureClock::now()};
                     elapsed_times_.emplace_back(end - start);
-                    std::lock_guard lk{mtx};
+                    std::lock_guard const lk{mtx};
                     done = true;
                     cv.notify_one();
                 });
@@ -157,7 +157,8 @@ class io_latency_probe_test : public beast::unit_test::suite, public beast::test
         auto interval = 99ms;
         auto probe_duration = 1s;
 
-        size_t expected_probe_count_max = (probe_duration / interval);
+        size_t const expected_probe_count_max = (probe_duration / interval);
+        // NOLINTNEXTLINE(misc-const-correctness)
         size_t expected_probe_count_min = expected_probe_count_max;
 #ifdef XRPL_RUNNING_IN_CI
         // adjust min expected based on measurements
diff --git a/src/test/consensus/ByzantineFailureSim_test.cpp b/src/test/consensus/ByzantineFailureSim_test.cpp
index 245c52d9e3..f86ae556bf 100644
--- a/src/test/consensus/ByzantineFailureSim_test.cpp
+++ b/src/test/consensus/ByzantineFailureSim_test.cpp
@@ -39,7 +39,7 @@ class ByzantineFailureSim_test : public beast::unit_test::suite
         f.trustAndConnect(f + d + e + g, delay);
         g.trustAndConnect(g + a + f, delay);
 
-        PeerGroup network = a + b + c + d + e + f + g;
+        PeerGroup const network = a + b + c + d + e + f + g;
 
         StreamCollector sc{std::cout};
 
diff --git a/src/test/consensus/Consensus_test.cpp b/src/test/consensus/Consensus_test.cpp
index 3550717a4d..8b562454e3 100644
--- a/src/test/consensus/Consensus_test.cpp
+++ b/src/test/consensus/Consensus_test.cpp
@@ -144,7 +144,7 @@ public:
         testcase("standalone");
 
         Sim s;
-        PeerGroup peers = s.createGroup(1);
+        PeerGroup const peers = s.createGroup(1);
         Peer* peer = peers[0];
         peer->targetLedgers = 1;
         peer->start();
@@ -235,7 +235,7 @@ public:
             // All peers are in sync even with a slower peer 0
             if (BEAST_EXPECT(sim.synchronized()))
             {
-                for (Peer* peer : network)
+                for (Peer const* peer : network)
                 {
                     auto const& lcl = peer->lastClosedLedger;
                     BEAST_EXPECT(lcl.id() == peer->prevLedgerID());
@@ -292,7 +292,7 @@ public:
                     // Verify all peers have same LCL but are missing
                     // transaction 0,1 which was not received by all peers
                     // before the ledger closed
-                    for (Peer* peer : network)
+                    for (Peer const* peer : network)
                     {
                         // Closed ledger has all but transaction 0,1
                         auto const& lcl = peer->lastClosedLedger;
@@ -317,7 +317,7 @@ public:
                         BEAST_EXPECT(slowPeer->prevProposers == fast.size());
                     }
 
-                    for (Peer* peer : fast)
+                    for (Peer const* peer : fast)
                     {
                         // Due to the network link delay settings
                         //    Peer 0 initially proposes {0}
@@ -388,8 +388,8 @@ public:
         Sim sim;
 
         PeerGroup groupA = sim.createGroup(2);
-        PeerGroup groupB = sim.createGroup(2);
-        PeerGroup groupC = sim.createGroup(2);
+        PeerGroup const groupB = sim.createGroup(2);
+        PeerGroup const groupC = sim.createGroup(2);
         PeerGroup network = groupA + groupB + groupC;
 
         network.trust(network);
@@ -397,7 +397,7 @@ public:
 
         // Run consensus without skew until we have a short close time
         // resolution
-        Peer* firstPeer = *groupA.begin();
+        Peer const* firstPeer = *groupA.begin();
         while (firstPeer->lastClosedLedger.closeTimeResolution() >= parms.proposeFRESHNESS)
             sim.run(1);
 
@@ -412,7 +412,7 @@ public:
         // All nodes agreed to disagree on the close time
         if (BEAST_EXPECT(sim.synchronized()))
         {
-            for (Peer* peer : network)
+            for (Peer const* peer : network)
                 BEAST_EXPECT(!peer->lastClosedLedger.closeAgree());
         }
     }
@@ -457,13 +457,13 @@ public:
             Sim sim;
 
             PeerGroup minority = sim.createGroup(2);
-            PeerGroup majorityA = sim.createGroup(3);
-            PeerGroup majorityB = sim.createGroup(5);
+            PeerGroup const majorityA = sim.createGroup(3);
+            PeerGroup const majorityB = sim.createGroup(5);
 
             PeerGroup majority = majorityA + majorityB;
-            PeerGroup network = minority + majority;
+            PeerGroup const network = minority + majority;
 
-            SimDuration delay = round<milliseconds>(0.2 * parms.ledgerGRANULARITY);
+            SimDuration const delay = round<milliseconds>(0.2 * parms.ledgerGRANULARITY);
             minority.trustAndConnect(minority + majorityA, delay);
             majority.trustAndConnect(majority, delay);
 
@@ -556,10 +556,10 @@ public:
 
             Sim sim;
             PeerGroup loner = sim.createGroup(1);
-            PeerGroup friends = sim.createGroup(3);
+            PeerGroup const friends = sim.createGroup(3);
             loner.trust(loner + friends);
 
-            PeerGroup others = sim.createGroup(6);
+            PeerGroup const others = sim.createGroup(6);
             PeerGroup clique = friends + others;
             clique.trust(clique);
 
@@ -581,7 +581,7 @@ public:
             sim.run(2);
 
             // Check all peers recovered
-            for (Peer* p : network)
+            for (Peer const* p : network)
                 BEAST_EXPECT(p->prevLedgerID() == network[0]->prevLedgerID());
         }
     }
@@ -596,7 +596,7 @@ public:
         // This is a specialized test engineered to yield ledgers with different
         // close times even though the peers believe they had close time
         // consensus on the ledger.
-        ConsensusParms parms;
+        ConsensusParms const parms;
 
         Sim sim;
 
@@ -634,7 +634,7 @@ public:
         NetClock::duration when = network[0]->now().time_since_epoch();
 
         // Check we are before the 30s to 20s transition
-        NetClock::duration resolution = network[0]->lastClosedLedger.closeTimeResolution();
+        NetClock::duration const resolution = network[0]->lastClosedLedger.closeTimeResolution();
         BEAST_EXPECT(resolution == NetClock::duration{30s});
 
         while (((when % NetClock::duration{30s}) != NetClock::duration{15s}) ||
@@ -650,7 +650,7 @@ public:
         {
             // close time should be ahead of clock time since we engineered
             // the close time to round up
-            for (Peer* peer : network)
+            for (Peer const* peer : network)
             {
                 BEAST_EXPECT(peer->lastClosedLedger.closeTime() > peer->now());
                 BEAST_EXPECT(peer->lastClosedLedger.closeAgree());
@@ -692,26 +692,26 @@ public:
         using namespace std::chrono;
         testcase("fork");
 
-        std::uint32_t numPeers = 10;
+        std::uint32_t const numPeers = 10;
         // Vary overlap between two UNLs
         for (std::uint32_t overlap = 0; overlap <= numPeers; ++overlap)
         {
             ConsensusParms const parms{};
             Sim sim;
 
-            std::uint32_t numA = (numPeers - overlap) / 2;
-            std::uint32_t numB = numPeers - numA - overlap;
+            std::uint32_t const numA = (numPeers - overlap) / 2;
+            std::uint32_t const numB = numPeers - numA - overlap;
 
-            PeerGroup aOnly = sim.createGroup(numA);
-            PeerGroup bOnly = sim.createGroup(numB);
-            PeerGroup commonOnly = sim.createGroup(overlap);
+            PeerGroup const aOnly = sim.createGroup(numA);
+            PeerGroup const bOnly = sim.createGroup(numB);
+            PeerGroup const commonOnly = sim.createGroup(overlap);
 
             PeerGroup a = aOnly + commonOnly;
             PeerGroup b = bOnly + commonOnly;
 
-            PeerGroup network = a + b;
+            PeerGroup const network = a + b;
 
-            SimDuration delay = round<milliseconds>(0.2 * parms.ledgerGRANULARITY);
+            SimDuration const delay = round<milliseconds>(0.2 * parms.ledgerGRANULARITY);
             a.trustAndConnect(a, delay);
             b.trustAndConnect(b, delay);
 
@@ -721,7 +721,7 @@ public:
             {
                 // Nodes have only seen transactions from their neighbors
                 peer->openTxs.insert(Tx{static_cast<std::uint32_t>(peer->id)});
-                for (Peer* to : sim.trustGraph.trustedPeers(peer))
+                for (Peer const* to : sim.trustGraph.trustedPeers(peer))
                     peer->openTxs.insert(Tx{static_cast<std::uint32_t>(to->id)});
             }
             sim.run(1);
@@ -759,7 +759,7 @@ public:
         validators.trust(validators);
         center.trust(validators);
 
-        SimDuration delay = round<milliseconds>(0.2 * parms.ledgerGRANULARITY);
+        SimDuration const delay = round<milliseconds>(0.2 * parms.ledgerGRANULARITY);
         validators.connect(center, delay);
 
         center[0]->runAsValidator = false;
@@ -866,7 +866,7 @@ public:
         Sim sim;
 
         // Goes A->B->D
-        PeerGroup groupABD = sim.createGroup(2);
+        PeerGroup const groupABD = sim.createGroup(2);
         // Single node that initially fully validates C before the split
         PeerGroup groupCfast = sim.createGroup(1);
         // Generates C, but fails to fully validate before the split
@@ -875,8 +875,8 @@ public:
         PeerGroup groupNotFastC = groupABD + groupCsplit;
         PeerGroup network = groupABD + groupCsplit + groupCfast;
 
-        SimDuration delay = round<milliseconds>(0.2 * parms.ledgerGRANULARITY);
-        SimDuration fDelay = round<milliseconds>(0.1 * parms.ledgerGRANULARITY);
+        SimDuration const delay = round<milliseconds>(0.2 * parms.ledgerGRANULARITY);
+        SimDuration const fDelay = round<milliseconds>(0.1 * parms.ledgerGRANULARITY);
 
         network.trust(network);
         // C must have a shorter delay to see all the validations before the
@@ -987,14 +987,14 @@ public:
 
         ConsensusParms const parms{};
         Sim sim;
-        SimDuration delay = round<milliseconds>(0.2 * parms.ledgerGRANULARITY);
+        SimDuration const delay = round<milliseconds>(0.2 * parms.ledgerGRANULARITY);
 
         PeerGroup behind = sim.createGroup(3);
-        PeerGroup ahead = sim.createGroup(2);
+        PeerGroup const ahead = sim.createGroup(2);
         PeerGroup network = ahead + behind;
 
         hash_set<Peer::NodeKey_t> trustedKeys;
-        for (Peer* p : network)
+        for (Peer const* p : network)
             trustedKeys.insert(p->key);
         for (Peer* p : network)
             p->trustedKeys = trustedKeys;
@@ -1061,7 +1061,7 @@ public:
         Tx const txFollowingTrue{97};
         Tx const txFollowingFalse{96};
         int const numPeers = 100;
-        ConsensusParms p;
+        ConsensusParms const p;
         std::size_t peersUnchanged = 0;
 
         auto logs = std::make_unique<Logs>(beast::severities::kError);
diff --git a/src/test/consensus/DistributedValidatorsSim_test.cpp b/src/test/consensus/DistributedValidatorsSim_test.cpp
index b430a63880..f510e00628 100644
--- a/src/test/consensus/DistributedValidatorsSim_test.cpp
+++ b/src/test/consensus/DistributedValidatorsSim_test.cpp
@@ -155,9 +155,9 @@ class DistributedValidators_test : public beast::unit_test::suite
         sim.run(1);
 
         // Run for 10 minutes, submitting 100 tx/second
-        std::chrono::nanoseconds simDuration = 10min;
-        std::chrono::nanoseconds quiet = 10s;
-        Rate rate{100, 1000ms};
+        std::chrono::nanoseconds const simDuration = 10min;
+        std::chrono::nanoseconds const quiet = 10s;
+        Rate const rate{100, 1000ms};
 
         // Initialize timers
         HeartbeatTimer heart(sim.scheduler);
diff --git a/src/test/consensus/LedgerTiming_test.cpp b/src/test/consensus/LedgerTiming_test.cpp
index 4441184af4..8313ffd0d4 100644
--- a/src/test/consensus/LedgerTiming_test.cpp
+++ b/src/test/consensus/LedgerTiming_test.cpp
@@ -66,7 +66,7 @@ class LedgerTiming_test : public beast::unit_test::suite
         using namespace std::chrono_literals;
         // A closeTime equal to the epoch is not modified
         using tp = NetClock::time_point;
-        tp def;
+        tp const def;
         BEAST_EXPECT(def == roundCloseTime(def, 30s));
 
         // Otherwise, the closeTime is rounded to the nearest
diff --git a/src/test/consensus/LedgerTrie_test.cpp b/src/test/consensus/LedgerTrie_test.cpp
index 7fd8c71b64..0836b9c342 100644
--- a/src/test/consensus/LedgerTrie_test.cpp
+++ b/src/test/consensus/LedgerTrie_test.cpp
@@ -278,7 +278,7 @@ class LedgerTrie_test : public beast::unit_test::suite
         LedgerHistoryHelper h;
         BEAST_EXPECT(t.empty());
 
-        Ledger genesis = h[""];
+        Ledger const genesis = h[""];
         t.insert(genesis);
         BEAST_EXPECT(!t.empty());
         t.remove(genesis);
@@ -344,7 +344,7 @@ class LedgerTrie_test : public beast::unit_test::suite
         using Seq = Ledger::Seq;
         // Empty
         {
-            LedgerTrie<Ledger> t;
+            LedgerTrie<Ledger> const t;
             BEAST_EXPECT(t.getPreferred(Seq{0}) == std::nullopt);
             BEAST_EXPECT(t.getPreferred(Seq{2}) == std::nullopt);
         }
@@ -352,7 +352,7 @@ class LedgerTrie_test : public beast::unit_test::suite
         {
             LedgerTrie<Ledger> t;
             LedgerHistoryHelper h;
-            Ledger genesis = h[""];
+            Ledger const genesis = h[""];
             t.insert(genesis);
 
             // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
@@ -670,11 +670,11 @@ class LedgerTrie_test : public beast::unit_test::suite
         {
             // pick a random ledger history
             std::string curr;
-            char depth = depthDist(gen);
+            char const depth = depthDist(gen);
             char offset = 0;
             for (char d = 0; d < depth; ++d)
             {
-                char a = offset + widthDist(gen);
+                char const a = offset + widthDist(gen);
                 curr += a;
                 offset = (a + 1) * width;
             }
diff --git a/src/test/consensus/NegativeUNL_test.cpp b/src/test/consensus/NegativeUNL_test.cpp
index cf8c8e87ef..0f97704755 100644
--- a/src/test/consensus/NegativeUNL_test.cpp
+++ b/src/test/consensus/NegativeUNL_test.cpp
@@ -261,7 +261,7 @@ class NegativeUNL_test : public beast::unit_test::suite
             {
                 BEAST_EXPECT(l->validatorToDisable() == publicKeys[0]);
                 //++ first ToDisable Tx in ledger's TxSet
-                uint256 txID = txDisable_0.getTransactionID();
+                uint256 const txID = txDisable_0.getTransactionID();
                 BEAST_EXPECT(l->txExists(txID));
             }
         }
@@ -628,7 +628,7 @@ struct NetworkHistory
     walkHistoryAndAddValidations(NeedValidation&& needVal)
     {
         std::uint32_t curr = 0;
-        std::size_t need = 256 + 1;
+        std::size_t const need = 256 + 1;
         // only last 256 + 1 ledgers need validations
         if (history.size() > need)
             curr = history.size() - need;
@@ -702,14 +702,14 @@ class NegativeUNLVoteInternal_test : public beast::unit_test::suite
         testcase("Create UNLModify Tx");
         jtx::Env env(*this);
 
-        NodeID myId(0xA0);
+        NodeID const myId(0xA0);
         NegativeUNLVote vote(myId, env.journal);
 
         // one add, one remove
         auto txSet = std::make_shared<SHAMap>(SHAMapType::TRANSACTION, env.app().getNodeFamily());
-        PublicKey toDisableKey(derivePublicKey(KeyType::ed25519, randomSecretKey()));
-        PublicKey toReEnableKey(derivePublicKey(KeyType::ed25519, randomSecretKey()));
-        LedgerIndex seq(1234);
+        PublicKey const toDisableKey(derivePublicKey(KeyType::ed25519, randomSecretKey()));
+        PublicKey const toReEnableKey(derivePublicKey(KeyType::ed25519, randomSecretKey()));
+        LedgerIndex const seq(1234);
         BEAST_EXPECT(countTx(txSet) == 0);
         vote.addTx(seq, toDisableKey, NegativeUNLVote::ToDisable, txSet);
         BEAST_EXPECT(countTx(txSet) == 1);
@@ -723,16 +723,16 @@ class NegativeUNLVoteInternal_test : public beast::unit_test::suite
     testPickOneCandidate()
     {
         testcase("Pick One Candidate");
-        jtx::Env env(*this);
+        jtx::Env const env(*this);
 
-        NodeID myId(0xA0);
-        NegativeUNLVote vote(myId, env.journal);
+        NodeID const myId(0xA0);
+        NegativeUNLVote const vote(myId, env.journal);
 
-        uint256 pad_0(0);
-        uint256 pad_f = ~pad_0;
-        NodeID n_1(1);
-        NodeID n_2(2);
-        NodeID n_3(3);
+        uint256 const pad_0(0);
+        uint256 const pad_f = ~pad_0;
+        NodeID const n_1(1);
+        NodeID const n_2(2);
+        NodeID const n_3(3);
         std::vector<NodeID> candidates({n_1});
         BEAST_EXPECT(vote.choose(pad_0, candidates) == n_1);
         BEAST_EXPECT(vote.choose(pad_f, candidates) == n_1);
@@ -803,7 +803,7 @@ class NegativeUNLVoteInternal_test : public beast::unit_test::suite
             // 5. local node had enough validations but on a wrong chain
             NetworkHistory history = {*this, {10, 0, false, false, 256 + 2}};
             // We need two chains for these tests
-            bool wrongChainSuccess = history.goodHistory;
+            bool const wrongChainSuccess = history.goodHistory;
             BEAST_EXPECT(wrongChainSuccess);
             NetworkHistory::LedgerHistory wrongChain = std::move(history.history);
             // Create a new chain and use it as the one that majority of nodes
@@ -814,7 +814,7 @@ class NegativeUNLVoteInternal_test : public beast::unit_test::suite
             if (history.goodHistory && wrongChainSuccess)
             {
                 NodeID myId = history.UNLNodeIDs[3];
-                NodeID badNode = history.UNLNodeIDs[4];
+                NodeID const badNode = history.UNLNodeIDs[4];
                 history.walkHistoryAndAddValidations(
                     [&](std::shared_ptr<Ledger const> const& l, std::size_t idx) -> bool {
                         // everyone but me
@@ -825,9 +825,9 @@ class NegativeUNLVoteInternal_test : public beast::unit_test::suite
                 // a node double validates
                 for (auto& l : wrongChain)
                 {
-                    RCLValidation v1(history.createSTVal(l, myId));
+                    RCLValidation const v1(history.createSTVal(l, myId));
                     history.validations.add(myId, v1);
-                    RCLValidation v2(history.createSTVal(l, badNode));
+                    RCLValidation const v2(history.createSTVal(l, badNode));
                     history.validations.add(badNode, v2);
                 }
 
@@ -909,8 +909,8 @@ class NegativeUNLVoteInternal_test : public beast::unit_test::suite
     {
         auto [disableCandidates, reEnableCandidates] =
             vote.findAllCandidates(unl, negUnl, scoreTable);
-        bool rightDisable = disableCandidates.size() == numDisable;
-        bool rightReEnable = reEnableCandidates.size() == numReEnable;
+        bool const rightDisable = disableCandidates.size() == numDisable;
+        bool const rightReEnable = reEnableCandidates.size() == numReEnable;
         return rightDisable && rightReEnable;
     };
 
@@ -1009,9 +1009,9 @@ class NegativeUNLVoteInternal_test : public beast::unit_test::suite
 
         {
             // 2 new validators
-            NodeID new_1(0xbead);
-            NodeID new_2(0xbeef);
-            hash_set<NodeID> nowTrusted = {new_1, new_2};
+            NodeID const new_1(0xbead);
+            NodeID const new_2(0xbeef);
+            hash_set<NodeID> const nowTrusted = {new_1, new_2};
             hash_set<NodeID> UNL_temp = history.UNLNodeIDSet;
             UNL_temp.insert(new_1);
             UNL_temp.insert(new_2);
@@ -1065,13 +1065,13 @@ class NegativeUNLVoteInternal_test : public beast::unit_test::suite
          * negativeUNLMinLocalValsToVote
          */
 
-        jtx::Env env(*this);
+        jtx::Env const env(*this);
 
-        NodeID myId(0xA0);
+        NodeID const myId(0xA0);
         NegativeUNLVote vote(myId, env.journal);
 
-        std::array<std::uint32_t, 3> unlSizes = {34, 35, 80};
-        std::array<std::uint32_t, 3> nUnlPercent = {0, 50, 100};
+        std::array<std::uint32_t, 3> const unlSizes = {34, 35, 80};
+        std::array<std::uint32_t, 3> const nUnlPercent = {0, 50, 100};
         std::array<std::uint32_t, 8> scores = {
             0,
             NegativeUNLVote::negativeUNLLowWaterMark - 1,
@@ -1091,7 +1091,7 @@ class NegativeUNLVoteInternal_test : public beast::unit_test::suite
                                       hash_set<NodeID>& negUnl,
                                       hash_map<NodeID, std::uint32_t>& scoreTable) {
                 std::vector<NodeID> nodeIDs;
-                std::vector<PublicKey> keys = createPublicKeys(unl_size);
+                std::vector<PublicKey> const keys = createPublicKeys(unl_size);
                 for (auto const& k : keys)
                 {
                     nodeIDs.emplace_back(calcNodeID(k));
@@ -1153,7 +1153,7 @@ class NegativeUNLVoteInternal_test : public beast::unit_test::suite
                                           hash_set<NodeID>& negUnl,
                                           hash_map<NodeID, std::uint32_t>& scoreTable) {
                     std::vector<NodeID> nodeIDs;
-                    std::vector<PublicKey> keys = createPublicKeys(unl_size);
+                    std::vector<PublicKey> const keys = createPublicKeys(unl_size);
                     for (auto const& k : keys)
                     {
                         nodeIDs.emplace_back(calcNodeID(k));
@@ -1221,9 +1221,9 @@ class NegativeUNLVoteInternal_test : public beast::unit_test::suite
     testNewValidators()
     {
         testcase("New Validators");
-        jtx::Env env(*this);
+        jtx::Env const env(*this);
 
-        NodeID myId(0xA0);
+        NodeID const myId(0xA0);
         NegativeUNLVote vote(myId, env.journal);
 
         // test cases:
@@ -1232,9 +1232,9 @@ class NegativeUNLVoteInternal_test : public beast::unit_test::suite
         // add a new one and some already added
         // purge and see some are expired
 
-        NodeID n1(0xA1);
-        NodeID n2(0xA2);
-        NodeID n3(0xA3);
+        NodeID const n1(0xA1);
+        NodeID const n2(0xA2);
+        NodeID const n3(0xA3);
 
         vote.newValidators(2, {n1});
         BEAST_EXPECT(vote.newValidators_.size() == 1);
@@ -1301,7 +1301,7 @@ class NegativeUNLVoteScoreTable_test : public beast::unit_test::suite
          * -- unl size: 10, 34, 35, 50
          * -- score pattern: all 0, all 50%, all 100%, two 0% two 50% rest 100%
          */
-        std::array<std::uint32_t, 4> unlSizes = {10, 34, 35, 50};
+        std::array<std::uint32_t, 4> const unlSizes = {10, 34, 35, 50};
         std::array<std::array<std::uint32_t, 3>, 4> scorePattern = {
             {{{0, 0, 0}}, {{50, 50, 50}}, {{100, 100, 100}}, {{0, 50, 100}}}};
 
@@ -1330,9 +1330,9 @@ class NegativeUNLVoteScoreTable_test : public beast::unit_test::suite
                                 k = 2;
                             }
 
-                            bool add_50 = scorePattern[sp][k] == 50 && l->seq() % 2 == 0;
-                            bool add_100 = scorePattern[sp][k] == 100;
-                            bool add_me = history.UNLNodeIDs[idx] == myId;
+                            bool const add_50 = scorePattern[sp][k] == 50 && l->seq() % 2 == 0;
+                            bool const add_100 = scorePattern[sp][k] == 100;
+                            bool const add_me = history.UNLNodeIDs[idx] == myId;
                             return add_50 || add_100 || add_me;
                         });
 
@@ -1698,8 +1698,8 @@ class NegativeUNLVoteFilterValidations_test : public beast::unit_test::suite
         };
 
         // create keys and validations
-        std::uint32_t numNodes = 10;
-        std::uint32_t negUnlSize = 3;
+        std::uint32_t const numNodes = 10;
+        std::uint32_t const negUnlSize = 3;
         std::vector<std::string> cfgKeys;
         hash_set<NodeID> activeValidators;
         hash_set<PublicKey> nUnlKeys;
@@ -1719,7 +1719,7 @@ class NegativeUNLVoteFilterValidations_test : public beast::unit_test::suite
         // setup the ValidatorList
         auto& validators = env.app().getValidators();
         auto& local = *nUnlKeys.begin();
-        std::vector<std::string> cfgPublishers;
+        std::vector<std::string> const cfgPublishers;
         validators.load(local, cfgKeys, cfgPublishers);
         validators.updateTrusted(
             activeValidators,
@@ -1765,9 +1765,9 @@ negUnlSizeTest(
     bool hasToDisable,
     bool hasToReEnable)
 {
-    bool sameSize = l->negativeUNL().size() == size;
-    bool sameToDisable = (l->validatorToDisable() != std::nullopt) == hasToDisable;
-    bool sameToReEnable = (l->validatorToReEnable() != std::nullopt) == hasToReEnable;
+    bool const sameSize = l->negativeUNL().size() == size;
+    bool const sameToDisable = (l->validatorToDisable() != std::nullopt) == hasToDisable;
+    bool const sameToReEnable = (l->validatorToReEnable() != std::nullopt) == hasToReEnable;
 
     return sameSize && sameToDisable && sameToReEnable;
 }
@@ -1809,7 +1809,7 @@ VerifyPubKeyAndSeq(
         auto s = makeSlice(d);
         if (!publicKeyType(s))
             return false;
-        PublicKey pk(s);
+        PublicKey const pk(s);
         auto it = nUnlLedgerSeq.find(pk);
         if (it == nUnlLedgerSeq.end())
             return false;
@@ -1835,13 +1835,13 @@ std::vector<PublicKey>
 createPublicKeys(std::size_t n)
 {
     std::vector<PublicKey> keys;
-    std::size_t ss = 33;
+    std::size_t const ss = 33;
     std::vector<uint8_t> data(ss, 0);
     data[0] = 0xED;
     for (int i = 0; i < n; ++i)
     {
         data[1]++;
-        Slice s(data.data(), ss);
+        Slice const s(data.data(), ss);
         keys.emplace_back(s);
     }
     return keys;
diff --git a/src/test/consensus/Validations_test.cpp b/src/test/consensus/Validations_test.cpp
index dc6dfe539c..fef6e79036 100644
--- a/src/test/consensus/Validations_test.cpp
+++ b/src/test/consensus/Validations_test.cpp
@@ -233,12 +233,12 @@ class Validations_test : public beast::unit_test::suite
 
         testcase("Add validation");
         LedgerHistoryHelper h;
-        Ledger ledgerA = h["a"];
+        Ledger const ledgerA = h["a"];
         Ledger ledgerAB = h["ab"];
         Ledger ledgerAZ = h["az"];
         Ledger ledgerABC = h["abc"];
-        Ledger ledgerABCD = h["abcd"];
-        Ledger ledgerABCDE = h["abcde"];
+        Ledger const ledgerABCD = h["abcd"];
+        Ledger const ledgerABCDE = h["abcde"];
 
         {
             TestHarness harness(h.oracle);
@@ -296,7 +296,7 @@ class Validations_test : public beast::unit_test::suite
             // Process validations out of order with shifted times
 
             TestHarness harness(h.oracle);
-            Node n = harness.makeNode();
+            Node const n = harness.makeNode();
 
             // Establish a new current validation
             BEAST_EXPECT(ValStatus::current == harness.add(n.validate(ledgerA)));
@@ -312,7 +312,7 @@ class Validations_test : public beast::unit_test::suite
         {
             // Test stale on arrival validations
             TestHarness harness(h.oracle);
-            Node n = harness.makeNode();
+            Node const n = harness.makeNode();
 
             BEAST_EXPECT(
                 ValStatus::stale ==
@@ -364,11 +364,11 @@ class Validations_test : public beast::unit_test::suite
 
         LedgerHistoryHelper h;
         Ledger ledgerA = h["a"];
-        Ledger ledgerAB = h["ab"];
+        Ledger const ledgerAB = h["ab"];
 
         using Trigger = std::function<void(TestValidations&)>;
 
-        std::vector<Trigger> triggers = {
+        std::vector<Trigger> const triggers = {
             [&](TestValidations& vals) { vals.currentTrusted(); },
             [&](TestValidations& vals) { vals.getCurrentNodeIDs(); },
             [&](TestValidations& vals) { vals.getPreferred(genesisLedger); },
@@ -376,7 +376,7 @@ class Validations_test : public beast::unit_test::suite
         for (Trigger const& trigger : triggers)
         {
             TestHarness harness(h.oracle);
-            Node n = harness.makeNode();
+            Node const n = harness.makeNode();
 
             BEAST_EXPECT(ValStatus::current == harness.add(n.validate(ledgerAB)));
             trigger(harness.vals());
@@ -405,39 +405,41 @@ class Validations_test : public beast::unit_test::suite
         testcase("Get nodes after");
 
         LedgerHistoryHelper h;
-        Ledger ledgerA = h["a"];
-        Ledger ledgerAB = h["ab"];
-        Ledger ledgerABC = h["abc"];
-        Ledger ledgerAD = h["ad"];
+        Ledger const ledgerA = h["a"];
+        Ledger const ledgerAB = h["ab"];
+        Ledger const ledgerABC = h["abc"];
+        Ledger const ledgerAD = h["ad"];
 
         TestHarness harness(h.oracle);
-        Node a = harness.makeNode(), b = harness.makeNode(), c = harness.makeNode(),
-             d = harness.makeNode();
-        c.untrust();
+        Node const trustedNode1 = harness.makeNode();
+        Node const trustedNode2 = harness.makeNode();
+        Node const trustedNode3 = harness.makeNode();
+
+        Node notTrustedNode = harness.makeNode();
+        notTrustedNode.untrust();
 
         // first round a,b,c agree, d has is partial
-        BEAST_EXPECT(ValStatus::current == harness.add(a.validate(ledgerA)));
-        BEAST_EXPECT(ValStatus::current == harness.add(b.validate(ledgerA)));
-        BEAST_EXPECT(ValStatus::current == harness.add(c.validate(ledgerA)));
-        BEAST_EXPECT(ValStatus::current == harness.add(d.partial(ledgerA)));
+        BEAST_EXPECT(ValStatus::current == harness.add(trustedNode1.validate(ledgerA)));
+        BEAST_EXPECT(ValStatus::current == harness.add(trustedNode2.validate(ledgerA)));
+        BEAST_EXPECT(ValStatus::current == harness.add(notTrustedNode.validate(ledgerA)));
+        BEAST_EXPECT(ValStatus::current == harness.add(trustedNode3.partial(ledgerA)));
 
         for (Ledger const& ledger : {ledgerA, ledgerAB, ledgerABC, ledgerAD})
             BEAST_EXPECT(harness.vals().getNodesAfter(ledger, ledger.id()) == 0);
 
         harness.clock().advance(5s);
 
-        BEAST_EXPECT(ValStatus::current == harness.add(a.validate(ledgerAB)));
-        BEAST_EXPECT(ValStatus::current == harness.add(b.validate(ledgerABC)));
-        BEAST_EXPECT(ValStatus::current == harness.add(c.validate(ledgerAB)));
-        BEAST_EXPECT(ValStatus::current == harness.add(d.partial(ledgerABC)));
+        BEAST_EXPECT(ValStatus::current == harness.add(trustedNode1.validate(ledgerAB)));
+        BEAST_EXPECT(ValStatus::current == harness.add(trustedNode2.validate(ledgerABC)));
+        BEAST_EXPECT(ValStatus::current == harness.add(notTrustedNode.validate(ledgerAB)));
+        BEAST_EXPECT(ValStatus::current == harness.add(trustedNode3.partial(ledgerABC)));
 
         BEAST_EXPECT(harness.vals().getNodesAfter(ledgerA, ledgerA.id()) == 3);
         BEAST_EXPECT(harness.vals().getNodesAfter(ledgerAB, ledgerAB.id()) == 2);
         BEAST_EXPECT(harness.vals().getNodesAfter(ledgerABC, ledgerABC.id()) == 0);
         BEAST_EXPECT(harness.vals().getNodesAfter(ledgerAD, ledgerAD.id()) == 0);
 
-        // If given a ledger inconsistent with the id, is still able to check
-        // using slower method
+        // If given a ledger inconsistent with the id, is still able to check using slower method
         BEAST_EXPECT(harness.vals().getNodesAfter(ledgerAD, ledgerA.id()) == 1);
         BEAST_EXPECT(harness.vals().getNodesAfter(ledgerAD, ledgerAB.id()) == 2);
     }
@@ -449,12 +451,13 @@ class Validations_test : public beast::unit_test::suite
         testcase("Current trusted validations");
 
         LedgerHistoryHelper h;
-        Ledger ledgerA = h["a"];
-        Ledger ledgerB = h["b"];
-        Ledger ledgerAC = h["ac"];
+        Ledger const ledgerA = h["a"];
+        Ledger const ledgerB = h["b"];
+        Ledger const ledgerAC = h["ac"];
 
         TestHarness harness(h.oracle);
-        Node a = harness.makeNode(), b = harness.makeNode();
+        Node const a = harness.makeNode();
+        Node b = harness.makeNode();
         b.untrust();
 
         BEAST_EXPECT(ValStatus::current == harness.add(a.validate(ledgerA)));
@@ -487,8 +490,8 @@ class Validations_test : public beast::unit_test::suite
         testcase("Current public keys");
 
         LedgerHistoryHelper h;
-        Ledger ledgerA = h["a"];
-        Ledger ledgerAC = h["ac"];
+        Ledger const ledgerA = h["a"];
+        Ledger const ledgerAC = h["ac"];
 
         TestHarness harness(h.oracle);
         Node a = harness.makeNode(), b = harness.makeNode();
@@ -567,7 +570,7 @@ class Validations_test : public beast::unit_test::suite
                     sorted(harness.vals().getTrustedForLedger(id, seq)) ==
                     sorted(expectedValidations));
 
-                std::uint32_t baseFee = 0;
+                std::uint32_t const baseFee = 0;
                 std::vector<uint32_t> expectedFees;
                 expectedFees.reserve(expectedValidations.size());
                 for (auto const& val : expectedValidations)
@@ -580,9 +583,9 @@ class Validations_test : public beast::unit_test::suite
         };
 
         //----------------------------------------------------------------------
-        Ledger ledgerA = h["a"];
-        Ledger ledgerB = h["b"];
-        Ledger ledgerAC = h["ac"];
+        Ledger const ledgerA = h["a"];
+        Ledger const ledgerB = h["b"];
+        Ledger const ledgerAC = h["ac"];
 
         // Add a dummy ID to cover unknown ledger identifiers
         trustedValidations[{Ledger::ID{100}, Ledger::Seq{100}}] = {};
@@ -689,14 +692,16 @@ class Validations_test : public beast::unit_test::suite
 
         LedgerHistoryHelper h;
         TestHarness harness(h.oracle);
-        Node a = harness.makeNode(), b = harness.makeNode(), c = harness.makeNode();
-        c.untrust();
+        Node const trustedNode1 = harness.makeNode();
+        Node const trustedNode2 = harness.makeNode();
+        Node notTrustedNode = harness.makeNode();
+        notTrustedNode.untrust();
 
-        Ledger ledgerA = h["a"];
-        Ledger ledgerAB = h["ab"];
+        Ledger const ledgerA = h["a"];
+        Ledger const ledgerAB = h["ab"];
 
         hash_map<PeerID, Validation> expected;
-        for (auto const& node : {a, b, c})
+        for (auto const& node : {trustedNode1, trustedNode2, notTrustedNode})
         {
             auto const val = node.validate(ledgerA);
             BEAST_EXPECT(ValStatus::current == harness.add(val));
@@ -706,9 +711,9 @@ class Validations_test : public beast::unit_test::suite
         // Send in a new validation for a, saving the new one into the expected
         // map after setting the proper prior ledger ID it replaced
         harness.clock().advance(1s);
-        auto newVal = a.validate(ledgerAB);
+        auto newVal = trustedNode1.validate(ledgerAB);
         BEAST_EXPECT(ValStatus::current == harness.add(newVal));
-        expected.find(a.nodeID())->second = newVal;
+        expected.find(trustedNode1.nodeID())->second = newVal;
     }
 
     void
@@ -719,14 +724,17 @@ class Validations_test : public beast::unit_test::suite
 
         LedgerHistoryHelper h;
         TestHarness harness(h.oracle);
-        Node a = harness.makeNode(), b = harness.makeNode(), c = harness.makeNode(),
-             d = harness.makeNode();
-        c.untrust();
+        Node const trustedNode1 = harness.makeNode();
+        Node const trustedNode2 = harness.makeNode();
+        Node const trustedNode3 = harness.makeNode();
 
-        Ledger ledgerA = h["a"];
-        Ledger ledgerB = h["b"];
-        Ledger ledgerAC = h["ac"];
-        Ledger ledgerACD = h["acd"];
+        Node notTrustedNode = harness.makeNode();
+        notTrustedNode.untrust();
+
+        Ledger const ledgerA = h["a"];
+        Ledger const ledgerB = h["b"];
+        Ledger const ledgerAC = h["ac"];
+        Ledger const ledgerACD = h["acd"];
 
         using Seq = Ledger::Seq;
 
@@ -736,7 +744,7 @@ class Validations_test : public beast::unit_test::suite
         BEAST_EXPECT(harness.vals().getPreferred(ledgerA) == std::nullopt);
 
         // Single ledger
-        BEAST_EXPECT(ValStatus::current == harness.add(a.validate(ledgerB)));
+        BEAST_EXPECT(ValStatus::current == harness.add(trustedNode1.validate(ledgerB)));
         BEAST_EXPECT(harness.vals().getPreferred(ledgerA) == pref(ledgerB));
         BEAST_EXPECT(harness.vals().getPreferred(ledgerB) == pref(ledgerB));
 
@@ -745,21 +753,21 @@ class Validations_test : public beast::unit_test::suite
 
         // Untrusted doesn't impact preferred ledger
         // (ledgerB has tie-break over ledgerA)
-        BEAST_EXPECT(ValStatus::current == harness.add(b.validate(ledgerA)));
-        BEAST_EXPECT(ValStatus::current == harness.add(c.validate(ledgerA)));
+        BEAST_EXPECT(ValStatus::current == harness.add(trustedNode2.validate(ledgerA)));
+        BEAST_EXPECT(ValStatus::current == harness.add(notTrustedNode.validate(ledgerA)));
         BEAST_EXPECT(ledgerB.id() > ledgerA.id());
         BEAST_EXPECT(harness.vals().getPreferred(ledgerA) == pref(ledgerB));
         BEAST_EXPECT(harness.vals().getPreferred(ledgerB) == pref(ledgerB));
 
         // Partial does break ties
-        BEAST_EXPECT(ValStatus::current == harness.add(d.partial(ledgerA)));
+        BEAST_EXPECT(ValStatus::current == harness.add(trustedNode3.partial(ledgerA)));
         BEAST_EXPECT(harness.vals().getPreferred(ledgerA) == pref(ledgerA));
         BEAST_EXPECT(harness.vals().getPreferred(ledgerB) == pref(ledgerA));
 
         harness.clock().advance(5s);
 
         // Parent of preferred-> stick with ledger
-        for (auto const& node : {a, b, c, d})
+        for (auto const& node : {trustedNode1, trustedNode2, notTrustedNode, trustedNode3})
             BEAST_EXPECT(ValStatus::current == harness.add(node.validate(ledgerAC)));
         // Parent of preferred stays put
         BEAST_EXPECT(harness.vals().getPreferred(ledgerA) == pref(ledgerA));
@@ -770,7 +778,7 @@ class Validations_test : public beast::unit_test::suite
 
         // Any later grandchild or different chain is preferred
         harness.clock().advance(5s);
-        for (auto const& node : {a, b, c, d})
+        for (auto const& node : {trustedNode1, trustedNode2, notTrustedNode, trustedNode3})
             BEAST_EXPECT(ValStatus::current == harness.add(node.validate(ledgerACD)));
         for (auto const& ledger : {ledgerA, ledgerB, ledgerACD})
             BEAST_EXPECT(harness.vals().getPreferred(ledger) == pref(ledgerACD));
@@ -784,11 +792,11 @@ class Validations_test : public beast::unit_test::suite
 
         LedgerHistoryHelper h;
         TestHarness harness(h.oracle);
-        Node a = harness.makeNode();
+        Node const a = harness.makeNode();
 
-        Ledger ledgerA = h["a"];
-        Ledger ledgerB = h["b"];
-        Ledger ledgerC = h["c"];
+        Ledger const ledgerA = h["a"];
+        Ledger const ledgerB = h["b"];
+        Ledger const ledgerC = h["c"];
 
         using ID = Ledger::ID;
         using Seq = Ledger::Seq;
@@ -830,14 +838,14 @@ class Validations_test : public beast::unit_test::suite
 
         LedgerHistoryHelper h;
         TestHarness harness(h.oracle);
-        Node a = harness.makeNode();
-        Node b = harness.makeNode();
+        Node const a = harness.makeNode();
+        Node const b = harness.makeNode();
 
         using ID = Ledger::ID;
         using Seq = Ledger::Seq;
 
         // Validate the ledger before it is actually available
-        Validation val = a.validate(ID{2}, Seq{2}, 0s, 0s, true);
+        Validation const val = a.validate(ID{2}, Seq{2}, 0s, 0s, true);
 
         BEAST_EXPECT(ValStatus::current == harness.add(val));
         // Validation is available
@@ -854,13 +862,13 @@ class Validations_test : public beast::unit_test::suite
         BEAST_EXPECT(harness.vals().getPreferred(genesisLedger) == std::make_pair(Seq{2}, ID{3}));
 
         // Create the ledger
-        Ledger ledgerAB = h["ab"];
+        Ledger const ledgerAB = h["ab"];
         // Now it should be available
         BEAST_EXPECT(harness.vals().getNodesAfter(genesisLedger, ID{0}) == 1);
 
         // Create a validation that is not available
         harness.clock().advance(5s);
-        Validation val2 = a.validate(ID{4}, Seq{4}, 0s, 0s, true);
+        Validation const val2 = a.validate(ID{4}, Seq{4}, 0s, 0s, true);
         BEAST_EXPECT(ValStatus::current == harness.add(val2));
         BEAST_EXPECT(harness.vals().numTrustedForLedger(ID{4}) == 1);
         BEAST_EXPECT(
@@ -868,7 +876,7 @@ class Validations_test : public beast::unit_test::suite
             std::make_pair(ledgerAB.seq(), ledgerAB.id()));
 
         // Another node requesting that ledger still doesn't change things
-        Validation val3 = b.validate(ID{4}, Seq{4}, 0s, 0s, true);
+        Validation const val3 = b.validate(ID{4}, Seq{4}, 0s, 0s, true);
         BEAST_EXPECT(ValStatus::current == harness.add(val3));
         BEAST_EXPECT(harness.vals().numTrustedForLedger(ID{4}) == 2);
         BEAST_EXPECT(
@@ -877,7 +885,7 @@ class Validations_test : public beast::unit_test::suite
 
         // Switch to validation that is available
         harness.clock().advance(5s);
-        Ledger ledgerABCDE = h["abcde"];
+        Ledger const ledgerABCDE = h["abcde"];
         BEAST_EXPECT(ValStatus::current == harness.add(a.partial(ledgerABCDE)));
         BEAST_EXPECT(ValStatus::current == harness.add(b.partial(ledgerABCDE)));
         BEAST_EXPECT(
@@ -891,9 +899,9 @@ class Validations_test : public beast::unit_test::suite
         testcase("NumTrustedForLedger");
         LedgerHistoryHelper h;
         TestHarness harness(h.oracle);
-        Node a = harness.makeNode();
-        Node b = harness.makeNode();
-        Ledger ledgerA = h["a"];
+        Node const a = harness.makeNode();
+        Node const b = harness.makeNode();
+        Ledger const ledgerA = h["a"];
 
         BEAST_EXPECT(ValStatus::current == harness.add(a.partial(ledgerA)));
         BEAST_EXPECT(harness.vals().numTrustedForLedger(ledgerA.id()) == 0);
@@ -912,7 +920,7 @@ class Validations_test : public beast::unit_test::suite
         beast::manual_clock<steady_clock> clock;
         SeqEnforcer<Seq> enforcer;
 
-        ValidationParms p;
+        ValidationParms const p;
 
         BEAST_EXPECT(enforcer(clock.now(), Seq{1}, p));
         BEAST_EXPECT(enforcer(clock.now(), Seq{10}, p));
@@ -934,9 +942,9 @@ class Validations_test : public beast::unit_test::suite
                            TestValidations& vals,
                            hash_set<PeerID> const& listed,
                            std::vector<Validation> const& trustedVals) {
-            Ledger::ID testID =
+            Ledger::ID const testID =
                 trustedVals.empty() ? this->genesisLedger.id() : trustedVals[0].ledgerID();
-            Ledger::Seq testSeq =
+            Ledger::Seq const testSeq =
                 trustedVals.empty() ? this->genesisLedger.seq() : trustedVals[0].seq();
             BEAST_EXPECT(vals.currentTrusted() == trustedVals);
             BEAST_EXPECT(vals.getCurrentNodeIDs() == listed);
@@ -958,12 +966,12 @@ class Validations_test : public beast::unit_test::suite
             // Trusted to untrusted
             LedgerHistoryHelper h;
             TestHarness harness(h.oracle);
-            Node a = harness.makeNode();
-            Ledger ledgerAB = h["ab"];
-            Validation v = a.validate(ledgerAB);
+            Node const a = harness.makeNode();
+            Ledger const ledgerAB = h["ab"];
+            Validation const v = a.validate(ledgerAB);
             BEAST_EXPECT(ValStatus::current == harness.add(v));
 
-            hash_set<PeerID> listed({a.nodeID()});
+            hash_set<PeerID> const listed({a.nodeID()});
             std::vector<Validation> trustedVals({v});
             checker(harness.vals(), listed, trustedVals);
 
@@ -978,11 +986,11 @@ class Validations_test : public beast::unit_test::suite
             TestHarness harness(h.oracle);
             Node a = harness.makeNode();
             a.untrust();
-            Ledger ledgerAB = h["ab"];
-            Validation v = a.validate(ledgerAB);
+            Ledger const ledgerAB = h["ab"];
+            Validation const v = a.validate(ledgerAB);
             BEAST_EXPECT(ValStatus::current == harness.add(v));
 
-            hash_set<PeerID> listed({a.nodeID()});
+            hash_set<PeerID> const listed({a.nodeID()});
             std::vector<Validation> trustedVals;
             checker(harness.vals(), listed, trustedVals);
 
@@ -995,11 +1003,11 @@ class Validations_test : public beast::unit_test::suite
             // Trusted but not acquired -> untrusted
             LedgerHistoryHelper h;
             TestHarness harness(h.oracle);
-            Node a = harness.makeNode();
-            Validation v = a.validate(Ledger::ID{2}, Ledger::Seq{2}, 0s, 0s, true);
+            Node const a = harness.makeNode();
+            Validation const v = a.validate(Ledger::ID{2}, Ledger::Seq{2}, 0s, 0s, true);
             BEAST_EXPECT(ValStatus::current == harness.add(v));
 
-            hash_set<PeerID> listed({a.nodeID()});
+            hash_set<PeerID> const listed({a.nodeID()});
             std::vector<Validation> trustedVals({v});
             auto& vals = harness.vals();
             BEAST_EXPECT(vals.currentTrusted() == trustedVals);
diff --git a/src/test/core/Config_test.cpp b/src/test/core/Config_test.cpp
index edcb67b767..a7f44836d5 100644
--- a/src/test/core/Config_test.cpp
+++ b/src/test/core/Config_test.cpp
@@ -268,7 +268,7 @@ public:
 
         Config c;
 
-        std::string toLoad(R"xrpldConfig(
+        std::string const toLoad(R"xrpldConfig(
 [server]
 port_rpc
 port_peer
@@ -297,15 +297,15 @@ port_wss_admin
         auto const cwd = current_path();
 
         // Test both config file names.
-        char const* configFiles[] = {Config::configFileName, Config::configLegacyName};
+        std::string_view const configFiles[] = {Config::configFileName, Config::configLegacyName};
 
         // Config file in current directory.
         for (auto const& configFile : configFiles)
         {
             // Use a temporary directory for testing.
-            beast::temp_dir td;
+            beast::temp_dir const td;
             current_path(td.path());
-            path const f = td.file(configFile);
+            path const f = td.file(std::string{configFile});
             std::ofstream o(f.string());
             o << detail::configContents("", "");
             o.close();
@@ -325,13 +325,13 @@ port_wss_admin
         {
             // Point the current working directory to a temporary directory, so
             // we don't pick up an actual config file from the repository root.
-            beast::temp_dir td;
+            beast::temp_dir const td;
             current_path(td.path());
 
             // The XDG config directory is set: the config file must be in a
             // subdirectory named after the system.
             {
-                beast::temp_dir tc;
+                beast::temp_dir const tc;
 
                 // Set the HOME and XDG_CONFIG_HOME environment variables. The
                 // HOME variable is not used when XDG_CONFIG_HOME is set, but
@@ -344,7 +344,7 @@ port_wss_admin
                 // Create the config file in '${XDG_CONFIG_HOME}/[systemName]'.
                 path p = tc.file(systemName());
                 create_directory(p);
-                p = tc.file(systemName() + "/" + configFile);
+                p = tc.file(systemName() + "/" + std::string{configFile});
                 std::ofstream o(p.string());
                 o << detail::configContents("", "");
                 o.close();
@@ -365,7 +365,7 @@ port_wss_admin
             // The XDG config directory is not set: the config file must be in a
             // subdirectory named .config followed by the system name.
             {
-                beast::temp_dir tc;
+                beast::temp_dir const tc;
 
                 // Set only the HOME environment variable.
                 char const* h = getenv("HOME");
@@ -380,7 +380,7 @@ port_wss_admin
                 s += "/" + systemName();
                 p = tc.file(s);
                 create_directory(p);
-                p = tc.file(s + "/" + configFile);
+                p = tc.file(s + "/" + std::string{configFile});
                 std::ofstream o(p.string());
                 o << detail::configContents("", "");
                 o.close();
@@ -626,7 +626,7 @@ main
         {
             // load validators from config into single section
             Config c;
-            std::string toLoad(R"xrpldConfig(
+            std::string const toLoad(R"xrpldConfig(
 [validators]
 n949f75evCHwgyP4fPVgaHqNHxUVN15PsJEZ3B3HnXPcPjcZAoy7
 n9MD5h24qrQqiyBC8aeqqCWvpiBiYQ3jxSr91uiDvmrkyHRdYLUj
@@ -644,7 +644,7 @@ nHBu9PTL9dn2GuZtdW4U2WzBwffyX9qsQCd9CNU4Z5YG3PQfViM8
         {
             // load validator list sites and keys from config
             Config c;
-            std::string toLoad(R"xrpldConfig(
+            std::string const toLoad(R"xrpldConfig(
 [validator_list_sites]
 xrpl-validators.com
 trust-these-validators.gov
@@ -674,7 +674,7 @@ trust-these-validators.gov
         {
             // load validator list sites and keys from config
             Config c;
-            std::string toLoad(R"xrpldConfig(
+            std::string const toLoad(R"xrpldConfig(
 [validator_list_sites]
 xrpl-validators.com
 trust-these-validators.gov
@@ -705,7 +705,7 @@ trust-these-validators.gov
             // load should throw if [validator_list_threshold] is greater than
             // the number of [validator_list_keys]
             Config c;
-            std::string toLoad(R"xrpldConfig(
+            std::string const toLoad(R"xrpldConfig(
 [validator_list_sites]
 xrpl-validators.com
 trust-these-validators.gov
@@ -734,7 +734,7 @@ trust-these-validators.gov
         {
             // load should throw if [validator_list_threshold] is malformed
             Config c;
-            std::string toLoad(R"xrpldConfig(
+            std::string const toLoad(R"xrpldConfig(
 [validator_list_sites]
 xrpl-validators.com
 trust-these-validators.gov
@@ -763,7 +763,7 @@ value = 2
         {
             // load should throw if [validator_list_threshold] is negative
             Config c;
-            std::string toLoad(R"xrpldConfig(
+            std::string const toLoad(R"xrpldConfig(
 [validator_list_sites]
 xrpl-validators.com
 trust-these-validators.gov
@@ -790,7 +790,7 @@ trust-these-validators.gov
             // load should throw if [validator_list_sites] is configured but
             // [validator_list_keys] is not
             Config c;
-            std::string toLoad(R"xrpldConfig(
+            std::string const toLoad(R"xrpldConfig(
 [validator_list_sites]
 xrpl-validators.com
 trust-these-validators.gov
@@ -958,7 +958,7 @@ trust-these-validators.gov
             // load should throw if [validators], [validator_keys] and
             // [validator_list_keys] are missing from xrpld.cfg and
             // validators file
-            Config c;
+            Config const c;
             boost::format cc("[validators_file]\n%1%\n");
             std::string error;
             detail::ValidatorsTxtGuard const vtg(*this, "test_cfg", "validators.cfg");
@@ -968,7 +968,7 @@ trust-these-validators.gov
                 "[validators], [validator_keys] or [validator_list_keys] "
                 "section: " +
                 vtg.validatorsFile();
-            std::ofstream o(vtg.validatorsFile());
+            std::ofstream const o(vtg.validatorsFile());
             try
             {
                 Config c2;
@@ -1141,7 +1141,7 @@ trust-these-validators.gov
         Config cfg;
         /* NOTE: this string includes some explicit
          * space chars in order to verify proper trimming */
-        std::string toLoad(
+        std::string const toLoad(
             R"(
 [port_rpc])"
             "\x20"
@@ -1182,7 +1182,7 @@ r.ripple.com 51235
         Config cfg;
         /* NOTE: this string includes some explicit
          * space chars in order to verify proper trimming */
-        std::string toLoad(
+        std::string const toLoad(
             R"(
 [port_rpc])"
             "\x20"
@@ -1261,7 +1261,7 @@ r.ripple.com:51235
             bool had_comment;
         };
 
-        std::array<TestCommentData, 13> tests = {
+        std::array<TestCommentData, 13> const tests = {
             {{"password = aaaa\\#bbbb", "password", "aaaa#bbbb", false},
              {"password = aaaa#bbbb", "password", "aaaa", true},
              {"password = aaaa #bbbb", "password", "aaaa", true},
@@ -1419,7 +1419,7 @@ r.ripple.com:51235
             bool shouldPass;
         };
 
-        std::vector<ConfigUnit> units = {
+        std::vector<ConfigUnit> const units = {
             {"seconds", 1, 15 * 60, false},
             {"minutes", 60, 14, false},
             {"minutes", 60, 15, true},
diff --git a/src/test/core/Coroutine_test.cpp b/src/test/core/Coroutine_test.cpp
index 73dc3c2f8f..4cfb86f931 100644
--- a/src/test/core/Coroutine_test.cpp
+++ b/src/test/core/Coroutine_test.cpp
@@ -34,7 +34,7 @@ public:
         void
         signal()
         {
-            std::lock_guard lk(mutex_);
+            std::lock_guard const lk(mutex_);
             signaled_ = true;
             cv_.notify_all();
         }
diff --git a/src/test/core/SociDB_test.cpp b/src/test/core/SociDB_test.cpp
index 66b368176d..c58c34756a 100644
--- a/src/test/core/SociDB_test.cpp
+++ b/src/test/core/SociDB_test.cpp
@@ -7,6 +7,8 @@
 #include <boost/algorithm/string.hpp>
 #include <boost/filesystem.hpp>
 
+#include <string_view>
+
 namespace xrpl {
 class SociDB_test final : public TestSuite
 {
@@ -87,7 +89,7 @@ public:
 
         for (auto const& i : d)
         {
-            DBConfig sc(c, i.first);
+            DBConfig const sc(c, i.first);
             BEAST_EXPECT(boost::ends_with(sc.connectionString(), i.first + i.second));
         }
     }
@@ -97,7 +99,7 @@ public:
         testcase("open");
         BasicConfig c;
         setupSQLiteConfig(c, getDatabasePath());
-        DBConfig sc(c, "SociTestDB");
+        DBConfig const sc(c, "SociTestDB");
         std::vector<std::string> const stringData({"String1", "String2", "String3"});
         std::vector<int> const intData({1, 2, 3});
         auto checkValues = [this, &stringData, &intData](soci::session& s) {
@@ -142,7 +144,7 @@ public:
         {
             namespace bfs = boost::filesystem;
             // Remove the database
-            bfs::path dbPath(sc.connectionString());
+            bfs::path const dbPath(sc.connectionString());
             if (bfs::is_regular_file(dbPath))
                 bfs::remove(dbPath);
         }
@@ -154,7 +156,7 @@ public:
         testcase("select");
         BasicConfig c;
         setupSQLiteConfig(c, getDatabasePath());
-        DBConfig sc(c, "SociTestDB");
+        DBConfig const sc(c, "SociTestDB");
         std::vector<std::uint64_t> const ubid(
             {(std::uint64_t)std::numeric_limits<std::int64_t>::max(), 20, 30});
         std::vector<std::int64_t> const bid({-10, -20, -30});
@@ -272,7 +274,7 @@ public:
         {
             namespace bfs = boost::filesystem;
             // Remove the database
-            bfs::path dbPath(sc.connectionString());
+            bfs::path const dbPath(sc.connectionString());
             if (bfs::is_regular_file(dbPath))
                 bfs::remove(dbPath);
         }
@@ -283,11 +285,12 @@ public:
         testcase("deleteWithSubselect");
         BasicConfig c;
         setupSQLiteConfig(c, getDatabasePath());
-        DBConfig sc(c, "SociTestDB");
+        DBConfig const sc(c, "SociTestDB");
         {
             soci::session s;
             sc.open(s);
-            char const* dbInit[] = {
+
+            std::string_view const dbInit[] = {
                 "BEGIN TRANSACTION;",
                 "CREATE TABLE Ledgers (                     \
                 LedgerHash      CHARACTER(64) PRIMARY KEY,  \
@@ -323,7 +326,7 @@ public:
         }
         namespace bfs = boost::filesystem;
         // Remove the database
-        bfs::path dbPath(sc.connectionString());
+        bfs::path const dbPath(sc.connectionString());
         if (bfs::is_regular_file(dbPath))
             bfs::remove(dbPath);
     }
diff --git a/src/test/core/Workers_test.cpp b/src/test/core/Workers_test.cpp
index 65245b8c94..6631cff1c4 100644
--- a/src/test/core/Workers_test.cpp
+++ b/src/test/core/Workers_test.cpp
@@ -88,7 +88,7 @@ public:
         void
         processTask(int instance) override
         {
-            std::lock_guard lk{mut};
+            std::lock_guard const lk{mut};
             if (--count == 0)
                 cv.notify_all();
         }
@@ -106,7 +106,7 @@ public:
             std::to_string(tc3));
 
         TestCallback cb;
-        std::unique_ptr<perf::PerfLog> perfLog = std::make_unique<perf::PerfLogTest>();
+        std::unique_ptr<perf::PerfLog> const perfLog = std::make_unique<perf::PerfLogTest>();
 
         Workers w(cb, perfLog.get(), "Test", tc1);
         BEAST_EXPECT(w.getNumberOfThreads() == tc1);
diff --git a/src/test/csf/BasicNetwork.h b/src/test/csf/BasicNetwork.h
index 697b20c2c7..85c77ac47d 100644
--- a/src/test/csf/BasicNetwork.h
+++ b/src/test/csf/BasicNetwork.h
@@ -199,7 +199,7 @@ BasicNetwork<Peer>::disconnect(Peer const& peer1, Peer const& peer2)
 {
     if (!links_.disconnect(peer1, peer2))
         return false;
-    bool r = links_.disconnect(peer2, peer1);
+    bool const r = links_.disconnect(peer2, peer1);
     (void)r;
     assert(r);
     return true;
diff --git a/src/test/csf/Digraph_test.cpp b/src/test/csf/Digraph_test.cpp
index a183234903..1c34bbcfec 100644
--- a/src/test/csf/Digraph_test.cpp
+++ b/src/test/csf/Digraph_test.cpp
@@ -57,7 +57,7 @@ public:
 
         // only 'a' has out edges
         BEAST_EXPECT(graph.outVertices().size() == 1);
-        std::vector<char> expected = {'b', 'c'};
+        std::vector<char> const expected = {'b', 'c'};
 
         BEAST_EXPECT((graph.outVertices('a') == expected));
         BEAST_EXPECT(graph.outVertices('b').size() == 0);
@@ -66,7 +66,7 @@ public:
 
         std::stringstream ss;
         graph.saveDot(ss, [](char v) { return v; });
-        std::string expectedDot =
+        std::string const expectedDot =
             "digraph {\n"
             "a -> b;\n"
             "a -> c;\n"
diff --git a/src/test/csf/Histogram.h b/src/test/csf/Histogram.h
index 9e7b471a2b..cbc2d42d6c 100644
--- a/src/test/csf/Histogram.h
+++ b/src/test/csf/Histogram.h
@@ -92,7 +92,7 @@ public:
     percentile(float p) const
     {
         assert(p >= 0 && p <= 1);
-        std::size_t pos = std::round(p * samples);
+        std::size_t const pos = std::round(p * samples);
 
         if (counts_.empty())
             return T{};
diff --git a/src/test/csf/Peer.h b/src/test/csf/Peer.h
index c36d600e6c..94b2c74a0b 100644
--- a/src/test/csf/Peer.h
+++ b/src/test/csf/Peer.h
@@ -550,9 +550,9 @@ struct Peer
             if (runAsValidator && isCompatible && !consensusFail &&
                 validations.canValidateSeq(newLedger.seq()))
             {
-                bool isFull = proposing;
+                bool const isFull = proposing;
 
-                Validation v{newLedger.id(), newLedger.seq(), now(), now(), key, id, isFull};
+                Validation const v{newLedger.id(), newLedger.seq(), now(), now(), key, id, isFull};
                 // share the new validation; it is trusted by the receiver
                 share(v);
                 // we trust ourselves
@@ -880,7 +880,7 @@ struct Peer
         issue(StartRound{bestLCL, lastClosedLedger});
 
         // Not yet modeling dynamic UNL.
-        hash_set<PeerID> nowUntrusted;
+        hash_set<PeerID> const nowUntrusted;
         consensus.startRound(now(), bestLCL, lastClosedLedger, nowUntrusted, runAsValidator, {});
     }
 
diff --git a/src/test/csf/PeerGroup.h b/src/test/csf/PeerGroup.h
index e900ab9934..5df6de84a6 100644
--- a/src/test/csf/PeerGroup.h
+++ b/src/test/csf/PeerGroup.h
@@ -313,8 +313,8 @@ randomRankedTrust(
     Generator& g)
 {
     std::vector<PeerGroup> const groups = randomRankedGroups(peers, ranks, numGroups, sizeDist, g);
+    std::uniform_int_distribution<int> u(0, groups.size() - 1);  // NOLINT(misc-const-correctness)
 
-    std::uniform_int_distribution<int> u(0, groups.size() - 1);
     for (auto& peer : peers)
     {
         for (auto& target : groups[u(g)])
@@ -337,8 +337,8 @@ randomRankedConnect(
     SimDuration delay)
 {
     std::vector<PeerGroup> const groups = randomRankedGroups(peers, ranks, numGroups, sizeDist, g);
+    std::uniform_int_distribution<int> u(0, groups.size() - 1);  // NOLINT(misc-const-correctness)
 
-    std::uniform_int_distribution<int> u(0, groups.size() - 1);
     for (auto& peer : peers)
     {
         for (auto& target : groups[u(g)])
diff --git a/src/test/csf/TrustGraph.h b/src/test/csf/TrustGraph.h
index bae0be4af7..3f1fcae0c1 100644
--- a/src/test/csf/TrustGraph.h
+++ b/src/test/csf/TrustGraph.h
@@ -122,9 +122,9 @@ public:
             {
                 auto const& unlA = uniqueUNLs[i];
                 auto const& unlB = uniqueUNLs[j];
-                double rhs = 2.0 * (1. - quorum) * std::max(unlA.size(), unlB.size());
+                double const rhs = 2.0 * (1. - quorum) * std::max(unlA.size(), unlB.size());
 
-                int intersectionSize = std::count_if(
+                int const intersectionSize = std::count_if(
                     unlA.begin(), unlA.end(), [&](Peer p) { return unlB.find(p) != unlB.end(); });
 
                 if (intersectionSize < rhs)
diff --git a/src/test/csf/impl/ledgers.cpp b/src/test/csf/impl/ledgers.cpp
index 2c5bf07880..9b0a4e3973 100644
--- a/src/test/csf/impl/ledgers.cpp
+++ b/src/test/csf/impl/ledgers.cpp
@@ -42,14 +42,14 @@ mismatch(Ledger const& a, Ledger const& b)
 
     // end is 1 past end of range
     Seq start{0};
-    Seq end = std::min(a.seq() + Seq{1}, b.seq() + Seq{1});
+    Seq const end = std::min(a.seq() + Seq{1}, b.seq() + Seq{1});
 
     // Find mismatch in [start,end)
     // Binary search
     Seq count = end - start;
     while (count > Seq{0})
     {
-        Seq step = count / Seq{2};
+        Seq const step = count / Seq{2};
         Seq curr = start + step;
         if (a[curr] == b[curr])
         {
diff --git a/src/test/csf/random.h b/src/test/csf/random.h
index fc5098af32..f3ecca1dbc 100644
--- a/src/test/csf/random.h
+++ b/src/test/csf/random.h
@@ -25,7 +25,7 @@ random_weighted_shuffle(std::vector<T> v, std::vector<double> w, G& g)
     for (int i = 0; i < v.size() - 1; ++i)
     {
         // pick a random item weighted by w
-        std::discrete_distribution<> dd(w.begin() + i, w.end());
+        std::discrete_distribution<> dd(w.begin() + i, w.end());  // NOLINT(misc-const-correctness)
         auto idx = dd(g);
         std::swap(v[i], v[idx]);
         std::swap(w[i], w[idx]);
diff --git a/src/test/csf/timers.h b/src/test/csf/timers.h
index c8d71d5b7a..beb4e142d9 100644
--- a/src/test/csf/timers.h
+++ b/src/test/csf/timers.h
@@ -47,11 +47,11 @@ public:
     beat(SimTime when)
     {
         using namespace std::chrono;
-        RealTime realTime = RealClock::now();
-        SimTime simTime = when;
+        RealTime const realTime = RealClock::now();
+        SimTime const simTime = when;
 
-        RealDuration realDuration = realTime - startRealTime_;
-        SimDuration simDuration = simTime - startSimTime_;
+        RealDuration const realDuration = realTime - startRealTime_;
+        SimDuration const simDuration = simTime - startSimTime_;
         out_ << "Heartbeat. Time Elapsed: {sim: " << duration_cast<seconds>(simDuration).count()
              << "s | real: " << duration_cast<seconds>(realDuration).count() << "s}\n"
              << std::flush;
diff --git a/src/test/jtx/AMMTest.h b/src/test/jtx/AMMTest.h
index dd18733ffd..a311d9c638 100644
--- a/src/test/jtx/AMMTest.h
+++ b/src/test/jtx/AMMTest.h
@@ -127,7 +127,7 @@ protected:
         void
         signal()
         {
-            std::lock_guard lk(mutex_);
+            std::lock_guard const lk(mutex_);
             signaled_ = true;
             cv_.notify_all();
         }
diff --git a/src/test/jtx/CaptureLogs.h b/src/test/jtx/CaptureLogs.h
index 8419c4dc70..8c8da6817b 100644
--- a/src/test/jtx/CaptureLogs.h
+++ b/src/test/jtx/CaptureLogs.h
@@ -37,14 +37,14 @@ class CaptureLogs : public Logs
         void
         write(beast::severities::Severity level, std::string const& text) override
         {
-            std::lock_guard lock(strmMutex_);
+            std::lock_guard const lock(strmMutex_);
             strm_ << text;
         }
 
         void
         writeAlways(beast::severities::Severity level, std::string const& text) override
         {
-            std::lock_guard lock(strmMutex_);
+            std::lock_guard const lock(strmMutex_);
             strm_ << text;
         }
     };
diff --git a/src/test/jtx/Env_test.cpp b/src/test/jtx/Env_test.cpp
index 51abac8101..4e9f0d99e2 100644
--- a/src/test/jtx/Env_test.cpp
+++ b/src/test/jtx/Env_test.cpp
@@ -37,7 +37,7 @@ public:
             Account b(a);
             a = b;
             a = std::move(b);
-            Account c(std::move(a));
+            Account const c(std::move(a));
         }
         Account("alice");                      // NOLINT(bugprone-unused-raii)
         Account("alice", KeyType::secp256k1);  // NOLINT(bugprone-unused-raii)
@@ -635,9 +635,10 @@ public:
         std::uint32_t const aliceSeq = env.seq("alice");
 
         // Sign jsonNoop.
-        Json::Value jsonNoop = env.json(noop("alice"), fee(baseFee), seq(aliceSeq), sig("alice"));
+        Json::Value const jsonNoop =
+            env.json(noop("alice"), fee(baseFee), seq(aliceSeq), sig("alice"));
         // Re-sign jsonNoop.
-        JTx jt = env.jt(jsonNoop);
+        JTx const jt = env.jt(jsonNoop);
         env(jt);
     }
 
@@ -752,7 +753,7 @@ public:
             Env env{*this, missingSomeFeatures};
             BEAST_EXPECT(env.app().config().features.size() == (supported.count() - 2));
             foreachFeature(supported, [&](uint256 const& f) {
-                bool hasnot = (f == featureDynamicMPT || f == featureTokenEscrow);
+                bool const hasnot = (f == featureDynamicMPT || f == featureTokenEscrow);
                 this->BEAST_EXPECT(hasnot != hasFeature(env, f));
             });
         }
@@ -771,7 +772,7 @@ public:
             BEAST_EXPECT(hasFeature(env, *neverSupportedFeat));
 
             foreachFeature(supported, [&](uint256 const& f) {
-                bool has = (f == featureDynamicMPT || f == featureTokenEscrow);
+                bool const has = (f == featureDynamicMPT || f == featureTokenEscrow);
                 this->BEAST_EXPECT(has == hasFeature(env, f));
             });
         }
@@ -787,7 +788,7 @@ public:
             BEAST_EXPECT(env.app().config().features.size() == (supported.count() - 2 + 1));
             BEAST_EXPECT(hasFeature(env, *neverSupportedFeat));
             foreachFeature(supported, [&](uint256 const& f) {
-                bool hasnot = (f == featureDynamicMPT || f == featureTokenEscrow);
+                bool const hasnot = (f == featureDynamicMPT || f == featureTokenEscrow);
                 this->BEAST_EXPECT(hasnot != hasFeature(env, f));
             });
         }
@@ -811,7 +812,7 @@ public:
     testExceptionalShutdown()
     {
         except([this] {
-            jtx::Env env{
+            jtx::Env const env{
                 *this,
                 jtx::envconfig([](std::unique_ptr<Config> cfg) {
                     (*cfg).deprecatedClearSection("port_rpc");
diff --git a/src/test/jtx/TestHelpers.h b/src/test/jtx/TestHelpers.h
index e2b623911c..4da086b05b 100644
--- a/src/test/jtx/TestHelpers.h
+++ b/src/test/jtx/TestHelpers.h
@@ -596,7 +596,7 @@ checkMetrics(
     std::uint64_t expectedMedFeeLevel = minEscalationFeeLevel.fee(),
     std::source_location const location = std::source_location::current())
 {
-    int line = location.line();
+    int const line = location.line();
     char const* file = location.file_name();
     FeeLevel64 const expectedMin{expectedMinFeeLevel};
     FeeLevel64 const expectedMed{expectedMedFeeLevel};
diff --git a/src/test/jtx/TrustedPublisherServer.h b/src/test/jtx/TrustedPublisherServer.h
index dc7682bb72..d36babf380 100644
--- a/src/test/jtx/TrustedPublisherServer.h
+++ b/src/test/jtx/TrustedPublisherServer.h
@@ -170,7 +170,7 @@ public:
             }
             data.pop_back();
             data += "]}";
-            std::string blob = base64_encode(data);
+            std::string const blob = base64_encode(data);
             return std::make_pair(data, blob);
         }();
         auto const sig = strHex(sign(keys.first, keys.second, makeSlice(data)));
@@ -198,7 +198,7 @@ public:
             }
             data.pop_back();
             data += "]}";
-            std::string blob = base64_encode(data);
+            std::string const blob = base64_encode(data);
             auto const sig = strHex(sign(keys.first, keys.second, makeSlice(data)));
             blobInfo.emplace_back(blob, sig);
         }
@@ -562,7 +562,7 @@ private:
                     res.result(http::status::ok);
                     res.insert("Content-Type", "text/example");
                     // if huge was requested, lie about content length
-                    std::uint64_t cl = boost::starts_with(path, "/textfile/huge")
+                    std::uint64_t const cl = boost::starts_with(path, "/textfile/huge")
                         ? std::numeric_limits<uint64_t>::max()
                         : 1024;
                     res.content_length(cl);
diff --git a/src/test/jtx/amount.h b/src/test/jtx/amount.h
index c4e97502db..1912f01330 100644
--- a/src/test/jtx/amount.h
+++ b/src/test/jtx/amount.h
@@ -196,8 +196,8 @@ public:
     PrettyAmount
     operator()(Number v, Number::rounding_mode rounding = Number::getround()) const
     {
-        NumberRoundModeGuard mg(rounding);
-        STAmount amount{asset_, v * scale_};
+        NumberRoundModeGuard const mg(rounding);
+        STAmount const amount{asset_, v * scale_};
         return {amount, ""};
     }
 
diff --git a/src/test/jtx/impl/AMM.cpp b/src/test/jtx/impl/AMM.cpp
index 7109a2131d..fe8fb8c443 100644
--- a/src/test/jtx/impl/AMM.cpp
+++ b/src/test/jtx/impl/AMM.cpp
@@ -677,13 +677,13 @@ AMM::bid(BidArg const& arg)
     };
     if (arg.bidMin)
     {
-        STAmount saTokens = getBid(*arg.bidMin);
+        STAmount const saTokens = getBid(*arg.bidMin);
         saTokens.setJson(jv[jss::BidMin]);
         bidMin_ = saTokens.iou();
     }
     if (arg.bidMax)
     {
-        STAmount saTokens = getBid(*arg.bidMax);
+        STAmount const saTokens = getBid(*arg.bidMax);
         saTokens.setJson(jv[jss::BidMax]);
         bidMax_ = saTokens.iou();
     }
diff --git a/src/test/jtx/impl/Env.cpp b/src/test/jtx/impl/Env.cpp
index 3f49a54ae6..a6344b5ab1 100644
--- a/src/test/jtx/impl/Env.cpp
+++ b/src/test/jtx/impl/Env.cpp
@@ -512,7 +512,7 @@ Env::autofill_sig(JTx& jt)
 {
     auto& jv = jt.jv;
 
-    scope_success success([&]() {
+    scope_success const success([&]() {
         // Call all the post-signers after the main signers or autofill are done
         for (auto const& signer : jt.postSigners)
             signer(*this, jt);
@@ -561,7 +561,7 @@ Env::autofill(JTx& jt)
 
     if (jt.fill_netid)
     {
-        uint32_t networkID = app().getNetworkIDService().getNetworkID();
+        uint32_t const networkID = app().getNetworkIDService().getNetworkID();
         if (!jv.isMember(jss::NetworkID) && networkID > 1024)
             jv[jss::NetworkID] = std::to_string(networkID);
     }
diff --git a/src/test/jtx/impl/WSClient.cpp b/src/test/jtx/impl/WSClient.cpp
index ebe4721d60..0c9b72c4d0 100644
--- a/src/test/jtx/impl/WSClient.cpp
+++ b/src/test/jtx/impl/WSClient.cpp
@@ -272,7 +272,7 @@ private:
         rb_.consume(rb_.size());
         auto m = std::make_shared<msg>(std::move(jv));
         {
-            std::lock_guard lock(m_);
+            std::lock_guard const lock(m_);
             msgs_.push_front(m);
             cv_.notify_all();
         }
@@ -286,7 +286,7 @@ private:
     void
     on_read_done()
     {
-        std::lock_guard lock(m0_);
+        std::lock_guard const lock(m0_);
         b0_ = true;
         cv0_.notify_all();
     }
diff --git a/src/test/jtx/impl/mpt.cpp b/src/test/jtx/impl/mpt.cpp
index 2b78777838..0a6af63450 100644
--- a/src/test/jtx/impl/mpt.cpp
+++ b/src/test/jtx/impl/mpt.cpp
@@ -140,7 +140,7 @@ MPTTester::create(MPTCreate const& arg)
     if (id_)
         Throw<std::runtime_error>("MPT can't be reused");
     id_ = makeMptID(env_.seq(issuer_), issuer_);
-    Json::Value jv = createJV(
+    Json::Value const jv = createJV(
         {.issuer = issuer_,
          .maxAmt = arg.maxAmt,
          .assetScale = arg.assetScale,
@@ -217,7 +217,7 @@ MPTTester::destroy(MPTDestroy const& arg)
 {
     if (!arg.id && !id_)
         Throw<std::runtime_error>("MPT has not been created");
-    Json::Value jv =
+    Json::Value const jv =
         destroyJV({.issuer = arg.issuer ? arg.issuer : issuer_, .id = arg.id ? arg.id : id_});
     submit(arg, jv);
 }
@@ -251,7 +251,7 @@ MPTTester::authorize(MPTAuthorize const& arg)
 {
     if (!arg.id && !id_)
         Throw<std::runtime_error>("MPT has not been created");
-    Json::Value jv = authorizeJV({
+    Json::Value const jv = authorizeJV({
         .account = arg.account ? arg.account : issuer_,
         .holder = arg.holder,
         .id = arg.id ? arg.id : id_,
@@ -361,7 +361,7 @@ MPTTester::set(MPTSet const& arg)
 {
     if (!arg.id && !id_)
         Throw<std::runtime_error>("MPT has not been created");
-    Json::Value jv = setJV(
+    Json::Value const jv = setJV(
         {.account = arg.account ? arg.account : issuer_,
          .holder = arg.holder,
          .id = arg.id ? arg.id : id_,
diff --git a/src/test/jtx/impl/multisign.cpp b/src/test/jtx/impl/multisign.cpp
index 02550b803c..8e3c37f68c 100644
--- a/src/test/jtx/impl/multisign.cpp
+++ b/src/test/jtx/impl/multisign.cpp
@@ -78,7 +78,7 @@ msig::operator()(Env& env, JTx& jt) const
             jo[jss::Account] = e.acct.human();
             jo[jss::SigningPubKey] = strHex(e.sig.pk().slice());
 
-            Serializer ss{buildMultiSigningData(*st, e.acct.id())};
+            Serializer const ss{buildMultiSigningData(*st, e.acct.id())};
             auto const sig = xrpl::sign(*publicKeyType(e.sig.pk().slice()), e.sig.sk(), ss.slice());
             jo[sfTxnSignature.getJsonName()] = strHex(Slice{sig.data(), sig.size()});
         }
diff --git a/src/test/jtx/impl/permissioned_dex.cpp b/src/test/jtx/impl/permissioned_dex.cpp
index 87b7896663..494ea897d4 100644
--- a/src/test/jtx/impl/permissioned_dex.cpp
+++ b/src/test/jtx/impl/permissioned_dex.cpp
@@ -20,7 +20,7 @@ setupDomain(
     env.fund(XRP(100000), domainOwner);
     env.close();
 
-    pdomain::Credentials credentials{{domainOwner, credType}};
+    pdomain::Credentials const credentials{{domainOwner, credType}};
     env(pdomain::setTx(domainOwner, credentials));
 
     auto const objects = pdomain::getObjects(domainOwner, env);
diff --git a/src/test/jtx/impl/xchain_bridge.cpp b/src/test/jtx/impl/xchain_bridge.cpp
index c2617f5073..19c1b7fab5 100644
--- a/src/test/jtx/impl/xchain_bridge.cpp
+++ b/src/test/jtx/impl/xchain_bridge.cpp
@@ -431,7 +431,7 @@ XChainBridgeObjects::XChainBridgeObjects()
 void
 XChainBridgeObjects::createMcBridgeObjects(Env& mcEnv)
 {
-    STAmount xrp_funds{XRP(10000)};
+    STAmount const xrp_funds{XRP(10000)};
     mcEnv.fund(xrp_funds, mcDoor, mcAlice, mcBob, mcCarol, mcGw);
 
     // Signer's list must match the attestation signers
@@ -448,7 +448,7 @@ XChainBridgeObjects::createMcBridgeObjects(Env& mcEnv)
 void
 XChainBridgeObjects::createScBridgeObjects(Env& scEnv)
 {
-    STAmount xrp_funds{XRP(10000)};
+    STAmount const xrp_funds{XRP(10000)};
     scEnv.fund(xrp_funds, scDoor, scAlice, scBob, scCarol, scGw, scAttester, scReward);
 
     // Signer's list must match the attestation signers
diff --git a/src/test/ledger/BookDirs_test.cpp b/src/test/ledger/BookDirs_test.cpp
index d7841fe502..e8733d159d 100644
--- a/src/test/ledger/BookDirs_test.cpp
+++ b/src/test/ledger/BookDirs_test.cpp
@@ -19,7 +19,7 @@ struct BookDirs_test : public beast::unit_test::suite
         env.close();
 
         {
-            Book book(xrpIssue(), USD.issue(), std::nullopt);
+            Book const book(xrpIssue(), USD.issue(), std::nullopt);
             {
                 auto d = BookDirs(*env.current(), book);
                 BEAST_EXPECT(std::begin(d) == std::end(d));
diff --git a/src/test/ledger/Directory_test.cpp b/src/test/ledger/Directory_test.cpp
index aec472fc6f..4115d03c19 100644
--- a/src/test/ledger/Directory_test.cpp
+++ b/src/test/ledger/Directory_test.cpp
@@ -282,7 +282,7 @@ struct Directory_test : public beast::unit_test::suite
         // All the offers have been cancelled, so the book
         // should have no entries and be empty:
         {
-            Sandbox sb(env.closed().get(), tapNONE);
+            Sandbox const sb(env.closed().get(), tapNONE);
             uint256 const bookBase = getBookBase({xrpIssue(), USD.issue(), std::nullopt});
 
             BEAST_EXPECT(dirIsEmpty(sb, keylet::page(bookBase)));
diff --git a/src/test/ledger/PaymentSandbox_test.cpp b/src/test/ledger/PaymentSandbox_test.cpp
index df23381ed3..ab01c4852e 100644
--- a/src/test/ledger/PaymentSandbox_test.cpp
+++ b/src/test/ledger/PaymentSandbox_test.cpp
@@ -65,7 +65,7 @@ class PaymentSandbox_test : public beast::unit_test::suite
         env(offer(snd, USD_gw1(2), USD_gw2(2)), txflags(tfPassive));
         env(offer(snd, USD_gw2(2), USD_gw1(2)), txflags(tfPassive));
 
-        PathSet paths(Path(gw1, USD_gw2, gw2), Path(gw2, USD_gw1, gw1));
+        PathSet const paths(Path(gw1, USD_gw2, gw2), Path(gw2, USD_gw1, gw1));
 
         env(pay(snd, rcv, any(USD_gw1(4))),
             json(paths.json()),
@@ -266,16 +266,16 @@ class PaymentSandbox_test : public beast::unit_test::suite
 
         using namespace jtx;
 
-        Env env(*this, features);
+        Env const env(*this, features);
 
         Account const gw("gw");
         Account const alice("alice");
         auto const USD = gw["USD"];
 
         auto const issue = USD.issue();
-        STAmount tinyAmt(
+        STAmount const tinyAmt(
             issue, STAmount::cMinValue, STAmount::cMinOffset + 1, false, STAmount::unchecked{});
-        STAmount hugeAmt(
+        STAmount const hugeAmt(
             issue, STAmount::cMaxValue, STAmount::cMaxOffset - 1, false, STAmount::unchecked{});
 
         ApplyViewImpl av(&*env.current(), tapNONE);
@@ -333,7 +333,7 @@ class PaymentSandbox_test : public beast::unit_test::suite
         testcase("balanceHook");
 
         using namespace jtx;
-        Env env(*this, features);
+        Env const env(*this, features);
 
         Account const gw("gw");
         auto const USD = gw["USD"];
diff --git a/src/test/ledger/SkipList_test.cpp b/src/test/ledger/SkipList_test.cpp
index ba339878ef..a2695bfce8 100644
--- a/src/test/ledger/SkipList_test.cpp
+++ b/src/test/ledger/SkipList_test.cpp
@@ -15,7 +15,7 @@ class SkipList_test : public beast::unit_test::suite
         jtx::Env env(*this);
         std::vector<std::shared_ptr<Ledger>> history;
         {
-            Config config;
+            Config const config;
             auto prev = std::make_shared<Ledger>(
                 create_genesis,
                 Rules{config.features},
diff --git a/src/test/ledger/View_test.cpp b/src/test/ledger/View_test.cpp
index 6e11508156..d2d930732e 100644
--- a/src/test/ledger/View_test.cpp
+++ b/src/test/ledger/View_test.cpp
@@ -114,7 +114,7 @@ class View_test : public beast::unit_test::suite
 
         using namespace jtx;
         Env env(*this);
-        Config config;
+        Config const config;
         std::shared_ptr<Ledger const> const genesis = std::make_shared<Ledger>(
             create_genesis,
             Rules{config.features},
@@ -124,7 +124,7 @@ class View_test : public beast::unit_test::suite
         auto const ledger =
             std::make_shared<Ledger>(*genesis, env.app().getTimeKeeper().closeTime());
         wipe(*ledger);
-        ReadView& v = *ledger;
+        ReadView const& v = *ledger;
         succ(v, 0, std::nullopt);
         ledger->rawInsert(sle(1, 1));
         BEAST_EXPECT(v.exists(k(1)));
@@ -338,7 +338,7 @@ class View_test : public beast::unit_test::suite
                 BEAST_EXPECT(v2.seq() == v1.seq());
                 BEAST_EXPECT(v2.flags() == tapRETRY);
 
-                Sandbox v3(&v2);
+                Sandbox const v3(&v2);
                 BEAST_EXPECT(v3.seq() == v2.seq());
                 BEAST_EXPECT(v3.parentCloseTime() == v2.parentCloseTime());
                 BEAST_EXPECT(v3.flags() == tapRETRY);
@@ -349,7 +349,7 @@ class View_test : public beast::unit_test::suite
                 BEAST_EXPECT(v2.seq() == v0.seq());
                 BEAST_EXPECT(v2.parentCloseTime() == v0.parentCloseTime());
                 BEAST_EXPECT(v2.flags() == tapRETRY);
-                PaymentSandbox v3(&v2);
+                PaymentSandbox const v3(&v2);
                 BEAST_EXPECT(v3.seq() == v2.seq());
                 BEAST_EXPECT(v3.parentCloseTime() == v2.parentCloseTime());
                 BEAST_EXPECT(v3.flags() == v2.flags());
@@ -382,7 +382,7 @@ class View_test : public beast::unit_test::suite
 
         using namespace jtx;
         Env env(*this);
-        Config config;
+        Config const config;
         std::shared_ptr<Ledger const> const genesis = std::make_shared<Ledger>(
             create_genesis,
             Rules{config.features},
@@ -591,7 +591,7 @@ class View_test : public beast::unit_test::suite
 
         using namespace jtx;
         Env env(*this);
-        Config config;
+        Config const config;
         std::shared_ptr<Ledger const> const genesis = std::make_shared<Ledger>(
             create_genesis,
             Rules{config.features},
@@ -942,7 +942,7 @@ class View_test : public beast::unit_test::suite
         // erase the item, apply.
         {
             Env env(*this);
-            Config config;
+            Config const config;
             std::shared_ptr<Ledger const> const genesis = std::make_shared<Ledger>(
                 create_genesis,
                 Rules{config.features},
@@ -953,7 +953,7 @@ class View_test : public beast::unit_test::suite
                 std::make_shared<Ledger>(*genesis, env.app().getTimeKeeper().closeTime());
             wipe(*ledger);
             ledger->rawInsert(sle(1));
-            ReadView& v0 = *ledger;
+            ReadView const& v0 = *ledger;
             ApplyViewImpl v1(&v0, tapNONE);
             {
                 Sandbox v2(&v1);
diff --git a/src/test/nodestore/Backend_test.cpp b/src/test/nodestore/Backend_test.cpp
index 19f3bc43e5..101138de88 100644
--- a/src/test/nodestore/Backend_test.cpp
+++ b/src/test/nodestore/Backend_test.cpp
@@ -26,7 +26,7 @@ public:
         testcase("Backend type=" + type);
 
         Section params;
-        beast::temp_dir tempDir;
+        beast::temp_dir const tempDir;
         params.set("type", type);
         params.set("path", tempDir.path());
 
diff --git a/src/test/nodestore/Basics_test.cpp b/src/test/nodestore/Basics_test.cpp
index e37544f58e..c9755d04d7 100644
--- a/src/test/nodestore/Basics_test.cpp
+++ b/src/test/nodestore/Basics_test.cpp
@@ -38,7 +38,7 @@ public:
 
         for (int i = 0; i < batch.size(); ++i)
         {
-            EncodedBlob encoded(batch[i]);
+            EncodedBlob const encoded(batch[i]);
 
             DecodedBlob decoded(encoded.getKey(), encoded.getData(), encoded.getSize());
 
diff --git a/src/test/nodestore/Database_test.cpp b/src/test/nodestore/Database_test.cpp
index 6943f0733e..43bda9dcae 100644
--- a/src/test/nodestore/Database_test.cpp
+++ b/src/test/nodestore/Database_test.cpp
@@ -191,7 +191,7 @@ public:
 
             try
             {
-                Env env(
+                Env const env(
                     *this,
                     std::move(p),
                     std::make_unique<CheckMessageLogs>(expected, &found),
@@ -220,7 +220,7 @@ public:
 
             try
             {
-                Env env(
+                Env const env(
                     *this,
                     std::move(p),
                     std::make_unique<CheckMessageLogs>(expected, &found),
@@ -249,7 +249,7 @@ public:
 
             try
             {
-                Env env(
+                Env const env(
                     *this,
                     std::move(p),
                     std::make_unique<CheckMessageLogs>(expected, &found),
@@ -278,7 +278,7 @@ public:
 
             try
             {
-                Env env(
+                Env const env(
                     *this,
                     std::move(p),
                     std::make_unique<CheckMessageLogs>(expected, &found),
@@ -306,7 +306,7 @@ public:
 
             try
             {
-                Env env(
+                Env const env(
                     *this,
                     std::move(p),
                     std::make_unique<CheckMessageLogs>(expected, &found),
@@ -334,7 +334,7 @@ public:
 
             try
             {
-                Env env(
+                Env const env(
                     *this,
                     std::move(p),
                     std::make_unique<CheckMessageLogs>(expected, &found),
@@ -362,7 +362,7 @@ public:
 
             try
             {
-                Env env(
+                Env const env(
                     *this,
                     std::move(p),
                     std::make_unique<CheckMessageLogs>(expected, &found),
@@ -390,7 +390,7 @@ public:
 
             try
             {
-                Env env(
+                Env const env(
                     *this,
                     std::move(p),
                     std::make_unique<CheckMessageLogs>(expected, &found),
@@ -445,7 +445,7 @@ public:
             }
             try
             {
-                Env env(
+                Env const env(
                     *this,
                     std::move(p),
                     std::make_unique<CheckMessageLogs>(expected, &found),
@@ -468,7 +468,7 @@ public:
             }
             try
             {
-                Env env(
+                Env const env(
                     *this,
                     std::move(p),
                     std::make_unique<CheckMessageLogs>(expected, &found),
@@ -491,7 +491,7 @@ public:
             }
             try
             {
-                Env env(
+                Env const env(
                     *this,
                     std::move(p),
                     std::make_unique<CheckMessageLogs>(expected, &found),
@@ -515,7 +515,7 @@ public:
     {
         DummyScheduler scheduler;
 
-        beast::temp_dir node_db;
+        beast::temp_dir const node_db;
         Section srcParams;
         srcParams.set("type", srcBackendType);
         srcParams.set("path", node_db.path());
@@ -538,7 +538,7 @@ public:
                 Manager::instance().make_Database(megabytes(4), scheduler, 2, srcParams, journal_);
 
             // Set up the destination database
-            beast::temp_dir dest_db;
+            beast::temp_dir const dest_db;
             Section destParams;
             destParams.set("type", destBackendType);
             destParams.set("path", dest_db.path());
@@ -572,11 +572,11 @@ public:
     {
         DummyScheduler scheduler;
 
-        std::string s = "NodeStore backend '" + type + "'";
+        std::string const s = "NodeStore backend '" + type + "'";
 
         testcase(s);
 
-        beast::temp_dir node_db;
+        beast::temp_dir const node_db;
         Section nodeParams;
         nodeParams.set("type", type);
         nodeParams.set("path", node_db.path());
@@ -639,7 +639,7 @@ public:
             try
             {
                 nodeParams.set("earliest_seq", "0");
-                std::unique_ptr<Database> db = Manager::instance().make_Database(
+                std::unique_ptr<Database> const db = Manager::instance().make_Database(
                     megabytes(4), scheduler, 2, nodeParams, journal_);
             }
             catch (std::runtime_error const& e)
@@ -662,7 +662,7 @@ public:
             {
                 // Set to default earliest ledger sequence
                 nodeParams.set("earliest_seq", std::to_string(XRP_LEDGER_EARLIEST_SEQ));
-                std::unique_ptr<Database> db2 = Manager::instance().make_Database(
+                std::unique_ptr<Database> const db2 = Manager::instance().make_Database(
                     megabytes(4), scheduler, 2, nodeParams, journal_);
             }
             catch (std::runtime_error const& e)
diff --git a/src/test/nodestore/NuDBFactory_test.cpp b/src/test/nodestore/NuDBFactory_test.cpp
index 0aa910ce01..3e6b68c9e5 100644
--- a/src/test/nodestore/NuDBFactory_test.cpp
+++ b/src/test/nodestore/NuDBFactory_test.cpp
@@ -76,12 +76,12 @@ private:
         std::string const& expectedMessage)
     {
         test::StreamSink sink(level);
-        beast::Journal journal(sink);
+        beast::Journal const journal(sink);
 
         DummyScheduler scheduler;
         auto backend = Manager::instance().make_Backend(params, megabytes(4), scheduler, journal);
 
-        std::string logOutput = sink.messages().str();
+        std::string const logOutput = sink.messages().str();
         BEAST_EXPECT(logOutput.find(expectedMessage) != std::string::npos);
     }
 
@@ -89,17 +89,17 @@ private:
     void
     testPowerOfTwoValidation(std::string const& size, bool shouldWork)
     {
-        beast::temp_dir tempDir;
+        beast::temp_dir const tempDir;
         auto params = createSection(tempDir.path(), size);
 
         test::StreamSink sink(beast::severities::kWarning);
-        beast::Journal journal(sink);
+        beast::Journal const journal(sink);
 
         DummyScheduler scheduler;
         auto backend = Manager::instance().make_Backend(params, megabytes(4), scheduler, journal);
 
-        std::string logOutput = sink.messages().str();
-        bool hasWarning = logOutput.find("Invalid nudb_block_size") != std::string::npos;
+        std::string const logOutput = sink.messages().str();
+        bool const hasWarning = logOutput.find("Invalid nudb_block_size") != std::string::npos;
 
         BEAST_EXPECT(hasWarning == !shouldWork);
     }
@@ -110,7 +110,7 @@ public:
     {
         testcase("Default block size (no nudb_block_size specified)");
 
-        beast::temp_dir tempDir;
+        beast::temp_dir const tempDir;
         auto params = createSection(tempDir.path());
 
         // Should work with default 4096 block size
@@ -122,18 +122,18 @@ public:
     {
         testcase("Valid block sizes");
 
-        std::vector<std::size_t> validSizes = {4096, 8192, 16384, 32768};
+        std::vector<std::size_t> const validSizes = {4096, 8192, 16384, 32768};
 
         for (auto const& size : validSizes)
         {
-            beast::temp_dir tempDir;
+            beast::temp_dir const tempDir;
             auto params = createSection(tempDir.path(), to_string(size));
 
             BEAST_EXPECT(testBackendFunctionality(params, size));
         }
         // Empty value is ignored by the config parser, so uses the
         // default
-        beast::temp_dir tempDir;
+        beast::temp_dir const tempDir;
         auto params = createSection(tempDir.path(), "");
 
         BEAST_EXPECT(testBackendFunctionality(params, 4096));
@@ -144,7 +144,7 @@ public:
     {
         testcase("Invalid block sizes");
 
-        std::vector<std::string> invalidSizes = {
+        std::vector<std::string> const invalidSizes = {
             "2048",    // Too small
             "1024",    // Too small
             "65536",   // Too large
@@ -161,7 +161,7 @@ public:
 
         for (auto const& size : invalidSizes)
         {
-            beast::temp_dir tempDir;
+            beast::temp_dir const tempDir;
             auto params = createSection(tempDir.path(), size);
 
             // Fails
@@ -169,14 +169,14 @@ public:
         }
 
         // Test whitespace cases separately since lexical_cast may handle them
-        std::vector<std::string> whitespaceInvalidSizes = {
+        std::vector<std::string> const whitespaceInvalidSizes = {
             "4096 ",  // Trailing space - might be handled by lexical_cast
             " 4096"   // Leading space - might be handled by lexical_cast
         };
 
         for (auto const& size : whitespaceInvalidSizes)
         {
-            beast::temp_dir tempDir;
+            beast::temp_dir const tempDir;
             auto params = createSection(tempDir.path(), size);
 
             // Fails
@@ -191,7 +191,7 @@ public:
 
         // Test valid custom block size logging
         {
-            beast::temp_dir tempDir;
+            beast::temp_dir const tempDir;
             auto params = createSection(tempDir.path(), "8192");
 
             testLogMessage(params, beast::severities::kInfo, "Using custom NuDB block size: 8192");
@@ -199,11 +199,11 @@ public:
 
         // Test invalid block size failure
         {
-            beast::temp_dir tempDir;
+            beast::temp_dir const tempDir;
             auto params = createSection(tempDir.path(), "5000");
 
             test::StreamSink sink(beast::severities::kWarning);
-            beast::Journal journal(sink);
+            beast::Journal const journal(sink);
 
             DummyScheduler scheduler;
             try
@@ -214,7 +214,7 @@ public:
             }
             catch (std::exception const& e)
             {
-                std::string logOutput{e.what()};
+                std::string const logOutput{e.what()};
                 BEAST_EXPECT(logOutput.find("Invalid nudb_block_size: 5000") != std::string::npos);
                 BEAST_EXPECT(
                     logOutput.find("Must be power of 2 between 4096 and 32768") !=
@@ -224,11 +224,11 @@ public:
 
         // Test non-numeric value failure
         {
-            beast::temp_dir tempDir;
+            beast::temp_dir const tempDir;
             auto params = createSection(tempDir.path(), "invalid");
 
             test::StreamSink sink(beast::severities::kWarning);
-            beast::Journal journal(sink);
+            beast::Journal const journal(sink);
 
             DummyScheduler scheduler;
             try
@@ -240,7 +240,7 @@ public:
             }
             catch (std::exception const& e)
             {
-                std::string logOutput{e.what()};
+                std::string const logOutput{e.what()};
                 BEAST_EXPECT(
                     logOutput.find("Invalid nudb_block_size value: invalid") != std::string::npos);
             }
@@ -253,7 +253,7 @@ public:
         testcase("Power of 2 validation logic");
 
         // Test edge cases around valid range
-        std::vector<std::pair<std::string, bool>> testCases = {
+        std::vector<std::pair<std::string, bool>> const testCases = {
             {"4095", false},   // Just below minimum
             {"4096", true},    // Minimum valid
             {"4097", false},   // Just above minimum, not power of 2
@@ -267,13 +267,13 @@ public:
 
         for (auto const& [size, shouldWork] : testCases)
         {
-            beast::temp_dir tempDir;
+            beast::temp_dir const tempDir;
             auto params = createSection(tempDir.path(), size);
 
             // We test the validation logic by catching exceptions for invalid
             // values
             test::StreamSink sink(beast::severities::kWarning);
-            beast::Journal journal(sink);
+            beast::Journal const journal(sink);
 
             DummyScheduler scheduler;
             try
@@ -284,7 +284,7 @@ public:
             }
             catch (std::exception const& e)
             {
-                std::string logOutput{e.what()};
+                std::string const logOutput{e.what()};
                 BEAST_EXPECT(logOutput.find("Invalid nudb_block_size") != std::string::npos);
             }
         }
@@ -295,7 +295,7 @@ public:
     {
         testcase("Both constructor variants work with custom block size");
 
-        beast::temp_dir tempDir;
+        beast::temp_dir const tempDir;
         auto params = createSection(tempDir.path(), "16384");
 
         DummyScheduler scheduler;
@@ -321,13 +321,13 @@ public:
         testcase("Configuration parsing edge cases");
 
         // Test that whitespace is handled correctly
-        std::vector<std::string> validFormats = {
+        std::vector<std::string> const validFormats = {
             "8192"  // Basic valid format
         };
 
         // Test whitespace handling separately since lexical_cast behavior may
         // vary
-        std::vector<std::string> whitespaceFormats = {
+        std::vector<std::string> const whitespaceFormats = {
             " 8192",  // Leading space - may or may not be handled by
                       // lexical_cast
             "8192 "   // Trailing space - may or may not be handled by
@@ -337,19 +337,19 @@ public:
         // Test basic valid format
         for (auto const& format : validFormats)
         {
-            beast::temp_dir tempDir;
+            beast::temp_dir const tempDir;
             auto params = createSection(tempDir.path(), format);
 
             test::StreamSink sink(beast::severities::kInfo);
-            beast::Journal journal(sink);
+            beast::Journal const journal(sink);
 
             DummyScheduler scheduler;
             auto backend =
                 Manager::instance().make_Backend(params, megabytes(4), scheduler, journal);
 
             // Should log success message for valid values
-            std::string logOutput = sink.messages().str();
-            bool hasSuccessMessage =
+            std::string const logOutput = sink.messages().str();
+            bool const hasSuccessMessage =
                 logOutput.find("Using custom NuDB block size") != std::string::npos;
             BEAST_EXPECT(hasSuccessMessage);
         }
@@ -358,12 +358,12 @@ public:
         // them
         for (auto const& format : whitespaceFormats)
         {
-            beast::temp_dir tempDir;
+            beast::temp_dir const tempDir;
             auto params = createSection(tempDir.path(), format);
 
             // Use a lower threshold to capture both info and warning messages
             test::StreamSink sink(beast::severities::kDebug);
-            beast::Journal journal(sink);
+            beast::Journal const journal(sink);
 
             DummyScheduler scheduler;
             try
@@ -385,11 +385,11 @@ public:
     {
         testcase("Data persistence with different block sizes");
 
-        std::vector<std::string> blockSizes = {"4096", "8192", "16384", "32768"};
+        std::vector<std::string> const blockSizes = {"4096", "8192", "16384", "32768"};
 
         for (auto const& size : blockSizes)
         {
-            beast::temp_dir tempDir;
+            beast::temp_dir const tempDir;
             auto params = createSection(tempDir.path(), size);
 
             DummyScheduler scheduler;
diff --git a/src/test/nodestore/TestBase.h b/src/test/nodestore/TestBase.h
index cb2a8e3bd5..893e06579c 100644
--- a/src/test/nodestore/TestBase.h
+++ b/src/test/nodestore/TestBase.h
@@ -187,7 +187,7 @@ public:
 
         for (int i = 0; i < batch.size(); ++i)
         {
-            std::shared_ptr<NodeObject> object = db.fetchNodeObject(batch[i]->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 fc8c042252..fb60e6c7a5 100644
--- a/src/test/nodestore/Timing_test.cpp
+++ b/src/test/nodestore/Timing_test.cpp
@@ -645,7 +645,7 @@ public:
             params.threads = threads;
             for (auto i = default_repeat; (i--) != 0u;)
             {
-                beast::temp_dir tempDir;
+                beast::temp_dir const tempDir;
                 Section config = parse(config_string);
                 config.set("path", tempDir.path());
                 std::stringstream ss;
@@ -672,7 +672,7 @@ public:
             items           Number of objects to create in the database
 
         */
-        std::string default_args =
+        std::string const default_args =
             "type=nudb"
 #if XRPL_ROCKSDB_AVAILABLE
             ";type=rocksdb,open_files=2000,filter_bits=12,cache_mb=256,"
diff --git a/src/test/nodestore/import_test.cpp b/src/test/nodestore/import_test.cpp
index 54d55e5ad0..6d336c1f51 100644
--- a/src/test/nodestore/import_test.cpp
+++ b/src/test/nodestore/import_test.cpp
@@ -71,7 +71,7 @@ template <class Rep, class Period>
 std::ostream&
 pretty_time(std::ostream& os, std::chrono::duration<Rep, Period> d)
 {
-    save_stream_state _(os);
+    save_stream_state const _(os);
     using namespace std::chrono;
     if (d < microseconds{1})
     {
@@ -332,7 +332,7 @@ public:
             options.create_if_missing = false;
             options.max_open_files = 2000;  // 5000?
             rocksdb::DB* pdb = nullptr;
-            rocksdb::Status status = rocksdb::DB::OpenForReadOnly(options, from_path, &pdb);
+            rocksdb::Status const status = rocksdb::DB::OpenForReadOnly(options, from_path, &pdb);
             if (!status.ok() || (pdb == nullptr))
                 Throw<std::runtime_error>("Can't open '" + from_path + "': " + status.ToString());
             db.reset(pdb);
@@ -374,7 +374,7 @@ public:
                 void const* const key = it->key().data();
                 void const* const data = it->value().data();
                 auto const size = it->value().size();
-                std::unique_ptr<char[]> clean(new char[size]);
+                std::unique_ptr<char[]> const clean(new char[size]);
                 std::memcpy(clean.get(), data, size);
                 filter_inner(clean.get(), size);
                 auto const out = nodeobject_compress(clean.get(), size, buf);
@@ -458,7 +458,7 @@ public:
             // Create empty buckets
             for (std::size_t i = 0; i < bn; ++i)
             {
-                bucket b(kh.block_size, buf.get() + (i * kh.block_size), empty);
+                bucket const b(kh.block_size, buf.get() + (i * kh.block_size), empty);
             }
             // Insert all keys into buckets
             // Iterate Data File
diff --git a/src/test/overlay/TMGetObjectByHash_test.cpp b/src/test/overlay/TMGetObjectByHash_test.cpp
index e4da8a28c7..a2a934f182 100644
--- a/src/test/overlay/TMGetObjectByHash_test.cpp
+++ b/src/test/overlay/TMGetObjectByHash_test.cpp
@@ -100,10 +100,10 @@ class TMGetObjectByHash_test : public beast::unit_test::suite
         auto stream_ptr =
             std::make_unique<stream_type>(socket_type(env.app().getIOContext()), *context_);
 
-        beast::IP::Endpoint local(boost::asio::ip::make_address("172.1.1.1"), 51235);
-        beast::IP::Endpoint remote(boost::asio::ip::make_address("172.1.1.2"), 51235);
+        beast::IP::Endpoint const local(boost::asio::ip::make_address("172.1.1.1"), 51235);
+        beast::IP::Endpoint const remote(boost::asio::ip::make_address("172.1.1.2"), 51235);
 
-        PublicKey key(std::get<0>(randomKeyPair(KeyType::ed25519)));
+        PublicKey const key(std::get<0>(randomKeyPair(KeyType::ed25519)));
         auto consumer = overlay.resourceManager().newInboundEndpoint(remote);
         auto [slot, _] = overlay.peerFinder().new_inbound_slot(local, remote);
 
@@ -132,7 +132,7 @@ class TMGetObjectByHash_test : public beast::unit_test::suite
         hashes.reserve(numObjects);
         for (int i = 0; i < numObjects; ++i)
         {
-            uint256 hash(xrpl::sha512Half(i));
+            uint256 const hash(xrpl::sha512Half(i));
             hashes.push_back(hash);
 
             Blob data(100, static_cast<unsigned char>(i % 256));
diff --git a/src/test/overlay/cluster_test.cpp b/src/test/overlay/cluster_test.cpp
index 59fa22a442..6fc7f3f59b 100644
--- a/src/test/overlay/cluster_test.cpp
+++ b/src/test/overlay/cluster_test.cpp
@@ -113,7 +113,7 @@ public:
 
         auto const node = randomNode();
         auto const name = toBase58(TokenType::NodePublic, node);
-        std::uint32_t load = 0;
+        std::uint32_t const load = 0;
         NetClock::time_point tick = {};
 
         // Initial update
diff --git a/src/test/overlay/compression_test.cpp b/src/test/overlay/compression_test.cpp
index 8cee7df7d2..4ffc805726 100644
--- a/src/test/overlay/compression_test.cpp
+++ b/src/test/overlay/compression_test.cpp
@@ -163,7 +163,7 @@ public:
     buildTransaction(Logs& logs)
     {
         Env env(*this, envconfig());
-        int fund = 10000;
+        int const fund = 10000;
         auto const alice = Account("alice");
         auto const bob = Account("bob");
         env.fund(XRP(fund), "alice", "bob");
@@ -205,7 +205,7 @@ public:
         uint256 const hash(xrpl::sha512Half(123456789));
         getLedger->set_ledgerhash(hash.begin(), hash.size());
         getLedger->set_ledgerseq(123456789);
-        xrpl::SHAMapNodeID sha(64, hash);
+        xrpl::SHAMapNodeID const sha(64, hash);
         getLedger->add_nodeids(sha.getRawString());
         getLedger->set_requestcookie(123456789);
         getLedger->set_querytype(protocol::qtINDIRECT);
@@ -268,7 +268,7 @@ public:
             uint256 hash(xrpl::sha512Half(i));
             auto object = getObject->add_objects();
             object->set_hash(hash.data(), hash.size());
-            xrpl::SHAMapNodeID sha(64, hash);
+            xrpl::SHAMapNodeID const sha(64, hash);
             object->set_nodeid(sha.getRawString());
             object->set_index("");
             object->set_data("");
@@ -295,7 +295,7 @@ public:
         st.add(s);
         list->set_manifest(s.data(), s.size());
         list->set_version(3);
-        STObject signature(sfSignature);
+        STObject const signature(sfSignature);
         xrpl::sign(st, HashPrefix::manifest, KeyType::ed25519, std::get<1>(signing));
         Serializer s1;
         st.add(s1);
@@ -322,7 +322,7 @@ public:
         st.add(s);
         list->set_manifest(s.data(), s.size());
         list->set_version(4);
-        STObject signature(sfSignature);
+        STObject const signature(sfSignature);
         xrpl::sign(st, HashPrefix::manifest, KeyType::ed25519, std::get<1>(signing));
         Serializer s1;
         st.add(s1);
@@ -338,14 +338,14 @@ public:
         auto thresh = beast::severities::Severity::kInfo;
         auto logs = std::make_unique<Logs>(thresh);
 
-        protocol::TMManifests manifests;
-        protocol::TMEndpoints endpoints;
-        protocol::TMTransaction transaction;
-        protocol::TMGetLedger get_ledger;
-        protocol::TMLedgerData ledger_data;
-        protocol::TMGetObjectByHash get_object;
-        protocol::TMValidatorList validator_list;
-        protocol::TMValidatorListCollection validator_list_collection;
+        protocol::TMManifests const manifests;
+        protocol::TMEndpoints const endpoints;
+        protocol::TMTransaction const transaction;
+        protocol::TMGetLedger const get_ledger;
+        protocol::TMLedgerData const ledger_data;
+        protocol::TMGetObjectByHash const get_object;
+        protocol::TMValidatorList const validator_list;
+        protocol::TMValidatorListCollection const validator_list_collection;
 
         // 4.5KB
         doTest(buildManifests(20), protocol::mtMANIFESTS, 4, "TMManifests20");
@@ -399,7 +399,7 @@ public:
             return env;
         };
         auto handshake = [&](int outboundEnable, int inboundEnable) {
-            beast::IP::Address addr = boost::asio::ip::make_address("172.1.1.100");
+            beast::IP::Address const addr = boost::asio::ip::make_address("172.1.1.100");
 
             auto env = getEnv(outboundEnable);
             auto request = xrpl::makeRequest(
diff --git a/src/test/overlay/reduce_relay_test.cpp b/src/test/overlay/reduce_relay_test.cpp
index 895332b94f..4a8d62fbc2 100644
--- a/src/test/overlay/reduce_relay_test.cpp
+++ b/src/test/overlay/reduce_relay_test.cpp
@@ -120,7 +120,7 @@ public:
     uint256 const&
     getClosedLedgerHash() const override
     {
-        static uint256 hash{};
+        static uint256 const hash{};
         return hash;
     }
     bool
@@ -481,7 +481,7 @@ public:
     onMessage(protocol::TMSquelch const& squelch) override
     {
         auto validator = squelch.validatorpubkey();
-        PublicKey key(Slice(validator.data(), validator.size()));
+        PublicKey const key(Slice(validator.data(), validator.size()));
         if (squelch.squelch())
         {
             squelch_.addSquelch(key, std::chrono::seconds{squelch.squelchduration()});
@@ -776,7 +776,7 @@ public:
         squelch.set_squelch(false);
         for (auto& v : validators_)
         {
-            PublicKey key = v;
+            PublicKey const key = v;
             squelch.clear_validatorpubkey();
             squelch.set_validatorpubkey(key.data(), key.size());
             v.for_links({peer}, [&](Link& l, MessageSPtr) {
@@ -886,7 +886,7 @@ protected:
         std::optional<std::uint32_t> duration)
     {
         protocol::TMSquelch squelch;
-        bool res = static_cast<bool>(duration);
+        bool const res = static_cast<bool>(duration);
         squelch.set_squelch(res);
         squelch.set_validatorpubkey(validator.data(), validator.size());
         if (res)
@@ -992,7 +992,7 @@ protected:
             if (events[EventType::PeerDisconnected].state_ == State::On)
             {
                 auto& event = events[EventType::PeerDisconnected];
-                bool allCounting = network_.allCounting(event.peer_);
+                bool const allCounting = network_.allCounting(event.peer_);
                 network_.overlay().deletePeer(
                     event.peer_, [&](PublicKey const& v, PeerWPtr const& peerPtr) {
                         if (event.isSelected_)
@@ -1004,7 +1004,7 @@ protected:
                 // take place because there is no peers in Squelched state in
                 // any of the slots where the peer is in Selected state
                 // (allCounting is true)
-                bool handled = (!event.isSelected_ && !event.handled_) ||
+                bool const handled = (!event.isSelected_ && !event.handled_) ||
                     (event.isSelected_ && (event.handled_ || allCounting));
                 BEAST_EXPECT(handled);
                 event.state_ = State::Off;
@@ -1047,7 +1047,7 @@ protected:
                         sendSquelch(validator, ptr, {});
                     }
                 });
-                bool handled = (event.handled_ && event.state_ == State::WaitReset) ||
+                bool const handled = (event.handled_ && event.state_ == State::WaitReset) ||
                     (!event.handled_ && !mustHandle);
                 BEAST_EXPECT(handled);
             }
@@ -1055,7 +1055,7 @@ protected:
                 (event.state_ == State::On &&
                  (now - event.time_ > (reduce_relay::IDLED + seconds(2)))))
             {
-                bool handled = event.state_ == State::WaitReset || !event.handled_;
+                bool const handled = event.state_ == State::WaitReset || !event.handled_;
                 BEAST_EXPECT(handled);
                 event.state_ = State::Off;
                 event.isSelected_ = false;
@@ -1270,7 +1270,7 @@ protected:
         doTest("Test Config - squelch enabled (legacy)", log, [&](bool log) {
             Config c;
 
-            std::string toLoad(R"rippleConfig(
+            std::string const toLoad(R"rippleConfig(
 [reduce_relay]
 vp_enable=1
 )rippleConfig");
@@ -1303,7 +1303,7 @@ vp_enable=0
         doTest("Test Config - squelch enabled", log, [&](bool log) {
             Config c;
 
-            std::string toLoad(R"rippleConfig(
+            std::string const toLoad(R"rippleConfig(
 [reduce_relay]
 vp_base_squelch_enable=1
 )rippleConfig");
@@ -1315,7 +1315,7 @@ vp_base_squelch_enable=1
         doTest("Test Config - squelch disabled", log, [&](bool log) {
             Config c;
 
-            std::string toLoad(R"rippleConfig(
+            std::string const toLoad(R"rippleConfig(
 [reduce_relay]
 vp_base_squelch_enable=0
 )rippleConfig");
@@ -1327,7 +1327,7 @@ vp_base_squelch_enable=0
         doTest("Test Config - legacy and new", log, [&](bool log) {
             Config c;
 
-            std::string toLoad(R"rippleConfig(
+            std::string const toLoad(R"rippleConfig(
 [reduce_relay]
 vp_base_squelch_enable=0
 vp_enable=0
@@ -1432,10 +1432,10 @@ vp_base_squelch_max_selected_peers=2
         doTest("Duplicate Message", log, [&](bool log) {
             network_.reset();
             // update message count for the same peer/validator
-            std::int16_t nMessages = 5;
+            std::int16_t const nMessages = 5;
             for (int i = 0; i < nMessages; i++)
             {
-                uint256 key(i);
+                uint256 const key(i);
                 network_.overlay().updateSlotAndSquelch(
                     key, network_.validator(0), 0, [&](PublicKey const&, PeerWPtr, std::uint32_t) {
                     });
@@ -1445,7 +1445,7 @@ vp_base_squelch_max_selected_peers=2
             // hence '-1'.
             BEAST_EXPECT(std::get<1>(peers[0]) == (nMessages - 1));
             // add duplicate
-            uint256 key(nMessages - 1);
+            uint256 const key(nMessages - 1);
             network_.overlay().updateSlotAndSquelch(
                 key, network_.validator(0), 0, [&](PublicKey const&, PeerWPtr, std::uint32_t) {});
             // confirm the same number of messages
@@ -1498,7 +1498,7 @@ vp_base_squelch_max_selected_peers=2
                     {
                         // make unique message hash to make the
                         // slot's internal hash router accept the message
-                        std::uint64_t mid = (m * 1000) + peer;
+                        std::uint64_t const mid = (m * 1000) + peer;
                         uint256 const message{mid};
                         slots.updateSlotAndSquelch(
                             message, validator, peer, protocol::MessageType::mtVALIDATION);
@@ -1568,7 +1568,7 @@ vp_base_squelch_max_selected_peers=2
                 env_.app().config().COMPRESSION = c.COMPRESSION;
             };
             auto handshake = [&](int outboundEnable, int inboundEnable) {
-                beast::IP::Address addr = boost::asio::ip::make_address("172.1.1.100");
+                beast::IP::Address const addr = boost::asio::ip::make_address("172.1.1.100");
 
                 setEnv(outboundEnable);
                 auto request = xrpl::makeRequest(
@@ -1622,7 +1622,7 @@ public:
     void
     run() override
     {
-        bool log = false;
+        bool const log = false;
         testConfig(log);
         testInitialRound(log);
         testPeerUnsquelchedTooSoon(log);
@@ -1649,7 +1649,7 @@ class reduce_relay_simulate_test : public reduce_relay_test
     void
     run() override
     {
-        bool log = false;
+        bool const log = false;
         testRandom(log);
     }
 };
diff --git a/src/test/overlay/short_read_test.cpp b/src/test/overlay/short_read_test.cpp
index d96f67c8a1..0c8b7f8a43 100644
--- a/src/test/overlay/short_read_test.cpp
+++ b/src/test/overlay/short_read_test.cpp
@@ -56,7 +56,7 @@ private:
         using boost::asio::buffer;
         using boost::asio::buffer_copy;
         using boost::asio::buffer_size;
-        boost::asio::const_buffer buf(s.data(), s.size());
+        boost::asio::const_buffer const buf(s.data(), s.size());
         sb.commit(buffer_copy(sb.prepare(buffer_size(buf)), buf));
     }
 
@@ -100,14 +100,14 @@ private:
         void
         add(std::shared_ptr<Child> const& child)
         {
-            std::lock_guard lock(mutex_);
+            std::lock_guard const lock(mutex_);
             list_.emplace(child.get(), child);
         }
 
         void
         remove(Child* child)
         {
-            std::lock_guard lock(mutex_);
+            std::lock_guard const lock(mutex_);
             list_.erase(child);
             if (list_.empty())
                 cond_.notify_one();
@@ -118,7 +118,7 @@ private:
         {
             std::vector<std::shared_ptr<Child>> v;
             {
-                std::lock_guard lock(mutex_);
+                std::lock_guard const lock(mutex_);
                 v.reserve(list_.size());
                 if (closed_)
                     return;
@@ -636,7 +636,7 @@ public:
     void
     run() override
     {
-        Server s(*this);
+        Server const s(*this);
         Client c(*this, s.endpoint());
         c.wait();
         pass();
diff --git a/src/test/overlay/tx_reduce_relay_test.cpp b/src/test/overlay/tx_reduce_relay_test.cpp
index 04d8bae768..abb1632858 100644
--- a/src/test/overlay/tx_reduce_relay_test.cpp
+++ b/src/test/overlay/tx_reduce_relay_test.cpp
@@ -159,10 +159,11 @@ private:
         auto stream_ptr = std::make_unique<stream_type>(
             socket_type(std::forward<boost::asio::io_context&>(env.app().getIOContext())),
             *context_);
-        beast::IP::Endpoint local(boost::asio::ip::make_address("172.1.1." + std::to_string(lid_)));
-        beast::IP::Endpoint remote(
+        beast::IP::Endpoint const local(
+            boost::asio::ip::make_address("172.1.1." + std::to_string(lid_)));
+        beast::IP::Endpoint const remote(
             boost::asio::ip::make_address("172.1.1." + std::to_string(rid_)));
-        PublicKey key(std::get<0>(randomKeyPair(KeyType::ed25519)));
+        PublicKey const key(std::get<0>(randomKeyPair(KeyType::ed25519)));
         auto consumer = overlay.resourceManager().newInboundEndpoint(remote);
         auto [slot, _] = overlay.peerFinder().new_inbound_slot(local, remote);
         auto const peer = std::make_shared<PeerTest>(
@@ -224,7 +225,7 @@ private:
     void
     run() override
     {
-        bool log = false;
+        bool const log = false;
         std::set<Peer::id_t> skip = {0, 1, 2, 3, 4};
         testConfig(log);
         // relay to all peers, no hash queue
diff --git a/src/test/peerfinder/Livecache_test.cpp b/src/test/peerfinder/Livecache_test.cpp
index b2d0eeeaf1..d12da84ffd 100644
--- a/src/test/peerfinder/Livecache_test.cpp
+++ b/src/test/peerfinder/Livecache_test.cpp
@@ -33,7 +33,7 @@ public:
     void
     add(beast::IP::Endpoint ep, C& c, std::uint32_t hops = 0)
     {
-        Endpoint cep{ep, hops};
+        Endpoint const cep{ep, hops};
         c.insert(cep);
     }
 
diff --git a/src/test/peerfinder/PeerFinder_test.cpp b/src/test/peerfinder/PeerFinder_test.cpp
index c39564c54c..a787a38e14 100644
--- a/src/test/peerfinder/PeerFinder_test.cpp
+++ b/src/test/peerfinder/PeerFinder_test.cpp
@@ -411,7 +411,7 @@ public:
                 (c.PEERS_MAX == max && c.PEERS_IN_MAX == 0 && c.PEERS_OUT_MAX == 0) ||
                 (c.PEERS_IN_MAX == *maxIn && c.PEERS_OUT_MAX == *maxOut));
 
-            Config config = Config::makeConfig(c, port, false, 0);
+            Config const config = Config::makeConfig(c, port, false, 0);
 
             Counts counts;
             counts.onConfig(config);
diff --git a/src/test/protocol/Hooks_test.cpp b/src/test/protocol/Hooks_test.cpp
index a280fd6bd4..53f20a2b5e 100644
--- a/src/test/protocol/Hooks_test.cpp
+++ b/src/test/protocol/Hooks_test.cpp
@@ -23,7 +23,7 @@ class Hooks_test : public beast::unit_test::suite
 
         using namespace test::jtx;
 
-        std::vector<std::reference_wrapper<SField const>> fields_to_test = {
+        std::vector<std::reference_wrapper<SField const>> const fields_to_test = {
             sfHookResult,
             sfHookStateChangeCount,
             sfHookEmitCount,
@@ -116,7 +116,7 @@ class Hooks_test : public beast::unit_test::suite
                 }
 
                 case STI_UINT256: {
-                    uint256 u = uint256::fromVoid(
+                    uint256 const u = uint256::fromVoid(
                         "DEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBE"
                         "EFDEADBEEF");
                     dummy.setFieldH256(f, u);
@@ -126,7 +126,7 @@ class Hooks_test : public beast::unit_test::suite
                 }
 
                 case STI_VL: {
-                    std::vector<uint8_t> v{1, 2, 3};
+                    std::vector<uint8_t> const v{1, 2, 3};
                     dummy.setFieldVL(f, v);
                     BEAST_EXPECT(dummy.getFieldVL(f) == v);
                     BEAST_EXPECT(dummy.isFieldPresent(f));
@@ -135,7 +135,8 @@ class Hooks_test : public beast::unit_test::suite
 
                 case STI_ACCOUNT: {
                     // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
-                    AccountID id = *parseBase58<AccountID>("rwfSjJNK2YQuN64bSWn7T2eY9FJAyAPYJT");
+                    AccountID const id =
+                        *parseBase58<AccountID>("rwfSjJNK2YQuN64bSWn7T2eY9FJAyAPYJT");
                     dummy.setAccountID(f, id);
                     BEAST_EXPECT(dummy.getAccountID(f) == id);
                     BEAST_EXPECT(dummy.isFieldPresent(f));
diff --git a/src/test/protocol/InnerObjectFormats_test.cpp b/src/test/protocol/InnerObjectFormats_test.cpp
index c06524b90e..2961e90db7 100644
--- a/src/test/protocol/InnerObjectFormats_test.cpp
+++ b/src/test/protocol/InnerObjectFormats_test.cpp
@@ -155,7 +155,7 @@ public:
         using namespace InnerObjectFormatsUnitTestDetail;
 
         // Instantiate a jtx::Env so debugLog writes are exercised.
-        test::jtx::Env env(*this);
+        test::jtx::Env const env(*this);
 
         for (auto const& test : testArray)
         {
@@ -166,7 +166,7 @@ public:
                 Throw<std::runtime_error>(
                     "Internal InnerObjectFormatsParsedJSON error.  Bad JSON.");
             }
-            STParsedJSONObject parsed("request", req);
+            STParsedJSONObject const parsed("request", req);
             bool const noObj = !parsed.object.has_value();
             if (noObj == test.expectFail)
             {
diff --git a/src/test/protocol/Issue_test.cpp b/src/test/protocol/Issue_test.cpp
index 2321da4a6e..eddaf1c6d8 100644
--- a/src/test/protocol/Issue_test.cpp
+++ b/src/test/protocol/Issue_test.cpp
@@ -42,7 +42,7 @@ public:
         BEAST_EXPECT(u3 >= u2);
         BEAST_EXPECT(u3 > u2);
 
-        std::hash<Unsigned> hash;
+        std::hash<Unsigned> const hash;
 
         BEAST_EXPECT(hash(u1) == hash(u1));
         BEAST_EXPECT(hash(u2) == hash(u2));
@@ -83,7 +83,7 @@ public:
         BEAST_EXPECT(Issue(c1, i3) >= Issue(c1, i2));
         BEAST_EXPECT(Issue(c1, i3) > Issue(c1, i2));
 
-        std::hash<Issue> hash;
+        std::hash<Issue> const hash;
 
         BEAST_EXPECT(hash(Issue(c1, i1)) == hash(Issue(c1, i1)));
         BEAST_EXPECT(hash(Issue(c1, i2)) == hash(Issue(c1, i2)));
@@ -394,10 +394,10 @@ public:
         Currency const c3(3);
         AccountID const i3(3);
 
-        Issue a1(c1, i1);
-        Issue a2(c1, i2);
-        Issue a3(c2, i2);
-        Issue a4(c3, i2);
+        Issue const a1(c1, i1);
+        Issue const a2(c1, i2);
+        Issue const a3(c2, i2);
+        Issue const a4(c3, i2);
         uint256 const domain1{1};
         uint256 const domain2{2};
 
@@ -477,7 +477,7 @@ public:
             BEAST_EXPECT(Book(a3, a4, domain2) > Book(a2, a3, domain1));
         }
 
-        std::hash<Book> hash;
+        std::hash<Book> const hash;
 
         //         log << std::hex << hash (Book (a1, a2));
         //         log << std::hex << hash (Book (a1, a2));
diff --git a/src/test/protocol/PublicKey_test.cpp b/src/test/protocol/PublicKey_test.cpp
index 79c1356bb4..79ab589404 100644
--- a/src/test/protocol/PublicKey_test.cpp
+++ b/src/test/protocol/PublicKey_test.cpp
@@ -304,7 +304,7 @@ public:
             auto s = good;
 
             // Remove all characters from the string in random order:
-            std::hash<std::string> r;
+            std::hash<std::string> const r;
 
             while (!s.empty())
             {
@@ -421,7 +421,7 @@ public:
             KeyType::secp256k1,
             generateSecretKey(KeyType::secp256k1, generateSeed("masterpassphrase")));
 
-        PublicKey pk2(pk1);
+        PublicKey const pk2(pk1);
         BEAST_EXPECT(pk1 == pk2);
         BEAST_EXPECT(pk2 == pk1);
 
diff --git a/src/test/protocol/Quality_test.cpp b/src/test/protocol/Quality_test.cpp
index 1dbbbfdf3d..f421f98c94 100644
--- a/src/test/protocol/Quality_test.cpp
+++ b/src/test/protocol/Quality_test.cpp
@@ -66,7 +66,7 @@ public:
 
         {
             // 1 in, 1 out:
-            Quality q(Amounts(amount(1), amount(1)));
+            Quality const q(Amounts(amount(1), amount(1)));
 
             ceil_in(
                 q,
@@ -95,7 +95,7 @@ public:
 
         {
             // 1 in, 2 out:
-            Quality q(Amounts(amount(1), amount(2)));
+            Quality const q(Amounts(amount(1), amount(2)));
 
             ceil_in(
                 q,
@@ -124,7 +124,7 @@ public:
 
         {
             // 2 in, 1 out:
-            Quality q(Amounts(amount(2), amount(1)));
+            Quality const q(Amounts(amount(2), amount(1)));
 
             ceil_in(
                 q,
@@ -159,7 +159,7 @@ public:
 
         {
             // 1 in, 1 out:
-            Quality q(Amounts(amount(1), amount(1)));
+            Quality const q(Amounts(amount(1), amount(1)));
 
             ceil_out(
                 q,
@@ -188,7 +188,7 @@ public:
 
         {
             // 1 in, 2 out:
-            Quality q(Amounts(amount(1), amount(2)));
+            Quality const q(Amounts(amount(1), amount(2)));
 
             ceil_out(
                 q,
@@ -217,7 +217,7 @@ public:
 
         {
             // 2 in, 1 out:
-            Quality q(Amounts(amount(2), amount(1)));
+            Quality const q(Amounts(amount(2), amount(1)));
 
             ceil_out(
                 q,
@@ -251,7 +251,7 @@ public:
         testcase("raw");
 
         {
-            Quality q(0x5d048191fb9130daull);  // 126836389.7680090
+            Quality const q(0x5d048191fb9130daull);  // 126836389.7680090
             Amounts const value(
                 amount(349469768),                             // 349.469768 XRP
                 raw(2755280000000000ull, -15));                // 2.75528
@@ -266,7 +266,7 @@ public:
     {
         testcase("round");
 
-        Quality q(0x59148191fb913522ull);  // 57719.63525051682
+        Quality const q(0x59148191fb913522ull);  // 57719.63525051682
         BEAST_EXPECT(q.round(3).rate().getText() == "57800");
         BEAST_EXPECT(q.round(4).rate().getText() == "57720");
         BEAST_EXPECT(q.round(5).rate().getText() == "57720");
diff --git a/src/test/protocol/STAmount_test.cpp b/src/test/protocol/STAmount_test.cpp
index 4f652dddd9..2c2e005146 100644
--- a/src/test/protocol/STAmount_test.cpp
+++ b/src/test/protocol/STAmount_test.cpp
@@ -28,7 +28,7 @@ public:
             return amount;
 
         std::uint64_t mantissa = amount.mantissa();
-        std::uint64_t valueDigits = mantissa % 1000000000;
+        std::uint64_t const valueDigits = mantissa % 1000000000;
 
         if (valueDigits == 1)
         {
@@ -67,15 +67,15 @@ public:
     roundTest(int n, int d, int m)
     {
         // check STAmount rounding
-        STAmount num(noIssue(), n);
-        STAmount den(noIssue(), d);
-        STAmount mul(noIssue(), m);
-        STAmount quot = divide(STAmount(n), STAmount(d), noIssue());
-        STAmount res = roundSelf(multiply(quot, mul, noIssue()));
+        STAmount const num(noIssue(), n);
+        STAmount const den(noIssue(), d);
+        STAmount const mul(noIssue(), m);
+        STAmount const quot = divide(STAmount(n), STAmount(d), noIssue());
+        STAmount const res = roundSelf(multiply(quot, mul, noIssue()));
 
         BEAST_EXPECT(!res.native());
 
-        STAmount cmp(noIssue(), (n * m) / d);
+        STAmount const cmp(noIssue(), (n * m) / d);
 
         BEAST_EXPECT(!cmp.native());
 
@@ -93,13 +93,14 @@ public:
     void
     mulTest(int a, int b)
     {
-        STAmount aa(noIssue(), a);
-        STAmount bb(noIssue(), b);
-        STAmount prod1(multiply(aa, bb, noIssue()));
+        STAmount const aa(noIssue(), a);
+        STAmount const bb(noIssue(), b);
+        STAmount const prod1(multiply(aa, bb, noIssue()));
 
         BEAST_EXPECT(!prod1.native());
 
-        STAmount prod2(noIssue(), static_cast<std::uint64_t>(a) * static_cast<std::uint64_t>(b));
+        STAmount const prod2(
+            noIssue(), static_cast<std::uint64_t>(a) * static_cast<std::uint64_t>(b));
 
         if (prod1 != prod2)
         {
@@ -196,7 +197,11 @@ public:
     testNativeCurrency()
     {
         testcase("native currency");
-        STAmount zeroSt, one(1), hundred(100);
+
+        STAmount const zeroSt;
+        STAmount const one(1);
+        STAmount const hundred(100);
+
         // VFALCO NOTE Why repeat "STAmount fail" so many times??
         unexpected(serializeAndDeserialize(zeroSt) != zeroSt, "STAmount fail");
         unexpected(serializeAndDeserialize(one) != one, "STAmount fail");
@@ -206,60 +211,60 @@ public:
         unexpected(zeroSt != beast::zero, "STAmount fail");
         unexpected(one == beast::zero, "STAmount fail");
         unexpected(hundred == beast::zero, "STAmount fail");
-        unexpected((zeroSt < zeroSt), "STAmount fail");
+        unexpected((zeroSt < zeroSt), "STAmount fail");  // NOLINT(misc-redundant-expression)
         unexpected(!(zeroSt < one), "STAmount fail");
         unexpected(!(zeroSt < hundred), "STAmount fail");
         unexpected((one < zeroSt), "STAmount fail");
-        unexpected((one < one), "STAmount fail");
+        unexpected((one < one), "STAmount fail");  // NOLINT(misc-redundant-expression)
         unexpected(!(one < hundred), "STAmount fail");
         unexpected((hundred < zeroSt), "STAmount fail");
         unexpected((hundred < one), "STAmount fail");
-        unexpected((hundred < hundred), "STAmount fail");
-        unexpected((zeroSt > zeroSt), "STAmount fail");
+        unexpected((hundred < hundred), "STAmount fail");  // NOLINT(misc-redundant-expression)
+        unexpected((zeroSt > zeroSt), "STAmount fail");    // NOLINT(misc-redundant-expression)
         unexpected((zeroSt > one), "STAmount fail");
         unexpected((zeroSt > hundred), "STAmount fail");
         unexpected(!(one > zeroSt), "STAmount fail");
-        unexpected((one > one), "STAmount fail");
+        unexpected((one > one), "STAmount fail");  // NOLINT(misc-redundant-expression)
         unexpected((one > hundred), "STAmount fail");
         unexpected(!(hundred > zeroSt), "STAmount fail");
         unexpected(!(hundred > one), "STAmount fail");
-        unexpected((hundred > hundred), "STAmount fail");
-        unexpected(!(zeroSt <= zeroSt), "STAmount fail");
+        unexpected((hundred > hundred), "STAmount fail");  // NOLINT(misc-redundant-expression)
+        unexpected(!(zeroSt <= zeroSt), "STAmount fail");  // NOLINT(misc-redundant-expression)
         unexpected(!(zeroSt <= one), "STAmount fail");
         unexpected(!(zeroSt <= hundred), "STAmount fail");
         unexpected((one <= zeroSt), "STAmount fail");
-        unexpected(!(one <= one), "STAmount fail");
+        unexpected(!(one <= one), "STAmount fail");  // NOLINT(misc-redundant-expression)
         unexpected(!(one <= hundred), "STAmount fail");
         unexpected((hundred <= zeroSt), "STAmount fail");
         unexpected((hundred <= one), "STAmount fail");
-        unexpected(!(hundred <= hundred), "STAmount fail");
-        unexpected(!(zeroSt >= zeroSt), "STAmount fail");
+        unexpected(!(hundred <= hundred), "STAmount fail");  // NOLINT(misc-redundant-expression)
+        unexpected(!(zeroSt >= zeroSt), "STAmount fail");    // NOLINT(misc-redundant-expression)
         unexpected((zeroSt >= one), "STAmount fail");
         unexpected((zeroSt >= hundred), "STAmount fail");
         unexpected(!(one >= zeroSt), "STAmount fail");
-        unexpected(!(one >= one), "STAmount fail");
+        unexpected(!(one >= one), "STAmount fail");  // NOLINT(misc-redundant-expression)
         unexpected((one >= hundred), "STAmount fail");
         unexpected(!(hundred >= zeroSt), "STAmount fail");
         unexpected(!(hundred >= one), "STAmount fail");
-        unexpected(!(hundred >= hundred), "STAmount fail");
-        unexpected(!(zeroSt == zeroSt), "STAmount fail");
+        unexpected(!(hundred >= hundred), "STAmount fail");  // NOLINT(misc-redundant-expression)
+        unexpected(!(zeroSt == zeroSt), "STAmount fail");    // NOLINT(misc-redundant-expression)
         unexpected((zeroSt == one), "STAmount fail");
         unexpected((zeroSt == hundred), "STAmount fail");
         unexpected((one == zeroSt), "STAmount fail");
-        unexpected(!(one == one), "STAmount fail");
+        unexpected(!(one == one), "STAmount fail");  // NOLINT(misc-redundant-expression)
         unexpected((one == hundred), "STAmount fail");
         unexpected((hundred == zeroSt), "STAmount fail");
         unexpected((hundred == one), "STAmount fail");
-        unexpected(!(hundred == hundred), "STAmount fail");
-        unexpected((zeroSt != zeroSt), "STAmount fail");
+        unexpected(!(hundred == hundred), "STAmount fail");  // NOLINT(misc-redundant-expression)
+        unexpected((zeroSt != zeroSt), "STAmount fail");     // NOLINT(misc-redundant-expression)
         unexpected(!(zeroSt != one), "STAmount fail");
         unexpected(!(zeroSt != hundred), "STAmount fail");
         unexpected(!(one != zeroSt), "STAmount fail");
-        unexpected((one != one), "STAmount fail");
+        unexpected((one != one), "STAmount fail");  // NOLINT(misc-redundant-expression)
         unexpected(!(one != hundred), "STAmount fail");
         unexpected(!(hundred != zeroSt), "STAmount fail");
         unexpected(!(hundred != one), "STAmount fail");
-        unexpected((hundred != hundred), "STAmount fail");
+        unexpected((hundred != hundred), "STAmount fail");  // NOLINT(misc-redundant-expression)
         unexpected(STAmount().getText() != "0", "STAmount fail");
         unexpected(STAmount(31).getText() != "31", "STAmount fail");
         unexpected(STAmount(310).getText() != "310", "STAmount fail");
@@ -279,7 +284,11 @@ public:
     testCustomCurrency()
     {
         testcase("custom currency");
-        STAmount zeroSt(noIssue()), one(noIssue(), 1), hundred(noIssue(), 100);
+
+        STAmount const zeroSt(noIssue());
+        STAmount const one(noIssue(), 1);
+        STAmount const hundred(noIssue(), 100);
+
         unexpected(serializeAndDeserialize(zeroSt) != zeroSt, "STAmount fail");
         unexpected(serializeAndDeserialize(one) != one, "STAmount fail");
         unexpected(serializeAndDeserialize(hundred) != hundred, "STAmount fail");
@@ -288,60 +297,60 @@ public:
         unexpected(zeroSt != beast::zero, "STAmount fail");
         unexpected(one == beast::zero, "STAmount fail");
         unexpected(hundred == beast::zero, "STAmount fail");
-        unexpected((zeroSt < zeroSt), "STAmount fail");
+        unexpected((zeroSt < zeroSt), "STAmount fail");  // NOLINT(misc-redundant-expression)
         unexpected(!(zeroSt < one), "STAmount fail");
         unexpected(!(zeroSt < hundred), "STAmount fail");
         unexpected((one < zeroSt), "STAmount fail");
-        unexpected((one < one), "STAmount fail");
+        unexpected((one < one), "STAmount fail");  // NOLINT(misc-redundant-expression)
         unexpected(!(one < hundred), "STAmount fail");
         unexpected((hundred < zeroSt), "STAmount fail");
         unexpected((hundred < one), "STAmount fail");
-        unexpected((hundred < hundred), "STAmount fail");
-        unexpected((zeroSt > zeroSt), "STAmount fail");
+        unexpected((hundred < hundred), "STAmount fail");  // NOLINT(misc-redundant-expression)
+        unexpected((zeroSt > zeroSt), "STAmount fail");    // NOLINT(misc-redundant-expression)
         unexpected((zeroSt > one), "STAmount fail");
         unexpected((zeroSt > hundred), "STAmount fail");
         unexpected(!(one > zeroSt), "STAmount fail");
-        unexpected((one > one), "STAmount fail");
+        unexpected((one > one), "STAmount fail");  // NOLINT(misc-redundant-expression)
         unexpected((one > hundred), "STAmount fail");
         unexpected(!(hundred > zeroSt), "STAmount fail");
         unexpected(!(hundred > one), "STAmount fail");
-        unexpected((hundred > hundred), "STAmount fail");
-        unexpected(!(zeroSt <= zeroSt), "STAmount fail");
+        unexpected((hundred > hundred), "STAmount fail");  // NOLINT(misc-redundant-expression)
+        unexpected(!(zeroSt <= zeroSt), "STAmount fail");  // NOLINT(misc-redundant-expression)
         unexpected(!(zeroSt <= one), "STAmount fail");
         unexpected(!(zeroSt <= hundred), "STAmount fail");
         unexpected((one <= zeroSt), "STAmount fail");
-        unexpected(!(one <= one), "STAmount fail");
+        unexpected(!(one <= one), "STAmount fail");  // NOLINT(misc-redundant-expression)
         unexpected(!(one <= hundred), "STAmount fail");
         unexpected((hundred <= zeroSt), "STAmount fail");
         unexpected((hundred <= one), "STAmount fail");
-        unexpected(!(hundred <= hundred), "STAmount fail");
-        unexpected(!(zeroSt >= zeroSt), "STAmount fail");
+        unexpected(!(hundred <= hundred), "STAmount fail");  // NOLINT(misc-redundant-expression)
+        unexpected(!(zeroSt >= zeroSt), "STAmount fail");    // NOLINT(misc-redundant-expression)
         unexpected((zeroSt >= one), "STAmount fail");
         unexpected((zeroSt >= hundred), "STAmount fail");
         unexpected(!(one >= zeroSt), "STAmount fail");
-        unexpected(!(one >= one), "STAmount fail");
+        unexpected(!(one >= one), "STAmount fail");  // NOLINT(misc-redundant-expression)
         unexpected((one >= hundred), "STAmount fail");
         unexpected(!(hundred >= zeroSt), "STAmount fail");
         unexpected(!(hundred >= one), "STAmount fail");
-        unexpected(!(hundred >= hundred), "STAmount fail");
-        unexpected(!(zeroSt == zeroSt), "STAmount fail");
+        unexpected(!(hundred >= hundred), "STAmount fail");  // NOLINT(misc-redundant-expression)
+        unexpected(!(zeroSt == zeroSt), "STAmount fail");    // NOLINT(misc-redundant-expression)
         unexpected((zeroSt == one), "STAmount fail");
         unexpected((zeroSt == hundred), "STAmount fail");
         unexpected((one == zeroSt), "STAmount fail");
-        unexpected(!(one == one), "STAmount fail");
+        unexpected(!(one == one), "STAmount fail");  // NOLINT(misc-redundant-expression)
         unexpected((one == hundred), "STAmount fail");
         unexpected((hundred == zeroSt), "STAmount fail");
         unexpected((hundred == one), "STAmount fail");
-        unexpected(!(hundred == hundred), "STAmount fail");
-        unexpected((zeroSt != zeroSt), "STAmount fail");
+        unexpected(!(hundred == hundred), "STAmount fail");  // NOLINT(misc-redundant-expression)
+        unexpected((zeroSt != zeroSt), "STAmount fail");     // NOLINT(misc-redundant-expression)
         unexpected(!(zeroSt != one), "STAmount fail");
         unexpected(!(zeroSt != hundred), "STAmount fail");
         unexpected(!(one != zeroSt), "STAmount fail");
-        unexpected((one != one), "STAmount fail");
+        unexpected((one != one), "STAmount fail");  // NOLINT(misc-redundant-expression)
         unexpected(!(one != hundred), "STAmount fail");
         unexpected(!(hundred != zeroSt), "STAmount fail");
         unexpected(!(hundred != one), "STAmount fail");
-        unexpected((hundred != hundred), "STAmount fail");
+        unexpected((hundred != hundred), "STAmount fail");  // NOLINT(misc-redundant-expression)
         unexpected(STAmount(noIssue()).getText() != "0", "STAmount fail");
         unexpected(STAmount(noIssue(), 31).getText() != "31", "STAmount fail");
         unexpected(STAmount(noIssue(), 31, 1).getText() != "310", "STAmount fail");
@@ -382,7 +391,8 @@ public:
             divide(STAmount(noIssue(), 60), STAmount(noIssue(), 3), xrpIssue()).getText() != "20",
             "STAmount divide fail");
 
-        STAmount a1(noIssue(), 60), a2(noIssue(), 10, -1);
+        STAmount const a1(noIssue(), 60);
+        STAmount const a2(noIssue(), 10, -1);
 
         unexpected(
             divide(a2, a1, noIssue()) != amountFromQuality(getRate(a1, a2)),
@@ -464,14 +474,14 @@ public:
     {
         testcase("underflow");
 
-        STAmount bigNative(STAmount::cMaxNative / 2);
-        STAmount bigValue(
+        STAmount const bigNative(STAmount::cMaxNative / 2);
+        STAmount const bigValue(
             noIssue(), (STAmount::cMinValue + STAmount::cMaxValue) / 2, STAmount::cMaxOffset - 1);
-        STAmount smallValue(
+        STAmount const smallValue(
             noIssue(), (STAmount::cMinValue + STAmount::cMaxValue) / 2, STAmount::cMinOffset + 1);
-        STAmount zeroSt(noIssue(), 0);
+        STAmount const zeroSt(noIssue(), 0);
 
-        STAmount smallXSmall = multiply(smallValue, smallValue, noIssue());
+        STAmount const smallXSmall = multiply(smallValue, smallValue, noIssue());
 
         BEAST_EXPECT(smallXSmall == beast::zero);
 
@@ -822,43 +832,43 @@ public:
 
         // Adding zero
         {
-            STAmount amt1(XRPAmount(0));
-            STAmount amt2(XRPAmount(1000));
+            STAmount const amt1(XRPAmount(0));
+            STAmount const amt2(XRPAmount(1000));
             BEAST_EXPECT(canAdd(amt1, amt2) == true);
         }
 
         // Adding zero
         {
-            STAmount amt1(XRPAmount(1000));
-            STAmount amt2(XRPAmount(0));
+            STAmount const amt1(XRPAmount(1000));
+            STAmount const amt2(XRPAmount(0));
             BEAST_EXPECT(canAdd(amt1, amt2) == true);
         }
 
         // Adding two positive XRP amounts
         {
-            STAmount amt1(XRPAmount(500));
-            STAmount amt2(XRPAmount(1500));
+            STAmount const amt1(XRPAmount(500));
+            STAmount const amt2(XRPAmount(1500));
             BEAST_EXPECT(canAdd(amt1, amt2) == true);
         }
 
         // Adding two negative XRP amounts
         {
-            STAmount amt1(XRPAmount(-500));
-            STAmount amt2(XRPAmount(-1500));
+            STAmount const amt1(XRPAmount(-500));
+            STAmount const amt2(XRPAmount(-1500));
             BEAST_EXPECT(canAdd(amt1, amt2) == true);
         }
 
         // Adding a positive and a negative XRP amount
         {
-            STAmount amt1(XRPAmount(1000));
-            STAmount amt2(XRPAmount(-1000));
+            STAmount const amt1(XRPAmount(1000));
+            STAmount const amt2(XRPAmount(-1000));
             BEAST_EXPECT(canAdd(amt1, amt2) == true);
         }
 
         // Overflow check for max XRP amounts
         {
-            STAmount amt1(std::numeric_limits<XRPAmount::value_type>::max());
-            STAmount amt2(XRPAmount(1));
+            STAmount const amt1(std::numeric_limits<XRPAmount::value_type>::max());
+            STAmount const amt2(XRPAmount(1));
             BEAST_EXPECT(canAdd(amt1, amt2) == false);
         }
 
@@ -866,7 +876,7 @@ public:
         {
             STAmount amt1(std::numeric_limits<XRPAmount::value_type>::max());
             amt1 += XRPAmount(1);
-            STAmount amt2(XRPAmount(-1));
+            STAmount const amt2(XRPAmount(-1));
             BEAST_EXPECT(canAdd(amt1, amt2) == false);
         }
     }
@@ -881,50 +891,50 @@ public:
 
         // Adding two IOU amounts
         {
-            STAmount amt1(usd, 500);
-            STAmount amt2(usd, 1500);
+            STAmount const amt1(usd, 500);
+            STAmount const amt2(usd, 1500);
             BEAST_EXPECT(canAdd(amt1, amt2) == true);
         }
 
         // Adding a positive and a negative IOU amount
         {
-            STAmount amt1(usd, 1000);
-            STAmount amt2(usd, -1000);
+            STAmount const amt1(usd, 1000);
+            STAmount const amt2(usd, -1000);
             BEAST_EXPECT(canAdd(amt1, amt2) == true);
         }
 
         // Overflow check for max IOU amounts
         {
-            STAmount amt1(usd, std::numeric_limits<int64_t>::max());
-            STAmount amt2(usd, 1);
+            STAmount const amt1(usd, std::numeric_limits<int64_t>::max());
+            STAmount const amt2(usd, 1);
             BEAST_EXPECT(canAdd(amt1, amt2) == false);
         }
 
         // Overflow check for min IOU amounts
         {
-            STAmount amt1(usd, std::numeric_limits<std::int64_t>::min());
-            STAmount amt2(usd, -1);
+            STAmount const amt1(usd, std::numeric_limits<std::int64_t>::min());
+            STAmount const amt2(usd, -1);
             BEAST_EXPECT(canAdd(amt1, amt2) == false);
         }
 
         // Adding XRP and IOU
         {
-            STAmount amt1(XRPAmount(1));
-            STAmount amt2(usd, 1);
+            STAmount const amt1(XRPAmount(1));
+            STAmount const amt2(usd, 1);
             BEAST_EXPECT(canAdd(amt1, amt2) == false);
         }
 
         // Adding different IOU issues (non zero)
         {
-            STAmount amt1(usd, 1000);
-            STAmount amt2(eur, 500);
+            STAmount const amt1(usd, 1000);
+            STAmount const amt2(eur, 500);
             BEAST_EXPECT(canAdd(amt1, amt2) == false);
         }
 
         // Adding different IOU issues (zero)
         {
-            STAmount amt1(usd, 0);
-            STAmount amt2(eur, 500);
+            STAmount const amt1(usd, 0);
+            STAmount const amt2(eur, 500);
             BEAST_EXPECT(canAdd(amt1, amt2) == false);
         }
     }
@@ -939,43 +949,43 @@ public:
 
         // Adding zero
         {
-            STAmount amt1(mpt, 0);
-            STAmount amt2(mpt, 1000);
+            STAmount const amt1(mpt, 0);
+            STAmount const amt2(mpt, 1000);
             BEAST_EXPECT(canAdd(amt1, amt2) == true);
         }
 
         // Adding zero
         {
-            STAmount amt1(mpt, 1000);
-            STAmount amt2(mpt, 0);
+            STAmount const amt1(mpt, 1000);
+            STAmount const amt2(mpt, 0);
             BEAST_EXPECT(canAdd(amt1, amt2) == true);
         }
 
         // Adding two positive MPT amounts
         {
-            STAmount amt1(mpt, 500);
-            STAmount amt2(mpt, 1500);
+            STAmount const amt1(mpt, 500);
+            STAmount const amt2(mpt, 1500);
             BEAST_EXPECT(canAdd(amt1, amt2) == true);
         }
 
         // Adding two negative MPT amounts
         {
-            STAmount amt1(mpt, -500);
-            STAmount amt2(mpt, -1500);
+            STAmount const amt1(mpt, -500);
+            STAmount const amt2(mpt, -1500);
             BEAST_EXPECT(canAdd(amt1, amt2) == true);
         }
 
         // Adding a positive and a negative MPT amount
         {
-            STAmount amt1(mpt, 1000);
-            STAmount amt2(mpt, -1000);
+            STAmount const amt1(mpt, 1000);
+            STAmount const amt2(mpt, -1000);
             BEAST_EXPECT(canAdd(amt1, amt2) == true);
         }
 
         // Overflow check for max MPT amounts
         {
-            STAmount amt1(mpt, std::numeric_limits<MPTAmount::value_type>::max());
-            STAmount amt2(mpt, 1);
+            STAmount const amt1(mpt, std::numeric_limits<MPTAmount::value_type>::max());
+            STAmount const amt2(mpt, 1);
             BEAST_EXPECT(canAdd(amt1, amt2) == false);
         }
 
@@ -985,22 +995,22 @@ public:
 
         // Adding MPT and XRP
         {
-            STAmount amt1(XRPAmount(1000));
-            STAmount amt2(mpt, 1000);
+            STAmount const amt1(XRPAmount(1000));
+            STAmount const amt2(mpt, 1000);
             BEAST_EXPECT(canAdd(amt1, amt2) == false);
         }
 
         // Adding different MPT issues (non zero)
         {
-            STAmount amt1(mpt2, 500);
-            STAmount amt2(mpt, 500);
+            STAmount const amt1(mpt2, 500);
+            STAmount const amt2(mpt, 500);
             BEAST_EXPECT(canAdd(amt1, amt2) == false);
         }
 
         // Adding different MPT issues (non zero)
         {
-            STAmount amt1(mpt2, 0);
-            STAmount amt2(mpt, 500);
+            STAmount const amt1(mpt2, 0);
+            STAmount const amt2(mpt, 500);
             BEAST_EXPECT(canAdd(amt1, amt2) == false);
         }
     }
@@ -1012,36 +1022,36 @@ public:
 
         // Subtracting zero
         {
-            STAmount amt1(XRPAmount(1000));
-            STAmount amt2(XRPAmount(0));
+            STAmount const amt1(XRPAmount(1000));
+            STAmount const amt2(XRPAmount(0));
             BEAST_EXPECT(canSubtract(amt1, amt2) == true);
         }
 
         // Subtracting zero
         {
-            STAmount amt1(XRPAmount(0));
-            STAmount amt2(XRPAmount(1000));
+            STAmount const amt1(XRPAmount(0));
+            STAmount const amt2(XRPAmount(1000));
             BEAST_EXPECT(canSubtract(amt1, amt2) == false);
         }
 
         // Subtracting two positive XRP amounts
         {
-            STAmount amt1(XRPAmount(1500));
-            STAmount amt2(XRPAmount(500));
+            STAmount const amt1(XRPAmount(1500));
+            STAmount const amt2(XRPAmount(500));
             BEAST_EXPECT(canSubtract(amt1, amt2) == true);
         }
 
         // Subtracting two negative XRP amounts
         {
-            STAmount amt1(XRPAmount(-1500));
-            STAmount amt2(XRPAmount(-500));
+            STAmount const amt1(XRPAmount(-1500));
+            STAmount const amt2(XRPAmount(-500));
             BEAST_EXPECT(canSubtract(amt1, amt2) == true);
         }
 
         // Subtracting a positive and a negative XRP amount
         {
-            STAmount amt1(XRPAmount(1000));
-            STAmount amt2(XRPAmount(-1000));
+            STAmount const amt1(XRPAmount(1000));
+            STAmount const amt2(XRPAmount(-1000));
             BEAST_EXPECT(canSubtract(amt1, amt2) == true);
         }
 
@@ -1049,14 +1059,14 @@ public:
         {
             STAmount amt1(std::numeric_limits<XRPAmount::value_type>::max());
             amt1 += XRPAmount(1);
-            STAmount amt2(XRPAmount(1));
+            STAmount const amt2(XRPAmount(1));
             BEAST_EXPECT(canSubtract(amt1, amt2) == false);
         }
 
         // Overflow check for max XRP amounts
         {
-            STAmount amt1(std::numeric_limits<XRPAmount::value_type>::max());
-            STAmount amt2(XRPAmount(-1));
+            STAmount const amt1(std::numeric_limits<XRPAmount::value_type>::max());
+            STAmount const amt2(XRPAmount(-1));
             BEAST_EXPECT(canSubtract(amt1, amt2) == false);
         }
     }
@@ -1070,29 +1080,29 @@ public:
 
         // Subtracting two IOU amounts
         {
-            STAmount amt1(usd, 1500);
-            STAmount amt2(usd, 500);
+            STAmount const amt1(usd, 1500);
+            STAmount const amt2(usd, 500);
             BEAST_EXPECT(canSubtract(amt1, amt2) == true);
         }
 
         // Subtracting XRP and IOU
         {
-            STAmount amt1(XRPAmount(1000));
-            STAmount amt2(usd, 1000);
+            STAmount const amt1(XRPAmount(1000));
+            STAmount const amt2(usd, 1000);
             BEAST_EXPECT(canSubtract(amt1, amt2) == false);
         }
 
         // Subtracting different IOU issues (non zero)
         {
-            STAmount amt1(usd, 1000);
-            STAmount amt2(eur, 500);
+            STAmount const amt1(usd, 1000);
+            STAmount const amt2(eur, 500);
             BEAST_EXPECT(canSubtract(amt1, amt2) == false);
         }
 
         // Subtracting different IOU issues (zero)
         {
-            STAmount amt1(usd, 0);
-            STAmount amt2(eur, 500);
+            STAmount const amt1(usd, 0);
+            STAmount const amt2(eur, 500);
             BEAST_EXPECT(canSubtract(amt1, amt2) == false);
         }
     }
@@ -1107,36 +1117,36 @@ public:
 
         // Subtracting zero
         {
-            STAmount amt1(mpt, 1000);
-            STAmount amt2(mpt, 0);
+            STAmount const amt1(mpt, 1000);
+            STAmount const amt2(mpt, 0);
             BEAST_EXPECT(canSubtract(amt1, amt2) == true);
         }
 
         // Subtracting zero
         {
-            STAmount amt1(mpt, 0);
-            STAmount amt2(mpt, 1000);
+            STAmount const amt1(mpt, 0);
+            STAmount const amt2(mpt, 1000);
             BEAST_EXPECT(canSubtract(amt1, amt2) == false);
         }
 
         // Subtracting two positive MPT amounts
         {
-            STAmount amt1(mpt, 1500);
-            STAmount amt2(mpt, 500);
+            STAmount const amt1(mpt, 1500);
+            STAmount const amt2(mpt, 500);
             BEAST_EXPECT(canSubtract(amt1, amt2) == true);
         }
 
         // Subtracting two negative MPT amounts
         {
-            STAmount amt1(mpt, -1500);
-            STAmount amt2(mpt, -500);
+            STAmount const amt1(mpt, -1500);
+            STAmount const amt2(mpt, -500);
             BEAST_EXPECT(canSubtract(amt1, amt2) == true);
         }
 
         // Subtracting a positive and a negative MPT amount
         {
-            STAmount amt1(mpt, 1000);
-            STAmount amt2(mpt, -1000);
+            STAmount const amt1(mpt, 1000);
+            STAmount const amt2(mpt, -1000);
             BEAST_EXPECT(canSubtract(amt1, amt2) == true);
         }
 
@@ -1146,29 +1156,29 @@ public:
 
         // Overflow check for max positive MPT amounts (should fail)
         {
-            STAmount amt1(mpt, std::numeric_limits<MPTAmount::value_type>::max());
-            STAmount amt2(mpt, -2);
+            STAmount const amt1(mpt, std::numeric_limits<MPTAmount::value_type>::max());
+            STAmount const amt2(mpt, -2);
             BEAST_EXPECT(canSubtract(amt1, amt2) == false);
         }
 
         // Subtracting MPT and XRP
         {
-            STAmount amt1(XRPAmount(1000));
-            STAmount amt2(mpt, 1000);
+            STAmount const amt1(XRPAmount(1000));
+            STAmount const amt2(mpt, 1000);
             BEAST_EXPECT(canSubtract(amt1, amt2) == false);
         }
 
         // Subtracting different MPT issues (non zero)
         {
-            STAmount amt1(mpt, 1000);
-            STAmount amt2(mpt2, 500);
+            STAmount const amt1(mpt, 1000);
+            STAmount const amt2(mpt2, 500);
             BEAST_EXPECT(canSubtract(amt1, amt2) == false);
         }
 
         // Subtracting different MPT issues (zero)
         {
-            STAmount amt1(mpt, 0);
-            STAmount amt2(mpt2, 500);
+            STAmount const amt1(mpt, 0);
+            STAmount const amt2(mpt2, 500);
             BEAST_EXPECT(canSubtract(amt1, amt2) == false);
         }
     }
diff --git a/src/test/protocol/STInteger_test.cpp b/src/test/protocol/STInteger_test.cpp
index 937dbd1a7f..4a0204d349 100644
--- a/src/test/protocol/STInteger_test.cpp
+++ b/src/test/protocol/STInteger_test.cpp
@@ -12,14 +12,14 @@ struct STInteger_test : public beast::unit_test::suite
     testUInt8()
     {
         testcase("UInt8");
-        STUInt8 u8(255);
+        STUInt8 const u8(255);
         BEAST_EXPECT(u8.value() == 255);
         BEAST_EXPECT(u8.getText() == "255");
         BEAST_EXPECT(u8.getSType() == STI_UINT8);
         BEAST_EXPECT(u8.getJson(JsonOptions::none) == 255);
 
         // there is some special handling for sfTransactionResult
-        STUInt8 tr(sfTransactionResult, 0);
+        STUInt8 const tr(sfTransactionResult, 0);
         BEAST_EXPECT(tr.value() == 0);
         BEAST_EXPECT(
             tr.getText() == "The transaction was applied. Only final in a validated ledger.");
@@ -27,7 +27,7 @@ struct STInteger_test : public beast::unit_test::suite
         BEAST_EXPECT(tr.getJson(JsonOptions::none) == "tesSUCCESS");
 
         // invalid transaction result
-        STUInt8 tr2(sfTransactionResult, 255);
+        STUInt8 const tr2(sfTransactionResult, 255);
         BEAST_EXPECT(tr2.value() == 255);
         BEAST_EXPECT(tr2.getText() == "255");
         BEAST_EXPECT(tr2.getSType() == STI_UINT8);
@@ -38,21 +38,21 @@ struct STInteger_test : public beast::unit_test::suite
     testUInt16()
     {
         testcase("UInt16");
-        STUInt16 u16(65535);
+        STUInt16 const u16(65535);
         BEAST_EXPECT(u16.value() == 65535);
         BEAST_EXPECT(u16.getText() == "65535");
         BEAST_EXPECT(u16.getSType() == STI_UINT16);
         BEAST_EXPECT(u16.getJson(JsonOptions::none) == 65535);
 
         // there is some special handling for sfLedgerEntryType
-        STUInt16 let(sfLedgerEntryType, ltACCOUNT_ROOT);
+        STUInt16 const let(sfLedgerEntryType, ltACCOUNT_ROOT);
         BEAST_EXPECT(let.value() == ltACCOUNT_ROOT);
         BEAST_EXPECT(let.getText() == "AccountRoot");
         BEAST_EXPECT(let.getSType() == STI_UINT16);
         BEAST_EXPECT(let.getJson(JsonOptions::none) == "AccountRoot");
 
         // there is some special handling for sfTransactionType
-        STUInt16 tlt(sfTransactionType, ttPAYMENT);
+        STUInt16 const tlt(sfTransactionType, ttPAYMENT);
         BEAST_EXPECT(tlt.value() == ttPAYMENT);
         BEAST_EXPECT(tlt.getText() == "Payment");
         BEAST_EXPECT(tlt.getSType() == STI_UINT16);
@@ -63,19 +63,19 @@ struct STInteger_test : public beast::unit_test::suite
     testUInt32()
     {
         testcase("UInt32");
-        STUInt32 u32(4'294'967'295u);
+        STUInt32 const u32(4'294'967'295u);
         BEAST_EXPECT(u32.value() == 4'294'967'295u);
         BEAST_EXPECT(u32.getText() == "4294967295");
         BEAST_EXPECT(u32.getSType() == STI_UINT32);
         BEAST_EXPECT(u32.getJson(JsonOptions::none) == 4'294'967'295u);
 
         // there is some special handling for sfPermissionValue
-        STUInt32 pv(sfPermissionValue, ttPAYMENT + 1);
+        STUInt32 const pv(sfPermissionValue, ttPAYMENT + 1);
         BEAST_EXPECT(pv.value() == ttPAYMENT + 1);
         BEAST_EXPECT(pv.getText() == "Payment");
         BEAST_EXPECT(pv.getSType() == STI_UINT32);
         BEAST_EXPECT(pv.getJson(JsonOptions::none) == "Payment");
-        STUInt32 pv2(sfPermissionValue, PaymentMint);
+        STUInt32 const pv2(sfPermissionValue, PaymentMint);
         BEAST_EXPECT(pv2.value() == PaymentMint);
         BEAST_EXPECT(pv2.getText() == "PaymentMint");
         BEAST_EXPECT(pv2.getSType() == STI_UINT32);
@@ -86,7 +86,7 @@ struct STInteger_test : public beast::unit_test::suite
     testUInt64()
     {
         testcase("UInt64");
-        STUInt64 u64(0xFFFFFFFFFFFFFFFFull);
+        STUInt64 const u64(0xFFFFFFFFFFFFFFFFull);
         BEAST_EXPECT(u64.value() == 0xFFFFFFFFFFFFFFFFull);
         BEAST_EXPECT(u64.getText() == "18446744073709551615");
         BEAST_EXPECT(u64.getSType() == STI_UINT64);
@@ -96,7 +96,7 @@ struct STInteger_test : public beast::unit_test::suite
         BEAST_EXPECT(jsonVal.isString());
         BEAST_EXPECT(jsonVal.asString() == "ffffffffffffffff");
 
-        STUInt64 u64_2(sfMaximumAmount, 0xFFFFFFFFFFFFFFFFull);
+        STUInt64 const u64_2(sfMaximumAmount, 0xFFFFFFFFFFFFFFFFull);
         BEAST_EXPECT(u64_2.value() == 0xFFFFFFFFFFFFFFFFull);
         BEAST_EXPECT(u64_2.getText() == "18446744073709551615");
         BEAST_EXPECT(u64_2.getSType() == STI_UINT64);
@@ -109,7 +109,7 @@ struct STInteger_test : public beast::unit_test::suite
         testcase("Int32");
         {
             int const minInt32 = -2147483648;
-            STInt32 i32(minInt32);
+            STInt32 const i32(minInt32);
             BEAST_EXPECT(i32.value() == minInt32);
             BEAST_EXPECT(i32.getText() == "-2147483648");
             BEAST_EXPECT(i32.getSType() == STI_INT32);
@@ -118,7 +118,7 @@ struct STInteger_test : public beast::unit_test::suite
 
         {
             int const maxInt32 = 2147483647;
-            STInt32 i32(maxInt32);
+            STInt32 const i32(maxInt32);
             BEAST_EXPECT(i32.value() == maxInt32);
             BEAST_EXPECT(i32.getText() == "2147483647");
             BEAST_EXPECT(i32.getSType() == STI_INT32);
diff --git a/src/test/protocol/STIssue_test.cpp b/src/test/protocol/STIssue_test.cpp
index 7e6fe5487c..2ffdb1d9af 100644
--- a/src/test/protocol/STIssue_test.cpp
+++ b/src/test/protocol/STIssue_test.cpp
@@ -22,7 +22,7 @@ public:
         {
             issue = xrpIssue();
             issue.account = alice;
-            STIssue stissue(sfAsset, Asset{issue});
+            STIssue const stissue(sfAsset, Asset{issue});
             fail("Inconsistent XRP Issue doesn't fail");
         }
         catch (...)
@@ -34,7 +34,7 @@ public:
         {
             issue = USD;
             issue.account = xrpAccount();
-            STIssue stissue(sfAsset, Asset{issue});
+            STIssue const stissue(sfAsset, Asset{issue});
             fail("Inconsistent IOU Issue doesn't fail");
         }
         catch (...)
@@ -51,7 +51,7 @@ public:
             base_uint<320> uint;
             (void)uint.parseHex(data);
             SerialIter iter(Slice(uint.data(), uint.size()));
-            STIssue stissue(iter, sfAsset);
+            STIssue const stissue(iter, sfAsset);
             fail("Inconsistent IOU Issue doesn't fail on serializer");
         }
         catch (...)
@@ -61,7 +61,7 @@ public:
 
         try
         {
-            STIssue stissue(sfAsset, Asset{xrpIssue()});
+            STIssue const stissue(sfAsset, Asset{xrpIssue()});
         }
         catch (...)
         {
@@ -70,7 +70,7 @@ public:
 
         try
         {
-            STIssue stissue(sfAsset, Asset{USD});
+            STIssue const stissue(sfAsset, Asset{USD});
         }
         catch (...)
         {
@@ -85,7 +85,7 @@ public:
             base_uint<320> uint;
             (void)uint.parseHex(data);
             SerialIter iter(Slice(uint.data(), uint.size()));
-            STIssue stissue(iter, sfAsset);
+            STIssue const stissue(iter, sfAsset);
             BEAST_EXPECT(stissue.value() == USD);
         }
         catch (...)
@@ -99,7 +99,7 @@ public:
             base_uint<160> uint;
             (void)uint.parseHex(data);
             SerialIter iter(Slice(uint.data(), uint.size()));
-            STIssue stissue(iter, sfAsset);
+            STIssue const stissue(iter, sfAsset);
             BEAST_EXPECT(stissue.value() == xrpCurrency());
         }
         catch (...)
diff --git a/src/test/protocol/STNumber_test.cpp b/src/test/protocol/STNumber_test.cpp
index 9d43ace638..3b794b23b5 100644
--- a/src/test/protocol/STNumber_test.cpp
+++ b/src/test/protocol/STNumber_test.cpp
@@ -45,19 +45,19 @@ struct STNumber_test : public beast::unit_test::suite
             0,
             1,
             std::numeric_limits<std::int64_t>::max()};
-        for (std::int64_t mantissa : mantissas)
+        for (std::int64_t const mantissa : mantissas)
             testCombo(Number{mantissa});
 
         std::initializer_list<std::int32_t> const exponents = {
             Number::minExponent, -1, 0, 1, Number::maxExponent - 1};
-        for (std::int32_t exponent : exponents)
+        for (std::int32_t const exponent : exponents)
             testCombo(Number{123, exponent});
 
         {
             STAmount const strikePrice{noIssue(), 100};
             STNumber const factor{sfNumber, 100};
             auto const iouValue = strikePrice.iou();
-            IOUAmount totalValue{iouValue * factor};
+            IOUAmount const totalValue{iouValue * factor};
             STAmount const totalAmount{totalValue, strikePrice.issue()};
             BEAST_EXPECT(totalAmount == Number{10'000});
         }
@@ -95,7 +95,7 @@ struct STNumber_test : public beast::unit_test::suite
             BEAST_EXPECT(numberFromJson(sfNumber, "-0.000e6") == STNumber(sfNumber, 0));
 
             {
-                NumberRoundModeGuard mg(Number::towards_zero);
+                NumberRoundModeGuard const mg(Number::towards_zero);
                 // maxint64 9,223,372,036,854,775,807
                 auto const maxInt = std::to_string(std::numeric_limits<std::int64_t>::max());
                 // minint64 -9,223,372,036,854,775,808
@@ -276,7 +276,7 @@ struct STNumber_test : public beast::unit_test::suite
 
         for (auto const scale : {MantissaRange::small, MantissaRange::large})
         {
-            NumberMantissaScaleGuard sg(scale);
+            NumberMantissaScaleGuard const sg(scale);
             testcase << to_string(Number::getMantissaScale());
             doRun();
         }
diff --git a/src/test/protocol/STObject_test.cpp b/src/test/protocol/STObject_test.cpp
index 0faa1946a9..135c577fb4 100644
--- a/src/test/protocol/STObject_test.cpp
+++ b/src/test/protocol/STObject_test.cpp
@@ -13,7 +13,8 @@ public:
         unexpected(sfGeneric.isUseful(), "sfGeneric must not be useful");
         {
             // Try to put sfGeneric in an SOTemplate.
-            except<std::runtime_error>([&]() { SOTemplate elements{{sfGeneric, soeREQUIRED}}; });
+            except<std::runtime_error>(
+                [&]() { SOTemplate const elements{{sfGeneric, soeREQUIRED}}; });
         }
 
         unexpected(sfInvalid.isUseful(), "sfInvalid must not be useful");
@@ -31,12 +32,13 @@ public:
         }
         {
             // Try to put sfInvalid in an SOTemplate.
-            except<std::runtime_error>([&]() { SOTemplate elements{{sfInvalid, soeREQUIRED}}; });
+            except<std::runtime_error>(
+                [&]() { SOTemplate const elements{{sfInvalid, soeREQUIRED}}; });
         }
         {
             // Try to put the same SField into an SOTemplate twice.
             except<std::runtime_error>([&]() {
-                SOTemplate elements{
+                SOTemplate const elements{
                     {sfAccount, soeREQUIRED},
                     {sfAccount, soeREQUIRED},
                 };
@@ -59,7 +61,7 @@ public:
         };
 
         STObject object1(elements, sfTestObject);
-        STObject object2(object1);
+        STObject const object2(object1);
 
         unexpected(object1.getSerializer() != object2.getSerializer(), "STObject error 1");
 
@@ -106,7 +108,7 @@ public:
 
         for (int i = 0; i < 1000; i++)
         {
-            Blob j(i, 2);
+            Blob const j(i, 2);
 
             object1.setFieldVL(sfTestVL, j);
 
@@ -114,7 +116,7 @@ public:
             object1.add(s);
             SerialIter it(s.slice());
 
-            STObject object3(elements, it, sfTestObject);
+            STObject const object3(elements, it, sfTestObject);
 
             unexpected(object1.getFieldVL(sfTestVL) != j, "STObject error");
 
@@ -134,7 +136,7 @@ public:
             object1.add(s);
             SerialIter it(s.slice());
 
-            STObject object3(elements, it, sfTestObject);
+            STObject const object3(elements, it, sfTestObject);
 
             auto const& uints1 = object1.getFieldV256(sfTestV256);
             auto const& uints3 = object3.getFieldV256(sfTestV256);
@@ -475,7 +477,7 @@ public:
     run() override
     {
         // Instantiate a jtx::Env so debugLog writes are exercised.
-        test::jtx::Env env(*this);
+        test::jtx::Env const env(*this);
 
         testFields();
         testSerialization();
diff --git a/src/test/protocol/STParsedJSON_test.cpp b/src/test/protocol/STParsedJSON_test.cpp
index 974975d05f..1c86a90348 100644
--- a/src/test/protocol/STParsedJSON_test.cpp
+++ b/src/test/protocol/STParsedJSON_test.cpp
@@ -71,7 +71,7 @@ class STParsedJSON_test : public beast::unit_test::suite
         {
             Json::Value j;
             j[sfCloseResolution] = -1;
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -79,7 +79,7 @@ class STParsedJSON_test : public beast::unit_test::suite
         {
             Json::Value j;
             j[sfCloseResolution] = 256;
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -87,7 +87,7 @@ class STParsedJSON_test : public beast::unit_test::suite
         {
             Json::Value j;
             j[sfCloseResolution] = Json::Value(Json::arrayValue);
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -95,7 +95,7 @@ class STParsedJSON_test : public beast::unit_test::suite
         {
             Json::Value j;
             j[sfCloseResolution] = Json::Value(Json::objectValue);
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
     }
@@ -154,7 +154,7 @@ class STParsedJSON_test : public beast::unit_test::suite
         {
             Json::Value j;
             j[sfLedgerEntryType] = -1;
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -162,7 +162,7 @@ class STParsedJSON_test : public beast::unit_test::suite
         {
             Json::Value j;
             j[sfLedgerEntryType] = 65536;
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -170,7 +170,7 @@ class STParsedJSON_test : public beast::unit_test::suite
         {
             Json::Value j;
             j[sfLedgerEntryType] = "65536";
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -178,7 +178,7 @@ class STParsedJSON_test : public beast::unit_test::suite
         {
             Json::Value j;
             j[sfLedgerEntryType] = Json::Value(Json::arrayValue);
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -186,7 +186,7 @@ class STParsedJSON_test : public beast::unit_test::suite
         {
             Json::Value j;
             j[sfLedgerEntryType] = Json::Value(Json::objectValue);
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -194,7 +194,7 @@ class STParsedJSON_test : public beast::unit_test::suite
         {
             Json::Value j;
             j[sfTransferFee] = "Payment";
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
     }
@@ -240,7 +240,7 @@ class STParsedJSON_test : public beast::unit_test::suite
         {
             Json::Value j;
             j[sfNetworkID] = -1;
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -248,7 +248,7 @@ class STParsedJSON_test : public beast::unit_test::suite
         {
             Json::Value j;
             j[sfNetworkID] = "4294967296";
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -256,7 +256,7 @@ class STParsedJSON_test : public beast::unit_test::suite
         {
             Json::Value j;
             j[sfNetworkID] = Json::Value(Json::arrayValue);
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -264,7 +264,7 @@ class STParsedJSON_test : public beast::unit_test::suite
         {
             Json::Value j;
             j[sfNetworkID] = Json::Value(Json::objectValue);
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
     }
@@ -298,7 +298,7 @@ class STParsedJSON_test : public beast::unit_test::suite
         {
             Json::Value j;
             j[sfIndexNext] = -1;
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -309,7 +309,7 @@ class STParsedJSON_test : public beast::unit_test::suite
         {
             Json::Value j;
             j[sfIndexNext] = "10000000000000000";  // uint64 max + 1 (in hex)
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -317,7 +317,7 @@ class STParsedJSON_test : public beast::unit_test::suite
         {
             Json::Value j;
             j[sfIndexNext] = "0xabcdefabcdef";
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -325,7 +325,7 @@ class STParsedJSON_test : public beast::unit_test::suite
         {
             Json::Value j;
             j[sfIndexNext] = "abcdefga";
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -333,7 +333,7 @@ class STParsedJSON_test : public beast::unit_test::suite
         {
             Json::Value j;
             j[sfIndexNext] = Json::Value(Json::arrayValue);
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -341,7 +341,7 @@ class STParsedJSON_test : public beast::unit_test::suite
         {
             Json::Value j;
             j[sfIndexNext] = Json::Value(Json::objectValue);
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
     }
@@ -359,7 +359,7 @@ class STParsedJSON_test : public beast::unit_test::suite
             BEAST_EXPECT(obj.object->isFieldPresent(sfEmailHash));
             // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->getFieldH128(sfEmailHash).size() == 16);
-            std::array<uint8_t, 16> expected = {
+            std::array<uint8_t, 16> const expected = {
                 0x01,
                 0x23,
                 0x45,
@@ -403,7 +403,8 @@ class STParsedJSON_test : public beast::unit_test::suite
             // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             auto const& h128 = obj.object->getFieldH128(sfEmailHash);
             BEAST_EXPECT(h128.size() == 16);
-            bool allZero = std::all_of(h128.begin(), h128.end(), [](auto b) { return b == 0; });
+            bool const allZero =
+                std::all_of(h128.begin(), h128.end(), [](auto b) { return b == 0; });
             BEAST_EXPECT(allZero);
         }
 
@@ -411,7 +412,7 @@ class STParsedJSON_test : public beast::unit_test::suite
         {
             Json::Value j;
             j[sfEmailHash] = "0123456789ABCDEF0123456789ABCDE";
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -419,7 +420,7 @@ class STParsedJSON_test : public beast::unit_test::suite
         {
             Json::Value j;
             j[sfEmailHash] = "nothexstring";
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -427,7 +428,7 @@ class STParsedJSON_test : public beast::unit_test::suite
         {
             Json::Value j;
             j[sfEmailHash] = "01234567";
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -435,7 +436,7 @@ class STParsedJSON_test : public beast::unit_test::suite
         {
             Json::Value j;
             j[sfEmailHash] = "0123456789ABCDEF0123456789ABCDEF00";
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -443,7 +444,7 @@ class STParsedJSON_test : public beast::unit_test::suite
         {
             Json::Value j;
             j[sfEmailHash] = Json::Value(Json::arrayValue);
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -451,7 +452,7 @@ class STParsedJSON_test : public beast::unit_test::suite
         {
             Json::Value j;
             j[sfEmailHash] = Json::Value(Json::objectValue);
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
     }
@@ -469,9 +470,9 @@ class STParsedJSON_test : public beast::unit_test::suite
             BEAST_EXPECT(obj.object->isFieldPresent(sfTakerPaysCurrency));
             // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->getFieldH160(sfTakerPaysCurrency).size() == 20);
-            std::array<uint8_t, 20> expected = {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD,
-                                                0xEF, 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB,
-                                                0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67};
+            std::array<uint8_t, 20> const expected = {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD,
+                                                      0xEF, 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB,
+                                                      0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67};
             // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->getFieldH160(sfTakerPaysCurrency) == uint160{expected});
         }
@@ -498,7 +499,8 @@ class STParsedJSON_test : public beast::unit_test::suite
             // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             auto const& h160 = obj.object->getFieldH160(sfTakerPaysCurrency);
             BEAST_EXPECT(h160.size() == 20);
-            bool allZero = std::all_of(h160.begin(), h160.end(), [](auto b) { return b == 0; });
+            bool const allZero =
+                std::all_of(h160.begin(), h160.end(), [](auto b) { return b == 0; });
             BEAST_EXPECT(allZero);
         }
 
@@ -506,7 +508,7 @@ class STParsedJSON_test : public beast::unit_test::suite
         {
             Json::Value j;
             j[sfTakerPaysCurrency] = "nothexstring";
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -514,7 +516,7 @@ class STParsedJSON_test : public beast::unit_test::suite
         {
             Json::Value j;
             j[sfTakerPaysCurrency] = "01234567";
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -522,7 +524,7 @@ class STParsedJSON_test : public beast::unit_test::suite
         {
             Json::Value j;
             j[sfTakerPaysCurrency] = "0123456789ABCDEF0123456789ABCDEF0123456789";
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -530,7 +532,7 @@ class STParsedJSON_test : public beast::unit_test::suite
         {
             Json::Value j;
             j[sfTakerPaysCurrency] = Json::Value(Json::arrayValue);
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -538,7 +540,7 @@ class STParsedJSON_test : public beast::unit_test::suite
         {
             Json::Value j;
             j[sfTakerPaysCurrency] = Json::Value(Json::objectValue);
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
     }
@@ -556,9 +558,9 @@ class STParsedJSON_test : public beast::unit_test::suite
             BEAST_EXPECT(obj.object->isFieldPresent(sfMPTokenIssuanceID));
             // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->getFieldH192(sfMPTokenIssuanceID).size() == 24);
-            std::array<uint8_t, 24> expected = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-                                                0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-                                                0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
+            std::array<uint8_t, 24> const expected = {
+                0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+                0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
             // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->getFieldH192(sfMPTokenIssuanceID) == uint192{expected});
         }
@@ -586,7 +588,8 @@ class STParsedJSON_test : public beast::unit_test::suite
             // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             auto const& h192 = obj.object->getFieldH192(sfMPTokenIssuanceID);
             BEAST_EXPECT(h192.size() == 24);
-            bool allZero = std::all_of(h192.begin(), h192.end(), [](auto b) { return b == 0; });
+            bool const allZero =
+                std::all_of(h192.begin(), h192.end(), [](auto b) { return b == 0; });
             BEAST_EXPECT(allZero);
         }
 
@@ -594,7 +597,7 @@ class STParsedJSON_test : public beast::unit_test::suite
         {
             Json::Value j;
             j[sfMPTokenIssuanceID] = "0123456789ABCDEF0123456789ABCDEF0123456789ABCDE";
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -602,7 +605,7 @@ class STParsedJSON_test : public beast::unit_test::suite
         {
             Json::Value j;
             j[sfMPTokenIssuanceID] = "nothexstring";
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -610,7 +613,7 @@ class STParsedJSON_test : public beast::unit_test::suite
         {
             Json::Value j;
             j[sfMPTokenIssuanceID] = "01234567";
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -618,7 +621,7 @@ class STParsedJSON_test : public beast::unit_test::suite
         {
             Json::Value j;
             j[sfMPTokenIssuanceID] = "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF00";
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -626,7 +629,7 @@ class STParsedJSON_test : public beast::unit_test::suite
         {
             Json::Value j;
             j[sfMPTokenIssuanceID] = Json::Value(Json::arrayValue);
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -634,7 +637,7 @@ class STParsedJSON_test : public beast::unit_test::suite
         {
             Json::Value j;
             j[sfMPTokenIssuanceID] = Json::Value(Json::objectValue);
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
     }
@@ -655,10 +658,10 @@ class STParsedJSON_test : public beast::unit_test::suite
             BEAST_EXPECT(obj.object->isFieldPresent(sfLedgerHash));
             // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->getFieldH256(sfLedgerHash).size() == 32);
-            std::array<uint8_t, 32> expected = {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF,
-                                                0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF,
-                                                0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF,
-                                                0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF};
+            std::array<uint8_t, 32> const expected = {
+                0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45,
+                0x67, 0x89, 0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB,
+                0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF};
             // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             BEAST_EXPECT(obj.object->getFieldH256(sfLedgerHash) == uint256{expected});
         }
@@ -687,7 +690,8 @@ class STParsedJSON_test : public beast::unit_test::suite
             // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
             auto const& h256 = obj.object->getFieldH256(sfLedgerHash);
             BEAST_EXPECT(h256.size() == 32);
-            bool allZero = std::all_of(h256.begin(), h256.end(), [](auto b) { return b == 0; });
+            bool const allZero =
+                std::all_of(h256.begin(), h256.end(), [](auto b) { return b == 0; });
             BEAST_EXPECT(allZero);
         }
 
@@ -697,7 +701,7 @@ class STParsedJSON_test : public beast::unit_test::suite
             j[sfLedgerHash] =
                 "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCD"
                 "E";
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -705,7 +709,7 @@ class STParsedJSON_test : public beast::unit_test::suite
         {
             Json::Value j;
             j[sfLedgerHash] = "nothexstring";
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -713,7 +717,7 @@ class STParsedJSON_test : public beast::unit_test::suite
         {
             Json::Value j;
             j[sfLedgerHash] = "01234567";
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -723,7 +727,7 @@ class STParsedJSON_test : public beast::unit_test::suite
             j[sfLedgerHash] =
                 "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCD"
                 "EF00";
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -731,7 +735,7 @@ class STParsedJSON_test : public beast::unit_test::suite
         {
             Json::Value j;
             j[sfLedgerHash] = Json::Value(Json::arrayValue);
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -739,7 +743,7 @@ class STParsedJSON_test : public beast::unit_test::suite
         {
             Json::Value j;
             j[sfLedgerHash] = Json::Value(Json::objectValue);
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
     }
@@ -810,7 +814,7 @@ class STParsedJSON_test : public beast::unit_test::suite
         // Test with string negative value
         {
             Json::Value j;
-            int value = -2147483648;
+            int const value = -2147483648;
             j[sfLoanScale] = std::to_string(value);
             STParsedJSONObject obj("Test", j);
             BEAST_EXPECT(obj.object.has_value());
@@ -826,7 +830,7 @@ class STParsedJSON_test : public beast::unit_test::suite
         {
             Json::Value j;
             j[sfLoanScale] = "-2147483649";
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -834,7 +838,7 @@ class STParsedJSON_test : public beast::unit_test::suite
         {
             Json::Value j;
             j[sfLoanScale] = 2147483648u;
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -842,7 +846,7 @@ class STParsedJSON_test : public beast::unit_test::suite
         {
             Json::Value j;
             j[sfLoanScale] = "2147483648";
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -850,7 +854,7 @@ class STParsedJSON_test : public beast::unit_test::suite
         {
             Json::Value j;
             j[sfLoanScale] = Json::Value(Json::arrayValue);
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -858,7 +862,7 @@ class STParsedJSON_test : public beast::unit_test::suite
         {
             Json::Value j;
             j[sfLoanScale] = Json::Value(Json::objectValue);
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
     }
@@ -918,7 +922,7 @@ class STParsedJSON_test : public beast::unit_test::suite
         {
             Json::Value j;
             j[sfPublicKey] = "XYZ123";
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -926,7 +930,7 @@ class STParsedJSON_test : public beast::unit_test::suite
         {
             Json::Value j;
             j[sfPublicKey] = Json::Value(Json::arrayValue);
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -934,7 +938,7 @@ class STParsedJSON_test : public beast::unit_test::suite
         {
             Json::Value j;
             j[sfPublicKey] = Json::Value(Json::objectValue);
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
     }
@@ -967,7 +971,7 @@ class STParsedJSON_test : public beast::unit_test::suite
         // Test empty array for Vector256 (should be valid, size 0)
         {
             Json::Value j;
-            Json::Value arr(Json::arrayValue);
+            Json::Value const arr(Json::arrayValue);
             j[sfHashes] = arr;
             STParsedJSONObject obj("Test", j);
             BEAST_EXPECT(obj.object.has_value());
@@ -984,7 +988,7 @@ class STParsedJSON_test : public beast::unit_test::suite
             Json::Value arr(Json::arrayValue);
             arr.append("nothexstring");
             j[sfHashes] = arr;
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -994,7 +998,7 @@ class STParsedJSON_test : public beast::unit_test::suite
             Json::Value arr(Json::arrayValue);
             arr.append("0123456789ABCDEF");  // too short for uint256
             j[sfHashes] = arr;
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -1004,7 +1008,7 @@ class STParsedJSON_test : public beast::unit_test::suite
             Json::Value arr(Json::arrayValue);
             arr.append(12345);
             j[sfHashes] = arr;
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -1012,7 +1016,7 @@ class STParsedJSON_test : public beast::unit_test::suite
         {
             Json::Value j;
             j[sfHashes] = "notanarray";
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -1024,7 +1028,7 @@ class STParsedJSON_test : public beast::unit_test::suite
             objElem["foo"] = "bar";
             arr.append(objElem);
             j[sfHashes] = arr;
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
     }
@@ -1064,7 +1068,7 @@ class STParsedJSON_test : public beast::unit_test::suite
         {
             Json::Value j;
             j[sfAccount] = "notAValidBase58Account";
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -1072,7 +1076,7 @@ class STParsedJSON_test : public beast::unit_test::suite
         {
             Json::Value j;
             j[sfAccount] = "001122334455";
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -1080,7 +1084,7 @@ class STParsedJSON_test : public beast::unit_test::suite
         {
             Json::Value j;
             j[sfAccount] = "000102030405060708090A0B0C0D0E0F101112131415";
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -1088,7 +1092,7 @@ class STParsedJSON_test : public beast::unit_test::suite
         {
             Json::Value j;
             j[sfAccount] = "000102030405060708090A0B0C0D0E0F1011121G";
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -1096,7 +1100,7 @@ class STParsedJSON_test : public beast::unit_test::suite
         {
             Json::Value j;
             j[sfAccount] = "";
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -1104,7 +1108,7 @@ class STParsedJSON_test : public beast::unit_test::suite
         {
             Json::Value j;
             j[sfAccount] = Json::Value(Json::arrayValue);
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -1112,7 +1116,7 @@ class STParsedJSON_test : public beast::unit_test::suite
         {
             Json::Value j;
             j[sfAccount] = Json::Value(Json::objectValue);
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
     }
@@ -1164,7 +1168,7 @@ class STParsedJSON_test : public beast::unit_test::suite
         {
             Json::Value j;
             j[sfBaseAsset] = "USDD";
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -1185,7 +1189,7 @@ class STParsedJSON_test : public beast::unit_test::suite
         {
             Json::Value j;
             j[sfBaseAsset] = "0123456789AB";
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -1193,7 +1197,7 @@ class STParsedJSON_test : public beast::unit_test::suite
         {
             Json::Value j;
             j[sfBaseAsset] = "0123456789ABCDEF0123456789";
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -1214,7 +1218,7 @@ class STParsedJSON_test : public beast::unit_test::suite
         {
             Json::Value j;
             j[sfBaseAsset] = Json::Value(Json::arrayValue);
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -1222,7 +1226,7 @@ class STParsedJSON_test : public beast::unit_test::suite
         {
             Json::Value j;
             j[sfBaseAsset] = Json::Value(Json::objectValue);
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
     }
@@ -1259,7 +1263,7 @@ class STParsedJSON_test : public beast::unit_test::suite
         {
             Json::Value j;
             j[sfAmount] = "123.45";
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -1267,7 +1271,7 @@ class STParsedJSON_test : public beast::unit_test::suite
         {
             Json::Value j;
             j[sfAmount] = "";
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -1275,7 +1279,7 @@ class STParsedJSON_test : public beast::unit_test::suite
         {
             Json::Value j;
             j[sfAmount] = "notanumber";
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -1283,7 +1287,7 @@ class STParsedJSON_test : public beast::unit_test::suite
         {
             Json::Value j;
             j[sfAmount] = Json::Value(Json::objectValue);
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
     }
@@ -1349,7 +1353,7 @@ class STParsedJSON_test : public beast::unit_test::suite
         {
             Json::Value j;
             j[sfPaths] = "notanarray";
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -1359,7 +1363,7 @@ class STParsedJSON_test : public beast::unit_test::suite
             Json::Value pathset(Json::arrayValue);
             pathset.append("notanarray");
             j[sfPaths] = pathset;
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -1372,7 +1376,7 @@ class STParsedJSON_test : public beast::unit_test::suite
             Json::Value pathset(Json::arrayValue);
             pathset.append(path);
             j[sfPaths] = pathset;
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -1387,7 +1391,7 @@ class STParsedJSON_test : public beast::unit_test::suite
             Json::Value pathset(Json::arrayValue);
             pathset.append(path);
             j[sfPaths] = pathset;
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -1402,7 +1406,7 @@ class STParsedJSON_test : public beast::unit_test::suite
             Json::Value pathset(Json::arrayValue);
             pathset.append(path);
             j[sfPaths] = pathset;
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -1416,7 +1420,7 @@ class STParsedJSON_test : public beast::unit_test::suite
             Json::Value pathset(Json::arrayValue);
             pathset.append(path);
             j[sfPaths] = pathset;
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -1430,7 +1434,7 @@ class STParsedJSON_test : public beast::unit_test::suite
             Json::Value pathset(Json::arrayValue);
             pathset.append(path);
             j[sfPaths] = pathset;
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -1444,7 +1448,7 @@ class STParsedJSON_test : public beast::unit_test::suite
             Json::Value pathset(Json::arrayValue);
             pathset.append(path);
             j[sfPaths] = pathset;
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -1458,7 +1462,7 @@ class STParsedJSON_test : public beast::unit_test::suite
             Json::Value pathset(Json::arrayValue);
             pathset.append(path);
             j[sfPaths] = pathset;
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -1472,7 +1476,7 @@ class STParsedJSON_test : public beast::unit_test::suite
             Json::Value pathset(Json::arrayValue);
             pathset.append(path);
             j[sfPaths] = pathset;
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
     }
@@ -1544,7 +1548,7 @@ class STParsedJSON_test : public beast::unit_test::suite
             Json::Value issue(Json::objectValue);
             issue["issuer"] = "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh";
             j[sfAsset] = issue;
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -1554,7 +1558,7 @@ class STParsedJSON_test : public beast::unit_test::suite
             Json::Value issue(Json::objectValue);
             issue["currency"] = "USD";
             j[sfAsset] = issue;
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -1565,7 +1569,7 @@ class STParsedJSON_test : public beast::unit_test::suite
             issue["currency"] = "USDD";
             issue["issuer"] = "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh";
             j[sfAsset] = issue;
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -1576,7 +1580,7 @@ class STParsedJSON_test : public beast::unit_test::suite
             issue["currency"] = "USD";
             issue["issuer"] = "notAValidIssuer";
             j[sfAsset] = issue;
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -1587,7 +1591,7 @@ class STParsedJSON_test : public beast::unit_test::suite
             issue["currency"] = Json::Value(Json::arrayValue);
             issue["issuer"] = "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh";
             j[sfAsset] = issue;
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -1598,7 +1602,7 @@ class STParsedJSON_test : public beast::unit_test::suite
             issue["currency"] = "USD";
             issue["issuer"] = Json::Value(Json::objectValue);
             j[sfAsset] = issue;
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -1606,7 +1610,7 @@ class STParsedJSON_test : public beast::unit_test::suite
         {
             Json::Value j;
             j[sfAsset] = "notanobject";
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
     }
@@ -1676,7 +1680,7 @@ class STParsedJSON_test : public beast::unit_test::suite
             bridge["LockingChainDoor"] = "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh";
             bridge["IssuingChainDoor"] = "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh";
             j[sfXChainBridge] = bridge;
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -1691,7 +1695,7 @@ class STParsedJSON_test : public beast::unit_test::suite
             bridge["LockingChainDoor"] = "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh";
             bridge["IssuingChainDoor"] = "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh";
             j[sfXChainBridge] = bridge;
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -1709,7 +1713,7 @@ class STParsedJSON_test : public beast::unit_test::suite
             bridge["LockingChainIssue"] = lockingChainIssue;
             bridge["IssuingChainDoor"] = "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh";
             j[sfXChainBridge] = bridge;
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -1727,7 +1731,7 @@ class STParsedJSON_test : public beast::unit_test::suite
             bridge["LockingChainIssue"] = lockingChainIssue;
             bridge["LockingChainDoor"] = "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh";
             j[sfXChainBridge] = bridge;
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -1738,7 +1742,7 @@ class STParsedJSON_test : public beast::unit_test::suite
             bridge["LockingChainIssue"] = "notanobject";
             bridge["IssuingChainIssue"] = "notanobject";
             j[sfXChainBridge] = bridge;
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -1754,7 +1758,7 @@ class STParsedJSON_test : public beast::unit_test::suite
             bridge["LockingChainIssue"] = lockingChainIssue;
             bridge["IssuingChainIssue"] = asset;
             j[sfXChainBridge] = bridge;
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -1770,7 +1774,7 @@ class STParsedJSON_test : public beast::unit_test::suite
             bridge["LockingChainIssue"] = lockingChainIssue;
             bridge["IssuingChainIssue"] = asset;
             j[sfXChainBridge] = bridge;
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -1787,7 +1791,7 @@ class STParsedJSON_test : public beast::unit_test::suite
             bridge["LockingChainIssue"] = lockingChainIssue;
             bridge["IssuingChainIssue"] = asset;
             j[sfXChainBridge] = bridge;
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -1795,7 +1799,7 @@ class STParsedJSON_test : public beast::unit_test::suite
         {
             Json::Value j;
             j[sfXChainBridge] = "notanobject";
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
     }
@@ -1880,7 +1884,7 @@ class STParsedJSON_test : public beast::unit_test::suite
         {
             Json::Value j;
             j[sfNumber] = "notanumber";
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -1888,7 +1892,7 @@ class STParsedJSON_test : public beast::unit_test::suite
         {
             Json::Value j;
             j[sfNumber] = Json::Value(Json::arrayValue);
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -1896,7 +1900,7 @@ class STParsedJSON_test : public beast::unit_test::suite
         {
             Json::Value j;
             j[sfNumber] = Json::Value(Json::objectValue);
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -1904,7 +1908,7 @@ class STParsedJSON_test : public beast::unit_test::suite
         {
             Json::Value j;
             j[sfNumber] = "";
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
     }
@@ -1932,7 +1936,7 @@ class STParsedJSON_test : public beast::unit_test::suite
         {
             Json::Value j;
             j[sfTransactionMetaData] = "notanobject";
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -1942,7 +1946,7 @@ class STParsedJSON_test : public beast::unit_test::suite
             Json::Value arr(Json::arrayValue);
             arr.append(1);
             j[sfTransactionMetaData] = arr;
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -1950,7 +1954,7 @@ class STParsedJSON_test : public beast::unit_test::suite
         {
             Json::Value j;
             j[sfTransactionMetaData] = Json::Value(Json::nullValue);
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -1962,7 +1966,7 @@ class STParsedJSON_test : public beast::unit_test::suite
             Json::Value* current = &obj;
             for (int i = 0; i < 63; ++i)
             {
-                Json::Value next(Json::objectValue);
+                Json::Value const next(Json::objectValue);
                 (*current)[sfTransactionMetaData] = next;
                 current = &((*current)[sfTransactionMetaData]);
             }
@@ -1981,13 +1985,13 @@ class STParsedJSON_test : public beast::unit_test::suite
             Json::Value* current = &obj;
             for (int i = 0; i < 64; ++i)
             {
-                Json::Value next(Json::objectValue);
+                Json::Value const next(Json::objectValue);
                 (*current)[sfTransactionMetaData] = next;
                 current = &((*current)[sfTransactionMetaData]);
             }
             (*current)[sfTransactionResult.getJsonName()] = 1;
             j[sfTransactionMetaData] = obj;
-            STParsedJSONObject parsed("Test", j);
+            STParsedJSONObject const parsed("Test", j);
             BEAST_EXPECT(!parsed.object.has_value());
         }
     }
@@ -2025,7 +2029,7 @@ class STParsedJSON_test : public beast::unit_test::suite
             Json::Value arr(Json::arrayValue);
             arr.append("notanobject");
             j[sfSignerEntries] = arr;
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -2037,7 +2041,7 @@ class STParsedJSON_test : public beast::unit_test::suite
             elem["invalidField"] = 1;
             arr.append(elem);
             j[sfSignerEntries] = arr;
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -2050,7 +2054,7 @@ class STParsedJSON_test : public beast::unit_test::suite
             elem[sfNetworkID] = 3;
             arr.append(elem);
             j[sfSignerEntries] = arr;
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -2058,7 +2062,7 @@ class STParsedJSON_test : public beast::unit_test::suite
         {
             Json::Value j;
             j[sfSignerEntries] = "notanarray";
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
@@ -2071,14 +2075,14 @@ class STParsedJSON_test : public beast::unit_test::suite
             elem[sfTransactionResult] = "notanint";
             arr.append(elem);
             j[sfSignerEntries] = arr;
-            STParsedJSONObject obj("Test", j);
+            STParsedJSONObject const obj("Test", j);
             BEAST_EXPECT(!obj.object.has_value());
         }
 
         // Test with empty array for Array (should be valid)
         {
             Json::Value j;
-            Json::Value arr(Json::arrayValue);
+            Json::Value const arr(Json::arrayValue);
             j[sfSignerEntries] = arr;
             STParsedJSONObject obj("Test", j);
             BEAST_EXPECT(obj.object.has_value());
@@ -2093,7 +2097,7 @@ class STParsedJSON_test : public beast::unit_test::suite
             obj.append(Json::Value(Json::objectValue));
             obj[0u][sfTransactionResult] = 1;
             j[sfSignerEntries] = obj;
-            STParsedJSONObject parsed("Test", j);
+            STParsedJSONObject const parsed("Test", j);
             BEAST_EXPECT(!parsed.object.has_value());
         }
 
@@ -2113,22 +2117,22 @@ class STParsedJSON_test : public beast::unit_test::suite
                 them.
 
                 */
-                std::string faulty(
+                std::string const faulty(
                     "{\"Template\":[{"
                     "\"ModifiedNode\":{\"Sequence\":1}, "
                     "\"DeletedNode\":{\"Sequence\":1}"
                     "}]}");
 
-                std::unique_ptr<STObject> so;
+                std::unique_ptr<STObject> const so;
                 Json::Value faultyJson;
-                bool parsedOK(parseJSONString(faulty, faultyJson));
+                bool const parsedOK(parseJSONString(faulty, faultyJson));
                 unexpected(!parsedOK, "failed to parse");
-                STParsedJSONObject parsed("test", faultyJson);
+                STParsedJSONObject const parsed("test", faultyJson);
                 BEAST_EXPECT(!parsed.object);
             }
             catch (std::runtime_error& e)
             {
-                std::string what(e.what());
+                std::string const what(e.what());
                 unexpected(what.find("First level children of `Template`") != 0);
             }
         }
@@ -2380,7 +2384,7 @@ class STParsedJSON_test : public beast::unit_test::suite
     run() override
     {
         // Instantiate a jtx::Env so debugLog writes are exercised.
-        test::jtx::Env env(*this);
+        test::jtx::Env const env(*this);
         testUInt8();
         testUInt16();
         testUInt32();
diff --git a/src/test/protocol/STTx_test.cpp b/src/test/protocol/STTx_test.cpp
index 93cfd16d3d..0804c89bd4 100644
--- a/src/test/protocol/STTx_test.cpp
+++ b/src/test/protocol/STTx_test.cpp
@@ -1149,7 +1149,7 @@ public:
 
             // Construct an SOTemplate to get the ball rolling on building
             // an STObject that can contain an STArray.
-            SOTemplate recurse{
+            SOTemplate const recurse{
                 {sfTransactionMetaData, soeOPTIONAL},
                 {sfTransactionHash, soeOPTIONAL},
                 {sfTemplate, soeOPTIONAL},
@@ -1211,7 +1211,7 @@ public:
             // Make an otherwise legit STTx with a duplicate field.  Should
             // generate an exception when we deserialize.
             auto const keypair = randomKeyPair(KeyType::secp256k1);
-            STTx acctSet(ttACCOUNT_SET, [&keypair](auto& obj) {
+            STTx const acctSet(ttACCOUNT_SET, [&keypair](auto& obj) {
                 obj.setAccountID(sfAccount, calcAccountID(keypair.first));
                 obj.setFieldU32(sfSequence, 7);
                 obj.setFieldAmount(sfFee, STAmount(2557891634ull));
@@ -1329,7 +1329,7 @@ public:
         Serializer rawTxn;
         j.add(rawTxn);
         SerialIter sit(rawTxn.slice());
-        STTx copy(sit);
+        STTx const copy(sit);
 
         if (copy != j)
         {
@@ -1466,7 +1466,7 @@ public:
         auto const id2 = calcAccountID(kp2.first);
 
         // Get the stream of the transaction for use in multi-signing.
-        Serializer s = buildMultiSigningData(txn, id2);
+        Serializer const s = buildMultiSigningData(txn, id2);
 
         auto const saMultiSignature = sign(kp2.first, kp2.second, s.slice());
 
@@ -1497,7 +1497,7 @@ public:
             bool serialized = false;
             try
             {
-                STTx copy(sit);
+                STTx const copy(sit);
                 serialized = true;
             }
             catch (std::exception const&)
diff --git a/src/test/protocol/SecretKey_test.cpp b/src/test/protocol/SecretKey_test.cpp
index e42bec3363..9072f5c0d9 100644
--- a/src/test/protocol/SecretKey_test.cpp
+++ b/src/test/protocol/SecretKey_test.cpp
@@ -216,7 +216,7 @@ public:
             auto s = good;
 
             // Remove all characters from the string in random order:
-            std::hash<std::string> r;
+            std::hash<std::string> const r;
 
             while (!s.empty())
             {
diff --git a/src/test/protocol/Serializer_test.cpp b/src/test/protocol/Serializer_test.cpp
index c5b56c3029..e4eaac8a58 100644
--- a/src/test/protocol/Serializer_test.cpp
+++ b/src/test/protocol/Serializer_test.cpp
@@ -17,7 +17,7 @@ struct Serializer_test : public beast::unit_test::suite
                 0,
                 1,
                 std::numeric_limits<std::int32_t>::max()};
-            for (std::int32_t value : values)
+            for (std::int32_t const value : values)
             {
                 Serializer s;
                 s.add32(value);
@@ -33,7 +33,7 @@ struct Serializer_test : public beast::unit_test::suite
                 0,
                 1,
                 std::numeric_limits<std::int64_t>::max()};
-            for (std::int64_t value : values)
+            for (std::int64_t const value : values)
             {
                 Serializer s;
                 s.add64(value);
diff --git a/src/test/protocol/TER_test.cpp b/src/test/protocol/TER_test.cpp
index cf88a570c5..2ad4b634aa 100644
--- a/src/test/protocol/TER_test.cpp
+++ b/src/test/protocol/TER_test.cpp
@@ -13,7 +13,7 @@ struct TER_test : public beast::unit_test::suite
     {
         for (auto i = -400; i < 400; ++i)
         {
-            TER t = TER::fromInt(i);
+            TER const t = TER::fromInt(i);
             auto inRange = isTelLocal(t) || isTemMalformed(t) || isTefFailure(t) || isTerRetry(t) ||
                 isTesSuccess(t) || isTecClaim(t);
 
@@ -75,7 +75,7 @@ struct TER_test : public beast::unit_test::suite
     std::enable_if_t<I1 != 0>
     testIterate(Tup const& tup, beast::unit_test::suite& s)
     {
-        Func<I1, I2> func;
+        Func<I1, I2> const func;
         func(tup, s);
         testIterate<I1 - 1, I2, Func>(tup, s);
     }
@@ -89,7 +89,7 @@ struct TER_test : public beast::unit_test::suite
     std::enable_if_t<I1 == 0 && I2 != 0>
     testIterate(Tup const& tup, beast::unit_test::suite& s)
     {
-        Func<I1, I2> func;
+        Func<I1, I2> const func;
         func(tup, s);
         testIterate<std::tuple_size<Tup>::value - 1, I2 - 1, Func>(tup, s);
     }
@@ -103,7 +103,7 @@ struct TER_test : public beast::unit_test::suite
     std::enable_if_t<I1 == 0 && I2 == 0>
     testIterate(Tup const& tup, beast::unit_test::suite& s)
     {
-        Func<I1, I2> func;
+        Func<I1, I2> const func;
         func(tup, s);
     }
 
diff --git a/src/test/resource/Logic_test.cpp b/src/test/resource/Logic_test.cpp
index 6d412b000f..12c1e631e2 100644
--- a/src/test/resource/Logic_test.cpp
+++ b/src/test/resource/Logic_test.cpp
@@ -54,7 +54,8 @@ public:
         {
             Gossip::Item item;
             item.balance = 100 + rand_int(499);
-            beast::IP::AddressV4::bytes_type d = {{192, 0, 2, static_cast<std::uint8_t>(v + i)}};
+            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);
         }
@@ -79,7 +80,7 @@ public:
         Charge const fee(dropThreshold + 1);
         beast::IP::Endpoint const addr(beast::IP::Endpoint::from_string("192.0.2.2"));
 
-        std::function<Consumer(beast::IP::Endpoint)> ep = limited
+        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);
 
@@ -147,7 +148,7 @@ public:
 
         // Make sure the consumer is on the blacklist for a while.
         {
-            Consumer c(logic.newInboundEndpoint(addr));
+            Consumer const c(logic.newInboundEndpoint(addr));
             logic.periodicActivity();
             if (c.disposition() != drop)
             {
@@ -174,7 +175,7 @@ public:
             {
                 ++logic.clock();
                 logic.periodicActivity();
-                Consumer c(logic.newInboundEndpoint(addr));
+                Consumer const c(logic.newInboundEndpoint(addr));
                 if (c.disposition() != drop)
                 {
                     readmitted = true;
@@ -218,7 +219,7 @@ public:
         Gossip g;
         Gossip::Item item;
         item.balance = 100;
-        beast::IP::AddressV4::bytes_type d = {{192, 0, 2, 1}};
+        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);
 
@@ -235,9 +236,9 @@ public:
         TestLogic logic(j);
 
         {
-            beast::IP::Endpoint address(beast::IP::Endpoint::from_string("192.0.2.1"));
+            beast::IP::Endpoint const address(beast::IP::Endpoint::from_string("192.0.2.1"));
             Consumer c(logic.newInboundEndpoint(address));
-            Charge fee(1000);
+            Charge const fee(1000);
             JLOG(j.info()) << "Charging " << c.to_string() << " " << fee << " per second";
             c.charge(fee);
             for (int i = 0; i < 128; ++i)
@@ -249,9 +250,9 @@ public:
         }
 
         {
-            beast::IP::Endpoint address(beast::IP::Endpoint::from_string("192.0.2.2"));
+            beast::IP::Endpoint const address(beast::IP::Endpoint::from_string("192.0.2.2"));
             Consumer c(logic.newInboundEndpoint(address));
-            Charge fee(1000);
+            Charge const fee(1000);
             JLOG(j.info()) << "Charging " << c.to_string() << " " << fee << " per second";
             for (int i = 0; i < 128; ++i)
             {
diff --git a/src/test/rpc/AccountCurrencies_test.cpp b/src/test/rpc/AccountCurrencies_test.cpp
index bb8ccf0a85..009af9d454 100644
--- a/src/test/rpc/AccountCurrencies_test.cpp
+++ b/src/test/rpc/AccountCurrencies_test.cpp
@@ -165,7 +165,8 @@ class AccountCurrencies_test : public beast::unit_test::suite
         env(pay(gw, alice, gw["USA"](50)));
         // USA should now be missing from receive_currencies
         result = env.rpc("json", "account_currencies", to_string(params))[jss::result];
-        decltype(gwCurrencies) gwCurrenciesNoUSA(gwCurrencies.begin() + 1, gwCurrencies.end());
+        decltype(gwCurrencies)
+            const gwCurrenciesNoUSA(gwCurrencies.begin() + 1, gwCurrencies.end());
         BEAST_EXPECT(arrayCheck(jss::receive_currencies, gwCurrenciesNoUSA));
         BEAST_EXPECT(arrayCheck(jss::send_currencies, gwCurrencies));
 
diff --git a/src/test/rpc/AccountObjects_test.cpp b/src/test/rpc/AccountObjects_test.cpp
index 905f8f2bb7..b6e8f6fa76 100644
--- a/src/test/rpc/AccountObjects_test.cpp
+++ b/src/test/rpc/AccountObjects_test.cpp
@@ -107,7 +107,7 @@ public:
 
         // test error on no account
         {
-            Json::Value params;
+            Json::Value const params;
             auto resp = env.rpc("json", "account_objects", to_string(params));
             BEAST_EXPECT(resp[jss::result][jss::error_message] == "Missing field 'account'.");
         }
@@ -488,7 +488,7 @@ public:
             params[jss::type] = jss::nft_page;
             auto resp = env.rpc("json", "account_objects", to_string(params));
             BEAST_EXPECT(!resp.isMember(jss::marker));
-            Json::Value& aobjs = resp[jss::result][jss::account_objects];
+            Json::Value const& aobjs = resp[jss::result][jss::account_objects];
             BEAST_EXPECT(aobjs.size() == 2);
         }
         // test stepped one-at-a-time with limit=1, resume from prev marker
@@ -1276,7 +1276,7 @@ public:
         // valid, because when dirIndex = 0, we will use root key to find
         // dir.
         {
-            std::string s = "0," + entryIndex;
+            std::string const s = "0," + entryIndex;
             Json::Value params;
             params[jss::account] = bob.human();
             params[jss::limit] = limit;
diff --git a/src/test/rpc/AccountTx_test.cpp b/src/test/rpc/AccountTx_test.cpp
index a11f957628..2470ec3c4c 100644
--- a/src/test/rpc/AccountTx_test.cpp
+++ b/src/test/rpc/AccountTx_test.cpp
@@ -97,7 +97,7 @@ class AccountTx_test : public beast::unit_test::suite
             cfg->FEES.reference_fee = 10;
             return cfg;
         }));
-        Account A1{"A1"};
+        Account const A1{"A1"};
         env.fund(XRP(10000), A1);
         env.close();
 
@@ -541,7 +541,7 @@ class AccountTx_test : public beast::unit_test::suite
 
         // PayChan
         {
-            std::uint32_t payChanSeq{env.seq(alice)};
+            std::uint32_t const payChanSeq{env.seq(alice)};
             Json::Value payChanCreate;
             payChanCreate[jss::TransactionType] = jss::PaymentChannelCreate;
             payChanCreate[jss::Account] = alice.human();
diff --git a/src/test/rpc/BookChanges_test.cpp b/src/test/rpc/BookChanges_test.cpp
index 6bd71b141b..0618f4e7d0 100644
--- a/src/test/rpc/BookChanges_test.cpp
+++ b/src/test/rpc/BookChanges_test.cpp
@@ -78,7 +78,7 @@ public:
             featurePermissionedDEX};
 
         Env env(*this, all);
-        PermissionedDEX permDex(env);
+        PermissionedDEX const permDex(env);
         auto const& [gw, domainOwner, alice, bob, carol, USD, domainID, credType] = permDex;
 
         auto wsc = makeWSClient(env.app().config());
diff --git a/src/test/rpc/Book_test.cpp b/src/test/rpc/Book_test.cpp
index 41442edb06..5e149ebc0e 100644
--- a/src/test/rpc/Book_test.cpp
+++ b/src/test/rpc/Book_test.cpp
@@ -877,9 +877,9 @@ public:
         testcase("TrackOffers");
         using namespace jtx;
         Env env(*this);
-        Account gw{"gw"};
-        Account alice{"alice"};
-        Account bob{"bob"};
+        Account const gw{"gw"};
+        Account const alice{"alice"};
+        Account const bob{"bob"};
         auto wsc = makeWSClient(env.app().config());
         env.fund(XRP(20000), alice, bob, gw);
         env.close();
@@ -1186,8 +1186,8 @@ public:
         testcase("BookOffersRPC Errors");
         using namespace jtx;
         Env env(*this);
-        Account gw{"gw"};
-        Account alice{"alice"};
+        Account const gw{"gw"};
+        Account const alice{"alice"};
         env.fund(XRP(10000), alice, gw);
         env.close();
         auto USD = gw["USD"];
@@ -1515,7 +1515,7 @@ public:
         testcase("BookOffer Limits");
         using namespace jtx;
         Env env{*this, asAdmin ? envconfig() : envconfig(no_admin)};
-        Account gw{"gw"};
+        Account const gw{"gw"};
         env.fund(XRP(200000), gw);
         // Note that calls to env.close() fail without admin permission.
         if (asAdmin)
@@ -1562,7 +1562,7 @@ public:
             featurePermissionedDEX};
 
         Env env(*this, all);
-        PermissionedDEX permDex(env);
+        PermissionedDEX const permDex(env);
         auto const alice = permDex.alice;
         auto const bob = permDex.bob;
         auto const carol = permDex.carol;
@@ -1685,7 +1685,7 @@ public:
             featurePermissionedDEX};
 
         Env env(*this, all);
-        PermissionedDEX permDex(env);
+        PermissionedDEX const permDex(env);
         auto const alice = permDex.alice;
         auto const bob = permDex.bob;
         auto const carol = permDex.carol;
diff --git a/src/test/rpc/DeliveredAmount_test.cpp b/src/test/rpc/DeliveredAmount_test.cpp
index 31b9b2aebf..358657a6c3 100644
--- a/src/test/rpc/DeliveredAmount_test.cpp
+++ b/src/test/rpc/DeliveredAmount_test.cpp
@@ -90,7 +90,7 @@ public:
         if (t[jss::TransactionType].asString() != jss::Payment)
             return true;
 
-        bool isSet = metaData.isMember(jss::delivered_amount);
+        bool const isSet = metaData.isMember(jss::delivered_amount);
         bool isSetUnavailable = false;
         bool isSetAvailable = false;
         if (isSet)
diff --git a/src/test/rpc/DepositAuthorized_test.cpp b/src/test/rpc/DepositAuthorized_test.cpp
index 87951e397c..7921d063c9 100644
--- a/src/test/rpc/DepositAuthorized_test.cpp
+++ b/src/test/rpc/DepositAuthorized_test.cpp
@@ -191,14 +191,14 @@ public:
         }
         {
             // Request an invalid ledger.
-            Json::Value args{depositAuthArgs(alice, becky, "-1")};
+            Json::Value const args{depositAuthArgs(alice, becky, "-1")};
             Json::Value const result{env.rpc("json", "deposit_authorized", args.toStyledString())};
             verifyErr(
                 result, "invalidParams", "Invalid field 'ledger_index', not string or number.");
         }
         {
             // Request a ledger that doesn't exist yet as a string.
-            Json::Value args{depositAuthArgs(alice, becky, "17")};
+            Json::Value const args{depositAuthArgs(alice, becky, "17")};
             Json::Value const result{env.rpc("json", "deposit_authorized", args.toStyledString())};
             verifyErr(result, "lgrNotFound", "ledgerNotFound");
         }
@@ -211,7 +211,7 @@ public:
         }
         {
             // alice is not yet funded.
-            Json::Value args{depositAuthArgs(alice, becky)};
+            Json::Value const args{depositAuthArgs(alice, becky)};
             Json::Value const result{env.rpc("json", "deposit_authorized", args.toStyledString())};
             verifyErr(result, "srcActNotFound", "Source account not found.");
         }
@@ -219,7 +219,7 @@ public:
         env.close();
         {
             // becky is not yet funded.
-            Json::Value args{depositAuthArgs(alice, becky)};
+            Json::Value const args{depositAuthArgs(alice, becky)};
             Json::Value const result{env.rpc("json", "deposit_authorized", args.toStyledString())};
             verifyErr(result, "dstActNotFound", "Destination account not found.");
         }
@@ -227,7 +227,7 @@ public:
         env.close();
         {
             // Once becky is funded try it again and see it succeed.
-            Json::Value args{depositAuthArgs(alice, becky)};
+            Json::Value const args{depositAuthArgs(alice, becky)};
             Json::Value const result{env.rpc("json", "deposit_authorized", args.toStyledString())};
             validateDepositAuthResult(result, true);
         }
diff --git a/src/test/rpc/Feature_test.cpp b/src/test/rpc/Feature_test.cpp
index 0050429c99..657eda2c1c 100644
--- a/src/test/rpc/Feature_test.cpp
+++ b/src/test/rpc/Feature_test.cpp
@@ -105,7 +105,7 @@ class Feature_test : public beast::unit_test::suite
         }
 
         // Test an arbitrary unknown feature
-        uint256 zero{0};
+        uint256 const zero{0};
         BEAST_EXPECT(featureToName(zero) == to_string(zero));
         BEAST_EXPECT(
             featureToName(zero) ==
@@ -143,8 +143,9 @@ class Feature_test : public beast::unit_test::suite
                 return;
             // default config - so all should be disabled, and
             // supported. Some may be vetoed.
-            bool expectVeto = (votes.at(feature[jss::name].asString()) == VoteBehavior::DefaultNo);
-            bool expectObsolete =
+            bool const expectVeto =
+                (votes.at(feature[jss::name].asString()) == VoteBehavior::DefaultNo);
+            bool const expectObsolete =
                 (votes.at(feature[jss::name].asString()) == VoteBehavior::Obsolete);
             BEAST_EXPECTS(
                 feature.isMember(jss::enabled) && !feature[jss::enabled].asBool(),
@@ -278,8 +279,8 @@ class Feature_test : public beast::unit_test::suite
                 (void)id.parseHex(it.key().asString().c_str());
                 if (!BEAST_EXPECT((*it).isMember(jss::name)))
                     return;
-                bool expectEnabled = env.app().getAmendmentTable().isEnabled(id);
-                bool expectSupported = env.app().getAmendmentTable().isSupported(id);
+                bool const expectEnabled = env.app().getAmendmentTable().isEnabled(id);
+                bool const expectSupported = env.app().getAmendmentTable().isSupported(id);
                 BEAST_EXPECTS(
                     (*it).isMember(jss::enabled) && (*it)[jss::enabled].asBool() == expectEnabled,
                     (*it)[jss::name].asString() + " enabled");
@@ -339,10 +340,12 @@ class Feature_test : public beast::unit_test::suite
             (void)id.parseHex(it.key().asString().c_str());
             if (!BEAST_EXPECT((*it).isMember(jss::name)))
                 return;
-            bool expectEnabled = env.app().getAmendmentTable().isEnabled(id);
-            bool expectSupported = env.app().getAmendmentTable().isSupported(id);
-            bool expectVeto = (votes.at((*it)[jss::name].asString()) == VoteBehavior::DefaultNo);
-            bool expectObsolete = (votes.at((*it)[jss::name].asString()) == VoteBehavior::Obsolete);
+            bool const expectEnabled = env.app().getAmendmentTable().isEnabled(id);
+            bool const expectSupported = env.app().getAmendmentTable().isSupported(id);
+            bool const expectVeto =
+                (votes.at((*it)[jss::name].asString()) == VoteBehavior::DefaultNo);
+            bool const expectObsolete =
+                (votes.at((*it)[jss::name].asString()) == VoteBehavior::Obsolete);
             BEAST_EXPECTS(
                 (*it).isMember(jss::enabled) && (*it)[jss::enabled].asBool() == expectEnabled,
                 (*it)[jss::name].asString() + " enabled");
@@ -421,8 +424,9 @@ class Feature_test : public beast::unit_test::suite
         {
             if (!BEAST_EXPECT(feature.isMember(jss::name)))
                 return;
-            bool expectVeto = (votes.at(feature[jss::name].asString()) == VoteBehavior::DefaultNo);
-            bool expectObsolete =
+            bool const expectVeto =
+                (votes.at(feature[jss::name].asString()) == VoteBehavior::DefaultNo);
+            bool const expectObsolete =
                 (votes.at(feature[jss::name].asString()) == VoteBehavior::Obsolete);
             BEAST_EXPECTS(
                 (expectVeto || expectObsolete) ^ feature.isMember(jss::majority),
diff --git a/src/test/rpc/GatewayBalances_test.cpp b/src/test/rpc/GatewayBalances_test.cpp
index 0deb1fc627..b6efea17fc 100644
--- a/src/test/rpc/GatewayBalances_test.cpp
+++ b/src/test/rpc/GatewayBalances_test.cpp
@@ -231,7 +231,7 @@ public:
         using namespace jtx;
 
         // Ensure MPT is enabled
-        FeatureBitset features = testable_amendments() | featureMPTokensV1;
+        FeatureBitset const features = testable_amendments() | featureMPTokensV1;
         Env env(*this, features);
 
         Account const alice{"alice"};
diff --git a/src/test/rpc/GetAggregatePrice_test.cpp b/src/test/rpc/GetAggregatePrice_test.cpp
index 5facd683a5..1d14678f76 100644
--- a/src/test/rpc/GetAggregatePrice_test.cpp
+++ b/src/test/rpc/GetAggregatePrice_test.cpp
@@ -34,7 +34,7 @@ public:
             BEAST_EXPECT(ret[jss::error_message].asString() == "Missing field 'quote_asset'.");
 
             // invalid base_asset, quote_asset
-            std::vector<AnyValue> invalidAsset = {
+            std::vector<AnyValue> const invalidAsset = {
                 NoneTag,
                 1,
                 -1,
@@ -76,7 +76,7 @@ public:
             ret = Oracle::aggregatePrice(env, "XRP", "USD", {{{owner, 2}}});
             BEAST_EXPECT(ret[jss::error].asString() == "objectNotFound");
             // invalid values
-            std::vector<AnyValue> invalidDocument = {NoneTag, 1.2, -1, "", "none", "1.2"};
+            std::vector<AnyValue> const invalidDocument = {NoneTag, 1.2, -1, "", "none", "1.2"};
             for (auto const& v : invalidDocument)
             {
                 ret = Oracle::aggregatePrice(env, "XRP", "USD", {{{owner, v}}});
@@ -97,7 +97,7 @@ public:
 
             // oracles have wrong asset pair
             env.fund(XRP(1'000), owner);
-            Oracle oracle(
+            Oracle const oracle(
                 env,
                 {.owner = owner,
                  .series = {{"XRP", "EUR", 740, 1}},
@@ -106,7 +106,7 @@ public:
             BEAST_EXPECT(ret[jss::error].asString() == "objectNotFound");
 
             // invalid trim value
-            std::vector<AnyValue> invalidTrim = {NoneTag, 0, 26, -1, 1.2, "", "none", "1.2"};
+            std::vector<AnyValue> const invalidTrim = {NoneTag, 0, 26, -1, 1.2, "", "none", "1.2"};
             for (auto const& v : invalidTrim)
             {
                 ret =
@@ -115,7 +115,7 @@ public:
             }
 
             // invalid time threshold value
-            std::vector<AnyValue> invalidTime = {NoneTag, -1, 1.2, "", "none", "1.2"};
+            std::vector<AnyValue> const invalidTime = {NoneTag, -1, 1.2, "", "none", "1.2"};
             for (auto const& v : invalidTime)
             {
                 ret = Oracle::aggregatePrice(
@@ -134,7 +134,7 @@ public:
             {
                 Account const owner(std::to_string(i));
                 env.fund(XRP(1'000), owner);
-                Oracle oracle(env, {.owner = owner, .documentID = i, .fee = baseFee});
+                Oracle const oracle(env, {.owner = owner, .documentID = i, .fee = baseFee});
                 oracles.emplace_back(owner, oracle.documentID());
             }
             auto const ret = Oracle::aggregatePrice(env, "XRP", "USD", oracles);
@@ -156,7 +156,7 @@ public:
 
                 Account const owner{std::to_string(i)};
                 env.fund(XRP(1'000), owner);
-                Oracle oracle(
+                Oracle const oracle(
                     env,
                     {.owner = owner,
                      .documentID = rand(),
@@ -178,7 +178,7 @@ public:
                     // the global mantissa size. And since it's a thread-local,
                     // overriding it locally won't make a difference either.
                     // This will mean all RPC will use the default of "large".
-                    NumberMantissaScaleGuard mg(mantissaSize);
+                    NumberMantissaScaleGuard const mg(mantissaSize);
 
                     Env env(*this, feats);
                     OraclesData oracles;
diff --git a/src/test/rpc/GetCounts_test.cpp b/src/test/rpc/GetCounts_test.cpp
index 07c29e3648..d0729b3f56 100644
--- a/src/test/rpc/GetCounts_test.cpp
+++ b/src/test/rpc/GetCounts_test.cpp
@@ -32,8 +32,8 @@ class GetCounts_test : public beast::unit_test::suite
 
         // create some transactions
         env.close();
-        Account alice{"alice"};
-        Account bob{"bob"};
+        Account const alice{"alice"};
+        Account const bob{"bob"};
         env.fund(XRP(10000), alice, bob);
         env.trust(alice["USD"](1000), bob);
         for (auto i = 0; i < 20; ++i)
diff --git a/src/test/rpc/JSONRPC_test.cpp b/src/test/rpc/JSONRPC_test.cpp
index 87c7d3dcd0..b9d4ee4a98 100644
--- a/src/test/rpc/JSONRPC_test.cpp
+++ b/src/test/rpc/JSONRPC_test.cpp
@@ -2119,7 +2119,7 @@ public:
             jt.jv.removeMember(jss::Fee);
             jt.jv.removeMember(jss::TxnSignature);
             req[jss::tx_json] = jt.jv;
-            Json::Value result = checkFee(
+            Json::Value const result = checkFee(
                 req,
                 Role::ADMIN,
                 true,
@@ -2189,7 +2189,7 @@ public:
                     alice));
 
             req[jss::tx_json] = jt.jv;
-            Json::Value result = checkFee(
+            Json::Value const result = checkFee(
                 req,
                 Role::ADMIN,
                 true,
@@ -2216,7 +2216,7 @@ public:
         {
             Json::Value req;
             Json::Reader().parse("{ \"fee_mult_max\" : 1, \"tx_json\" : { } } ", req);
-            Json::Value result = checkFee(
+            Json::Value const result = checkFee(
                 req,
                 Role::ADMIN,
                 true,
@@ -2236,7 +2236,7 @@ public:
                 "{ \"fee_mult_max\" : 3, \"fee_div_max\" : 2, "
                 "\"tx_json\" : { } } ",
                 req);
-            Json::Value result = checkFee(
+            Json::Value const result = checkFee(
                 req,
                 Role::ADMIN,
                 true,
@@ -2253,7 +2253,7 @@ public:
         {
             Json::Value req;
             Json::Reader().parse("{ \"fee_mult_max\" : 0, \"tx_json\" : { } } ", req);
-            Json::Value result = checkFee(
+            Json::Value const result = checkFee(
                 req,
                 Role::ADMIN,
                 true,
@@ -2274,7 +2274,7 @@ public:
                 "{ \"fee_mult_max\" : 3, \"fee_div_max\" : 6, "
                 "\"tx_json\" : { } } ",
                 req);
-            Json::Value result = checkFee(
+            Json::Value const result = checkFee(
                 req,
                 Role::ADMIN,
                 true,
@@ -2293,7 +2293,7 @@ public:
                 "{ \"fee_mult_max\" : 0, \"fee_div_max\" : 2, "
                 "\"tx_json\" : { } } ",
                 req);
-            Json::Value result = checkFee(
+            Json::Value const result = checkFee(
                 req,
                 Role::ADMIN,
                 true,
@@ -2312,7 +2312,7 @@ public:
                 "{ \"fee_mult_max\" : 10, \"fee_div_max\" : 0, "
                 "\"tx_json\" : { } } ",
                 req);
-            Json::Value result = checkFee(
+            Json::Value const result = checkFee(
                 req,
                 Role::ADMIN,
                 true,
@@ -2330,7 +2330,7 @@ public:
             Json::Value req;
             test::jtx::Account const alice("alice");
             req[jss::tx_json] = test::jtx::acctdelete(env.master.human(), alice.human());
-            Json::Value result = checkFee(
+            Json::Value const result = checkFee(
                 req,
                 Role::ADMIN,
                 true,
@@ -2367,7 +2367,7 @@ public:
                 "tx_json" : { }
             })",
                 req);
-            Json::Value result = checkFee(
+            Json::Value const result = checkFee(
                 req,
                 Role::ADMIN,
                 true,
@@ -2389,7 +2389,7 @@ public:
                 "tx_json" : { }
             })",
                 req);
-            Json::Value result = checkFee(
+            Json::Value const result = checkFee(
                 req,
                 Role::ADMIN,
                 true,
@@ -2417,7 +2417,7 @@ public:
                 "tx_json" : { }
             })",
                 req);
-            Json::Value result = checkFee(
+            Json::Value const result = checkFee(
                 req,
                 Role::ADMIN,
                 true,
@@ -2440,7 +2440,7 @@ public:
                 "tx_json" : { }
             })",
                 req);
-            Json::Value result = checkFee(
+            Json::Value const result = checkFee(
                 req,
                 Role::ADMIN,
                 true,
@@ -2463,7 +2463,7 @@ public:
                 "tx_json" : { }
             })",
                 req);
-            Json::Value result = checkFee(
+            Json::Value const result = checkFee(
                 req,
                 Role::ADMIN,
                 true,
@@ -2486,7 +2486,7 @@ public:
                 "tx_json" : { }
             })",
                 req);
-            Json::Value result = checkFee(
+            Json::Value const result = checkFee(
                 req,
                 Role::ADMIN,
                 true,
@@ -2509,7 +2509,7 @@ public:
                 "tx_json" : { }
             })",
                 req);
-            Json::Value result = checkFee(
+            Json::Value const result = checkFee(
                 req,
                 Role::ADMIN,
                 true,
@@ -2530,7 +2530,7 @@ public:
                 "tx_json" : { }
             })",
                 req);
-            Json::Value result = checkFee(
+            Json::Value const result = checkFee(
                 req,
                 Role::ADMIN,
                 true,
@@ -2552,7 +2552,7 @@ public:
                 "tx_json" : { }
             })",
                 req);
-            Json::Value result = checkFee(
+            Json::Value const result = checkFee(
                 req,
                 Role::ADMIN,
                 true,
@@ -2648,7 +2648,7 @@ public:
                 env(noop(env.master), fee(47));
             }
 
-            Env_ss envs(env);
+            Env_ss const envs(env);
 
             Json::Value toSign;
             toSign[jss::tx_json] = noop(env.master);
@@ -2732,7 +2732,7 @@ public:
         env(pay(g, env.master, USD(50)));
         env.close();
 
-        ProcessTransactionFn processTxn = fakeProcessTransaction;
+        ProcessTransactionFn const processTxn = fakeProcessTransaction;
 
         // A list of all the functions we want to test.
         using signFunc = Json::Value (*)(
@@ -2773,7 +2773,7 @@ public:
                 static Role const testedRoles[] = {
                     Role::GUEST, Role::USER, Role::ADMIN, Role::FORBID};
 
-                for (Role testRole : testedRoles)
+                for (Role const testRole : testedRoles)
                 {
                     Json::Value result;
                     auto const signFn = get<0>(testFunc);
diff --git a/src/test/rpc/KeyGeneration_test.cpp b/src/test/rpc/KeyGeneration_test.cpp
index e4af2608b7..87d2ded7ad 100644
--- a/src/test/rpc/KeyGeneration_test.cpp
+++ b/src/test/rpc/KeyGeneration_test.cpp
@@ -98,7 +98,7 @@ public:
             params.isMember(jss::key_type) ? params[jss::key_type] : "secp256k1");
         BEAST_EXPECT(!result.isMember(jss::warning));
 
-        std::string seed = result[jss::master_seed].asString();
+        std::string const seed = result[jss::master_seed].asString();
 
         result = walletPropose(params);
 
diff --git a/src/test/rpc/LedgerEntry_test.cpp b/src/test/rpc/LedgerEntry_test.cpp
index 474f29da17..bd053d71c9 100644
--- a/src/test/rpc/LedgerEntry_test.cpp
+++ b/src/test/rpc/LedgerEntry_test.cpp
@@ -172,7 +172,7 @@ class LedgerEntry_test : public beast::unit_test::suite
         };
 
         auto remove = [&](std::vector<std::uint8_t> indices) -> std::vector<Json::Value> {
-            std::unordered_set<std::uint8_t> indexSet(indices.begin(), indices.end());
+            std::unordered_set<std::uint8_t> const indexSet(indices.begin(), indices.end());
             std::vector<Json::Value> values;
             values.reserve(allBadValues.size() - indexSet.size());
             for (std::size_t i = 0; i < allBadValues.size(); ++i)
@@ -595,7 +595,7 @@ class LedgerEntry_test : public beast::unit_test::suite
         }
         {
             // Check malformed cases
-            Json::Value jvParams;
+            Json::Value const jvParams;
             testMalformedField(
                 env, jvParams, jss::account_root, FieldType::AccountField, "malformedAddress");
         }
@@ -699,7 +699,7 @@ class LedgerEntry_test : public beast::unit_test::suite
         Account const alice{"alice"};
         env.fund(XRP(10000), alice);
         env.close();
-        AMM amm(env, alice, XRP(10), alice["USD"](1000));
+        AMM const amm(env, alice, XRP(10), alice["USD"](1000));
         env.close();
 
         {
@@ -1961,7 +1961,7 @@ class LedgerEntry_test : public beast::unit_test::suite
         }
         {
             // Malformed DID index
-            Json::Value jvParams;
+            Json::Value const jvParams;
             testMalformedField(
                 env, jvParams, jss::did, FieldType::AccountField, "malformedAddress");
         }
@@ -1977,7 +1977,7 @@ class LedgerEntry_test : public beast::unit_test::suite
         Env env(*this);
         Account const owner("owner");
         env.fund(XRP(1'000), owner);
-        Oracle oracle(
+        Oracle const oracle(
             env, {.owner = owner, .fee = static_cast<int>(env.current()->fees().base.drops())});
 
         {
@@ -2008,11 +2008,11 @@ class LedgerEntry_test : public beast::unit_test::suite
             Account const owner(std::string("owner") + std::to_string(i));
             env.fund(XRP(1'000), owner);
             // different accounts can have the same asset pair
-            Oracle oracle(env, {.owner = owner, .documentID = i, .fee = baseFee});
+            Oracle const oracle(env, {.owner = owner, .documentID = i, .fee = baseFee});
             accounts.push_back(owner.id());
             oracles.push_back(oracle.documentID());
             // same account can have different asset pair
-            Oracle oracle1(env, {.owner = owner, .documentID = i + 10, .fee = baseFee});
+            Oracle const oracle1(env, {.owner = owner, .documentID = i + 10, .fee = baseFee});
             accounts.push_back(owner.id());
             oracles.push_back(oracle1.documentID());
         }
@@ -2102,7 +2102,7 @@ class LedgerEntry_test : public beast::unit_test::suite
         }
         {
             // Malformed MPTIssuance index
-            Json::Value jvParams;
+            Json::Value const jvParams;
             testMalformedField(
                 env, jvParams, jss::mptoken, FieldType::HashOrObjectField, "malformedRequest");
         }
diff --git a/src/test/rpc/LedgerRequest_test.cpp b/src/test/rpc/LedgerRequest_test.cpp
index 18c717ec19..4462c1f039 100644
--- a/src/test/rpc/LedgerRequest_test.cpp
+++ b/src/test/rpc/LedgerRequest_test.cpp
@@ -102,7 +102,7 @@ public:
         }
 
         {
-            std::string ledgerHash(64, 'q');
+            std::string const ledgerHash(64, 'q');
 
             auto const result = env.rpc("ledger_request", ledgerHash);
 
@@ -113,7 +113,7 @@ public:
         }
 
         {
-            std::string ledgerHash(64, '1');
+            std::string const ledgerHash(64, '1');
 
             auto const result = env.rpc("ledger_request", ledgerHash);
 
diff --git a/src/test/rpc/Peers_test.cpp b/src/test/rpc/Peers_test.cpp
index de46fd766c..984e767516 100644
--- a/src/test/rpc/Peers_test.cpp
+++ b/src/test/rpc/Peers_test.cpp
@@ -31,7 +31,7 @@ class Peers_test : public beast::unit_test::suite
         {
             auto kp = generateKeyPair(KeyType::secp256k1, generateSeed("seed" + std::to_string(i)));
 
-            std::string name = "Node " + std::to_string(i);
+            std::string const name = "Node " + std::to_string(i);
 
             using namespace std::chrono_literals;
             env.app().getCluster().update(kp.first, name, 200, env.timeKeeper().now() - 10s);
diff --git a/src/test/rpc/RPCCall_test.cpp b/src/test/rpc/RPCCall_test.cpp
index e4ef3aca6a..ae876dded4 100644
--- a/src/test/rpc/RPCCall_test.cpp
+++ b/src/test/rpc/RPCCall_test.cpp
@@ -5854,7 +5854,7 @@ public:
                 apiVersion <= RPC::apiMaximumValidVersion))
             return;
 
-        test::jtx::Env env(*this, makeNetworkConfig(11111));  // Used only for its Journal.
+        test::jtx::Env const env(*this, makeNetworkConfig(11111));  // Used only for its Journal.
 
         // For each RPCCall test.
         for (RPCCallTestData const& rpcCallTest : rpcCallTestArray)
diff --git a/src/test/rpc/Simulate_test.cpp b/src/test/rpc/Simulate_test.cpp
index e096b0479f..0581313e7a 100644
--- a/src/test/rpc/Simulate_test.cpp
+++ b/src/test/rpc/Simulate_test.cpp
@@ -1127,7 +1127,7 @@ class Simulate_test : public beast::unit_test::suite
                 tx[jss::TransactionType] = jss::NFTokenMint;
                 tx[sfNFTokenTaxon] = 1;
 
-                Json::Value nftokenId = to_string(token::getNextID(env, alice, 1));
+                Json::Value const nftokenId = to_string(token::getNextID(env, alice, 1));
                 // test nft synthetic
                 testTxJsonMetadataField(env, tx, validateOutput, jss::nftoken_id, nftokenId);
             }
@@ -1137,7 +1137,7 @@ class Simulate_test : public beast::unit_test::suite
                 tx[jss::Account] = alice.human();
                 tx[jss::TransactionType] = jss::MPTokenIssuanceCreate;
 
-                Json::Value mptIssuanceId = to_string(makeMptID(env.seq(alice), alice));
+                Json::Value const mptIssuanceId = to_string(makeMptID(env.seq(alice), alice));
                 // test mpt issuance id
                 testTxJsonMetadataField(
                     env, tx, validateOutput, jss::mpt_issuance_id, mptIssuanceId);
diff --git a/src/test/rpc/Status_test.cpp b/src/test/rpc/Status_test.cpp
index 01fc81430f..a4a7b8c961 100644
--- a/src/test/rpc/Status_test.cpp
+++ b/src/test/rpc/Status_test.cpp
@@ -136,7 +136,8 @@ private:
         expect(m == message, m + " != " + message);
 
         auto d = error[jss::data];
-        size_t s1 = d.size(), s2 = messages.size();
+        size_t const s1 = d.size();
+        size_t const s2 = messages.size();
         expect(
             s1 == s2,
             prefix + "Data sizes differ " + std::to_string(s1) + " != " + std::to_string(s2));
diff --git a/src/test/rpc/Subscribe_test.cpp b/src/test/rpc/Subscribe_test.cpp
index e96286aefc..bf52bde7aa 100644
--- a/src/test/rpc/Subscribe_test.cpp
+++ b/src/test/rpc/Subscribe_test.cpp
@@ -461,7 +461,7 @@ public:
                 if (!jv.isMember(jss::validated_hash))
                     return false;
 
-                uint32_t netID = env.app().getNetworkIDService().getNetworkID();
+                uint32_t const netID = env.app().getNetworkIDService().getNetworkID();
                 if (!jv.isMember(jss::network_id) || jv[jss::network_id] != netID)
                     return false;
 
@@ -784,9 +784,9 @@ public:
         using IdxHashVec = std::vector<std::tuple<int, std::string, bool, int>>;
 
         Account alice("alice");
-        Account bob("bob");
+        Account const bob("bob");
         Account carol("carol");
-        Account david("david");
+        Account const david("david");
         ///////////////////////////////////////////////////////////////////
 
         /*
@@ -820,8 +820,8 @@ public:
                         idx = r[jss::account_history_tx_index].asInt();
                     if (r.isMember(jss::account_history_tx_first))
                         first_flag = true;
-                    bool boundary = r.isMember(jss::account_history_boundary);
-                    int ledger_idx = r[jss::ledger_index].asInt();
+                    bool const boundary = r.isMember(jss::account_history_boundary);
+                    int const ledger_idx = r[jss::ledger_index].asInt();
                     if (r.isMember(jss::transaction) && r[jss::transaction].isMember(jss::hash))
                     {
                         auto t{r[jss::transaction]};
@@ -932,7 +932,7 @@ public:
         // (-10, "E5B8B...", true, 4
 
         auto checkBoundary = [](IdxHashVec const& vec, bool /* forward */) {
-            size_t num_tx = vec.size();
+            size_t const num_tx = vec.size();
             for (size_t i = 0; i < num_tx; ++i)
             {
                 auto [idx, hash, boundary, ledger] = vec[i];
@@ -1075,7 +1075,7 @@ public:
             auto wscAccount = makeWSClient(env.app().config());
             auto wscTxHistory = makeWSClient(env.app().config());
 
-            std::array<Account, 2> accounts = {alice, bob};
+            std::array<Account, 2> const accounts = {alice, bob};
             env.fund(XRP(222222), accounts);
             BEAST_EXPECT(env.syncClose());
 
@@ -1143,7 +1143,7 @@ public:
             Env env(*this, single_thread_io(envconfig()));
             auto const USD_a = alice["USD"];
 
-            std::array<Account, 2> accounts = {alice, carol};
+            std::array<Account, 2> const accounts = {alice, carol};
             env.fund(XRP(333333), accounts);
             env.trust(USD_a(20000), carol);
             BEAST_EXPECT(env.syncClose());
@@ -1180,7 +1180,7 @@ public:
              * long transaction history
              */
             Env env(*this, single_thread_io(envconfig()));
-            std::array<Account, 2> accounts = {alice, carol};
+            std::array<Account, 2> const accounts = {alice, carol};
             env.fund(XRP(444444), accounts);
             BEAST_EXPECT(env.syncClose());
 
@@ -1234,7 +1234,7 @@ public:
             featurePermissionedDEX};
 
         Env env(*this, single_thread_io(envconfig()), all);
-        PermissionedDEX permDex(env);
+        PermissionedDEX const permDex(env);
         auto const alice = permDex.alice;
         auto const bob = permDex.bob;
         auto const carol = permDex.carol;
diff --git a/src/test/rpc/TransactionEntry_test.cpp b/src/test/rpc/TransactionEntry_test.cpp
index 14e75d04da..6421587478 100644
--- a/src/test/rpc/TransactionEntry_test.cpp
+++ b/src/test/rpc/TransactionEntry_test.cpp
@@ -211,8 +211,8 @@ class TransactionEntry_test : public beast::unit_test::suite
             BEAST_EXPECT(clHash["result"] == resIndex);
         };
 
-        Account A1{"A1"};
-        Account A2{"A2"};
+        Account const A1{"A1"};
+        Account const A2{"A2"};
 
         env.fund(XRP(10000), A1);
         auto fund_1_tx = to_string(env.tx()->getTransactionID());
diff --git a/src/test/rpc/Transaction_test.cpp b/src/test/rpc/Transaction_test.cpp
index c53207e04d..9f06607729 100644
--- a/src/test/rpc/Transaction_test.cpp
+++ b/src/test/rpc/Transaction_test.cpp
@@ -283,7 +283,7 @@ class Transaction_test : public beast::unit_test::suite
         char const* EXCESSIVE = RPC::get_error_info(rpcEXCESSIVE_LGR_RANGE).token;
 
         Env env{*this, makeNetworkConfig(11111)};
-        uint32_t netID = env.app().getNetworkIDService().getNetworkID();
+        uint32_t const netID = env.app().getNetworkIDService().getNetworkID();
 
         auto const alice = Account("alice");
         env.fund(XRP(1000), alice);
@@ -306,7 +306,7 @@ class Transaction_test : public beast::unit_test::suite
         {
             auto const& tx = txns[i];
             auto const& meta = metas[i];
-            uint32_t txnIdx = meta->getFieldU32(sfTransactionIndex);
+            uint32_t const txnIdx = meta->getFieldU32(sfTransactionIndex);
             auto const result = env.rpc(
                 COMMAND,
                 // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
@@ -347,7 +347,7 @@ class Transaction_test : public beast::unit_test::suite
         {
             // auto const& tx = txns[i];
             auto const& meta = metas[i];
-            uint32_t txnIdx = meta->getFieldU32(sfTransactionIndex);
+            uint32_t const txnIdx = meta->getFieldU32(sfTransactionIndex);
             auto const result = env.rpc(
                 COMMAND,
                 // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
@@ -407,7 +407,7 @@ class Transaction_test : public beast::unit_test::suite
         // field. (Tests parameter parsing)
         {
             auto const& meta = metas[0];
-            uint32_t txnIdx = meta->getFieldU32(sfTransactionIndex);
+            uint32_t const txnIdx = meta->getFieldU32(sfTransactionIndex);
             auto const result = env.rpc(
                 COMMAND,
                 // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
@@ -500,7 +500,7 @@ class Transaction_test : public beast::unit_test::suite
         using namespace test::jtx;
         using std::to_string;
 
-        Env env{*this, makeNetworkConfig(11111)};
+        Env const env{*this, makeNetworkConfig(11111)};
 
         // Test case 1: Valid input values
         auto const expected11 = std::optional<std::string>("CFFFFFFFFFFFFFFF");
@@ -583,7 +583,7 @@ class Transaction_test : public beast::unit_test::suite
         using namespace test::jtx;
 
         // Use a Concise Transaction Identifier to request a transaction.
-        for (uint32_t netID : {11111, 65535, 65536})
+        for (uint32_t const netID : {11111, 65535, 65536})
         {
             Env env{*this, makeNetworkConfig(netID)};
             BEAST_EXPECT(netID == env.app().getNetworkIDService().getNetworkID());
@@ -655,7 +655,7 @@ class Transaction_test : public beast::unit_test::suite
         // test that if the network is 65535 the ctid is not in the response
         // Using a hash to request the transaction, test the network ID
         // boundary where the CTID is (not) in the response.
-        for (uint32_t netID : {2, 1024, 65535, 65536})
+        for (uint32_t const netID : {2, 1024, 65535, 65536})
         {
             Env env{*this, makeNetworkConfig(netID)};
             BEAST_EXPECT(netID == env.app().getNetworkIDService().getNetworkID());
@@ -691,7 +691,7 @@ class Transaction_test : public beast::unit_test::suite
         // test the wrong network ID was submitted
         {
             Env env{*this, makeNetworkConfig(21337)};
-            uint32_t netID = env.app().getNetworkIDService().getNetworkID();
+            uint32_t const netID = env.app().getNetworkIDService().getNetworkID();
 
             auto const alice = Account("alice");
             auto const bob = Account("bob");
@@ -743,9 +743,9 @@ class Transaction_test : public beast::unit_test::suite
         // Payment
         env(pay(alice, gw, XRP(100)));
 
-        std::shared_ptr<STTx const> txn = env.tx();
+        std::shared_ptr<STTx const> const txn = env.tx();
         env.close();
-        std::shared_ptr<STObject const> meta =
+        std::shared_ptr<STObject const> const meta =
             env.closed()->txRead(env.tx()->getTransactionID()).second;
 
         Json::Value expected = txn->getJson(JsonOptions::none);
@@ -817,7 +817,8 @@ class Transaction_test : public beast::unit_test::suite
             to_string(txn->getTransactionID()) ==
             "3F8BDE5A5F82C4F4708E5E9255B713E303E6E1A371FD5C7A704AFD1387C23981");
         env.close();
-        std::shared_ptr<STObject const> meta = env.closed()->txRead(txn->getTransactionID()).second;
+        std::shared_ptr<STObject const> const meta =
+            env.closed()->txRead(txn->getTransactionID()).second;
 
         std::string const expected_tx_blob = serializeHex(*txn);
         std::string const expected_meta_blob = serializeHex(*meta);
diff --git a/src/test/rpc/ValidatorRPC_test.cpp b/src/test/rpc/ValidatorRPC_test.cpp
index eece5c4448..6c6a75dd01 100644
--- a/src/test/rpc/ValidatorRPC_test.cpp
+++ b/src/test/rpc/ValidatorRPC_test.cpp
@@ -27,7 +27,7 @@ public:
 
         for (bool const isAdmin : {true, false})
         {
-            for (std::string cmd : {"validators", "validator_list_sites"})
+            for (std::string const cmd : {"validators", "validator_list_sites"})
             {
                 Env env{*this, isAdmin ? envconfig() : envconfig(no_admin)};
                 env.set_retries(isAdmin ? 5 : 0);
@@ -154,7 +154,7 @@ public:
         };
 
         // Validator keys that will be in the published list
-        std::vector<Validator> validators = {
+        std::vector<Validator> const validators = {
             TrustedPublisherServer::randomValidator(), TrustedPublisherServer::randomValidator()};
         std::set<std::string> expectedKeys;
         for (auto const& val : validators)
diff --git a/src/test/rpc/Version_test.cpp b/src/test/rpc/Version_test.cpp
index 7fa6720f83..c12e397459 100644
--- a/src/test/rpc/Version_test.cpp
+++ b/src/test/rpc/Version_test.cpp
@@ -77,13 +77,13 @@ class Version_test : public beast::unit_test::suite
     {
         testcase("test getAPIVersionNumber function");
 
-        unsigned int versionIfUnspecified =
+        unsigned int const versionIfUnspecified =
             RPC::apiVersionIfUnspecified < RPC::apiMinimumSupportedVersion
             ? RPC::apiInvalidVersion
             : RPC::apiVersionIfUnspecified;
 
-        Json::Value j_array = Json::Value(Json::arrayValue);
-        Json::Value j_null = Json::Value(Json::nullValue);
+        Json::Value const j_array = Json::Value(Json::arrayValue);
+        Json::Value const j_null = Json::Value(Json::nullValue);
         BEAST_EXPECT(RPC::getAPIVersionNumber(j_array, false) == versionIfUnspecified);
         BEAST_EXPECT(RPC::getAPIVersionNumber(j_null, false) == versionIfUnspecified);
 
@@ -185,7 +185,7 @@ class Version_test : public beast::unit_test::suite
     {
         testcase("config test");
         {
-            Config c;
+            Config const c;
             BEAST_EXPECT(c.BETA_RPC_API == false);
         }
 
diff --git a/src/test/server/ServerStatus_test.cpp b/src/test/server/ServerStatus_test.cpp
index 1a5da25d65..b7c9825a55 100644
--- a/src/test/server/ServerStatus_test.cpp
+++ b/src/test/server/ServerStatus_test.cpp
@@ -572,7 +572,7 @@ class ServerStatus_test : public beast::unit_test::suite, public beast::test::en
         // for zero limit, pick an arbitrary nonzero number of clients - all
         // should connect fine.
 
-        int testTo = (limit == 0) ? 50 : limit + 1;
+        int const testTo = (limit == 0) ? 50 : limit + 1;
         while (connectionCount < testTo)
         {
             clients.emplace_back(
@@ -1106,7 +1106,7 @@ class ServerStatus_test : public beast::unit_test::suite, public beast::test::en
         boost::system::error_code ec;
         doHTTPRequest(env, yield, false, resp, ec);
         BEAST_EXPECT(resp.result() == boost::beast::http::status::internal_server_error);
-        std::regex body{"Server cannot accept clients"};
+        std::regex const body{"Server cannot accept clients"};
         BEAST_EXPECT(std::regex_search(resp.body(), body));
     }
 
diff --git a/src/test/server/Server_test.cpp b/src/test/server/Server_test.cpp
index b6ff180bd4..97a822fd76 100644
--- a/src/test/server/Server_test.cpp
+++ b/src/test/server/Server_test.cpp
@@ -282,7 +282,7 @@ public:
         TestSink sink{*this};
         TestThread thread;
         sink.threshold(beast::severities::Severity::kAll);
-        beast::Journal journal{sink};
+        beast::Journal const journal{sink};
         TestHandler handler;
         auto s = make_Server(handler, thread.get_io_context(), journal);
         std::vector<Port> serverPort(1);
@@ -377,7 +377,7 @@ public:
         std::string messages;
 
         except([&] {
-            Env env{
+            Env const env{
                 *this,
                 envconfig([](std::unique_ptr<Config> cfg) {
                     (*cfg).deprecatedClearSection("port_rpc");
@@ -388,7 +388,7 @@ public:
         BEAST_EXPECT(messages.find("Missing 'ip' in [port_rpc]") != std::string::npos);
 
         except([&] {
-            Env env{
+            Env const env{
                 *this,
                 envconfig([](std::unique_ptr<Config> cfg) {
                     (*cfg).deprecatedClearSection("port_rpc");
@@ -400,7 +400,7 @@ public:
         BEAST_EXPECT(messages.find("Missing 'port' in [port_rpc]") != std::string::npos);
 
         except([&] {
-            Env env{
+            Env const env{
                 *this,
                 envconfig([](std::unique_ptr<Config> cfg) {
                     (*cfg).deprecatedClearSection("port_rpc");
@@ -414,7 +414,7 @@ public:
             messages.find("Invalid value '0' for key 'port' in [port_rpc]") == std::string::npos);
 
         except([&] {
-            Env env{
+            Env const env{
                 *this,
                 envconfig([](std::unique_ptr<Config> cfg) {
                     (*cfg)["server"].set("port", "0");
@@ -426,7 +426,7 @@ public:
             messages.find("Invalid value '0' for key 'port' in [server]") != std::string::npos);
 
         except([&] {
-            Env env{
+            Env const env{
                 *this,
                 envconfig([](std::unique_ptr<Config> cfg) {
                     (*cfg).deprecatedClearSection("port_rpc");
@@ -442,7 +442,7 @@ public:
         except([&]  // this creates a standard test config without the server
                     // section
                {
-                   Env env{
+                   Env const env{
                        *this,
                        envconfig([](std::unique_ptr<Config> cfg) {
                            cfg = std::make_unique<Config>();
@@ -471,7 +471,7 @@ public:
         except([&]  // this creates a standard test config without some of the
                     // port sections
                {
-                   Env env{
+                   Env const env{
                        *this,
                        envconfig([](std::unique_ptr<Config> cfg) {
                            cfg = std::make_unique<Config>();
diff --git a/src/test/shamap/FetchPack_test.cpp b/src/test/shamap/FetchPack_test.cpp
index ad86e066af..1cf7d97b33 100644
--- a/src/test/shamap/FetchPack_test.cpp
+++ b/src/test/shamap/FetchPack_test.cpp
@@ -53,7 +53,7 @@ public:
         std::optional<Blob>
         getNode(SHAMapHash const& nodeHash) const override
         {
-            Map::iterator it = mMap.find(nodeHash);
+            Map::iterator const it = mMap.find(nodeHash);
             if (it == mMap.end())
             {
                 JLOG(mJournal.fatal()) << "Test filter missing node";
@@ -100,7 +100,7 @@ public:
         test::SuiteJournal journal("FetchPack_test", *this);
 
         TestNodeFamily f(journal);
-        std::shared_ptr<Table> t1(std::make_shared<Table>(SHAMapType::FREE, f));
+        std::shared_ptr<Table> const t1(std::make_shared<Table>(SHAMapType::FREE, f));
 
         pass();
 
diff --git a/src/test/shamap/SHAMapSync_test.cpp b/src/test/shamap/SHAMapSync_test.cpp
index a8f3a478b2..6374e49e71 100644
--- a/src/test/shamap/SHAMapSync_test.cpp
+++ b/src/test/shamap/SHAMapSync_test.cpp
@@ -30,7 +30,7 @@ public:
     {
         // add a bunch of random states to a map, then remove them
         // map should be the same
-        SHAMapHash beforeHash = map.getHash();
+        SHAMapHash const beforeHash = map.getHash();
 
         std::list<uint256> items;
 
@@ -74,7 +74,7 @@ public:
         SHAMap source(SHAMapType::FREE, f);
         SHAMap destination(SHAMapType::FREE, f2);
 
-        int items = 10000;
+        int const items = 10000;
         for (int i = 0; i < items; ++i)
         {
             source.addItem(SHAMapNodeType::tnACCOUNT_STATE, makeRandomAS());
@@ -96,10 +96,6 @@ public:
         source.walkMap(missingNodes, 2048);
         BEAST_EXPECT(missingNodes.empty());
 
-        std::vector<SHAMapNodeID> nodeIDs, gotNodeIDs;
-        std::vector<Blob> gotNodes;
-        std::vector<uint256> hashes;
-
         destination.setSynching();
 
         {
diff --git a/src/test/shamap/SHAMap_test.cpp b/src/test/shamap/SHAMap_test.cpp
index b16f7b157f..1c6d62be97 100644
--- a/src/test/shamap/SHAMap_test.cpp
+++ b/src/test/shamap/SHAMap_test.cpp
@@ -175,8 +175,8 @@ public:
             testcase("snapshot unbacked");
         }
 
-        SHAMapHash mapHash = sMap.getHash();
-        std::shared_ptr<SHAMap> map2 = sMap.snapShot(false);
+        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");
@@ -370,7 +370,7 @@ class SHAMapPathProof_test : public beast::unit_test::suite
                 path->insert(path->begin(), path->front());
                 BEAST_EXPECT(!map.verifyProofPath(root, k, *path));
                 // wrong key
-                uint256 wrongKey(c + 1);
+                uint256 const wrongKey(c + 1);
                 BEAST_EXPECT(!map.getProofPath(wrongKey));
             }
             if (c == 99)
diff --git a/src/test/unit_test/SuiteJournal.h b/src/test/unit_test/SuiteJournal.h
index 08c40af43d..93005401e6 100644
--- a/src/test/unit_test/SuiteJournal.h
+++ b/src/test/unit_test/SuiteJournal.h
@@ -70,7 +70,7 @@ SuiteJournalSink::writeAlways(beast::severities::Severity level, std::string con
     }();
 
     static std::mutex log_mutex;
-    std::lock_guard lock(log_mutex);
+    std::lock_guard const lock(log_mutex);
     suite_.log << s << partition_ << text << std::endl;
 }
 
diff --git a/src/test/unit_test/multi_runner.cpp b/src/test/unit_test/multi_runner.cpp
index 239564bd7c..e4fb1c4f45 100644
--- a/src/test/unit_test/multi_runner.cpp
+++ b/src/test/unit_test/multi_runner.cpp
@@ -154,7 +154,7 @@ template <bool IsParent>
 std::size_t
 multi_runner_base<IsParent>::inner::tests() const
 {
-    std::lock_guard l{m_};
+    std::lock_guard const l{m_};
     return results_.total;
 }
 
@@ -162,7 +162,7 @@ template <bool IsParent>
 std::size_t
 multi_runner_base<IsParent>::inner::suites() const
 {
-    std::lock_guard l{m_};
+    std::lock_guard const l{m_};
     return results_.suites;
 }
 
@@ -184,7 +184,7 @@ template <bool IsParent>
 void
 multi_runner_base<IsParent>::inner::add(results const& r)
 {
-    std::lock_guard l{m_};
+    std::lock_guard const l{m_};
     results_.merge(r);
 }
 
@@ -193,7 +193,7 @@ template <class S>
 void
 multi_runner_base<IsParent>::inner::print_results(S& s)
 {
-    std::lock_guard l{m_};
+    std::lock_guard const l{m_};
     results_.print(s);
 }
 
@@ -326,7 +326,7 @@ void
 multi_runner_base<IsParent>::message_queue_send(MessageType mt, std::string const& s)
 {
     // must use a mutex since the two "sends" must happen in order
-    std::lock_guard l{inner_->m_};
+    std::lock_guard const l{inner_->m_};
     message_queue_->send(&mt, sizeof(mt), /*priority*/ 0);
     message_queue_->send(s.c_str(), s.size(), /*priority*/ 0);
 }
@@ -386,7 +386,7 @@ multi_runner_parent::multi_runner_parent() : os_(std::cout)
                 if (!recvd_size)
                     continue;
                 assert(recvd_size == 1);
-                MessageType mt{*reinterpret_cast<MessageType*>(buf.data())};
+                MessageType const mt{*reinterpret_cast<MessageType*>(buf.data())};
 
                 this->message_queue_->receive(buf.data(), buf.size(), recvd_size, priority);
                 if (recvd_size)
diff --git a/src/tests/libxrpl/basics/MallocTrim.cpp b/src/tests/libxrpl/basics/MallocTrim.cpp
index 483cf37fe2..93ed48b885 100644
--- a/src/tests/libxrpl/basics/MallocTrim.cpp
+++ b/src/tests/libxrpl/basics/MallocTrim.cpp
@@ -52,8 +52,8 @@ TEST(parseStatmRSSkB, standard_format)
     // Test standard format: size resident shared text lib data dt
     // Assuming 4KB page size: resident=1000 pages = 4000 KB
     {
-        std::string statm = "25365 1000 2377 0 0 5623 0";
-        long result = parseStatmRSSkB(statm);
+        std::string const statm = "25365 1000 2377 0 0 5623 0";
+        long const result = parseStatmRSSkB(statm);
         // Note: actual result depends on system page size
         // On most systems it's 4KB, so 1000 pages = 4000 KB
         EXPECT_GT(result, 0);
@@ -61,57 +61,57 @@ TEST(parseStatmRSSkB, standard_format)
 
     // Test with newline
     {
-        std::string statm = "12345 2000 1234 0 0 3456 0\n";
-        long result = parseStatmRSSkB(statm);
+        std::string const statm = "12345 2000 1234 0 0 3456 0\n";
+        long const result = parseStatmRSSkB(statm);
         EXPECT_GT(result, 0);
     }
 
     // Test with tabs
     {
-        std::string statm = "12345\t2000\t1234\t0\t0\t3456\t0";
-        long result = parseStatmRSSkB(statm);
+        std::string const statm = "12345\t2000\t1234\t0\t0\t3456\t0";
+        long const result = parseStatmRSSkB(statm);
         EXPECT_GT(result, 0);
     }
 
     // Test zero resident pages
     {
-        std::string statm = "25365 0 2377 0 0 5623 0";
-        long result = parseStatmRSSkB(statm);
+        std::string const statm = "25365 0 2377 0 0 5623 0";
+        long const result = parseStatmRSSkB(statm);
         EXPECT_EQ(result, 0);
     }
 
     // Test with extra whitespace
     {
-        std::string statm = "  25365   1000   2377  ";
-        long result = parseStatmRSSkB(statm);
+        std::string const statm = "  25365   1000   2377  ";
+        long const result = parseStatmRSSkB(statm);
         EXPECT_GT(result, 0);
     }
 
     // Test empty string
     {
-        std::string statm;
-        long result = parseStatmRSSkB(statm);
+        std::string const statm;
+        long const result = parseStatmRSSkB(statm);
         EXPECT_EQ(result, -1);
     }
 
     // Test malformed data (only one field)
     {
-        std::string statm = "25365";
-        long result = parseStatmRSSkB(statm);
+        std::string const statm = "25365";
+        long const result = parseStatmRSSkB(statm);
         EXPECT_EQ(result, -1);
     }
 
     // Test malformed data (non-numeric)
     {
-        std::string statm = "abc def ghi";
-        long result = parseStatmRSSkB(statm);
+        std::string const statm = "abc def ghi";
+        long const result = parseStatmRSSkB(statm);
         EXPECT_EQ(result, -1);
     }
 
     // Test malformed data (second field non-numeric)
     {
-        std::string statm = "25365 abc 2377";
-        long result = parseStatmRSSkB(statm);
+        std::string const statm = "25365 abc 2377";
+        long const result = parseStatmRSSkB(statm);
         EXPECT_EQ(result, -1);
     }
 }
@@ -119,9 +119,9 @@ TEST(parseStatmRSSkB, standard_format)
 
 TEST(mallocTrim, without_debug_logging)
 {
-    beast::Journal journal{beast::Journal::getNullSink()};
+    beast::Journal const journal{beast::Journal::getNullSink()};
 
-    MallocTrimReport report = mallocTrim("without_debug", journal);
+    MallocTrimReport const report = mallocTrim("without_debug", journal);
 
 #if defined(__GLIBC__) && BOOST_OS_LINUX
     EXPECT_EQ(report.supported, true);
@@ -142,8 +142,8 @@ TEST(mallocTrim, without_debug_logging)
 
 TEST(mallocTrim, empty_tag)
 {
-    beast::Journal journal{beast::Journal::getNullSink()};
-    MallocTrimReport report = mallocTrim("", journal);
+    beast::Journal const journal{beast::Journal::getNullSink()};
+    MallocTrimReport const report = mallocTrim("", journal);
 
 #if defined(__GLIBC__) && BOOST_OS_LINUX
     EXPECT_EQ(report.supported, true);
@@ -171,9 +171,9 @@ TEST(mallocTrim, with_debug_logging)
     };
 
     DebugSink sink;
-    beast::Journal journal{sink};
+    beast::Journal const journal{sink};
 
-    MallocTrimReport report = mallocTrim("debug_test", journal);
+    MallocTrimReport const report = mallocTrim("debug_test", journal);
 
 #if defined(__GLIBC__) && BOOST_OS_LINUX
     EXPECT_EQ(report.supported, true);
@@ -192,12 +192,12 @@ TEST(mallocTrim, with_debug_logging)
 
 TEST(mallocTrim, repeated_calls)
 {
-    beast::Journal journal{beast::Journal::getNullSink()};
+    beast::Journal const journal{beast::Journal::getNullSink()};
 
     // Call malloc_trim multiple times to ensure it's safe
     for (int i = 0; i < 5; ++i)
     {
-        MallocTrimReport report = mallocTrim("iteration_" + std::to_string(i), journal);
+        MallocTrimReport const report = mallocTrim("iteration_" + std::to_string(i), journal);
 
 #if defined(__GLIBC__) && BOOST_OS_LINUX
         EXPECT_EQ(report.supported, true);
diff --git a/src/tests/libxrpl/basics/Mutex.cpp b/src/tests/libxrpl/basics/Mutex.cpp
index 3bcee92276..9f58799fe7 100644
--- a/src/tests/libxrpl/basics/Mutex.cpp
+++ b/src/tests/libxrpl/basics/Mutex.cpp
@@ -183,7 +183,7 @@ TEST_F(MutexConstCorrectnessTest, non_const_allows_modification)
 
 TEST_F(MutexConstCorrectnessTest, const_reference_provides_const_access)
 {
-    Mutex<std::vector<int>> m({1, 2, 3, 4, 5, 6});
+    Mutex<std::vector<int>> const m({1, 2, 3, 4, 5, 6});
     Mutex<std::vector<int>> const& const_ref = m;
     auto lock = const_ref.lock();
     static_assert(std::is_const_v<std::remove_reference_t<decltype(*lock)>>);
@@ -225,7 +225,7 @@ struct MutexSharedMutexTest : ::testing::Test
 
 TEST_F(MutexSharedMutexTest, shared_lock_for_const_access)
 {
-    Mutex<int, std::shared_mutex> m(100);
+    Mutex<int, std::shared_mutex> const m(100);
     Mutex<int, std::shared_mutex> const& const_ref = m;
     auto lock = const_ref.lock<std::shared_lock>();
     EXPECT_EQ(*lock, 100);
diff --git a/src/tests/libxrpl/basics/scope.cpp b/src/tests/libxrpl/basics/scope.cpp
index 8efa4a84b1..067698bce4 100644
--- a/src/tests/libxrpl/basics/scope.cpp
+++ b/src/tests/libxrpl/basics/scope.cpp
@@ -10,7 +10,7 @@ TEST(scope, scope_exit)
     // unless release() is called
     int i = 0;
     {
-        scope_exit x{[&i]() { i = 1; }};
+        scope_exit const x{[&i]() { i = 1; }};
     }
     EXPECT_EQ(i, 1);
     {
@@ -32,7 +32,7 @@ TEST(scope, scope_exit)
     {
         try
         {
-            scope_exit x{[&i]() { i = 5; }};
+            scope_exit const x{[&i]() { i = 5; }};
             throw 1;
         }
         catch (...)  // NOLINT(bugprone-empty-catch)
@@ -60,7 +60,7 @@ TEST(scope, scope_fail)
     // if an exception is unwinding, unless release() is called
     int i = 0;
     {
-        scope_fail x{[&i]() { i = 1; }};
+        scope_fail const x{[&i]() { i = 1; }};
     }
     EXPECT_EQ(i, 0);
     {
@@ -82,7 +82,7 @@ TEST(scope, scope_fail)
     {
         try
         {
-            scope_fail x{[&i]() { i = 5; }};
+            scope_fail const x{[&i]() { i = 5; }};
             throw 1;
         }
         catch (...)  // NOLINT(bugprone-empty-catch)
@@ -110,7 +110,7 @@ TEST(scope, scope_success)
     // if an exception is not unwinding, unless release() is called
     int i = 0;
     {
-        scope_success x{[&i]() { i = 1; }};
+        scope_success const x{[&i]() { i = 1; }};
     }
     EXPECT_EQ(i, 1);
     {
@@ -132,7 +132,7 @@ TEST(scope, scope_success)
     {
         try
         {
-            scope_success x{[&i]() { i = 5; }};
+            scope_success const x{[&i]() { i = 5; }};
             throw 1;
         }
         catch (...)  // NOLINT(bugprone-empty-catch)
diff --git a/src/tests/libxrpl/basics/tagged_integer.cpp b/src/tests/libxrpl/basics/tagged_integer.cpp
index 09f8b6787b..85a246428b 100644
--- a/src/tests/libxrpl/basics/tagged_integer.cpp
+++ b/src/tests/libxrpl/basics/tagged_integer.cpp
@@ -147,7 +147,7 @@ TEST(tagged_integer, increment_decrement_operators)
 
 TEST(tagged_integer, arithmetic_operators)
 {
-    TagInt a{-2};
+    TagInt const a{-2};
     EXPECT_EQ(+a, TagInt{-2});
     EXPECT_EQ(-a, TagInt{2});
     EXPECT_EQ(TagInt{-3} + TagInt{4}, TagInt{1});
diff --git a/src/tests/libxrpl/json/Value.cpp b/src/tests/libxrpl/json/Value.cpp
index 943e517669..194c677024 100644
--- a/src/tests/libxrpl/json/Value.cpp
+++ b/src/tests/libxrpl/json/Value.cpp
@@ -38,7 +38,7 @@ TEST(json_value, construct_and_compare_Json_StaticString)
     EXPECT_EQ(test1, test2);
     EXPECT_NE(test1, test3);
 
-    std::string str{sample};
+    std::string const str{sample};
     EXPECT_EQ(str, test2);
     EXPECT_NE(str, test3);
     EXPECT_EQ(test2, str);
@@ -52,7 +52,7 @@ TEST(json_value, different_types)
 
     auto testCopy = [](Json::ValueType typ) {
         Json::Value val{typ};
-        Json::Value cpy{val};
+        Json::Value const cpy{val};
         EXPECT_EQ(val.type(), typ);
         EXPECT_EQ(cpy.type(), typ);
         return val;
@@ -135,7 +135,7 @@ TEST(json_value, different_types)
     {
         Json::Value const staticStrV{staticStr};
         {
-            Json::Value cpy{staticStrV};
+            Json::Value const cpy{staticStrV};
             EXPECT_EQ(staticStrV.type(), Json::stringValue);
             EXPECT_EQ(cpy.type(), Json::stringValue);
         }
@@ -588,13 +588,13 @@ TEST(json_value, bad_json)
 
 TEST(json_value, edge_cases)
 {
-    std::uint32_t max_uint = std::numeric_limits<std::uint32_t>::max();
-    std::int32_t max_int = std::numeric_limits<std::int32_t>::max();
-    std::int32_t min_int = std::numeric_limits<std::int32_t>::min();
+    std::uint32_t const max_uint = std::numeric_limits<std::uint32_t>::max();
+    std::int32_t const max_int = std::numeric_limits<std::int32_t>::max();
+    std::int32_t const min_int = std::numeric_limits<std::int32_t>::min();
 
-    std::uint32_t a_uint = max_uint - 1978;
-    std::int32_t a_large_int = max_int - 1978;
-    std::int32_t a_small_int = min_int + 1978;
+    std::uint32_t const a_uint = max_uint - 1978;
+    std::int32_t const a_large_int = max_int - 1978;
+    std::int32_t const a_small_int = min_int + 1978;
 
     {
         std::string json = "{\"max_uint\":" + std::to_string(max_uint);
@@ -628,7 +628,7 @@ TEST(json_value, edge_cases)
         EXPECT_LT(j1["a_small_int"], a_uint);
     }
 
-    std::uint64_t overflow = std::uint64_t(max_uint) + 1;
+    std::uint64_t const overflow = std::uint64_t(max_uint) + 1;
     {
         std::string json = "{\"overflow\":";
         json += std::to_string(overflow);
@@ -640,7 +640,7 @@ TEST(json_value, edge_cases)
         EXPECT_FALSE(r2.parse(json, j2));
     }
 
-    std::int64_t underflow = std::int64_t(min_int) - 1;
+    std::int64_t const underflow = std::int64_t(min_int) - 1;
     {
         std::string json = "{\"underflow\":";
         json += std::to_string(underflow);
@@ -739,7 +739,7 @@ TEST(json_value, copy)
     EXPECT_TRUE(v1.isDouble());
     EXPECT_EQ(v1.asDouble(), 2.5);
 
-    Json::Value v2 = v1;
+    Json::Value const v2 = v1;
     EXPECT_TRUE(v1.isDouble());
     EXPECT_EQ(v1.asDouble(), 2.5);
     EXPECT_TRUE(v2.isDouble());
@@ -819,7 +819,7 @@ TEST(json_value, comparisons)
     b["a"] = Json::Int(-1);
     testGreaterThan("negative");
 
-    Json::Int big = std::numeric_limits<int>::max();
+    Json::Int const big = std::numeric_limits<int>::max();
     Json::UInt bigger = big;
     bigger++;
 
@@ -859,7 +859,7 @@ TEST(json_value, conversions)
     // TODO: What's the thinking here?
     {
         // null
-        Json::Value val;
+        Json::Value const val;
         EXPECT_TRUE(val.isNull());
         // val.asCString() should trigger an assertion failure
         EXPECT_EQ(val.asString(), "");
@@ -880,7 +880,7 @@ TEST(json_value, conversions)
     }
     {
         // int
-        Json::Value val = -1234;
+        Json::Value const val = -1234;
         EXPECT_TRUE(val.isInt());
         // val.asCString() should trigger an assertion failure
         EXPECT_EQ(val.asString(), "-1234");
@@ -901,7 +901,7 @@ TEST(json_value, conversions)
     }
     {
         // uint
-        Json::Value val = 1234U;
+        Json::Value const val = 1234U;
         EXPECT_TRUE(val.isUInt());
         // val.asCString() should trigger an assertion failure
         EXPECT_EQ(val.asString(), "1234");
@@ -922,7 +922,7 @@ TEST(json_value, conversions)
     }
     {
         // real
-        Json::Value val = 2.0;
+        Json::Value const val = 2.0;
         EXPECT_TRUE(val.isDouble());
         // val.asCString() should trigger an assertion failure
         EXPECT_TRUE(std::regex_match(val.asString(), std::regex("^2\\.0*$")));
@@ -943,7 +943,7 @@ TEST(json_value, conversions)
     }
     {
         // numeric string
-        Json::Value val = "54321";
+        Json::Value const val = "54321";
         EXPECT_TRUE(val.isString());
         EXPECT_EQ(strcmp(val.asCString(), "54321"), 0);
         EXPECT_EQ(val.asString(), "54321");
@@ -964,7 +964,7 @@ TEST(json_value, conversions)
     }
     {
         // non-numeric string
-        Json::Value val(Json::stringValue);
+        Json::Value const val(Json::stringValue);
         EXPECT_TRUE(val.isString());
         EXPECT_EQ(val.asCString(), nullptr);
         EXPECT_EQ(val.asString(), "");
@@ -985,7 +985,7 @@ TEST(json_value, conversions)
     }
     {
         // bool false
-        Json::Value val = false;
+        Json::Value const val = false;
         EXPECT_TRUE(val.isBool());
         // val.asCString() should trigger an assertion failure
         EXPECT_EQ(val.asString(), "false");
@@ -1006,7 +1006,7 @@ TEST(json_value, conversions)
     }
     {
         // bool true
-        Json::Value val = true;
+        Json::Value const val = true;
         EXPECT_TRUE(val.isBool());
         // val.asCString() should trigger an assertion failure
         EXPECT_EQ(val.asString(), "true");
@@ -1027,7 +1027,7 @@ TEST(json_value, conversions)
     }
     {
         // array type
-        Json::Value val(Json::arrayValue);
+        Json::Value const val(Json::arrayValue);
         EXPECT_TRUE(val.isArray());
         // val.asCString should trigger an assertion failure
         EXPECT_THROW(val.asString(), Json::error);
@@ -1048,7 +1048,7 @@ TEST(json_value, conversions)
     }
     {
         // object type
-        Json::Value val(Json::objectValue);
+        Json::Value const val(Json::objectValue);
         EXPECT_TRUE(val.isObject());
         // val.asCString should trigger an assertion failure
         EXPECT_THROW(val.asString(), Json::error);
diff --git a/src/tests/libxrpl/net/HTTPClient.cpp b/src/tests/libxrpl/net/HTTPClient.cpp
index 36159cb089..de567a93ab 100644
--- a/src/tests/libxrpl/net/HTTPClient.cpp
+++ b/src/tests/libxrpl/net/HTTPClient.cpp
@@ -267,7 +267,7 @@ protected:
 TEST_F(HTTPClientTest, case_insensitive_content_length)
 {
     // Test different cases of Content-Length header
-    std::vector<std::string> headerCases = {
+    std::vector<std::string> const headerCases = {
         "Content-Length",  // Standard case
         "content-length",  // Lowercase - this tests the regex icase fix
         "CONTENT-LENGTH",  // Uppercase
@@ -278,7 +278,7 @@ TEST_F(HTTPClientTest, case_insensitive_content_length)
     for (auto const& headerName : headerCases)
     {
         TestHTTPServer server;
-        std::string testBody = "Hello World!";
+        std::string const testBody = "Hello World!";
         server.setResponseBody(testBody);
         server.setHeader(headerName, std::to_string(testBody.size()));
 
@@ -287,7 +287,7 @@ TEST_F(HTTPClientTest, case_insensitive_content_length)
         std::string resultData;
         boost::system::error_code resultError;
 
-        bool testCompleted =
+        bool const testCompleted =
             runHTTPTest(server, "/test", completed, resultStatus, resultData, resultError);
         // Verify results
         EXPECT_TRUE(testCompleted);
@@ -300,7 +300,7 @@ TEST_F(HTTPClientTest, case_insensitive_content_length)
 TEST_F(HTTPClientTest, basic_http_request)
 {
     TestHTTPServer server;
-    std::string testBody = "Test response body";
+    std::string const testBody = "Test response body";
     server.setResponseBody(testBody);
     server.setHeader("Content-Type", "text/plain");
 
@@ -309,7 +309,7 @@ TEST_F(HTTPClientTest, basic_http_request)
     std::string resultData;
     boost::system::error_code resultError;
 
-    bool testCompleted =
+    bool const testCompleted =
         runHTTPTest(server, "/basic", completed, resultStatus, resultData, resultError);
 
     EXPECT_TRUE(testCompleted);
@@ -329,7 +329,7 @@ TEST_F(HTTPClientTest, empty_response)
     std::string resultData;
     boost::system::error_code resultError;
 
-    bool testCompleted =
+    bool const testCompleted =
         runHTTPTest(server, "/empty", completed, resultStatus, resultData, resultError);
 
     EXPECT_TRUE(testCompleted);
@@ -340,7 +340,7 @@ TEST_F(HTTPClientTest, empty_response)
 
 TEST_F(HTTPClientTest, different_status_codes)
 {
-    std::vector<unsigned int> statusCodes = {200, 404, 500};
+    std::vector<unsigned int> const statusCodes = {200, 404, 500};
 
     for (auto status : statusCodes)
     {
@@ -353,7 +353,7 @@ TEST_F(HTTPClientTest, different_status_codes)
         std::string resultData;
         boost::system::error_code resultError;
 
-        bool testCompleted =
+        bool const testCompleted =
             runHTTPTest(server, "/status", completed, resultStatus, resultData, resultError);
 
         EXPECT_TRUE(testCompleted);
diff --git a/src/tests/libxrpl/protocol_autogen/.clang-tidy b/src/tests/libxrpl/protocol_autogen/.clang-tidy
new file mode 100644
index 0000000000..fbc003598d
--- /dev/null
+++ b/src/tests/libxrpl/protocol_autogen/.clang-tidy
@@ -0,0 +1,3 @@
+# This disables all checks for this directory and its subdirectories
+Checks: "-*"
+InheritParentConfig: false
diff --git a/src/tests/libxrpl/protocol_autogen/STObjectValidation.cpp b/src/tests/libxrpl/protocol_autogen/STObjectValidation.cpp
deleted file mode 100644
index 5c100364dc..0000000000
--- a/src/tests/libxrpl/protocol_autogen/STObjectValidation.cpp
+++ /dev/null
@@ -1,70 +0,0 @@
-#include <xrpl/protocol/MPTAmount.h>
-#include <xrpl/protocol/MPTIssue.h>
-#include <xrpl/protocol/STAmount.h>
-#include <xrpl/protocol_autogen/STObjectValidation.h>
-
-#include <gtest/gtest.h>
-
-namespace xrpl {
-TEST(STObjectValidation, validate_required_field)
-{
-    SOTemplate format{{sfFlags, soeREQUIRED}};
-    STObject obj(sfGeneric);
-    obj.setFieldU32(sfFlags, 0);
-    EXPECT_TRUE(protocol_autogen::validateSTObject(obj, format));
-}
-
-TEST(STObjectValidation, validate_missing_required_field)
-{
-    SOTemplate format{{sfFlags, soeREQUIRED}};
-    STObject obj(sfGeneric);
-    EXPECT_FALSE(protocol_autogen::validateSTObject(obj, format));
-}
-
-TEST(STObjectValidation, validate_optional_field)
-{
-    SOTemplate format{{sfFlags, soeOPTIONAL}};
-    STObject obj(sfGeneric);
-    obj.setFieldU32(sfFlags, 0);
-    EXPECT_TRUE(protocol_autogen::validateSTObject(obj, format));
-}
-
-TEST(STObjectValidation, validate_missing_optional_field)
-{
-    SOTemplate format{{sfFlags, soeOPTIONAL}};
-    STObject obj(sfGeneric);
-    EXPECT_TRUE(protocol_autogen::validateSTObject(obj, format));
-}
-
-TEST(STObjectValidation, validate_mpt_amount_supported)
-{
-    SOTemplate format{{sfAmount, soeREQUIRED, soeMPTSupported}};
-    STObject obj(sfGeneric);
-    obj.setFieldAmount(sfAmount, STAmount{MPTAmount{Number{1}}, MPTIssue{}});
-    EXPECT_TRUE(protocol_autogen::validateSTObject(obj, format));
-}
-
-TEST(STObjectValidation, validate_mpt_amount_not_supported)
-{
-    SOTemplate format{{sfAmount, soeREQUIRED, soeMPTNotSupported}};
-    STObject obj(sfGeneric);
-    obj.setFieldAmount(sfAmount, STAmount{MPTAmount{Number{1}}, MPTIssue{}});
-    EXPECT_FALSE(protocol_autogen::validateSTObject(obj, format));
-}
-
-TEST(STObjectValidation, validate_mpt_issue_supported)
-{
-    SOTemplate format{{sfAsset, soeREQUIRED, soeMPTSupported}};
-    STObject obj(sfGeneric);
-    obj.setFieldIssue(sfAsset, STIssue{sfAsset, MPTIssue{}});
-    EXPECT_TRUE(protocol_autogen::validateSTObject(obj, format));
-}
-
-TEST(STObjectValidation, validate_mpt_issue_not_supported)
-{
-    SOTemplate format{{sfAsset, soeREQUIRED, soeMPTNotSupported}};
-    STObject obj(sfGeneric);
-    obj.setFieldIssue(sfAsset, STIssue{sfAsset, MPTIssue{}});
-    EXPECT_FALSE(protocol_autogen::validateSTObject(obj, format));
-}
-}  // namespace xrpl
diff --git a/src/tests/libxrpl/protocol_autogen/main.cpp b/src/tests/libxrpl/protocol_autogen/main.cpp
deleted file mode 100644
index 5142bbe08a..0000000000
--- a/src/tests/libxrpl/protocol_autogen/main.cpp
+++ /dev/null
@@ -1,8 +0,0 @@
-#include <gtest/gtest.h>
-
-int
-main(int argc, char** argv)
-{
-    ::testing::InitGoogleTest(&argc, argv);
-    return RUN_ALL_TESTS();
-}
diff --git a/src/xrpld/app/consensus/RCLConsensus.cpp b/src/xrpld/app/consensus/RCLConsensus.cpp
index 71f3d1cf2a..838529795b 100644
--- a/src/xrpld/app/consensus/RCLConsensus.cpp
+++ b/src/xrpld/app/consensus/RCLConsensus.cpp
@@ -160,7 +160,7 @@ RCLConsensus::Adaptor::share(RCLCxTx const& tx)
         msg.set_rawtransaction(slice.data(), slice.size());
         msg.set_status(protocol::tsNEW);
         msg.set_receivetimestamp(app_.getTimeKeeper().now().time_since_epoch().count());
-        static std::set<Peer::id_t> skip{};
+        static std::set<Peer::id_t> const skip{};
         app_.getOverlay().relay(tx.id(), msg, skip);
     }
     else
@@ -853,7 +853,7 @@ RCLConsensus::getJson(bool full) const
 {
     Json::Value ret;
     {
-        std::lock_guard _{mutex_};
+        std::lock_guard const _{mutex_};
         ret = consensus_.getJson(full);
     }
     ret["validating"] = adaptor_.validating();
@@ -867,7 +867,7 @@ RCLConsensus::timerEntry(
 {
     try
     {
-        std::lock_guard _{mutex_};
+        std::lock_guard const _{mutex_};
         consensus_.timerEntry(now, clog);
     }
     catch (SHAMapMissingNode const& mn)
@@ -886,7 +886,7 @@ RCLConsensus::gotTxSet(NetClock::time_point const& now, RCLTxSet const& txSet)
 {
     try
     {
-        std::lock_guard _{mutex_};
+        std::lock_guard const _{mutex_};
         consensus_.gotTxSet(now, txSet);
     }
     catch (SHAMapMissingNode const& mn)
@@ -904,14 +904,14 @@ RCLConsensus::simulate(
     NetClock::time_point const& now,
     std::optional<std::chrono::milliseconds> consensusDelay)
 {
-    std::lock_guard _{mutex_};
+    std::lock_guard const _{mutex_};
     consensus_.simulate(now, consensusDelay);
 }
 
 bool
 RCLConsensus::peerProposal(NetClock::time_point const& now, RCLCxPeerPos const& newProposal)
 {
-    std::lock_guard _{mutex_};
+    std::lock_guard const _{mutex_};
     return consensus_.peerProposal(now, newProposal);
 }
 
@@ -1010,7 +1010,7 @@ RCLConsensus::startRound(
     hash_set<NodeID> const& nowTrusted,
     std::unique_ptr<std::stringstream> const& clog)
 {
-    std::lock_guard _{mutex_};
+    std::lock_guard const _{mutex_};
     consensus_.startRound(
         now, prevLgrId, prevLgr, nowUntrusted, adaptor_.preStartRound(prevLgr, nowTrusted), clog);
 }
diff --git a/src/xrpld/app/consensus/RCLConsensus.h b/src/xrpld/app/consensus/RCLConsensus.h
index 15d36a1aa6..c965ed3d87 100644
--- a/src/xrpld/app/consensus/RCLConsensus.h
+++ b/src/xrpld/app/consensus/RCLConsensus.h
@@ -472,7 +472,7 @@ public:
     RCLCxLedger::ID
     prevLedgerID() const
     {
-        std::lock_guard _{mutex_};
+        std::lock_guard const _{mutex_};
         return consensus_.prevLedgerID();
     }
 
diff --git a/src/xrpld/app/ledger/ConsensusTransSetSF.cpp b/src/xrpld/app/ledger/ConsensusTransSetSF.cpp
index 2313d29f86..5fd614a1d9 100644
--- a/src/xrpld/app/ledger/ConsensusTransSetSF.cpp
+++ b/src/xrpld/app/ledger/ConsensusTransSetSF.cpp
@@ -36,7 +36,7 @@ ConsensusTransSetSF::gotNode(
         try
         {
             // skip prefix
-            Serializer s(nodeData.data() + 4, nodeData.size() - 4);
+            Serializer const s(nodeData.data() + 4, nodeData.size() - 4);
             SerialIter sit(s.slice());
             auto stx = std::make_shared<STTx const>(std::ref(sit));
             XRPL_ASSERT(
diff --git a/src/xrpld/app/ledger/LedgerHistory.cpp b/src/xrpld/app/ledger/LedgerHistory.cpp
index b96760f04d..969511db4c 100644
--- a/src/xrpld/app/ledger/LedgerHistory.cpp
+++ b/src/xrpld/app/ledger/LedgerHistory.cpp
@@ -40,7 +40,7 @@ LedgerHistory::insert(std::shared_ptr<Ledger const> const& ledger, bool validate
     XRPL_ASSERT(
         ledger->stateMap().getHash().isNonZero(), "xrpl::LedgerHistory::insert : nonzero hash");
 
-    std::unique_lock sl(m_ledgers_by_hash.peekMutex());
+    std::unique_lock const sl(m_ledgers_by_hash.peekMutex());
 
     bool const alreadyHad =
         m_ledgers_by_hash.canonicalize_replace_cache(ledger->header().hash, ledger);
@@ -53,7 +53,7 @@ LedgerHistory::insert(std::shared_ptr<Ledger const> const& ledger, bool validate
 LedgerHash
 LedgerHistory::getLedgerHash(LedgerIndex index)
 {
-    std::unique_lock sl(m_ledgers_by_hash.peekMutex());
+    std::unique_lock const sl(m_ledgers_by_hash.peekMutex());
     if (auto it = mLedgersByIndex.find(index); it != mLedgersByIndex.end())
         return it->second;
     return {};
@@ -68,7 +68,7 @@ LedgerHistory::getLedgerBySeq(LedgerIndex index)
 
         if (it != mLedgersByIndex.end())
         {
-            uint256 hash = it->second;
+            uint256 const hash = it->second;
             sl.unlock();
             return getLedgerByHash(hash);
         }
@@ -86,7 +86,7 @@ LedgerHistory::getLedgerBySeq(LedgerIndex index)
 
     {
         // Add this ledger to the local tracking by index
-        std::unique_lock sl(m_ledgers_by_hash.peekMutex());
+        std::unique_lock const sl(m_ledgers_by_hash.peekMutex());
 
         XRPL_ASSERT(
             ret->isImmutable(), "xrpl::LedgerHistory::getLedgerBySeq : immutable result ledger");
@@ -405,11 +405,11 @@ LedgerHistory::builtLedger(
     uint256 const& consensusHash,
     Json::Value consensus)
 {
-    LedgerIndex index = ledger->header().seq;
-    LedgerHash hash = ledger->header().hash;
+    LedgerIndex const index = ledger->header().seq;
+    LedgerHash const hash = ledger->header().hash;
     XRPL_ASSERT(!hash.isZero(), "xrpl::LedgerHistory::builtLedger : nonzero hash");
 
-    std::unique_lock sl(m_consensus_validated.peekMutex());
+    std::unique_lock const sl(m_consensus_validated.peekMutex());
 
     auto entry = std::make_shared<cv_entry>();
     m_consensus_validated.canonicalize_replace_client(index, entry);
@@ -444,11 +444,11 @@ LedgerHistory::validatedLedger(
     std::shared_ptr<Ledger const> const& ledger,
     std::optional<uint256> const& consensusHash)
 {
-    LedgerIndex index = ledger->header().seq;
-    LedgerHash hash = ledger->header().hash;
+    LedgerIndex const index = ledger->header().seq;
+    LedgerHash const hash = ledger->header().hash;
     XRPL_ASSERT(!hash.isZero(), "xrpl::LedgerHistory::validatedLedger : nonzero hash");
 
-    std::unique_lock sl(m_consensus_validated.peekMutex());
+    std::unique_lock const sl(m_consensus_validated.peekMutex());
 
     auto entry = std::make_shared<cv_entry>();
     m_consensus_validated.canonicalize_replace_client(index, entry);
@@ -482,7 +482,7 @@ LedgerHistory::validatedLedger(
 bool
 LedgerHistory::fixIndex(LedgerIndex ledgerIndex, LedgerHash const& ledgerHash)
 {
-    std::unique_lock sl(m_ledgers_by_hash.peekMutex());
+    std::unique_lock const sl(m_ledgers_by_hash.peekMutex());
     auto it = mLedgersByIndex.find(ledgerIndex);
 
     if ((it != mLedgersByIndex.end()) && (it->second != ledgerHash))
@@ -496,7 +496,7 @@ LedgerHistory::fixIndex(LedgerIndex ledgerIndex, LedgerHash const& ledgerHash)
 void
 LedgerHistory::clearLedgerCachePrior(LedgerIndex seq)
 {
-    for (LedgerHash it : m_ledgers_by_hash.getKeys())
+    for (LedgerHash const it : m_ledgers_by_hash.getKeys())
     {
         auto const ledger = getLedgerByHash(it);
         if (!ledger || ledger->header().seq < seq)
diff --git a/src/xrpld/app/ledger/LedgerHolder.h b/src/xrpld/app/ledger/LedgerHolder.h
index 8d2ac9f308..bf9d478c40 100644
--- a/src/xrpld/app/ledger/LedgerHolder.h
+++ b/src/xrpld/app/ledger/LedgerHolder.h
@@ -28,7 +28,7 @@ public:
             LogicError("LedgerHolder::set with nullptr");
         if (!ledger->isImmutable())
             LogicError("LedgerHolder::set with mutable Ledger");
-        std::lock_guard sl(m_lock);
+        std::lock_guard const sl(m_lock);
         m_heldLedger = std::move(ledger);
     }
 
@@ -36,14 +36,14 @@ public:
     std::shared_ptr<Ledger const>
     get()
     {
-        std::lock_guard sl(m_lock);
+        std::lock_guard const sl(m_lock);
         return m_heldLedger;
     }
 
     bool
     empty()
     {
-        std::lock_guard sl(m_lock);
+        std::lock_guard const sl(m_lock);
         return m_heldLedger == nullptr;
     }
 
diff --git a/src/xrpld/app/ledger/LedgerMaster.h b/src/xrpld/app/ledger/LedgerMaster.h
index 16e35c3dcd..e598787047 100644
--- a/src/xrpld/app/ledger/LedgerMaster.h
+++ b/src/xrpld/app/ledger/LedgerMaster.h
@@ -387,7 +387,7 @@ private:
     void
     collect_metrics()
     {
-        std::lock_guard lock(m_mutex);
+        std::lock_guard const lock(m_mutex);
         m_stats.validatedLedgerAge.set(getValidatedLedgerAge().count());
         m_stats.publishedLedgerAge.set(getPublishedLedgerAge().count());
     }
diff --git a/src/xrpld/app/ledger/LedgerReplayer.h b/src/xrpld/app/ledger/LedgerReplayer.h
index 218d22fb07..ce2acb0699 100644
--- a/src/xrpld/app/ledger/LedgerReplayer.h
+++ b/src/xrpld/app/ledger/LedgerReplayer.h
@@ -103,21 +103,21 @@ public:
     std::size_t
     tasksSize() const
     {
-        std::lock_guard<std::mutex> lock(mtx_);
+        std::lock_guard<std::mutex> const lock(mtx_);
         return tasks_.size();
     }
 
     std::size_t
     deltasSize() const
     {
-        std::lock_guard<std::mutex> lock(mtx_);
+        std::lock_guard<std::mutex> const lock(mtx_);
         return deltas_.size();
     }
 
     std::size_t
     skipListsSize() const
     {
-        std::lock_guard<std::mutex> lock(mtx_);
+        std::lock_guard<std::mutex> const lock(mtx_);
         return skipLists_.size();
     }
 
diff --git a/src/xrpld/app/ledger/OrderBookDBImpl.cpp b/src/xrpld/app/ledger/OrderBookDBImpl.cpp
index c8ea46cf7f..229110fa04 100644
--- a/src/xrpld/app/ledger/OrderBookDBImpl.cpp
+++ b/src/xrpld/app/ledger/OrderBookDBImpl.cpp
@@ -160,7 +160,7 @@ OrderBookDBImpl::update(std::shared_ptr<ReadView const> const& ledger)
     JLOG(j_.debug()) << "Update completed (" << ledger->seq() << "): " << cnt << " books found";
 
     {
-        std::lock_guard sl(mLock);
+        std::lock_guard const sl(mLock);
         allBooks_.swap(allBooks);
         xrpBooks_.swap(xrpBooks);
         domainBooks_.swap(domainBooks);
@@ -173,9 +173,9 @@ OrderBookDBImpl::update(std::shared_ptr<ReadView const> const& ledger)
 void
 OrderBookDBImpl::addOrderBook(Book const& book)
 {
-    bool toXRP = isXRP(book.out);
+    bool const toXRP = isXRP(book.out);
 
-    std::lock_guard sl(mLock);
+    std::lock_guard const sl(mLock);
 
     if (book.domain)
     {
@@ -203,7 +203,7 @@ OrderBookDBImpl::getBooksByTakerPays(Issue const& issue, std::optional<uint256>
     std::vector<Book> ret;
 
     {
-        std::lock_guard sl(mLock);
+        std::lock_guard const sl(mLock);
 
         auto getBooks = [&](auto const& container, auto const& key) {
             if (auto it = container.find(key); it != container.end())
@@ -232,7 +232,7 @@ OrderBookDBImpl::getBooksByTakerPays(Issue const& issue, std::optional<uint256>
 int
 OrderBookDBImpl::getBookSize(Issue const& issue, std::optional<uint256> const& domain)
 {
-    std::lock_guard sl(mLock);
+    std::lock_guard const sl(mLock);
 
     if (!domain)
     {
@@ -251,7 +251,7 @@ OrderBookDBImpl::getBookSize(Issue const& issue, std::optional<uint256> const& d
 bool
 OrderBookDBImpl::isBookToXRP(Issue const& issue, std::optional<Domain> const& domain)
 {
-    std::lock_guard sl(mLock);
+    std::lock_guard const sl(mLock);
     if (domain)
         return xrpDomainBooks_.contains({issue, *domain});
     return xrpBooks_.contains(issue);
@@ -260,7 +260,7 @@ OrderBookDBImpl::isBookToXRP(Issue const& issue, std::optional<Domain> const& do
 BookListeners::pointer
 OrderBookDBImpl::makeBookListeners(Book const& book)
 {
-    std::lock_guard sl(mLock);
+    std::lock_guard const sl(mLock);
     auto ret = getBookListeners(book);
 
     if (!ret)
@@ -281,7 +281,7 @@ BookListeners::pointer
 OrderBookDBImpl::getBookListeners(Book const& book)
 {
     BookListeners::pointer ret;
-    std::lock_guard sl(mLock);
+    std::lock_guard const sl(mLock);
 
     auto it0 = mListeners.find(book);
     if (it0 != mListeners.end())
@@ -298,7 +298,7 @@ OrderBookDBImpl::processTxn(
     AcceptedLedgerTx const& alTx,
     MultiApiJson const& jvObj)
 {
-    std::lock_guard sl(mLock);
+    std::lock_guard const sl(mLock);
 
     // For this particular transaction, maintain the set of unique
     // subscriptions that have already published it.  This prevents sending
diff --git a/src/xrpld/app/ledger/detail/InboundLedger.cpp b/src/xrpld/app/ledger/detail/InboundLedger.cpp
index 4e7190c8c8..69af55b8f3 100644
--- a/src/xrpld/app/ledger/detail/InboundLedger.cpp
+++ b/src/xrpld/app/ledger/detail/InboundLedger.cpp
@@ -127,7 +127,7 @@ InboundLedger::getPeerCount() const
 void
 InboundLedger::update(std::uint32_t seq)
 {
-    ScopedLockType sl(mtx_);
+    ScopedLockType const sl(mtx_);
 
     // If we didn't know the sequence number, but now do, save it
     if ((seq != 0) && (mSeq == 0))
@@ -140,7 +140,7 @@ InboundLedger::update(std::uint32_t seq)
 bool
 InboundLedger::checkLocal()
 {
-    ScopedLockType sl(mtx_);
+    ScopedLockType const sl(mtx_);
     if (!isDone())
     {
         if (mLedger)
@@ -363,7 +363,7 @@ InboundLedger::onTimer(bool wasProgress, ScopedLockType&)
 
         mByHash = true;
 
-        std::size_t pc = getPeerCount();
+        std::size_t const pc = getPeerCount();
         JLOG(journal_.debug()) << "No progress(" << pc << ") for ledger " << hash_;
 
         // addPeers triggers if the reason is not HISTORY
@@ -996,7 +996,7 @@ InboundLedger::gotData(
     std::weak_ptr<Peer> peer,
     std::shared_ptr<protocol::TMLedgerData> const& data)
 {
-    std::lock_guard sl(mReceivedDataLock);
+    std::lock_guard const sl(mReceivedDataLock);
 
     if (isDone())
         return false;
@@ -1032,7 +1032,7 @@ InboundLedger::processData(std::shared_ptr<Peer> peer, protocol::TMLedgerData& p
 
         SHAMapAddNode san;
 
-        ScopedLockType sl(mtx_);
+        ScopedLockType const sl(mtx_);
 
         try
         {
@@ -1084,7 +1084,7 @@ InboundLedger::processData(std::shared_ptr<Peer> peer, protocol::TMLedgerData& p
             return -1;
         }
 
-        ScopedLockType sl(mtx_);
+        ScopedLockType const sl(mtx_);
 
         // Verify node IDs and data are complete
         for (auto const& node : packet.nodes())
@@ -1208,7 +1208,7 @@ InboundLedger::runData()
         data.clear();
 
         {
-            std::lock_guard sl(mReceivedDataLock);
+            std::lock_guard const sl(mReceivedDataLock);
 
             if (mReceivedData.empty())
             {
@@ -1223,7 +1223,7 @@ InboundLedger::runData()
         {
             if (auto peer = entry.first.lock())
             {
-                int count = processData(peer, *(entry.second));
+                int const count = processData(peer, *(entry.second));
                 dataCounts.update(std::move(peer), count);
             }
         }
@@ -1242,7 +1242,7 @@ InboundLedger::getJson(int)
 {
     Json::Value ret(Json::objectValue);
 
-    ScopedLockType sl(mtx_);
+    ScopedLockType const sl(mtx_);
 
     ret[jss::hash] = to_string(hash_);
 
diff --git a/src/xrpld/app/ledger/detail/InboundLedgers.cpp b/src/xrpld/app/ledger/detail/InboundLedgers.cpp
index 3a83aa6018..f147a35ca4 100644
--- a/src/xrpld/app/ledger/detail/InboundLedgers.cpp
+++ b/src/xrpld/app/ledger/detail/InboundLedgers.cpp
@@ -110,7 +110,7 @@ public:
             if (pendingAcquires_.contains(hash))
                 return;
             pendingAcquires_.insert(hash);
-            scope_unlock unlock(lock);
+            scope_unlock const unlock(lock);
             acquire(hash, seq, reason);
         }
         catch (std::exception const& e)
@@ -133,7 +133,7 @@ public:
         std::shared_ptr<InboundLedger> ret;
 
         {
-            ScopedLockType sl(mLock);
+            ScopedLockType const sl(mLock);
 
             auto it = mLedgers.find(hash);
             if (it != mLedgers.end())
@@ -197,7 +197,7 @@ public:
     void
     logFailure(uint256 const& h, std::uint32_t seq) override
     {
-        ScopedLockType sl(mLock);
+        ScopedLockType const sl(mLock);
 
         mRecentFailures.emplace(h, seq);
     }
@@ -205,7 +205,7 @@ public:
     bool
     isFailure(uint256 const& h) override
     {
-        ScopedLockType sl(mLock);
+        ScopedLockType const sl(mLock);
 
         beast::expire(mRecentFailures, kReacquireInterval);
         return mRecentFailures.find(h) != mRecentFailures.end();
@@ -250,7 +250,7 @@ public:
     void
     clearFailures() override
     {
-        ScopedLockType sl(mLock);
+        ScopedLockType const sl(mLock);
 
         mRecentFailures.clear();
         mLedgers.clear();
@@ -259,7 +259,7 @@ public:
     std::size_t
     fetchRate() override
     {
-        std::lock_guard lock(fetchRateMutex_);
+        std::lock_guard const lock(fetchRateMutex_);
         return 60 * fetchRate_.value(m_clock.now());
     }
 
@@ -268,7 +268,7 @@ public:
     void
     onLedgerFetched() override
     {
-        std::lock_guard lock(fetchRateMutex_);
+        std::lock_guard const lock(fetchRateMutex_);
         fetchRate_.add(1, m_clock.now());
     }
 
@@ -280,7 +280,7 @@ public:
         std::vector<std::pair<uint256, std::shared_ptr<InboundLedger>>> acqs;
 
         {
-            ScopedLockType sl(mLock);
+            ScopedLockType const sl(mLock);
 
             acqs.reserve(mLedgers.size());
             for (auto const& it : mLedgers)
@@ -304,7 +304,7 @@ public:
         for (auto const& it : acqs)
         {
             // getJson is expensive, so call without the lock
-            std::uint32_t seq = it.second->getSeq();
+            std::uint32_t const seq = it.second->getSeq();
             if (seq > 1)
             {
                 ret[std::to_string(seq)] = it.second->getJson(0);
@@ -323,7 +323,7 @@ public:
     {
         std::vector<std::shared_ptr<InboundLedger>> acquires;
         {
-            ScopedLockType sl(mLock);
+            ScopedLockType const sl(mLock);
 
             acquires.reserve(mLedgers.size());
             for (auto const& it : mLedgers)
@@ -352,7 +352,7 @@ public:
         std::size_t total = 0;
 
         {
-            ScopedLockType sl(mLock);
+            ScopedLockType const sl(mLock);
             MapType::iterator it(mLedgers.begin());
             total = mLedgers.size();
 
@@ -393,7 +393,7 @@ public:
     void
     stop() override
     {
-        ScopedLockType lock(mLock);
+        ScopedLockType const lock(mLock);
         stopping_ = true;
         mLedgers.clear();
         mRecentFailures.clear();
@@ -402,7 +402,7 @@ public:
     std::size_t
     cacheSize() override
     {
-        ScopedLockType lock(mLock);
+        ScopedLockType const lock(mLock);
         return mLedgers.size();
     }
 
diff --git a/src/xrpld/app/ledger/detail/InboundTransactions.cpp b/src/xrpld/app/ledger/detail/InboundTransactions.cpp
index 064953f665..cc3585a3fb 100644
--- a/src/xrpld/app/ledger/detail/InboundTransactions.cpp
+++ b/src/xrpld/app/ledger/detail/InboundTransactions.cpp
@@ -64,7 +64,7 @@ public:
     getAcquire(uint256 const& hash)
     {
         {
-            std::lock_guard sl(mLock);
+            std::lock_guard const sl(mLock);
 
             auto it = m_map.find(hash);
 
@@ -80,7 +80,7 @@ public:
         TransactionAcquire::pointer ta;
 
         {
-            std::lock_guard sl(mLock);
+            std::lock_guard const sl(mLock);
 
             if (auto it = m_map.find(hash); it != m_map.end())
             {
@@ -118,12 +118,12 @@ public:
         std::shared_ptr<Peer> peer,
         std::shared_ptr<protocol::TMLedgerData> packet_ptr) override
     {
-        protocol::TMLedgerData& packet = *packet_ptr;
+        protocol::TMLedgerData const& packet = *packet_ptr;
 
         JLOG(j_.trace()) << "Got data (" << packet.nodes().size()
                          << ") for acquiring ledger: " << hash;
 
-        TransactionAcquire::pointer ta = getAcquire(hash);
+        TransactionAcquire::pointer const ta = getAcquire(hash);
 
         if (ta == nullptr)
         {
@@ -163,7 +163,7 @@ public:
         bool isNew = true;
 
         {
-            std::lock_guard sl(mLock);
+            std::lock_guard const sl(mLock);
 
             auto& inboundSet = m_map[hash];
 
@@ -188,7 +188,7 @@ public:
     void
     newRound(std::uint32_t seq) override
     {
-        std::lock_guard lock(mLock);
+        std::lock_guard const lock(mLock);
 
         // Protect zero set from expiration
         m_zeroSet.mSeq = seq;
@@ -200,7 +200,7 @@ public:
             auto it = m_map.begin();
 
             std::uint32_t const minSeq = (seq < setKeepRounds) ? 0 : (seq - setKeepRounds);
-            std::uint32_t maxSeq = seq + setKeepRounds;
+            std::uint32_t const maxSeq = seq + setKeepRounds;
 
             while (it != m_map.end())
             {
@@ -219,7 +219,7 @@ public:
     void
     stop() override
     {
-        std::lock_guard lock(mLock);
+        std::lock_guard const lock(mLock);
         stopping_ = true;
         m_map.clear();
     }
diff --git a/src/xrpld/app/ledger/detail/LedgerCleaner.cpp b/src/xrpld/app/ledger/detail/LedgerCleaner.cpp
index af358fbfc6..a0d168f299 100644
--- a/src/xrpld/app/ledger/detail/LedgerCleaner.cpp
+++ b/src/xrpld/app/ledger/detail/LedgerCleaner.cpp
@@ -76,7 +76,7 @@ public:
     {
         JLOG(j_.info()) << "Stopping";
         {
-            std::lock_guard lock(mutex_);
+            std::lock_guard const lock(mutex_);
             shouldExit_ = true;
             wakeup_.notify_one();
         }
@@ -92,7 +92,7 @@ public:
     void
     onWrite(beast::PropertyStream::Map& map) override
     {
-        std::lock_guard lock(mutex_);
+        std::lock_guard const lock(mutex_);
 
         if (maxRange_ == 0)
         {
@@ -124,7 +124,7 @@ public:
         app_.getLedgerMaster().getFullValidatedRange(minRange, maxRange);
 
         {
-            std::lock_guard lock(mutex_);
+            std::lock_guard const lock(mutex_);
 
             maxRange_ = maxRange;
             minRange_ = minRange;
@@ -327,8 +327,8 @@ private:
                 // No. Try to get another ledger that might have the hash we
                 // need: compute the index and hash of a ledger that will have
                 // the hash we need.
-                LedgerIndex refIndex = getCandidateLedger(ledgerIndex);
-                LedgerHash refHash = getLedgerHash(referenceLedger, refIndex);
+                LedgerIndex const refIndex = getCandidateLedger(ledgerIndex);
+                LedgerHash const refHash = getLedgerHash(referenceLedger, refIndex);
 
                 bool const nonzero(refHash.isNonZero());
                 XRPL_ASSERT(nonzero, "xrpl::LedgerCleanerImp::getHash : nonzero hash");
@@ -354,7 +354,7 @@ private:
     doLedgerCleaner()
     {
         auto shouldExit = [this] {
-            std::lock_guard lock(mutex_);
+            std::lock_guard const lock(mutex_);
             return shouldExit_;
         };
 
@@ -375,7 +375,7 @@ private:
             }
 
             {
-                std::lock_guard lock(mutex_);
+                std::lock_guard const lock(mutex_);
                 if ((minRange_ > maxRange_) || (maxRange_ == 0) || (minRange_ == 0))
                 {
                     minRange_ = maxRange_ = 0;
@@ -403,7 +403,7 @@ private:
             if (fail)
             {
                 {
-                    std::lock_guard lock(mutex_);
+                    std::lock_guard const lock(mutex_);
                     ++failures_;
                 }
                 // Wait for acquiring to catch up to us
@@ -412,7 +412,7 @@ private:
             else
             {
                 {
-                    std::lock_guard lock(mutex_);
+                    std::lock_guard const lock(mutex_);
                     if (ledgerIndex == minRange_)
                         ++minRange_;
                     if (ledgerIndex == maxRange_)
diff --git a/src/xrpld/app/ledger/detail/LedgerDeltaAcquire.cpp b/src/xrpld/app/ledger/detail/LedgerDeltaAcquire.cpp
index 1d48a9741d..f829e58830 100644
--- a/src/xrpld/app/ledger/detail/LedgerDeltaAcquire.cpp
+++ b/src/xrpld/app/ledger/detail/LedgerDeltaAcquire.cpp
@@ -178,7 +178,7 @@ LedgerDeltaAcquire::tryBuild(std::shared_ptr<Ledger const> const& parent)
         parent->header().hash == replayTemp_->header().parentHash,
         "xrpl::LedgerDeltaAcquire::tryBuild : parent hash match");
     // build ledger
-    LedgerReplay replayData(parent, replayTemp_, std::move(orderedTxns_));
+    LedgerReplay const replayData(parent, replayTemp_, std::move(orderedTxns_));
     fullLedger_ = buildLedger(replayData, tapNONE, app_, journal_);
     if (fullLedger_ && fullLedger_->header().hash == hash_)
     {
diff --git a/src/xrpld/app/ledger/detail/LedgerMaster.cpp b/src/xrpld/app/ledger/detail/LedgerMaster.cpp
index 6253b33da3..876a7e0578 100644
--- a/src/xrpld/app/ledger/detail/LedgerMaster.cpp
+++ b/src/xrpld/app/ledger/detail/LedgerMaster.cpp
@@ -122,7 +122,7 @@ LedgerMaster::isCompatible(ReadView const& view, beast::Journal::Stream s, char
     }
 
     {
-        std::lock_guard sl(m_mutex);
+        std::lock_guard const sl(m_mutex);
 
         if ((mLastValidLedger.second != 0) &&
             !areCompatible(mLastValidLedger.first, mLastValidLedger.second, view, s, reason))
@@ -138,7 +138,7 @@ std::chrono::seconds
 LedgerMaster::getPublishedLedgerAge()
 {
     using namespace std::chrono_literals;
-    std::chrono::seconds pubClose{mPubLedgerClose.load()};
+    std::chrono::seconds const pubClose{mPubLedgerClose.load()};
     if (pubClose == 0s)
     {
         JLOG(m_journal.debug()) << "No published ledger";
@@ -163,7 +163,7 @@ LedgerMaster::getValidatedLedgerAge()
 {
     using namespace std::chrono_literals;
 
-    std::chrono::seconds valClose{mValidLedgerSign.load()};
+    std::chrono::seconds const valClose{mValidLedgerSign.load()};
     if (valClose == 0s)
     {
         JLOG(m_journal.debug()) << "No validated ledger";
@@ -193,8 +193,8 @@ LedgerMaster::isCaughtUp(std::string& reason)
         reason = "No recently-published ledger";
         return false;
     }
-    std::uint32_t validClose = mValidLedgerSign.load();
-    std::uint32_t pubClose = mPubLedgerClose.load();
+    std::uint32_t const validClose = mValidLedgerSign.load();
+    std::uint32_t const pubClose = mPubLedgerClose.load();
     if ((validClose == 0u) || (pubClose == 0u))
     {
         reason = "No published ledger";
@@ -301,7 +301,7 @@ LedgerMaster::setPubLedger(std::shared_ptr<Ledger const> const& l)
 void
 LedgerMaster::addHeldTransaction(std::shared_ptr<Transaction> const& transaction)
 {
-    std::lock_guard ml(m_mutex);
+    std::lock_guard const ml(m_mutex);
     mHeldTransactions.insert(transaction->getSTransaction());
 }
 
@@ -384,7 +384,7 @@ LedgerMaster::switchLCL(std::shared_ptr<Ledger const> const& lastClosed)
         LogicError("The new last closed ledger is open!");
 
     {
-        std::lock_guard ml(m_mutex);
+        std::lock_guard const ml(m_mutex);
         mClosedLedger.set(lastClosed);
     }
 
@@ -408,7 +408,7 @@ LedgerMaster::fixIndex(LedgerIndex ledgerIndex, LedgerHash const& ledgerHash)
 bool
 LedgerMaster::storeLedger(std::shared_ptr<Ledger const> ledger)
 {
-    bool validated = ledger->header().validated;
+    bool const validated = ledger->header().validated;
     // Returns true if we already had the ledger
     return mLedgerHistory.insert(ledger, validated);
 }
@@ -422,7 +422,7 @@ void
 LedgerMaster::applyHeldTransactions()
 {
     CanonicalTXSet const set = [this]() {
-        std::lock_guard sl(m_mutex);
+        std::lock_guard const sl(m_mutex);
         // VFALCO NOTE The hash for an open ledger is undefined so we use
         // something that is a reasonable substitute.
         CanonicalTXSet set(app_.getOpenLedger().current()->header().parentHash);
@@ -437,7 +437,7 @@ LedgerMaster::applyHeldTransactions()
 std::shared_ptr<STTx const>
 LedgerMaster::popAcctTransaction(std::shared_ptr<STTx const> const& tx)
 {
-    std::lock_guard sl(m_mutex);
+    std::lock_guard const sl(m_mutex);
 
     return mHeldTransactions.popAcctTransaction(tx);
 }
@@ -451,14 +451,14 @@ LedgerMaster::setBuildingLedger(LedgerIndex i)
 bool
 LedgerMaster::haveLedger(std::uint32_t seq)
 {
-    std::lock_guard sl(mCompleteLock);
+    std::lock_guard const sl(mCompleteLock);
     return boost::icl::contains(mCompleteLedgers, seq);
 }
 
 void
 LedgerMaster::clearLedger(std::uint32_t seq)
 {
-    std::lock_guard sl(mCompleteLock);
+    std::lock_guard const sl(mCompleteLock);
     mCompleteLedgers.erase(seq);
 }
 
@@ -485,7 +485,7 @@ LedgerMaster::isValidated(ReadView const& ledger)
             if (hash)
             {
                 XRPL_ASSERT(hash->isNonZero(), "xrpl::LedgerMaster::isValidated : nonzero hash");
-                uint256 valHash = app_.getRelationalDatabase().getHashByIndex(seq);
+                uint256 const valHash = app_.getRelationalDatabase().getHashByIndex(seq);
                 if (valHash == ledger.header().hash)
                 {
                     // SQL database doesn't match ledger chain
@@ -519,7 +519,7 @@ LedgerMaster::getFullValidatedRange(std::uint32_t& minVal, std::uint32_t& maxVal
 
     std::optional<std::uint32_t> maybeMin;
     {
-        std::lock_guard sl(mCompleteLock);
+        std::lock_guard const sl(mCompleteLock);
         maybeMin = prevMissing(mCompleteLedgers, maxVal);
     }
 
@@ -614,7 +614,7 @@ LedgerMaster::tryFill(std::shared_ptr<Ledger const> ledger)
     while (!app_.getJobQueue().isStopping() && seq > 0)
     {
         {
-            std::lock_guard ml(m_mutex);
+            std::lock_guard const ml(m_mutex);
             minHas = seq;
             --seq;
 
@@ -630,7 +630,7 @@ LedgerMaster::tryFill(std::shared_ptr<Ledger const> ledger)
                 return;
 
             {
-                std::lock_guard ml(mCompleteLock);
+                std::lock_guard const ml(mCompleteLock);
                 mCompleteLedgers.insert(range(minHas, maxHas));
             }
             maxHas = minHas;
@@ -658,11 +658,11 @@ LedgerMaster::tryFill(std::shared_ptr<Ledger const> ledger)
     }
 
     {
-        std::lock_guard ml(mCompleteLock);
+        std::lock_guard const ml(mCompleteLock);
         mCompleteLedgers.insert(range(minHas, maxHas));
     }
     {
-        std::lock_guard ml(m_mutex);
+        std::lock_guard const ml(m_mutex);
         mFillInProgress = 0;
         tryAdvance();
     }
@@ -692,7 +692,7 @@ LedgerMaster::getFetchPack(LedgerIndex missing, InboundLedger::Reason reason)
         {
             if (peer->hasRange(missing, missing + 1))
             {
-                int score = peer->getScore(true);
+                int const score = peer->getScore(true);
                 if (!target || (score > maxScore))
                 {
                     target = peer;
@@ -791,7 +791,8 @@ LedgerMaster::setFullLedger(
     {
         // Check the SQL database's entry for the sequence before this
         // ledger, if it's not this ledger's parent, invalidate it
-        uint256 prevHash = app_.getRelationalDatabase().getHashByIndex(ledger->header().seq - 1);
+        uint256 const prevHash =
+            app_.getRelationalDatabase().getHashByIndex(ledger->header().seq - 1);
         if (prevHash.isNonZero() && prevHash != ledger->header().parentHash)
             clearLedger(ledger->header().seq - 1);
     }
@@ -799,12 +800,12 @@ LedgerMaster::setFullLedger(
     pendSaveValidated(app_, ledger, isSynchronous, isCurrent);
 
     {
-        std::lock_guard ml(mCompleteLock);
+        std::lock_guard const ml(mCompleteLock);
         mCompleteLedgers.insert(ledger->header().seq);
     }
 
     {
-        std::lock_guard ml(m_mutex);
+        std::lock_guard const ml(m_mutex);
 
         if (ledger->header().seq > mValidLedgerSeq)
             setValidLedger(ledger);
@@ -854,7 +855,7 @@ LedgerMaster::checkAccept(uint256 const& hash, std::uint32_t seq)
         valCount = validations.size();
         if (valCount >= app_.getValidators().quorum())
         {
-            std::lock_guard ml(m_mutex);
+            std::lock_guard const ml(m_mutex);
             if (seq > mLastValidLedger.second)
                 mLastValidLedger = std::make_pair(hash, seq);
         }
@@ -908,7 +909,7 @@ LedgerMaster::checkAccept(std::shared_ptr<Ledger const> const& ledger)
 
     // Can we advance the last fully-validated ledger? If so, can we
     // publish?
-    std::lock_guard ml(m_mutex);
+    std::lock_guard const ml(m_mutex);
 
     if (ledger->header().seq <= mValidLedgerSeq)
         return;
@@ -1200,9 +1201,9 @@ LedgerMaster::findNewLedgersToPublish(std::unique_lock<std::recursive_mutex>& sl
 
     auto pubSeq = mPubLedgerSeq + 1;  // Next sequence to publish
     auto valLedger = mValidLedger.get();
-    std::uint32_t valSeq = valLedger->header().seq;
+    std::uint32_t const valSeq = valLedger->header().seq;
 
-    scope_unlock sul{sl};
+    scope_unlock const sul{sl};
     try
     {
         for (std::uint32_t seq = pubSeq; seq <= valSeq; ++seq)
@@ -1302,7 +1303,7 @@ LedgerMaster::findNewLedgersToPublish(std::unique_lock<std::recursive_mutex>& sl
 void
 LedgerMaster::tryAdvance()
 {
-    std::lock_guard ml(m_mutex);
+    std::lock_guard const ml(m_mutex);
 
     // Can't advance without at least one fully-valid ledger
     mAdvanceWork = true;
@@ -1337,7 +1338,7 @@ void
 LedgerMaster::updatePaths()
 {
     {
-        std::lock_guard ml(m_mutex);
+        std::lock_guard const ml(m_mutex);
         if (app_.getOPs().isNeedNetworkLedger())
         {
             --mPathFindThread;
@@ -1352,7 +1353,7 @@ LedgerMaster::updatePaths()
         JLOG(m_journal.debug()) << "updatePaths running";
         std::shared_ptr<ReadView const> lastLedger;
         {
-            std::lock_guard ml(m_mutex);
+            std::lock_guard const ml(m_mutex);
 
             if (!mValidLedger.empty() &&
                 (!mPathLedger || (mPathLedger->header().seq != mValidLedgerSeq)))
@@ -1381,7 +1382,7 @@ LedgerMaster::updatePaths()
             if (age > 1min)
             {
                 JLOG(m_journal.debug()) << "Published ledger too old for updating paths";
-                std::lock_guard ml(m_mutex);
+                std::lock_guard const ml(m_mutex);
                 --mPathFindThread;
                 mPathLedger.reset();
                 return;
@@ -1392,7 +1393,7 @@ LedgerMaster::updatePaths()
         {
             auto& pathRequests = app_.getPathRequestManager();
             {
-                std::lock_guard ml(m_mutex);
+                std::lock_guard const ml(m_mutex);
                 if (!pathRequests.requestsPending())
                 {
                     --mPathFindThread;
@@ -1406,7 +1407,7 @@ LedgerMaster::updatePaths()
             JLOG(m_journal.debug()) << "Updating paths";
             pathRequests.updateAll(lastLedger);
 
-            std::lock_guard ml(m_mutex);
+            std::lock_guard const ml(m_mutex);
             if (!pathRequests.requestsPending())
             {
                 JLOG(m_journal.debug()) << "No path requests left. No need for further updating "
@@ -1450,7 +1451,7 @@ LedgerMaster::newPathRequest()
 bool
 LedgerMaster::isNewPathRequest()
 {
-    std::lock_guard ml(m_mutex);
+    std::lock_guard const ml(m_mutex);
     bool const ret = mPathFindNewRequest;
     mPathFindNewRequest = false;
     return ret;
@@ -1523,21 +1524,21 @@ LedgerMaster::getValidatedRules()
 std::shared_ptr<ReadView const>
 LedgerMaster::getPublishedLedger()
 {
-    std::lock_guard lock(m_mutex);
+    std::lock_guard const lock(m_mutex);
     return mPubLedger;
 }
 
 std::string
 LedgerMaster::getCompleteLedgers()
 {
-    std::lock_guard sl(mCompleteLock);
+    std::lock_guard const sl(mCompleteLock);
     return to_string(mCompleteLedgers);
 }
 
 std::optional<NetClock::time_point>
 LedgerMaster::getCloseTimeBySeq(LedgerIndex ledgerIndex)
 {
-    uint256 hash = getHashBySeq(ledgerIndex);
+    uint256 const hash = getHashBySeq(ledgerIndex);
     return hash.isNonZero() ? getCloseTimeByHash(hash, ledgerIndex) : std::nullopt;
 }
 
@@ -1601,7 +1602,7 @@ LedgerMaster::walkHashBySeq(
 
     // The hash is not in the reference ledger. Get another ledger which can
     // be located easily and should contain the hash.
-    LedgerIndex refIndex = getCandidateLedger(index);
+    LedgerIndex const refIndex = getCandidateLedger(index);
     auto const refHash = hashOfSeq(*referenceLedger, refIndex, m_journal);
     XRPL_ASSERT(refHash, "xrpl::LedgerMaster::walkHashBySeq : found ledger");
     if (refHash)
@@ -1689,7 +1690,7 @@ LedgerMaster::getLedgerByHash(uint256 const& hash)
 void
 LedgerMaster::setLedgerRangePresent(std::uint32_t minV, std::uint32_t maxV)
 {
-    std::lock_guard sl(mCompleteLock);
+    std::lock_guard const sl(mCompleteLock);
     mCompleteLedgers.insert(range(minV, maxV));
 }
 
@@ -1709,7 +1710,7 @@ LedgerMaster::getCacheHitRate()
 void
 LedgerMaster::clearPriorLedgers(LedgerIndex seq)
 {
-    std::lock_guard sl(mCompleteLock);
+    std::lock_guard const sl(mCompleteLock);
     if (seq > 0)
         mCompleteLedgers.erase(range(0u, seq - 1));
 }
@@ -1739,7 +1740,7 @@ LedgerMaster::fetchForHistory(
     InboundLedger::Reason reason,
     std::unique_lock<std::recursive_mutex>& sl)
 {
-    scope_unlock sul{sl};
+    scope_unlock const sul{sl};
     if (auto hash = getLedgerHashForHistory(missing, reason))
     {
         XRPL_ASSERT(hash->isNonZero(), "xrpl::LedgerMaster::fetchForHistory : found ledger");
@@ -1770,7 +1771,7 @@ LedgerMaster::fetchForHistory(
             setFullLedger(ledger, false, false);
             int fillInProgress = 0;
             {
-                std::lock_guard lock(m_mutex);
+                std::lock_guard const lock(m_mutex);
                 mHistLedger = ledger;
                 fillInProgress = mFillInProgress;
             }
@@ -1779,7 +1780,7 @@ LedgerMaster::fetchForHistory(
             {
                 {
                     // Previous ledger is in DB
-                    std::lock_guard lock(m_mutex);
+                    std::lock_guard const lock(m_mutex);
                     mFillInProgress = seq;
                 }
                 app_.getJobQueue().addJob(
@@ -1799,7 +1800,7 @@ LedgerMaster::fetchForHistory(
             {
                 for (std::uint32_t i = 0; i < fetchSz; ++i)
                 {
-                    std::uint32_t seq = missing - i;
+                    std::uint32_t const seq = missing - i;
                     if (auto h = getLedgerHashForHistory(seq, reason))
                     {
                         XRPL_ASSERT(
@@ -1848,10 +1849,10 @@ LedgerMaster::doAdvance(std::unique_lock<std::recursive_mutex>& sl)
                 (app_.getNodeStore().getWriteLoad() < MAX_WRITE_LOAD_ACQUIRE))
             {
                 // We are in sync, so can acquire
-                InboundLedger::Reason reason = InboundLedger::Reason::HISTORY;
+                InboundLedger::Reason const reason = InboundLedger::Reason::HISTORY;
                 std::optional<std::uint32_t> missing;
                 {
-                    std::lock_guard sll(mCompleteLock);
+                    std::lock_guard const sll(mCompleteLock);
                     missing = prevMissing(
                         mCompleteLedgers,
                         mPubLedger->header().seq,
@@ -1898,7 +1899,7 @@ LedgerMaster::doAdvance(std::unique_lock<std::recursive_mutex>& sl)
             for (auto const& ledger : pubLedgers)
             {
                 {
-                    scope_unlock sul{sl};
+                    scope_unlock const sul{sl};
                     JLOG(m_journal.debug()) << "tryAdvance publishing seq " << ledger->header().seq;
                     setFullLedger(ledger, true, true);
                 }
@@ -1906,7 +1907,7 @@ LedgerMaster::doAdvance(std::unique_lock<std::recursive_mutex>& sl)
                 setPubLedger(ledger);
 
                 {
-                    scope_unlock sul{sl};
+                    scope_unlock const sul{sl};
                     app_.getOPs().pubLedger(ledger);
                 }
             }
@@ -2087,7 +2088,7 @@ LedgerMaster::makeFetchPack(
         //     the same process adding the previous ledger to the FetchPack.
         do
         {
-            std::uint32_t lSeq = want->header().seq;
+            std::uint32_t const lSeq = want->header().seq;
 
             {
                 // Serialize the ledger header:
diff --git a/src/xrpld/app/ledger/detail/LedgerReplayMsgHandler.cpp b/src/xrpld/app/ledger/detail/LedgerReplayMsgHandler.cpp
index a212629d28..93d7ac0d2f 100644
--- a/src/xrpld/app/ledger/detail/LedgerReplayMsgHandler.cpp
+++ b/src/xrpld/app/ledger/detail/LedgerReplayMsgHandler.cpp
@@ -82,7 +82,7 @@ bool
 LedgerReplayMsgHandler::processProofPathResponse(
     std::shared_ptr<protocol::TMProofPathResponse> const& msg)
 {
-    protocol::TMProofPathResponse& reply = *msg;
+    protocol::TMProofPathResponse const& reply = *msg;
     if (reply.has_error() || !reply.has_key() || !reply.has_ledgerhash() || !reply.has_type() ||
         !reply.has_ledgerheader() || reply.path_size() == 0)
     {
@@ -98,7 +98,7 @@ LedgerReplayMsgHandler::processProofPathResponse(
 
     // deserialize the header
     auto info = deserializeHeader({reply.ledgerheader().data(), reply.ledgerheader().size()});
-    uint256 replyHash(reply.ledgerhash());
+    uint256 const replyHash(reply.ledgerhash());
     if (calculateLedgerHash(info) != replyHash)
     {
         JLOG(journal_.debug()) << "Bad message: Hash mismatch";
@@ -106,7 +106,7 @@ LedgerReplayMsgHandler::processProofPathResponse(
     }
     info.hash = replyHash;
 
-    uint256 key(reply.key());
+    uint256 const key(reply.key());
     if (key != keylet::skip().key)
     {
         JLOG(journal_.debug()) << "Bad message: we only support the short skip list for now. "
@@ -151,7 +151,7 @@ protocol::TMReplayDeltaResponse
 LedgerReplayMsgHandler::processReplayDeltaRequest(
     std::shared_ptr<protocol::TMReplayDeltaRequest> const& msg)
 {
-    protocol::TMReplayDeltaRequest& packet = *msg;
+    protocol::TMReplayDeltaRequest const& packet = *msg;
     protocol::TMReplayDeltaResponse reply;
 
     if (!packet.has_ledgerhash() || packet.ledgerhash().size() != uint256::size())
@@ -190,7 +190,7 @@ bool
 LedgerReplayMsgHandler::processReplayDeltaResponse(
     std::shared_ptr<protocol::TMReplayDeltaResponse> const& msg)
 {
-    protocol::TMReplayDeltaResponse& reply = *msg;
+    protocol::TMReplayDeltaResponse const& reply = *msg;
     if (reply.has_error() || !reply.has_ledgerheader())
     {
         JLOG(journal_.debug()) << "Bad message: Error reply";
@@ -198,7 +198,7 @@ LedgerReplayMsgHandler::processReplayDeltaResponse(
     }
 
     auto info = deserializeHeader({reply.ledgerheader().data(), reply.ledgerheader().size()});
-    uint256 replyHash(reply.ledgerhash());
+    uint256 const replyHash(reply.ledgerhash());
     if (calculateLedgerHash(info) != replyHash)
     {
         JLOG(journal_.debug()) << "Bad message: Hash mismatch";
@@ -217,7 +217,8 @@ LedgerReplayMsgHandler::processReplayDeltaResponse(
             // -- TxShaMapItem for building a ShaMap for verification
             // -- Tx
             // -- TxMetaData for Tx ordering
-            Serializer shaMapItemData(reply.transaction(i).data(), reply.transaction(i).size());
+            Serializer const shaMapItemData(
+                reply.transaction(i).data(), reply.transaction(i).size());
 
             SerialIter txMetaSit(makeSlice(reply.transaction(i)));
             SerialIter txSit(txMetaSit.getSlice(txMetaSit.getVLDataLength()));
diff --git a/src/xrpld/app/ledger/detail/LedgerReplayTask.cpp b/src/xrpld/app/ledger/detail/LedgerReplayTask.cpp
index 6db0cebf1a..f393c7fca8 100644
--- a/src/xrpld/app/ledger/detail/LedgerReplayTask.cpp
+++ b/src/xrpld/app/ledger/detail/LedgerReplayTask.cpp
@@ -96,7 +96,7 @@ LedgerReplayTask::init()
 {
     JLOG(journal_.debug()) << "Task start " << hash_;
 
-    std::weak_ptr<LedgerReplayTask> wptr = shared_from_this();
+    std::weak_ptr<LedgerReplayTask> const wptr = shared_from_this();
     skipListAcquirer_->addDataCallback([wptr](bool good, uint256 const& hash) {
         if (auto sptr = wptr.lock(); sptr)
         {
@@ -163,7 +163,8 @@ LedgerReplayTask::tryAdvance(ScopedLockType& sl)
                            << ", deltaIndex=" << deltaToBuild_ << ", totalDeltas=" << deltas_.size()
                            << ", parent " << (parent_ ? parent_->header().hash : uint256());
 
-    bool shouldTry = parent_ && parameter_.full_ && parameter_.totalLedgers_ - 1 == deltas_.size();
+    bool const shouldTry =
+        parent_ && parameter_.full_ && parameter_.totalLedgers_ - 1 == deltas_.size();
     if (!shouldTry)
         return;
 
@@ -204,7 +205,7 @@ LedgerReplayTask::updateSkipList(
     std::vector<uint256> const& sList)
 {
     {
-        ScopedLockType sl(mtx_);
+        ScopedLockType const sl(mtx_);
         if (isDone())
             return;
         if (!parameter_.update(hash, seq, sList))
@@ -245,7 +246,7 @@ LedgerReplayTask::pmDowncast()
 void
 LedgerReplayTask::addDelta(std::shared_ptr<LedgerDeltaAcquire> const& delta)
 {
-    std::weak_ptr<LedgerReplayTask> wptr = shared_from_this();
+    std::weak_ptr<LedgerReplayTask> const wptr = shared_from_this();
     delta->addDataCallback(parameter_.reason_, [wptr](bool good, uint256 const& hash) {
         if (auto sptr = wptr.lock(); sptr)
         {
@@ -260,7 +261,7 @@ LedgerReplayTask::addDelta(std::shared_ptr<LedgerDeltaAcquire> const& delta)
         }
     });
 
-    ScopedLockType sl(mtx_);
+    ScopedLockType const sl(mtx_);
     if (!isDone())
     {
         JLOG(journal_.trace()) << "addDelta task " << hash_ << " deltaIndex=" << deltaToBuild_
@@ -276,7 +277,7 @@ LedgerReplayTask::addDelta(std::shared_ptr<LedgerDeltaAcquire> const& delta)
 bool
 LedgerReplayTask::finished() const
 {
-    ScopedLockType sl(mtx_);
+    ScopedLockType const sl(mtx_);
     return isDone();
 }
 
diff --git a/src/xrpld/app/ledger/detail/LedgerReplayer.cpp b/src/xrpld/app/ledger/detail/LedgerReplayer.cpp
index 9161c05d9a..ae3552f258 100644
--- a/src/xrpld/app/ledger/detail/LedgerReplayer.cpp
+++ b/src/xrpld/app/ledger/detail/LedgerReplayer.cpp
@@ -17,7 +17,7 @@ LedgerReplayer::LedgerReplayer(
 
 LedgerReplayer::~LedgerReplayer()
 {
-    std::lock_guard<std::mutex> lock(mtx_);
+    std::lock_guard<std::mutex> const lock(mtx_);
     tasks_.clear();
 }
 
@@ -32,13 +32,14 @@ LedgerReplayer::replay(
             totalNumLedgers <= LedgerReplayParameters::MAX_TASK_SIZE,
         "xrpl::LedgerReplayer::replay : valid inputs");
 
+    // NOLINTNEXTLINE(misc-const-correctness)
     LedgerReplayTask::TaskParameter parameter(r, finishLedgerHash, totalNumLedgers);
 
     std::shared_ptr<LedgerReplayTask> task;
     std::shared_ptr<SkipListAcquire> skipList;
     bool newSkipList = false;
     {
-        std::lock_guard<std::mutex> lock(mtx_);
+        std::lock_guard<std::mutex> const lock(mtx_);
         if (app_.isStopping())
             return;
         if (tasks_.size() >= LedgerReplayParameters::MAX_TASKS)
@@ -117,7 +118,7 @@ LedgerReplayer::createDeltas(std::shared_ptr<LedgerReplayTask> task)
             std::shared_ptr<LedgerDeltaAcquire> delta;
             bool newDelta = false;
             {
-                std::lock_guard<std::mutex> lock(mtx_);
+                std::lock_guard<std::mutex> const lock(mtx_);
                 if (app_.isStopping())
                     return;
                 auto i = deltas_.find(*skipListItem);
@@ -147,7 +148,7 @@ LedgerReplayer::gotSkipList(
 {
     std::shared_ptr<SkipListAcquire> skipList = {};
     {
-        std::lock_guard<std::mutex> lock(mtx_);
+        std::lock_guard<std::mutex> const lock(mtx_);
         auto i = skipLists_.find(info.hash);
         if (i == skipLists_.end())
             return;
@@ -170,7 +171,7 @@ LedgerReplayer::gotReplayDelta(
 {
     std::shared_ptr<LedgerDeltaAcquire> delta = {};
     {
-        std::lock_guard<std::mutex> lock(mtx_);
+        std::lock_guard<std::mutex> const lock(mtx_);
         auto i = deltas_.find(info.hash);
         if (i == deltas_.end())
             return;
@@ -191,7 +192,7 @@ LedgerReplayer::sweep()
 {
     auto const start = std::chrono::steady_clock::now();
     {
-        std::lock_guard<std::mutex> lock(mtx_);
+        std::lock_guard<std::mutex> const lock(mtx_);
         JLOG(j_.debug()) << "Sweeping, LedgerReplayer has " << tasks_.size() << " tasks, "
                          << skipLists_.size() << " skipLists, and " << deltas_.size() << " deltas.";
 
@@ -237,7 +238,7 @@ LedgerReplayer::stop()
 {
     JLOG(j_.info()) << "Stopping...";
     {
-        std::lock_guard<std::mutex> lock(mtx_);
+        std::lock_guard<std::mutex> const lock(mtx_);
         std::for_each(tasks_.begin(), tasks_.end(), [](auto& i) { i->cancel(); });
         tasks_.clear();
         auto lockAndCancel = [](auto& i) {
diff --git a/src/xrpld/app/ledger/detail/LocalTxs.cpp b/src/xrpld/app/ledger/detail/LocalTxs.cpp
index 8f04da9c2d..38969a092c 100644
--- a/src/xrpld/app/ledger/detail/LocalTxs.cpp
+++ b/src/xrpld/app/ledger/detail/LocalTxs.cpp
@@ -94,7 +94,7 @@ public:
     void
     push_back(LedgerIndex index, std::shared_ptr<STTx const> const& txn) override
     {
-        std::lock_guard lock(m_lock);
+        std::lock_guard const lock(m_lock);
 
         m_txns.emplace_back(index, txn);
     }
@@ -107,7 +107,7 @@ public:
         // Get the set of local transactions as a canonical
         // set (so they apply in a valid order)
         {
-            std::lock_guard lock(m_lock);
+            std::lock_guard const lock(m_lock);
 
             for (auto const& it : m_txns)
                 tset.insert(it.getTX());
@@ -121,7 +121,7 @@ public:
     void
     sweep(ReadView const& view) override
     {
-        std::lock_guard lock(m_lock);
+        std::lock_guard const lock(m_lock);
 
         m_txns.remove_if([&view](auto const& txn) {
             if (txn.isExpired(view.header().seq))
@@ -158,7 +158,7 @@ public:
     std::size_t
     size() override
     {
-        std::lock_guard lock(m_lock);
+        std::lock_guard const lock(m_lock);
 
         return m_txns.size();
     }
diff --git a/src/xrpld/app/ledger/detail/OpenLedger.cpp b/src/xrpld/app/ledger/detail/OpenLedger.cpp
index da35a72bbc..dfce2278a5 100644
--- a/src/xrpld/app/ledger/detail/OpenLedger.cpp
+++ b/src/xrpld/app/ledger/detail/OpenLedger.cpp
@@ -25,26 +25,26 @@ OpenLedger::OpenLedger(
 bool
 OpenLedger::empty() const
 {
-    std::lock_guard lock(modify_mutex_);
+    std::lock_guard const lock(modify_mutex_);
     return current_->txCount() == 0;
 }
 
 std::shared_ptr<OpenView const>
 OpenLedger::current() const
 {
-    std::lock_guard lock(current_mutex_);
+    std::lock_guard const lock(current_mutex_);
     return current_;
 }
 
 bool
 OpenLedger::modify(modify_type const& f)
 {
-    std::lock_guard lock1(modify_mutex_);
+    std::lock_guard const lock1(modify_mutex_);
     auto next = std::make_shared<OpenView>(*current_);
     auto const changed = f(*next, j_);
     if (changed)
     {
-        std::lock_guard lock2(current_mutex_);
+        std::lock_guard const lock2(current_mutex_);
         current_ = std::move(next);
     }
     return changed;
@@ -73,7 +73,7 @@ OpenLedger::accept(
     // Block calls to modify, otherwise
     // new tx going into the open ledger
     // would get lost.
-    std::lock_guard lock1(modify_mutex_);
+    std::lock_guard const lock1(modify_mutex_);
     // Apply tx from the current open view
     if (!current_->txs.empty())
     {
@@ -131,7 +131,7 @@ OpenLedger::accept(
     }
 
     // Switch to the new open view
-    std::lock_guard lock2(current_mutex_);
+    std::lock_guard const lock2(current_mutex_);
     current_ = std::move(next);
 }
 
diff --git a/src/xrpld/app/ledger/detail/SkipListAcquire.cpp b/src/xrpld/app/ledger/detail/SkipListAcquire.cpp
index 3a60fbdc6d..20d63bcb64 100644
--- a/src/xrpld/app/ledger/detail/SkipListAcquire.cpp
+++ b/src/xrpld/app/ledger/detail/SkipListAcquire.cpp
@@ -151,7 +151,7 @@ SkipListAcquire::addDataCallback(OnSkipListDataCB&& cb)
 std::shared_ptr<SkipListAcquire::SkipListData const>
 SkipListAcquire::getData() const
 {
-    ScopedLockType sl(mtx_);
+    ScopedLockType const sl(mtx_);
     return data_;
 }
 
diff --git a/src/xrpld/app/ledger/detail/TimeoutCounter.cpp b/src/xrpld/app/ledger/detail/TimeoutCounter.cpp
index e2d4409717..f329665031 100644
--- a/src/xrpld/app/ledger/detail/TimeoutCounter.cpp
+++ b/src/xrpld/app/ledger/detail/TimeoutCounter.cpp
@@ -96,7 +96,7 @@ TimeoutCounter::invokeOnTimer()
 void
 TimeoutCounter::cancel()
 {
-    ScopedLockType sl(mtx_);
+    ScopedLockType const sl(mtx_);
     if (!isDone())
     {
         failed_ = true;
diff --git a/src/xrpld/app/ledger/detail/TransactionAcquire.cpp b/src/xrpld/app/ledger/detail/TransactionAcquire.cpp
index 9cf35b93dc..0dd654d80b 100644
--- a/src/xrpld/app/ledger/detail/TransactionAcquire.cpp
+++ b/src/xrpld/app/ledger/detail/TransactionAcquire.cpp
@@ -162,7 +162,7 @@ TransactionAcquire::takeNodes(
     std::vector<std::pair<SHAMapNodeID, Slice>> const& data,
     std::shared_ptr<Peer> const& peer)
 {
-    ScopedLockType sl(mtx_);
+    ScopedLockType const sl(mtx_);
 
     if (complete_)
     {
@@ -241,7 +241,7 @@ TransactionAcquire::init(int numPeers)
 void
 TransactionAcquire::stillNeed()
 {
-    ScopedLockType sl(mtx_);
+    ScopedLockType const sl(mtx_);
 
     timeouts_ = std::min<int>(timeouts_, NORM_TIMEOUTS);
     failed_ = false;
diff --git a/src/xrpld/app/main/Application.cpp b/src/xrpld/app/main/Application.cpp
index 0d8325be54..6d02ea38ae 100644
--- a/src/xrpld/app/main/Application.cpp
+++ b/src/xrpld/app/main/Application.cpp
@@ -1811,7 +1811,7 @@ ApplicationImp::loadLedgerFromFile(std::string const& name)
 
             // VFALCO TODO This is the only place that
             //             constructor is used, try to remove it
-            STLedgerEntry sle(*stp.object, uIndex);
+            STLedgerEntry const sle(*stp.object, uIndex);
 
             if (!loadLedger->addSLE(sle))
             {
diff --git a/src/xrpld/app/main/Application.h b/src/xrpld/app/main/Application.h
index 9c79aabb02..45bd94adce 100644
--- a/src/xrpld/app/main/Application.h
+++ b/src/xrpld/app/main/Application.h
@@ -18,16 +18,16 @@ namespace xrpl {
 
 namespace unl {
 class Manager;
-}
+}  // namespace unl
 namespace Resource {
 class Manager;
-}
+}  // namespace Resource
 namespace NodeStore {
 class Database;
 }  // namespace NodeStore
 namespace perf {
 class PerfLog;
-}
+}  // namespace perf
 
 // VFALCO TODO Fix forward declares required for header dependency loops
 class AmendmentTable;
diff --git a/src/xrpld/app/main/GRPCServer.cpp b/src/xrpld/app/main/GRPCServer.cpp
index 130d0f01b9..a6c0c933be 100644
--- a/src/xrpld/app/main/GRPCServer.cpp
+++ b/src/xrpld/app/main/GRPCServer.cpp
@@ -16,8 +16,8 @@ getEndpoint(std::string const& peer)
 {
     try
     {
-        std::size_t first = peer.find_first_of(':');
-        std::size_t last = peer.find_last_of(':');
+        std::size_t const first = peer.find_first_of(':');
+        std::size_t const last = peer.find_last_of(':');
         std::string peerClean(peer);
         if (first != last)
         {
@@ -88,7 +88,7 @@ GRPCServerImpl::CallData<Request, Response>::process()
     // sanity check
     BOOST_ASSERT(!finished_);
 
-    std::shared_ptr<CallData<Request, Response>> thisShared = this->shared_from_this();
+    std::shared_ptr<CallData<Request, Response>> const thisShared = this->shared_from_this();
 
     // Need to set finished to true before processing the response,
     // because as soon as the response is posted to the completion
@@ -107,7 +107,7 @@ GRPCServerImpl::CallData<Request, Response>::process()
     // If coro is null, then the JobQueue has already been shutdown
     if (!coro)
     {
-        grpc::Status status{grpc::StatusCode::INTERNAL, "Job Queue is already stopped"};
+        grpc::Status const status{grpc::StatusCode::INTERNAL, "Job Queue is already stopped"};
         responder_.FinishWithError(status, this);
     }
 }
@@ -119,10 +119,10 @@ GRPCServerImpl::CallData<Request, Response>::process(std::shared_ptr<JobQueue::C
     try
     {
         auto usage = getUsage();
-        bool isUnlimited = clientIsUnlimited();
+        bool const isUnlimited = clientIsUnlimited();
         if (!isUnlimited && usage.disconnect(app_.getJournal("gRPCServer")))
         {
-            grpc::Status status{
+            grpc::Status const status{
                 grpc::StatusCode::RESOURCE_EXHAUSTED, "usage balance exceeds threshold"};
             responder_.FinishWithError(status, this);
         }
@@ -162,12 +162,12 @@ GRPCServerImpl::CallData<Request, Response>::process(std::shared_ptr<JobQueue::C
                 request_};
 
             // Make sure we can currently handle the rpc
-            error_code_i conditionMetRes = RPC::conditionMet(requiredCondition_, context);
+            error_code_i const conditionMetRes = RPC::conditionMet(requiredCondition_, context);
 
             if (conditionMetRes != rpcSUCCESS)
             {
-                RPC::ErrorInfo errorInfo = RPC::get_error_info(conditionMetRes);
-                grpc::Status status{
+                RPC::ErrorInfo const errorInfo = RPC::get_error_info(conditionMetRes);
+                grpc::Status const status{
                     grpc::StatusCode::FAILED_PRECONDITION, errorInfo.message.c_str()};
                 responder_.FinishWithError(status, this);
             }
@@ -181,7 +181,7 @@ GRPCServerImpl::CallData<Request, Response>::process(std::shared_ptr<JobQueue::C
     }
     catch (std::exception const& ex)
     {
-        grpc::Status status{grpc::StatusCode::INTERNAL, ex.what()};
+        grpc::Status const status{grpc::StatusCode::INTERNAL, ex.what()};
         responder_.FinishWithError(status, this);
     }
 }
@@ -302,7 +302,7 @@ GRPCServerImpl::GRPCServerImpl(Application& app)
             return;
         try
         {
-            boost::asio::ip::tcp::endpoint endpoint(
+            boost::asio::ip::tcp::endpoint const endpoint(
                 boost::asio::ip::make_address(*optIp), std::stoi(*optPort));
 
             std::stringstream ss;
diff --git a/src/xrpld/app/main/LoadManager.cpp b/src/xrpld/app/main/LoadManager.cpp
index f0fc4085ac..47948a4031 100644
--- a/src/xrpld/app/main/LoadManager.cpp
+++ b/src/xrpld/app/main/LoadManager.cpp
@@ -35,7 +35,7 @@ LoadManager::~LoadManager()
 void
 LoadManager::activateStallDetector()
 {
-    std::lock_guard sl(mutex_);
+    std::lock_guard const sl(mutex_);
     armed_ = true;
     lastHeartbeat_ = std::chrono::steady_clock::now();
 }
@@ -44,7 +44,7 @@ void
 LoadManager::heartbeat()
 {
     auto const heartbeat = std::chrono::steady_clock::now();
-    std::lock_guard sl(mutex_);
+    std::lock_guard const sl(mutex_);
     lastHeartbeat_ = heartbeat;
 }
 
@@ -63,7 +63,7 @@ void
 LoadManager::stop()
 {
     {
-        std::lock_guard lock(mutex_);
+        std::lock_guard const lock(mutex_);
         stop_ = true;
         // There is at most one thread waiting on this condition.
         cv_.notify_all();
diff --git a/src/xrpld/app/main/Main.cpp b/src/xrpld/app/main/Main.cpp
index 570131b52d..f3953823dd 100644
--- a/src/xrpld/app/main/Main.cpp
+++ b/src/xrpld/app/main/Main.cpp
@@ -215,7 +215,7 @@ public:
 
 namespace test {
 extern std::atomic<bool> envUseIPv4;
-}
+}  // namespace test
 
 template <class Runner>
 static bool
@@ -257,11 +257,11 @@ runUnitTests(
 
     if (!child && num_jobs == 1)
     {
-        multi_runner_parent parent_runner;
+        multi_runner_parent const parent_runner;
 
         multi_runner_child child_runner{num_jobs, quiet, log};
         child_runner.arg(argument);
-        multi_selector pred(pattern);
+        multi_selector const pred(pattern);
         auto const any_failed = child_runner.run_multi(pred) || anyMissing(child_runner, pred);
 
         if (any_failed)
diff --git a/src/xrpld/app/misc/DeliverMax.h b/src/xrpld/app/misc/DeliverMax.h
index 1b4241f091..7fec517d28 100644
--- a/src/xrpld/app/misc/DeliverMax.h
+++ b/src/xrpld/app/misc/DeliverMax.h
@@ -4,7 +4,7 @@
 
 namespace Json {
 class Value;
-}
+}  // namespace Json
 
 namespace xrpl {
 
diff --git a/src/xrpld/app/misc/FeeVoteImpl.cpp b/src/xrpld/app/misc/FeeVoteImpl.cpp
index 450e53e86c..414d8d7421 100644
--- a/src/xrpld/app/misc/FeeVoteImpl.cpp
+++ b/src/xrpld/app/misc/FeeVoteImpl.cpp
@@ -255,7 +255,7 @@ FeeVoteImpl::doVoting(
         JLOG(journal_.warn()) << "We are voting for a fee change: " << baseFee.first << "/"
                               << baseReserve.first << "/" << incReserve.first;
 
-        STTx feeTx(ttFEE, [=, &rules](auto& obj) {
+        STTx const feeTx(ttFEE, [=, &rules](auto& obj) {
             obj[sfAccount] = AccountID();
             obj[sfLedgerSequence] = seq;
             if (rules.enabled(featureXRPFees))
@@ -277,7 +277,7 @@ FeeVoteImpl::doVoting(
             }
         });
 
-        uint256 txID = feeTx.getTransactionID();
+        uint256 const txID = feeTx.getTransactionID();
 
         JLOG(journal_.warn()) << "Vote: " << txID;
 
diff --git a/src/xrpld/app/misc/NegativeUNLVote.cpp b/src/xrpld/app/misc/NegativeUNLVote.cpp
index fe031749bc..212cfaa2e9 100644
--- a/src/xrpld/app/misc/NegativeUNLVote.cpp
+++ b/src/xrpld/app/misc/NegativeUNLVote.cpp
@@ -90,7 +90,7 @@ NegativeUNLVote::addTx(
     NegativeUNLModify modify,
     std::shared_ptr<SHAMap> const& initialSet)
 {
-    STTx negUnlTx(ttUNL_MODIFY, [&](auto& obj) {
+    STTx const negUnlTx(ttUNL_MODIFY, [&](auto& obj) {
         obj.setFieldU8(sfUNLModifyDisabling, modify == ToDisable ? 1 : 0);
         obj.setFieldU32(sfLedgerSequence, seq);
         obj.setFieldVL(sfUNLModifyValidator, vp.slice());
@@ -118,7 +118,7 @@ NegativeUNLVote::choose(uint256 const& randomPadData, std::vector<NodeID> const&
 {
     XRPL_ASSERT(!candidates.empty(), "xrpl::NegativeUNLVote::choose : non-empty input");
     static_assert(NodeID::bytes <= uint256::bytes);
-    NodeID randomPad = NodeID::fromVoid(randomPadData.data());
+    NodeID const randomPad = NodeID::fromVoid(randomPadData.data());
     NodeID txNodeID = candidates[0];
     for (int j = 1; j < candidates.size(); ++j)
     {
@@ -285,7 +285,7 @@ NegativeUNLVote::findAllCandidates(
 void
 NegativeUNLVote::newValidators(LedgerIndex seq, hash_set<NodeID> const& nowTrusted)
 {
-    std::lock_guard lock(mutex_);
+    std::lock_guard const lock(mutex_);
     for (auto const& n : nowTrusted)
     {
         if (!newValidators_.contains(n))
@@ -299,7 +299,7 @@ NegativeUNLVote::newValidators(LedgerIndex seq, hash_set<NodeID> const& nowTrust
 void
 NegativeUNLVote::purgeNewValidators(LedgerIndex seq)
 {
-    std::lock_guard lock(mutex_);
+    std::lock_guard const lock(mutex_);
     auto i = newValidators_.begin();
     while (i != newValidators_.end())
     {
diff --git a/src/xrpld/app/misc/NetworkOPs.cpp b/src/xrpld/app/misc/NetworkOPs.cpp
index b323541362..361eada455 100644
--- a/src/xrpld/app/misc/NetworkOPs.cpp
+++ b/src/xrpld/app/misc/NetworkOPs.cpp
@@ -177,7 +177,7 @@ class NetworkOPsImp final : public NetworkOPs
         CounterData
         getCounterData() const
         {
-            std::lock_guard lock(mutex_);
+            std::lock_guard const lock(mutex_);
             return {counters_, mode_, start_, initialSyncUs_};
         }
     };
@@ -1079,7 +1079,7 @@ NetworkOPsImp::processClusterTimer()
             n.set_nodename(node.name());
     });
 
-    Resource::Gossip gossip = registry_.get().getResourceManager().exportConsumers();
+    Resource::Gossip const gossip = registry_.get().getResourceManager().exportConsumers();
     for (auto& item : gossip.items)
     {
         protocol::TMLoadSource& node = *cluster.add_loadsources();
@@ -1249,7 +1249,7 @@ NetworkOPsImp::doTransactionAsync(
     bool bUnlimited,
     FailHard failType)
 {
-    std::lock_guard lock(mMutex);
+    std::lock_guard const lock(mMutex);
 
     if (transaction->getApplying())
         return;
@@ -1441,7 +1441,7 @@ NetworkOPsImp::apply(std::unique_lock<std::mutex>& batchLock)
             validatedLedgerIndex = l->header().seq;
 
         auto newOL = registry_.get().getOpenLedger().current();
-        for (TransactionStatus& e : transactions)
+        for (TransactionStatus const& e : transactions)
         {
             e.transaction->clearSubmitResult();
 
@@ -1471,7 +1471,7 @@ NetworkOPsImp::apply(std::unique_lock<std::mutex>& batchLock)
             }
 #endif
 
-            bool addLocal = e.local;
+            bool const addLocal = e.local;
 
             if (isTesSuccess(e.result))
             {
@@ -1620,7 +1620,7 @@ NetworkOPsImp::apply(std::unique_lock<std::mutex>& batchLock)
 
     batchLock.lock();
 
-    for (TransactionStatus& e : transactions)
+    for (TransactionStatus const& e : transactions)
         e.transaction->clearApplying();
 
     if (!submit_held.empty())
@@ -1782,7 +1782,7 @@ NetworkOPsImp::checkLastClosedLedger(Overlay::PeerSequence const& peerList, uint
         return false;
 
     uint256 closedLedger = ourClosed->header().hash;
-    uint256 prevClosedLedger = ourClosed->header().parentHash;
+    uint256 const prevClosedLedger = ourClosed->header().parentHash;
     JLOG(m_journal.trace()) << "OurClosed:  " << closedLedger;
     JLOG(m_journal.trace()) << "PrevClosed: " << prevClosedLedger;
 
@@ -1800,7 +1800,7 @@ NetworkOPsImp::checkLastClosedLedger(Overlay::PeerSequence const& peerList, uint
 
     for (auto& peer : peerList)
     {
-        uint256 peerLedger = peer->getClosedLedgerHash();
+        uint256 const peerLedger = peer->getClosedLedgerHash();
 
         if (peerLedger.isNonZero())
             ++peerCounts[peerLedger];
@@ -1809,7 +1809,7 @@ NetworkOPsImp::checkLastClosedLedger(Overlay::PeerSequence const& peerList, uint
     for (auto const& it : peerCounts)
         JLOG(m_journal.debug()) << "L: " << it.first << " n=" << it.second;
 
-    uint256 preferredLCL = validations.getPreferredLCL(
+    uint256 const preferredLCL = validations.getPreferredLCL(
         RCLValidatedLedger{ourClosed, validations.adaptor().journal()},
         m_ledgerMaster.getValidLedgerIndex(),
         peerCounts);
@@ -2042,7 +2042,7 @@ NetworkOPsImp::mapComplete(std::shared_ptr<SHAMap> const& map, bool fromAcquire)
 void
 NetworkOPsImp::endConsensus(std::unique_ptr<std::stringstream> const& clog)
 {
-    uint256 deadLedger = m_ledgerMaster.getClosedLedger()->header().parentHash;
+    uint256 const deadLedger = m_ledgerMaster.getClosedLedger()->header().parentHash;
     for (auto const& it : registry_.get().getOverlay().getActivePeers())
     {
         if (it && (it->getClosedLedgerHash() == deadLedger))
@@ -2053,7 +2053,7 @@ NetworkOPsImp::endConsensus(std::unique_ptr<std::stringstream> const& clog)
     }
 
     uint256 networkClosed;
-    bool ledgerChange =
+    bool const ledgerChange =
         checkLastClosedLedger(registry_.get().getOverlay().getActivePeers(), networkClosed);
 
     if (networkClosed.isZero())
@@ -2107,7 +2107,7 @@ void
 NetworkOPsImp::pubManifest(Manifest const& mo)
 {
     // VFALCO consider std::shared_mutex
-    std::lock_guard sl(mSubLock);
+    std::lock_guard const sl(mSubLock);
 
     if (!mStreamMaps[sManifests].empty())
     {
@@ -2185,7 +2185,7 @@ NetworkOPsImp::pubServer()
     //             list into a local array while holding the lock then release
     //             the lock and call send on everyone.
     //
-    std::lock_guard sl(mSubLock);
+    std::lock_guard const sl(mSubLock);
 
     if (!mStreamMaps[sServer].empty())
     {
@@ -2223,7 +2223,7 @@ NetworkOPsImp::pubServer()
 
         for (auto i = mStreamMaps[sServer].begin(); i != mStreamMaps[sServer].end();)
         {
-            InfoSub::pointer p = i->second.lock();
+            InfoSub::pointer const p = i->second.lock();
 
             // VFALCO TODO research the possibility of using thread queues and
             //             linearizing the deletion of subscribers with the
@@ -2244,7 +2244,7 @@ NetworkOPsImp::pubServer()
 void
 NetworkOPsImp::pubConsensus(ConsensusPhase phase)
 {
-    std::lock_guard sl(mSubLock);
+    std::lock_guard const sl(mSubLock);
 
     auto& streamMap = mStreamMaps[sConsensusPhase];
     if (!streamMap.empty())
@@ -2272,7 +2272,7 @@ void
 NetworkOPsImp::pubValidation(std::shared_ptr<STValidation> const& val)
 {
     // VFALCO consider std::shared_mutex
-    std::lock_guard sl(mSubLock);
+    std::lock_guard const sl(mSubLock);
 
     if (!mStreamMaps[sValidations].empty())
     {
@@ -2377,7 +2377,7 @@ NetworkOPsImp::pubValidation(std::shared_ptr<STValidation> const& val)
 void
 NetworkOPsImp::pubPeerStatus(std::function<Json::Value(void)> const& func)
 {
-    std::lock_guard sl(mSubLock);
+    std::lock_guard const sl(mSubLock);
 
     if (!mStreamMaps[sPeerStatus].empty())
     {
@@ -2387,7 +2387,7 @@ NetworkOPsImp::pubPeerStatus(std::function<Json::Value(void)> const& func)
 
         for (auto i = mStreamMaps[sPeerStatus].begin(); i != mStreamMaps[sPeerStatus].end();)
         {
-            InfoSub::pointer p = i->second.lock();
+            InfoSub::pointer const p = i->second.lock();
 
             if (p)
             {
@@ -2448,7 +2448,7 @@ NetworkOPsImp::recvValidation(std::shared_ptr<STValidation> const& val, std::str
         {
             pendingValidations_.insert(val->getLedgerHash());
         }
-        scope_unlock unlock(lock);
+        scope_unlock const unlock(lock);
         handleNewValidation(registry_.get().getApp(), val, source, bypassAccept, m_journal);
     }
     catch (std::exception const& e)
@@ -2933,7 +2933,7 @@ NetworkOPsImp::pubProposedTransaction(
     MultiApiJson jvObj = transJson(transaction, result, false, ledger, std::nullopt);
 
     {
-        std::lock_guard sl(mSubLock);
+        std::lock_guard const sl(mSubLock);
 
         auto it = mStreamMaps[sRTTransactions].begin();
         while (it != mStreamMaps[sRTTransactions].end())
@@ -2980,7 +2980,7 @@ NetworkOPsImp::pubLedger(std::shared_ptr<ReadView const> const& lpAccepted)
         JLOG(m_journal.debug()) << "Publishing ledger " << lpAccepted->header().seq << " "
                                 << lpAccepted->header().hash;
 
-        std::lock_guard sl(mSubLock);
+        std::lock_guard const sl(mSubLock);
 
         if (!mStreamMaps[sLedger].empty())
         {
@@ -3011,7 +3011,7 @@ NetworkOPsImp::pubLedger(std::shared_ptr<ReadView const> const& lpAccepted)
             auto it = mStreamMaps[sLedger].begin();
             while (it != mStreamMaps[sLedger].end())
             {
-                InfoSub::pointer p = it->second.lock();
+                InfoSub::pointer const p = it->second.lock();
                 if (p)
                 {
                     p->send(jvObj, true);
@@ -3026,12 +3026,12 @@ NetworkOPsImp::pubLedger(std::shared_ptr<ReadView const> const& lpAccepted)
 
         if (!mStreamMaps[sBookChanges].empty())
         {
-            Json::Value jvObj = xrpl::RPC::computeBookChanges(lpAccepted);
+            Json::Value const jvObj = xrpl::RPC::computeBookChanges(lpAccepted);
 
             auto it = mStreamMaps[sBookChanges].begin();
             while (it != mStreamMaps[sBookChanges].end())
             {
-                InfoSub::pointer p = it->second.lock();
+                InfoSub::pointer const p = it->second.lock();
                 if (p)
                 {
                     p->send(jvObj, true);
@@ -3076,7 +3076,7 @@ NetworkOPsImp::pubLedger(std::shared_ptr<ReadView const> const& lpAccepted)
 void
 NetworkOPsImp::reportFeeChange()
 {
-    ServerFeeSummary f{
+    ServerFeeSummary const f{
         registry_.get().getOpenLedger().current()->fees().base,
         registry_.get().getTxQ().getMetrics(*registry_.get().getOpenLedger().current()),
         registry_.get().getFeeTrack()};
@@ -3220,7 +3220,7 @@ NetworkOPsImp::pubValidatedTransaction(
     MultiApiJson jvObj = transJson(stTxn, trResult, true, ledger, metaRef);
 
     {
-        std::lock_guard sl(mSubLock);
+        std::lock_guard const sl(mSubLock);
 
         auto it = mStreamMaps[sTransactions].begin();
         while (it != mStreamMaps[sTransactions].end())
@@ -3279,7 +3279,7 @@ NetworkOPsImp::pubAccountTransaction(
     std::vector<SubAccountHistoryInfo> accountHistoryNotify;
     auto const currLedgerSeq = ledger->seq();
     {
-        std::lock_guard sl(mSubLock);
+        std::lock_guard const sl(mSubLock);
 
         if (!mSubAccount.empty() || !mSubRTAccount.empty() || !mSubAccountHistory.empty())
         {
@@ -3292,7 +3292,7 @@ NetworkOPsImp::pubAccountTransaction(
 
                     while (it != simiIt->second.end())
                     {
-                        InfoSub::pointer p = it->second.lock();
+                        InfoSub::pointer const p = it->second.lock();
 
                         if (p)
                         {
@@ -3312,7 +3312,7 @@ NetworkOPsImp::pubAccountTransaction(
                     auto it = simiIt->second.begin();
                     while (it != simiIt->second.end())
                     {
-                        InfoSub::pointer p = it->second.lock();
+                        InfoSub::pointer const p = it->second.lock();
 
                         if (p)
                         {
@@ -3412,7 +3412,7 @@ NetworkOPsImp::pubProposedAccountTransaction(
     std::vector<SubAccountHistoryInfo> accountHistoryNotify;
 
     {
-        std::lock_guard sl(mSubLock);
+        std::lock_guard const sl(mSubLock);
 
         if (mSubRTAccount.empty())
             return;
@@ -3428,7 +3428,7 @@ NetworkOPsImp::pubProposedAccountTransaction(
 
                     while (it != simiIt->second.end())
                     {
-                        InfoSub::pointer p = it->second.lock();
+                        InfoSub::pointer const p = it->second.lock();
 
                         if (p)
                         {
@@ -3496,7 +3496,7 @@ NetworkOPsImp::subAccount(
         isrListener->insertSubAccountInfo(naAccountID, rt);
     }
 
-    std::lock_guard sl(mSubLock);
+    std::lock_guard const sl(mSubLock);
 
     for (auto const& naAccountID : vnaAccountIDs)
     {
@@ -3539,7 +3539,7 @@ NetworkOPsImp::unsubAccountInternal(
     hash_set<AccountID> const& vnaAccountIDs,
     bool rt)
 {
-    std::lock_guard sl(mSubLock);
+    std::lock_guard const sl(mSubLock);
 
     SubInfoMapType& subMap = rt ? mSubRTAccount : mSubAccount;
 
@@ -3672,7 +3672,7 @@ NetworkOPsImp::addAccountHistoryJob(SubAccountHistoryInfoWeak subInfo)
                 {
                     case Sqlite: {
                         auto& db = registry_.get().getRelationalDatabase();
-                        RelationalDatabase::AccountTxPageOptions options{
+                        RelationalDatabase::AccountTxPageOptions const options{
                             accountId, {minLedger, maxLedger}, marker, 0, true};
                         return db.newestAccountTxPage(options);
                     }
@@ -3751,7 +3751,7 @@ NetworkOPsImp::addAccountHistoryJob(SubAccountHistoryInfoWeak subInfo)
 
                     auto const& txns = dbResult->first;
                     marker = dbResult->second;
-                    size_t num_txns = txns.size();
+                    size_t const num_txns = txns.size();
                     for (size_t i = 0; i < num_txns; ++i)
                     {
                         auto const& [tx, meta] = txns[i];
@@ -3777,7 +3777,7 @@ NetworkOPsImp::addAccountHistoryJob(SubAccountHistoryInfoWeak subInfo)
                             return;
                             // LCOV_EXCL_STOP
                         }
-                        std::shared_ptr<STTx const> stTxn = tx->getSTransaction();
+                        std::shared_ptr<STTx const> const stTxn = tx->getSTransaction();
                         if (!stTxn)
                         {
                             // LCOV_EXCL_START
@@ -3896,7 +3896,7 @@ NetworkOPsImp::subAccountHistory(InfoSub::ref isrListener, AccountID const& acco
         return rpcINVALID_PARAMS;
     }
 
-    std::lock_guard sl(mSubLock);
+    std::lock_guard const sl(mSubLock);
     SubAccountHistoryInfoWeak ahi{isrListener, std::make_shared<SubAccountHistoryIndex>(accountId)};
     auto simIterator = mSubAccountHistory.find(accountId);
     if (simIterator == mSubAccountHistory.end())
@@ -3943,7 +3943,7 @@ NetworkOPsImp::unsubAccountHistoryInternal(
     AccountID const& account,
     bool historyOnly)
 {
-    std::lock_guard sl(mSubLock);
+    std::lock_guard const sl(mSubLock);
     auto simIterator = mSubAccountHistory.find(account);
     if (simIterator != mSubAccountHistory.end())
     {
@@ -4032,7 +4032,7 @@ NetworkOPsImp::subLedger(InfoSub::ref isrListener, Json::Value& jvResult)
         jvResult[jss::validated_ledgers] = registry_.get().getLedgerMaster().getCompleteLedgers();
     }
 
-    std::lock_guard sl(mSubLock);
+    std::lock_guard const sl(mSubLock);
     return mStreamMaps[sLedger].emplace(isrListener->getSeq(), isrListener).second;
 }
 
@@ -4040,7 +4040,7 @@ NetworkOPsImp::subLedger(InfoSub::ref isrListener, Json::Value& jvResult)
 bool
 NetworkOPsImp::subBookChanges(InfoSub::ref isrListener)
 {
-    std::lock_guard sl(mSubLock);
+    std::lock_guard const sl(mSubLock);
     return mStreamMaps[sBookChanges].emplace(isrListener->getSeq(), isrListener).second;
 }
 
@@ -4048,7 +4048,7 @@ NetworkOPsImp::subBookChanges(InfoSub::ref isrListener)
 bool
 NetworkOPsImp::unsubLedger(std::uint64_t uSeq)
 {
-    std::lock_guard sl(mSubLock);
+    std::lock_guard const sl(mSubLock);
     return mStreamMaps[sLedger].erase(uSeq) != 0u;
 }
 
@@ -4056,7 +4056,7 @@ NetworkOPsImp::unsubLedger(std::uint64_t uSeq)
 bool
 NetworkOPsImp::unsubBookChanges(std::uint64_t uSeq)
 {
-    std::lock_guard sl(mSubLock);
+    std::lock_guard const sl(mSubLock);
     return mStreamMaps[sBookChanges].erase(uSeq) != 0u;
 }
 
@@ -4064,7 +4064,7 @@ NetworkOPsImp::unsubBookChanges(std::uint64_t uSeq)
 bool
 NetworkOPsImp::subManifests(InfoSub::ref isrListener)
 {
-    std::lock_guard sl(mSubLock);
+    std::lock_guard const sl(mSubLock);
     return mStreamMaps[sManifests].emplace(isrListener->getSeq(), isrListener).second;
 }
 
@@ -4072,7 +4072,7 @@ NetworkOPsImp::subManifests(InfoSub::ref isrListener)
 bool
 NetworkOPsImp::unsubManifests(std::uint64_t uSeq)
 {
-    std::lock_guard sl(mSubLock);
+    std::lock_guard const sl(mSubLock);
     return mStreamMaps[sManifests].erase(uSeq) != 0u;
 }
 
@@ -4097,7 +4097,7 @@ NetworkOPsImp::subServer(InfoSub::ref isrListener, Json::Value& jvResult, bool a
     jvResult[jss::pubkey_node] =
         toBase58(TokenType::NodePublic, registry_.get().getApp().nodeIdentity().first);
 
-    std::lock_guard sl(mSubLock);
+    std::lock_guard const sl(mSubLock);
     return mStreamMaps[sServer].emplace(isrListener->getSeq(), isrListener).second;
 }
 
@@ -4105,7 +4105,7 @@ NetworkOPsImp::subServer(InfoSub::ref isrListener, Json::Value& jvResult, bool a
 bool
 NetworkOPsImp::unsubServer(std::uint64_t uSeq)
 {
-    std::lock_guard sl(mSubLock);
+    std::lock_guard const sl(mSubLock);
     return mStreamMaps[sServer].erase(uSeq) != 0u;
 }
 
@@ -4113,7 +4113,7 @@ NetworkOPsImp::unsubServer(std::uint64_t uSeq)
 bool
 NetworkOPsImp::subTransactions(InfoSub::ref isrListener)
 {
-    std::lock_guard sl(mSubLock);
+    std::lock_guard const sl(mSubLock);
     return mStreamMaps[sTransactions].emplace(isrListener->getSeq(), isrListener).second;
 }
 
@@ -4121,7 +4121,7 @@ NetworkOPsImp::subTransactions(InfoSub::ref isrListener)
 bool
 NetworkOPsImp::unsubTransactions(std::uint64_t uSeq)
 {
-    std::lock_guard sl(mSubLock);
+    std::lock_guard const sl(mSubLock);
     return mStreamMaps[sTransactions].erase(uSeq) != 0u;
 }
 
@@ -4129,7 +4129,7 @@ NetworkOPsImp::unsubTransactions(std::uint64_t uSeq)
 bool
 NetworkOPsImp::subRTTransactions(InfoSub::ref isrListener)
 {
-    std::lock_guard sl(mSubLock);
+    std::lock_guard const sl(mSubLock);
     return mStreamMaps[sRTTransactions].emplace(isrListener->getSeq(), isrListener).second;
 }
 
@@ -4137,7 +4137,7 @@ NetworkOPsImp::subRTTransactions(InfoSub::ref isrListener)
 bool
 NetworkOPsImp::unsubRTTransactions(std::uint64_t uSeq)
 {
-    std::lock_guard sl(mSubLock);
+    std::lock_guard const sl(mSubLock);
     return mStreamMaps[sRTTransactions].erase(uSeq) != 0u;
 }
 
@@ -4145,7 +4145,7 @@ NetworkOPsImp::unsubRTTransactions(std::uint64_t uSeq)
 bool
 NetworkOPsImp::subValidations(InfoSub::ref isrListener)
 {
-    std::lock_guard sl(mSubLock);
+    std::lock_guard const sl(mSubLock);
     return mStreamMaps[sValidations].emplace(isrListener->getSeq(), isrListener).second;
 }
 
@@ -4159,7 +4159,7 @@ NetworkOPsImp::stateAccounting(Json::Value& obj)
 bool
 NetworkOPsImp::unsubValidations(std::uint64_t uSeq)
 {
-    std::lock_guard sl(mSubLock);
+    std::lock_guard const sl(mSubLock);
     return mStreamMaps[sValidations].erase(uSeq) != 0u;
 }
 
@@ -4167,7 +4167,7 @@ NetworkOPsImp::unsubValidations(std::uint64_t uSeq)
 bool
 NetworkOPsImp::subPeerStatus(InfoSub::ref isrListener)
 {
-    std::lock_guard sl(mSubLock);
+    std::lock_guard const sl(mSubLock);
     return mStreamMaps[sPeerStatus].emplace(isrListener->getSeq(), isrListener).second;
 }
 
@@ -4175,7 +4175,7 @@ NetworkOPsImp::subPeerStatus(InfoSub::ref isrListener)
 bool
 NetworkOPsImp::unsubPeerStatus(std::uint64_t uSeq)
 {
-    std::lock_guard sl(mSubLock);
+    std::lock_guard const sl(mSubLock);
     return mStreamMaps[sPeerStatus].erase(uSeq) != 0u;
 }
 
@@ -4183,7 +4183,7 @@ NetworkOPsImp::unsubPeerStatus(std::uint64_t uSeq)
 bool
 NetworkOPsImp::subConsensus(InfoSub::ref isrListener)
 {
-    std::lock_guard sl(mSubLock);
+    std::lock_guard const sl(mSubLock);
     return mStreamMaps[sConsensusPhase].emplace(isrListener->getSeq(), isrListener).second;
 }
 
@@ -4191,16 +4191,16 @@ NetworkOPsImp::subConsensus(InfoSub::ref isrListener)
 bool
 NetworkOPsImp::unsubConsensus(std::uint64_t uSeq)
 {
-    std::lock_guard sl(mSubLock);
+    std::lock_guard const sl(mSubLock);
     return mStreamMaps[sConsensusPhase].erase(uSeq) != 0u;
 }
 
 InfoSub::pointer
 NetworkOPsImp::findRpcSub(std::string const& strUrl)
 {
-    std::lock_guard sl(mSubLock);
+    std::lock_guard const sl(mSubLock);
 
-    subRpcMapType::iterator it = mRpcSubMap.find(strUrl);
+    subRpcMapType::iterator const it = mRpcSubMap.find(strUrl);
 
     if (it != mRpcSubMap.end())
         return it->second;
@@ -4211,7 +4211,7 @@ NetworkOPsImp::findRpcSub(std::string const& strUrl)
 InfoSub::pointer
 NetworkOPsImp::addRpcSub(std::string const& strUrl, InfoSub::ref rspEntry)
 {
-    std::lock_guard sl(mSubLock);
+    std::lock_guard const sl(mSubLock);
 
     mRpcSubMap.emplace(strUrl, rspEntry);
 
@@ -4221,7 +4221,7 @@ NetworkOPsImp::addRpcSub(std::string const& strUrl, InfoSub::ref rspEntry)
 bool
 NetworkOPsImp::tryRemoveRpcSub(std::string const& strUrl)
 {
-    std::lock_guard sl(mSubLock);
+    std::lock_guard const sl(mSubLock);
     auto pInfo = findRpcSub(strUrl);
 
     if (!pInfo)
@@ -4409,7 +4409,7 @@ NetworkOPsImp::getBookPage(
                         .setJson(jvOffer[jss::taker_pays_funded]);
                 }
 
-                STAmount saOwnerPays = (parityRate == offerRate)
+                STAmount const saOwnerPays = (parityRate == offerRate)
                     ? saTakerGetsFunded
                     : std::min(saOwnerFunds, multiply(saTakerGetsFunded, offerRate));
 
@@ -4582,7 +4582,7 @@ NetworkOPsImp::collect_metrics()
         std::chrono::steady_clock::now() - start);
     counters[static_cast<std::size_t>(mode)].dur += current;
 
-    std::lock_guard lock(m_statsMutex);
+    std::lock_guard const lock(m_statsMutex);
     m_stats.disconnected_duration.set(
         counters[static_cast<std::size_t>(OperatingMode::DISCONNECTED)].dur.count());
     m_stats.connected_duration.set(
@@ -4610,7 +4610,7 @@ NetworkOPsImp::StateAccounting::mode(OperatingMode om)
 {
     auto now = std::chrono::steady_clock::now();
 
-    std::lock_guard lock(mutex_);
+    std::lock_guard const lock(mutex_);
     ++counters_[static_cast<std::size_t>(om)].transitions;
     if (om == OperatingMode::FULL && counters_[static_cast<std::size_t>(om)].transitions == 1)
     {
diff --git a/src/xrpld/app/misc/SHAMapStoreImp.cpp b/src/xrpld/app/misc/SHAMapStoreImp.cpp
index 6460d99686..140f260d56 100644
--- a/src/xrpld/app/misc/SHAMapStoreImp.cpp
+++ b/src/xrpld/app/misc/SHAMapStoreImp.cpp
@@ -16,14 +16,14 @@ namespace xrpl {
 void
 SHAMapStoreImp::SavedStateDB::init(BasicConfig const& config, std::string const& dbName)
 {
-    std::lock_guard lock(mutex_);
+    std::lock_guard const lock(mutex_);
     initStateDB(sqlDb_, config, dbName);
 }
 
 LedgerIndex
 SHAMapStoreImp::SavedStateDB::getCanDelete()
 {
-    std::lock_guard lock(mutex_);
+    std::lock_guard const lock(mutex_);
 
     return xrpl::getCanDelete(sqlDb_);
 }
@@ -31,7 +31,7 @@ SHAMapStoreImp::SavedStateDB::getCanDelete()
 LedgerIndex
 SHAMapStoreImp::SavedStateDB::setCanDelete(LedgerIndex canDelete)
 {
-    std::lock_guard lock(mutex_);
+    std::lock_guard const lock(mutex_);
 
     return xrpl::setCanDelete(sqlDb_, canDelete);
 }
@@ -39,7 +39,7 @@ SHAMapStoreImp::SavedStateDB::setCanDelete(LedgerIndex canDelete)
 SavedState
 SHAMapStoreImp::SavedStateDB::getState()
 {
-    std::lock_guard lock(mutex_);
+    std::lock_guard const lock(mutex_);
 
     return xrpl::getSavedState(sqlDb_);
 }
@@ -47,14 +47,14 @@ SHAMapStoreImp::SavedStateDB::getState()
 void
 SHAMapStoreImp::SavedStateDB::setState(SavedState const& state)
 {
-    std::lock_guard lock(mutex_);
+    std::lock_guard const lock(mutex_);
     xrpl::setSavedState(sqlDb_, state);
 }
 
 void
 SHAMapStoreImp::SavedStateDB::setLastRotated(LedgerIndex seq)
 {
-    std::lock_guard lock(mutex_);
+    std::lock_guard const lock(mutex_);
     xrpl::setLastRotated(sqlDb_, seq);
 }
 
@@ -180,7 +180,7 @@ void
 SHAMapStoreImp::onLedgerClosed(std::shared_ptr<Ledger const> const& ledger)
 {
     {
-        std::lock_guard lock(mutex_);
+        std::lock_guard const lock(mutex_);
         newLedger_ = ledger;
         working_ = true;
     }
@@ -338,7 +338,7 @@ SHAMapStoreImp::run()
 void
 SHAMapStoreImp::dbPaths()
 {
-    Section section{app_.config().section(ConfigSection::nodeDatabase())};
+    Section const section{app_.config().section(ConfigSection::nodeDatabase())};
     boost::filesystem::path dbPath = get(section, "path");
 
     if (boost::filesystem::exists(dbPath))
@@ -426,7 +426,7 @@ SHAMapStoreImp::dbPaths()
     }
 
     // The necessary directories exist. Now, remove any others.
-    for (boost::filesystem::path& p : pathsToDelete)
+    for (boost::filesystem::path const& p : pathsToDelete)
         boost::filesystem::remove_all(p);
 }
 
@@ -595,7 +595,7 @@ SHAMapStoreImp::stop()
     if (thread_.joinable())
     {
         {
-            std::lock_guard lock(mutex_);
+            std::lock_guard const lock(mutex_);
             stop_ = true;
             cond_.notify_one();
         }
diff --git a/src/xrpld/app/misc/ValidatorList.h b/src/xrpld/app/misc/ValidatorList.h
index e774da4713..c10561b6e7 100644
--- a/src/xrpld/app/misc/ValidatorList.h
+++ b/src/xrpld/app/misc/ValidatorList.h
@@ -646,7 +646,7 @@ public:
     QuorumKeys
     getQuorumKeys() const
     {
-        shared_lock read_lock{mutex_};
+        shared_lock const read_lock{mutex_};
         return {quorum_, trustedSigningKeys_};
     }
 
diff --git a/src/xrpld/app/misc/detail/AmendmentTable.cpp b/src/xrpld/app/misc/detail/AmendmentTable.cpp
index 7569fa13b5..afecb08b24 100644
--- a/src/xrpld/app/misc/detail/AmendmentTable.cpp
+++ b/src/xrpld/app/misc/detail/AmendmentTable.cpp
@@ -632,7 +632,7 @@ AmendmentTableImpl::get(uint256 const& amendmentHash, std::lock_guard<std::mutex
 uint256
 AmendmentTableImpl::find(std::string const& name) const
 {
-    std::lock_guard lock(mutex_);
+    std::lock_guard const lock(mutex_);
 
     for (auto const& e : amendmentMap_)
     {
@@ -659,7 +659,7 @@ AmendmentTableImpl::persistVote(
 bool
 AmendmentTableImpl::veto(uint256 const& amendment)
 {
-    std::lock_guard lock(mutex_);
+    std::lock_guard const lock(mutex_);
     AmendmentState& s = add(amendment, lock);
 
     if (s.vote != AmendmentVote::up)
@@ -672,7 +672,7 @@ AmendmentTableImpl::veto(uint256 const& amendment)
 bool
 AmendmentTableImpl::unVeto(uint256 const& amendment)
 {
-    std::lock_guard lock(mutex_);
+    std::lock_guard const lock(mutex_);
     AmendmentState* const s = get(amendment, lock);
 
     if ((s == nullptr) || s->vote != AmendmentVote::down)
@@ -685,7 +685,7 @@ AmendmentTableImpl::unVeto(uint256 const& amendment)
 bool
 AmendmentTableImpl::enable(uint256 const& amendment)
 {
-    std::lock_guard lock(mutex_);
+    std::lock_guard const lock(mutex_);
     AmendmentState& s = add(amendment, lock);
 
     if (s.enabled)
@@ -705,7 +705,7 @@ AmendmentTableImpl::enable(uint256 const& amendment)
 bool
 AmendmentTableImpl::isEnabled(uint256 const& amendment) const
 {
-    std::lock_guard lock(mutex_);
+    std::lock_guard const lock(mutex_);
     AmendmentState const* s = get(amendment, lock);
     return (s != nullptr) && s->enabled;
 }
@@ -713,7 +713,7 @@ AmendmentTableImpl::isEnabled(uint256 const& amendment) const
 bool
 AmendmentTableImpl::isSupported(uint256 const& amendment) const
 {
-    std::lock_guard lock(mutex_);
+    std::lock_guard const lock(mutex_);
     AmendmentState const* s = get(amendment, lock);
     return (s != nullptr) && s->supported;
 }
@@ -721,14 +721,14 @@ AmendmentTableImpl::isSupported(uint256 const& amendment) const
 bool
 AmendmentTableImpl::hasUnsupportedEnabled() const
 {
-    std::lock_guard lock(mutex_);
+    std::lock_guard const lock(mutex_);
     return unsupportedEnabled_;
 }
 
 std::optional<NetClock::time_point>
 AmendmentTableImpl::firstUnsupportedExpected() const
 {
-    std::lock_guard lock(mutex_);
+    std::lock_guard const lock(mutex_);
     return firstUnsupportedExpected_;
 }
 
@@ -740,7 +740,7 @@ AmendmentTableImpl::doValidation(std::set<uint256> const& enabled) const
     std::vector<uint256> amendments;
 
     {
-        std::lock_guard lock(mutex_);
+        std::lock_guard const lock(mutex_);
         amendments.reserve(amendmentMap_.size());
         for (auto const& e : amendmentMap_)
         {
@@ -778,7 +778,7 @@ AmendmentTableImpl::doVoting(
                      << enabledAmendments.size() << ", " << majorityAmendments.size() << ", "
                      << valSet.size();
 
-    std::lock_guard lock(mutex_);
+    std::lock_guard const lock(mutex_);
 
     // Keep a record of the votes we received.
     previousTrustedVotes_.recordVotes(rules, valSet, closeTime, j_, lock);
@@ -860,7 +860,7 @@ AmendmentTableImpl::doVoting(
 bool
 AmendmentTableImpl::needValidatedLedger(LedgerIndex ledgerSeq) const
 {
-    std::lock_guard lock(mutex_);
+    std::lock_guard const lock(mutex_);
 
     // Is there a ledger in which an amendment could have been enabled
     // between these two ledger sequences?
@@ -877,7 +877,7 @@ AmendmentTableImpl::doValidatedLedger(
     for (auto& e : enabled)
         enable(e);
 
-    std::lock_guard lock(mutex_);
+    std::lock_guard const lock(mutex_);
 
     // Remember the ledger sequence of this update.
     lastUpdateSeq_ = ledgerSeq;
@@ -888,7 +888,7 @@ AmendmentTableImpl::doValidatedLedger(
     firstUnsupportedExpected_.reset();
     for (auto const& [hash, time] : majority)
     {
-        AmendmentState& s = add(hash, lock);
+        AmendmentState const& s = add(hash, lock);
 
         if (s.enabled)
             continue;
@@ -908,7 +908,7 @@ AmendmentTableImpl::doValidatedLedger(
 void
 AmendmentTableImpl::trustChanged(hash_set<PublicKey> const& allTrusted)
 {
-    std::lock_guard lock(mutex_);
+    std::lock_guard const lock(mutex_);
     previousTrustedVotes_.trustChanged(allTrusted, lock);
 }
 
@@ -956,7 +956,7 @@ AmendmentTableImpl::getJson(bool isAdmin) const
 {
     Json::Value ret(Json::objectValue);
     {
-        std::lock_guard lock(mutex_);
+        std::lock_guard const lock(mutex_);
         for (auto const& e : amendmentMap_)
         {
             injectJson(
@@ -972,7 +972,7 @@ AmendmentTableImpl::getJson(uint256 const& amendmentID, bool isAdmin) const
     Json::Value ret = Json::objectValue;
 
     {
-        std::lock_guard lock(mutex_);
+        std::lock_guard const lock(mutex_);
         AmendmentState const* a = get(amendmentID, lock);
         if (a != nullptr)
         {
diff --git a/src/xrpld/app/misc/detail/TxQ.cpp b/src/xrpld/app/misc/detail/TxQ.cpp
index c03ef6872e..8f8f14d5a7 100644
--- a/src/xrpld/app/misc/detail/TxQ.cpp
+++ b/src/xrpld/app/misc/detail/TxQ.cpp
@@ -20,8 +20,8 @@ static FeeLevel64
 getFeeLevelPaid(ReadView const& view, STTx const& tx)
 {
     auto const [baseFee, effectiveFeePaid] = [&view, &tx]() {
-        XRPAmount baseFee = calculateBaseFee(view, tx);
-        XRPAmount feePaid = tx[sfFee].xrp();
+        XRPAmount const baseFee = calculateBaseFee(view, tx);
+        XRPAmount const feePaid = tx[sfFee].xrp();
 
         // If baseFee is 0 then the cost of a basic transaction is free, but we
         // need the effective fee level to be non-zero.
@@ -172,7 +172,7 @@ sumOfFirstSquares(std::size_t xIn)
 
     // We expect that size_t == std::uint64_t but, just in case, guarantee
     // we lose no bits.
-    std::uint64_t x{xIn};
+    std::uint64_t const x{xIn};
 
     // If x is anywhere on the order of 2^^21, it's going
     // to completely dominate the computation and is likely
@@ -268,7 +268,7 @@ TxQ::MaybeTx::apply(Application& app, OpenView& view, beast::Journal j)
 {
     // If the rules or flags change, preflight again
     XRPL_ASSERT(pfResult, "xrpl::TxQ::MaybeTx::apply : preflight result is set");
-    NumberSO stNumberSO{view.rules().enabled(fixUniversalNumber)};
+    NumberSO const stNumberSO{view.rules().enabled(fixUniversalNumber)};
 
     if (pfResult->rules != view.rules() || pfResult->flags != flags)
     {
@@ -691,7 +691,7 @@ TxQ::apply(
     ApplyFlags flags,
     beast::Journal j)
 {
-    NumberSO stNumberSO{view.rules().enabled(fixUniversalNumber)};
+    NumberSO const stNumberSO{view.rules().enabled(fixUniversalNumber)};
 
     // See if the transaction is valid, properly formed,
     // etc. before doing potentially expensive queue
@@ -736,7 +736,7 @@ TxQ::apply(
         return {terPRE_TICKET, false};
     }
 
-    std::lock_guard lock(mutex_);
+    std::lock_guard const lock(mutex_);
 
     // accountIter is not const because it may be updated further down.
     AccountMap::iterator accountIter = byAccount_.find(account);
@@ -1287,7 +1287,7 @@ TxQ::apply(
 void
 TxQ::processClosedLedger(Application& app, ReadView const& view, bool timeLeap)
 {
-    std::lock_guard lock(mutex_);
+    std::lock_guard const lock(mutex_);
 
     feeMetrics_.update(app, view, timeLeap, setup_);
     auto const& snapshot = feeMetrics_.getSnapshot();
@@ -1366,7 +1366,7 @@ TxQ::accept(Application& app, OpenView& view)
 
     auto ledgerChanged = false;
 
-    std::lock_guard lock(mutex_);
+    std::lock_guard const lock(mutex_);
 
     auto const metricsSnapshot = feeMetrics_.getSnapshot();
 
@@ -1530,7 +1530,7 @@ TxQ::accept(Application& app, OpenView& view)
 SeqProxy
 TxQ::nextQueuableSeq(std::shared_ptr<SLE const> const& sleAccount) const
 {
-    std::lock_guard<std::mutex> lock(mutex_);
+    std::lock_guard<std::mutex> const lock(mutex_);
     return nextQueuableSeqImpl(sleAccount, lock);
 }
 
@@ -1621,7 +1621,7 @@ TxQ::tryDirectApply(
         return {};
 
     FeeLevel64 const requiredFeeLevel = [this, &view, flags]() {
-        std::lock_guard lock(mutex_);
+        std::lock_guard const lock(mutex_);
         return getRequiredFeeLevel(view, flags, feeMetrics_.getSnapshot(), lock);
     }();
 
@@ -1645,9 +1645,9 @@ TxQ::tryDirectApply(
         {
             // If the applied transaction replaced a transaction in the
             // queue then remove the replaced transaction.
-            std::lock_guard lock(mutex_);
+            std::lock_guard const lock(mutex_);
 
-            AccountMap::iterator accountIter = byAccount_.find(account);
+            AccountMap::iterator const accountIter = byAccount_.find(account);
             if (accountIter != byAccount_.end())
             {
                 TxQAccount& txQAcct = accountIter->second;
@@ -1694,7 +1694,7 @@ TxQ::getMetrics(OpenView const& view) const
 {
     Metrics result;
 
-    std::lock_guard lock(mutex_);
+    std::lock_guard const lock(mutex_);
 
     auto const snapshot = feeMetrics_.getSnapshot();
 
@@ -1715,7 +1715,7 @@ TxQ::getTxRequiredFeeAndSeq(OpenView const& view, std::shared_ptr<STTx const> co
 {
     auto const account = (*tx)[sfAccount];
 
-    std::lock_guard lock(mutex_);
+    std::lock_guard const lock(mutex_);
 
     auto const snapshot = feeMetrics_.getSnapshot();
     auto const baseFee = calculateBaseFee(view, *tx);
@@ -1737,7 +1737,7 @@ TxQ::getAccountTxs(AccountID const& account) const
 {
     std::vector<TxDetails> result;
 
-    std::lock_guard lock(mutex_);
+    std::lock_guard const lock(mutex_);
 
     AccountMap::const_iterator const accountIter{byAccount_.find(account)};
 
@@ -1757,7 +1757,7 @@ TxQ::getTxs() const
 {
     std::vector<TxDetails> result;
 
-    std::lock_guard lock(mutex_);
+    std::lock_guard const lock(mutex_);
 
     result.reserve(byFee_.size());
 
diff --git a/src/xrpld/app/misc/detail/ValidatorList.cpp b/src/xrpld/app/misc/detail/ValidatorList.cpp
index abf64a4a93..5543d0029f 100644
--- a/src/xrpld/app/misc/detail/ValidatorList.cpp
+++ b/src/xrpld/app/misc/detail/ValidatorList.cpp
@@ -132,7 +132,7 @@ ValidatorList::load(
         ")?"                 // end optional comment block
     );
 
-    std::lock_guard lock{mutex_};
+    std::lock_guard const lock{mutex_};
 
     JLOG(j_.debug()) << "Loading configured trusted validator list publisher keys";
 
@@ -901,7 +901,7 @@ ValidatorList::applyListsAndBroadcast(
             networkOPs.clearUNLBlocked();
         }
     }
-    bool broadcast = disposition <= ListDisposition::known_sequence;
+    bool const broadcast = disposition <= ListDisposition::known_sequence;
 
     // this function is only called for PublicKeys which are not specified
     // in the config file (Note: Keys specified in the local config file are
@@ -936,7 +936,7 @@ ValidatorList::applyLists(
         1)
         return PublisherListStats{ListDisposition::unsupported_version};
 
-    std::lock_guard lock{mutex_};
+    std::lock_guard const lock{mutex_};
 
     PublisherListStats result;
     for (auto const& blobInfo : blobs)
@@ -1106,7 +1106,7 @@ ValidatorList::applyList(
         // LCOV_EXCL_STOP
     }
 
-    PublicKey pubKey = *pubKeyOpt;
+    PublicKey const pubKey = *pubKeyOpt;
     if (result > ListDisposition::pending)
     {
         if (publisherLists_.contains(pubKey))
@@ -1238,7 +1238,7 @@ ValidatorList::loadLists()
     using namespace boost::filesystem;
     using namespace boost::system::errc;
 
-    std::lock_guard lock{mutex_};
+    std::lock_guard const lock{mutex_};
 
     std::vector<std::string> sites;
     sites.reserve(publisherLists_.size());
@@ -1381,7 +1381,7 @@ ValidatorList::verify(
 bool
 ValidatorList::listed(PublicKey const& identity) const
 {
-    std::shared_lock read_lock{mutex_};
+    std::shared_lock const read_lock{mutex_};
 
     auto const pubKey = validatorManifests_.getMasterKey(identity);
     return keyListings_.contains(pubKey);
@@ -1397,14 +1397,14 @@ ValidatorList::trusted(ValidatorList::shared_lock const&, PublicKey const& ident
 bool
 ValidatorList::trusted(PublicKey const& identity) const
 {
-    std::shared_lock read_lock{mutex_};
+    std::shared_lock const read_lock{mutex_};
     return trusted(read_lock, identity);
 }
 
 std::optional<PublicKey>
 ValidatorList::getListedKey(PublicKey const& identity) const
 {
-    std::shared_lock read_lock{mutex_};
+    std::shared_lock const read_lock{mutex_};
 
     auto pubKey = validatorManifests_.getMasterKey(identity);
     if (keyListings_.contains(pubKey))
@@ -1424,7 +1424,7 @@ ValidatorList::getTrustedKey(ValidatorList::shared_lock const&, PublicKey const&
 std::optional<PublicKey>
 ValidatorList::getTrustedKey(PublicKey const& identity) const
 {
-    std::shared_lock read_lock{mutex_};
+    std::shared_lock const read_lock{mutex_};
 
     return getTrustedKey(read_lock, identity);
 }
@@ -1432,7 +1432,7 @@ ValidatorList::getTrustedKey(PublicKey const& identity) const
 bool
 ValidatorList::trustedPublisher(PublicKey const& identity) const
 {
-    std::shared_lock read_lock{mutex_};
+    std::shared_lock const read_lock{mutex_};
     return (identity.size() != 0u) && publisherLists_.contains(identity) &&
         publisherLists_.at(identity).status < PublisherStatus::revoked;
 }
@@ -1440,7 +1440,7 @@ ValidatorList::trustedPublisher(PublicKey const& identity) const
 std::optional<PublicKey>
 ValidatorList::localPublicKey() const
 {
-    std::shared_lock read_lock{mutex_};
+    std::shared_lock const read_lock{mutex_};
     return localPubKey_;
 }
 
@@ -1490,7 +1490,7 @@ ValidatorList::count(ValidatorList::shared_lock const&) const
 std::size_t
 ValidatorList::count() const
 {
-    std::shared_lock read_lock{mutex_};
+    std::shared_lock const read_lock{mutex_};
     return count(read_lock);
 }
 
@@ -1533,7 +1533,7 @@ ValidatorList::expires(ValidatorList::shared_lock const&) const
 
     if (!localPublisherList.list.empty())
     {
-        PublisherList collection = localPublisherList;
+        PublisherList const collection = localPublisherList;
         // Unfetched
         auto const& current = collection;
         auto chainedExpiration = current.validUntil;
@@ -1550,7 +1550,7 @@ ValidatorList::expires(ValidatorList::shared_lock const&) const
 std::optional<TimeKeeper::time_point>
 ValidatorList::expires() const
 {
-    std::shared_lock read_lock{mutex_};
+    std::shared_lock const read_lock{mutex_};
     return expires(read_lock);
 }
 
@@ -1559,7 +1559,7 @@ ValidatorList::getJson() const
 {
     Json::Value res(Json::objectValue);
 
-    std::shared_lock read_lock{mutex_};
+    std::shared_lock const read_lock{mutex_};
 
     res[jss::validation_quorum] = static_cast<Json::UInt>(quorum_);
 
@@ -1687,7 +1687,7 @@ ValidatorList::getJson() const
 void
 ValidatorList::for_each_listed(std::function<void(PublicKey const&, bool)> func) const
 {
-    std::shared_lock read_lock{mutex_};
+    std::shared_lock const read_lock{mutex_};
 
     for (auto const& v : keyListings_)
         func(v.first, trusted(read_lock, v.first));
@@ -1703,7 +1703,7 @@ ValidatorList::for_each_available(
         std::size_t maxSequence,
         uint256 const& hash)> func) const
 {
-    std::shared_lock read_lock{mutex_};
+    std::shared_lock const read_lock{mutex_};
 
     for (auto const& [key, plCollection] : publisherLists_)
     {
@@ -1727,7 +1727,7 @@ ValidatorList::getAvailable(
     std::string_view pubKey,
     std::optional<std::uint32_t> forceVersion /* = {} */)
 {
-    std::shared_lock read_lock{mutex_};
+    std::shared_lock const read_lock{mutex_};
 
     auto const keyBlob = strViewUnHex(pubKey);
 
@@ -1851,7 +1851,7 @@ ValidatorList::updateTrusted(
     if (timeKeeper_.now() > closeTime + 30s)
         closeTime = timeKeeper_.now();
 
-    std::lock_guard lock{mutex_};
+    std::lock_guard const lock{mutex_};
 
     // Rotate pending and remove expired published lists
     bool good = true;
@@ -2023,28 +2023,28 @@ ValidatorList::updateTrusted(
 hash_set<PublicKey>
 ValidatorList::getTrustedMasterKeys() const
 {
-    std::shared_lock read_lock{mutex_};
+    std::shared_lock const read_lock{mutex_};
     return trustedMasterKeys_;
 }
 
 std::size_t
 ValidatorList::getListThreshold() const
 {
-    std::shared_lock read_lock{mutex_};
+    std::shared_lock const read_lock{mutex_};
     return listThreshold_;
 }
 
 hash_set<PublicKey>
 ValidatorList::getNegativeUNL() const
 {
-    std::shared_lock read_lock{mutex_};
+    std::shared_lock const read_lock{mutex_};
     return negativeUNL_;
 }
 
 void
 ValidatorList::setNegativeUNL(hash_set<PublicKey> const& negUnl)
 {
-    std::lock_guard lock{mutex_};
+    std::lock_guard const lock{mutex_};
     negativeUNL_ = negUnl;
 }
 
diff --git a/src/xrpld/app/misc/detail/ValidatorSite.cpp b/src/xrpld/app/misc/detail/ValidatorSite.cpp
index b93a1b8007..f9b6553fc2 100644
--- a/src/xrpld/app/misc/detail/ValidatorSite.cpp
+++ b/src/xrpld/app/misc/detail/ValidatorSite.cpp
@@ -110,7 +110,7 @@ ValidatorSite::load(std::vector<std::string> const& siteURIs)
 {
     JLOG(j_.debug()) << "Loading configured validator list sites";
 
-    std::lock_guard lock{sites_mutex_};
+    std::lock_guard const lock{sites_mutex_};
 
     return load(siteURIs, lock);
 }
@@ -147,8 +147,8 @@ ValidatorSite::load(
 void
 ValidatorSite::start()
 {
-    std::lock_guard l0{sites_mutex_};
-    std::lock_guard l1{state_mutex_};
+    std::lock_guard const l0{sites_mutex_};
+    std::lock_guard const l1{state_mutex_};
     if (timer_.expiry() == clock_type::time_point{})
         setTimer(l0, l1);
 }
@@ -216,7 +216,7 @@ ValidatorSite::makeRequest(
     sites_[siteIdx].activeResource = resource;
     std::shared_ptr<detail::Work> sp;
     auto timeoutCancel = [this]() {
-        std::lock_guard lock_state{state_mutex_};
+        std::lock_guard const lock_state{state_mutex_};
         // docs indicate cancel_one() can throw, but this
         // should be reconsidered if it changes to noexcept
         try
@@ -280,7 +280,7 @@ ValidatorSite::makeRequest(
     sp->run();
     // start a timer for the request, which shouldn't take more
     // than requestTimeout_ to complete
-    std::lock_guard lock_state{state_mutex_};
+    std::lock_guard const lock_state{state_mutex_};
     timer_.expires_after(requestTimeout_);
     timer_.async_wait([this, siteIdx](boost::system::error_code const& ec) {
         this->onRequestTimeout(siteIdx, ec);
@@ -294,7 +294,7 @@ ValidatorSite::onRequestTimeout(std::size_t siteIdx, error_code const& ec)
         return;
 
     {
-        std::lock_guard lock_site{sites_mutex_};
+        std::lock_guard const lock_site{sites_mutex_};
         // In some circumstances, both this function and the response
         // handler (onSiteFetch or onTextFetch) can get queued and
         // processed. In all observed cases, the response handler
@@ -311,7 +311,7 @@ ValidatorSite::onRequestTimeout(std::size_t siteIdx, error_code const& ec)
                                 "already been processed";
     }
 
-    std::lock_guard lock_state{state_mutex_};
+    std::lock_guard const lock_state{state_mutex_};
     if (auto sp = work_.lock())
         sp->cancel();
 }
@@ -330,7 +330,7 @@ ValidatorSite::onTimer(std::size_t siteIdx, error_code const& ec)
 
     try
     {
-        std::lock_guard lock{sites_mutex_};
+        std::lock_guard const lock{sites_mutex_};
         sites_[siteIdx].nextRefresh = clock_type::now() + sites_[siteIdx].refreshInterval;
         sites_[siteIdx].redirCount = 0;
         // the WorkSSL client ctor can throw if SSL init fails
@@ -579,7 +579,7 @@ ValidatorSite::onSiteFetch(
         sites_[siteIdx].activeResource.reset();
     }
 
-    std::lock_guard lock_state{state_mutex_};
+    std::lock_guard const lock_state{state_mutex_};
     fetching_ = false;
     if (!stopping_)
         setTimer(lock_sites, lock_state);
@@ -592,7 +592,7 @@ ValidatorSite::onTextFetch(
     std::string const& res,
     std::size_t siteIdx)
 {
-    std::lock_guard lock_sites{sites_mutex_};
+    std::lock_guard const lock_sites{sites_mutex_};
     {
         try
         {
@@ -616,7 +616,7 @@ ValidatorSite::onTextFetch(
         sites_[siteIdx].activeResource.reset();
     }
 
-    std::lock_guard lock_state{state_mutex_};
+    std::lock_guard const lock_state{state_mutex_};
     fetching_ = false;
     if (!stopping_)
         setTimer(lock_sites, lock_state);
@@ -632,7 +632,7 @@ ValidatorSite::getJson() const
     Json::Value jrr(Json::objectValue);
     Json::Value& jSites = (jrr[jss::validator_sites] = Json::arrayValue);
     {
-        std::lock_guard lock{sites_mutex_};
+        std::lock_guard const lock{sites_mutex_};
         for (Site const& site : sites_)
         {
             Json::Value& v = jSites.append(Json::objectValue);
diff --git a/src/xrpld/app/misc/detail/WorkFile.h b/src/xrpld/app/misc/detail/WorkFile.h
index 896d7ddc71..5113ec5f3a 100644
--- a/src/xrpld/app/misc/detail/WorkFile.h
+++ b/src/xrpld/app/misc/detail/WorkFile.h
@@ -44,18 +44,18 @@ private:
 
 //------------------------------------------------------------------------------
 
-WorkFile::WorkFile(std::string const& path, boost::asio::io_context& ios, callback_type cb)
+inline WorkFile::WorkFile(std::string const& path, boost::asio::io_context& ios, callback_type cb)
     : path_(path), cb_(std::move(cb)), ios_(ios), strand_(boost::asio::make_strand(ios))
 {
 }
 
-WorkFile::~WorkFile()
+inline WorkFile::~WorkFile()
 {
     if (cb_)
         cb_(make_error_code(boost::system::errc::interrupted), {});
 }
 
-void
+inline void
 WorkFile::run()
 {
     if (!strand_.running_in_this_thread())
@@ -71,7 +71,7 @@ WorkFile::run()
     cb_ = nullptr;
 }
 
-void
+inline void
 WorkFile::cancel()
 {
     // Nothing to do. Either it finished in run, or it didn't start.
diff --git a/src/xrpld/app/misc/detail/WorkPlain.h b/src/xrpld/app/misc/detail/WorkPlain.h
index d1df5b4b3b..361a7b4513 100644
--- a/src/xrpld/app/misc/detail/WorkPlain.h
+++ b/src/xrpld/app/misc/detail/WorkPlain.h
@@ -35,7 +35,7 @@ private:
 
 //------------------------------------------------------------------------------
 
-WorkPlain::WorkPlain(
+inline WorkPlain::WorkPlain(
     std::string const& host,
     std::string const& path,
     std::string const& port,
@@ -47,7 +47,7 @@ WorkPlain::WorkPlain(
 {
 }
 
-void
+inline void
 WorkPlain::onConnect(error_code const& ec)
 {
     if (ec)
diff --git a/src/xrpld/app/rdb/backend/detail/Node.cpp b/src/xrpld/app/rdb/backend/detail/Node.cpp
index 926c01b8b3..b176588771 100644
--- a/src/xrpld/app/rdb/backend/detail/Node.cpp
+++ b/src/xrpld/app/rdb/backend/detail/Node.cpp
@@ -105,7 +105,7 @@ makeLedgerDBs(
 std::optional<LedgerIndex>
 getMinLedgerSeq(soci::session& session, TableType type)
 {
-    std::string query = "SELECT MIN(LedgerSeq) FROM " + to_string(type) + ";";
+    std::string const query = "SELECT MIN(LedgerSeq) FROM " + to_string(type) + ";";
     // SOCI requires boost::optional (not std::optional) as the parameter.
     boost::optional<LedgerIndex> m;
     session << query, soci::into(m);
@@ -115,7 +115,7 @@ getMinLedgerSeq(soci::session& session, TableType type)
 std::optional<LedgerIndex>
 getMaxLedgerSeq(soci::session& session, TableType type)
 {
-    std::string query = "SELECT MAX(LedgerSeq) FROM " + to_string(type) + ";";
+    std::string const query = "SELECT MAX(LedgerSeq) FROM " + to_string(type) + ";";
     // SOCI requires boost::optional (not std::optional) as the parameter.
     boost::optional<LedgerIndex> m;
     session << query, soci::into(m);
@@ -330,7 +330,7 @@ saveValidatedLedger(
         }
 
         {
-            static std::string addLedger(
+            static std::string const addLedger(
                 R"sql(INSERT OR REPLACE INTO Ledgers
                 (LedgerHash,LedgerSeq,PrevHash,TotalCoins,ClosingTime,PrevClosingTime,
                 CloseTimeRes,CloseFlags,AccountSetHash,TransSetHash)
@@ -576,7 +576,7 @@ getHashesByIndex(soci::session& session, LedgerIndex minSeq, LedgerIndex maxSeq,
 std::pair<std::vector<std::shared_ptr<Transaction>>, int>
 getTxHistory(soci::session& session, Application& app, LedgerIndex startIndex, int quantity)
 {
-    std::string sql = boost::str(
+    std::string const sql = boost::str(
         boost::format(
             "SELECT LedgerSeq, Status, RawTxn "
             "FROM Transactions ORDER BY LedgerSeq DESC LIMIT %u,%u;") %
@@ -749,7 +749,7 @@ getAccountTxs(
 {
     RelationalDatabase::AccountTxs ret;
 
-    std::string sql = transactionsSQL(
+    std::string const sql = transactionsSQL(
         app,
         "AccountTransactions.LedgerSeq,Status,RawTxn,TxnMeta",
         options,
@@ -873,7 +873,7 @@ getAccountTxsB(
 {
     std::vector<RelationalDatabase::txnMetaLedgerType> ret;
 
-    std::string sql = transactionsSQL(
+    std::string const sql = transactionsSQL(
         app,
         "AccountTransactions.LedgerSeq,Status,RawTxn,TxnMeta",
         options,
@@ -1222,7 +1222,7 @@ getTransaction(
         if (!ledgerSeq)
             return std::pair{std::move(txn), nullptr};
 
-        std::uint32_t 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);
 
@@ -1242,7 +1242,8 @@ getTransaction(
 bool
 dbHasSpace(soci::session& session, Config const& config, beast::Journal j)
 {
-    boost::filesystem::space_info space = boost::filesystem::space(config.legacy("database_path"));
+    boost::filesystem::space_info const space =
+        boost::filesystem::space(config.legacy("database_path"));
 
     if (space.available < megabytes(512))
     {
@@ -1252,8 +1253,8 @@ dbHasSpace(soci::session& session, Config const& config, beast::Journal j)
 
     if (config.useTxTables())
     {
-        DatabaseCon::Setup dbSetup = setup_DatabaseCon(config);
-        boost::filesystem::path dbPath = dbSetup.dataDir / TxDBName;
+        DatabaseCon::Setup const dbSetup = setup_DatabaseCon(config);
+        boost::filesystem::path const dbPath = dbSetup.dataDir / TxDBName;
         boost::system::error_code ec;
         std::optional<std::uint64_t> dbSize = boost::filesystem::file_size(dbPath, ec);
         if (ec)
@@ -1274,8 +1275,8 @@ dbHasSpace(soci::session& session, Config const& config, beast::Journal j)
         }();
         std::uint32_t pageCount = 0;
         session << "PRAGMA page_count;", soci::into(pageCount);
-        std::uint32_t freePages = maxPages - pageCount;
-        std::uint64_t freeSpace = safe_cast<std::uint64_t>(freePages) * pageSize;
+        std::uint32_t const freePages = maxPages - pageCount;
+        std::uint64_t const freeSpace = safe_cast<std::uint64_t>(freePages) * pageSize;
         JLOG(j.info()) << "Transaction DB pathname: " << dbPath.string()
                        << "; file size: " << dbSize.value_or(-1) << " bytes"
                        << "; SQLite page size: " << pageSize << " bytes"
diff --git a/src/xrpld/app/rdb/detail/PeerFinder.cpp b/src/xrpld/app/rdb/detail/PeerFinder.cpp
index d619d4bb85..a568461fb7 100644
--- a/src/xrpld/app/rdb/detail/PeerFinder.cpp
+++ b/src/xrpld/app/rdb/detail/PeerFinder.cpp
@@ -5,7 +5,7 @@ namespace xrpl {
 void
 initPeerFinderDB(soci::session& session, BasicConfig const& config, beast::Journal j)
 {
-    DBConfig m_sociConfig(config, "peerfinder");
+    DBConfig const m_sociConfig(config, "peerfinder");
     m_sociConfig.open(session);
 
     JLOG(j.info()) << "Opening database at '" << m_sociConfig.connectionString() << "'";
diff --git a/src/xrpld/consensus/Consensus.cpp b/src/xrpld/consensus/Consensus.cpp
index 29d0e9db1c..9ad7e677ad 100644
--- a/src/xrpld/consensus/Consensus.cpp
+++ b/src/xrpld/consensus/Consensus.cpp
@@ -132,7 +132,7 @@ checkConsensusReached(
         CLOG(clog) << "agreeing and total adjusted: " << agreeing << ',' << total << ". ";
     }
 
-    std::size_t currentPercentage = (agreeing * 100) / total;
+    std::size_t const currentPercentage = (agreeing * 100) / total;
 
     CLOG(clog) << "currentPercentage: " << currentPercentage;
     bool const ret = currentPercentage >= minConsensusPct;
diff --git a/src/xrpld/consensus/Consensus.h b/src/xrpld/consensus/Consensus.h
index 2ed40cd2eb..d5441dc1c4 100644
--- a/src/xrpld/consensus/Consensus.h
+++ b/src/xrpld/consensus/Consensus.h
@@ -1116,7 +1116,7 @@ Consensus<Adaptor>::phaseOpen(std::unique_ptr<std::stringstream> const& clog)
     using namespace std::chrono;
 
     // it is shortly before ledger close time
-    bool anyTransactions = adaptor_.hasOpenTransactions();
+    bool const anyTransactions = adaptor_.hasOpenTransactions();
     auto proposersClosed = currPeerPositions_.size();
     auto proposersValidated = adaptor_.proposersValidated(prevLedgerID_);
 
@@ -1186,7 +1186,7 @@ Consensus<Adaptor>::shouldPause(std::unique_ptr<std::stringstream> const& clog)
         previousLedger_.seq() - std::min(adaptor_.getValidLedgerIndex(), previousLedger_.seq()));
     auto [quorum, trustedKeys] = adaptor_.getQuorumKeys();
     std::size_t const totalValidators = trustedKeys.size();
-    std::size_t laggards = adaptor_.laggards(previousLedger_.seq(), trustedKeys);
+    std::size_t const laggards = adaptor_.laggards(previousLedger_.seq(), trustedKeys);
     std::size_t const offline = trustedKeys.size();
 
     std::stringstream vars;
@@ -1408,7 +1408,7 @@ this.
 inline int
 participantsNeeded(int participants, int percent)
 {
-    int result = ((participants * percent) + (percent / 2)) / 100;
+    int const result = ((participants * percent) + (percent / 2)) / 100;
 
     return (result == 0) ? 1 : result;
 }
@@ -1757,7 +1757,7 @@ Consensus<Adaptor>::createDisputes(TxSet_t const& o, std::unique_ptr<std::string
                 (!inThisSet && !result_->txns.find(txId) && o.find(txId)),
             "xrpl::Consensus::createDisputes : has disputed transactions");
 
-        Tx_t tx = inThisSet ? result_->txns.find(txId) : o.find(txId);
+        Tx_t const tx = inThisSet ? result_->txns.find(txId) : o.find(txId);
         auto txID = tx.id();
 
         if (result_->disputes.find(txID) != result_->disputes.end())
diff --git a/src/xrpld/consensus/DisputedTx.h b/src/xrpld/consensus/DisputedTx.h
index 89cb5115bb..0657ad7ac2 100644
--- a/src/xrpld/consensus/DisputedTx.h
+++ b/src/xrpld/consensus/DisputedTx.h
@@ -97,7 +97,7 @@ public:
 
         // Compute the percentage of nodes voting 'yes' (possibly including us)
         int const support = (yays_ + (proposing && ourVote_ ? 1 : 0)) * 100;
-        int total = nays_ + yays_ + (proposing ? 1 : 0);
+        int const total = nays_ + yays_ + (proposing ? 1 : 0);
         if (!total)
             // There are no votes, so we know nothing
             return false;
diff --git a/src/xrpld/consensus/LedgerTrie.h b/src/xrpld/consensus/LedgerTrie.h
index d34dda8e1b..335c2cae7f 100644
--- a/src/xrpld/consensus/LedgerTrie.h
+++ b/src/xrpld/consensus/LedgerTrie.h
@@ -128,7 +128,7 @@ public:
     SpanTip<Ledger>
     tip() const
     {
-        Seq tipSeq{end_ - Seq{1}};
+        Seq const tipSeq{end_ - Seq{1}};
         return SpanTip<Ledger>{tipSeq, ledger_[tipSeq], ledger_};
     }
 
@@ -149,8 +149,8 @@ private:
     std::optional<Span>
     sub(Seq from, Seq to) const
     {
-        Seq newFrom = clamp(from);
-        Seq newTo = clamp(to);
+        Seq const newFrom = clamp(from);
+        Seq const newTo = clamp(to);
         if (newFrom < newTo)
             return Span(newFrom, newTo, ledger_);
         return std::nullopt;
@@ -344,6 +344,7 @@ class LedgerTrie
     std::pair<Node*, Seq>
     find(Ledger const& ledger) const
     {
+        // NOLINTNEXTLINE(misc-const-correctness)
         Node* curr = root.get();
 
         // Root is always defined and is in common with all ledgers
diff --git a/src/xrpld/consensus/Validations.h b/src/xrpld/consensus/Validations.h
index 4cd922d6b2..4d0b64a350 100644
--- a/src/xrpld/consensus/Validations.h
+++ b/src/xrpld/consensus/Validations.h
@@ -422,7 +422,7 @@ private:
 
         checkAcquired(lock);
 
-        std::pair<Seq, ID> valPair{val.seq(), val.ledgerID()};
+        std::pair<Seq, ID> const valPair{val.seq(), val.ledgerID()};
         auto it = acquiring_.find(valPair);
         if (it != acquiring_.end())
         {
@@ -479,7 +479,7 @@ private:
     void
     current(std::lock_guard<Mutex> const& lock, Pre&& pre, F&& f)
     {
-        NetClock::time_point t = adaptor_.now();
+        NetClock::time_point const t = adaptor_.now();
         pre(current_.size());
         auto it = current_.begin();
         while (it != current_.end())
@@ -569,7 +569,7 @@ public:
     bool
     canValidateSeq(Seq const s)
     {
-        std::lock_guard lock{mutex_};
+        std::lock_guard const lock{mutex_};
         return localSeqEnforcer_(byLedger_.clock().now(), s, parms_);
     }
 
@@ -588,7 +588,7 @@ public:
             return ValStatus::stale;
 
         {
-            std::lock_guard lock{mutex_};
+            std::lock_guard const lock{mutex_};
 
             // Check that validation sequence is greater than any non-expired
             // validations sequence from that validator; if it's not, perform
@@ -645,7 +645,7 @@ public:
             if (!inserted)
             {
                 // Replace existing only if this one is newer
-                Validation& oldVal = it->second;
+                Validation const& oldVal = it->second;
                 if (val.signTime() > oldVal.signTime())
                 {
                     std::pair<Seq, ID> old(oldVal.seq(), oldVal.ledgerID());
@@ -674,7 +674,7 @@ public:
     void
     setSeqToKeep(Seq const& low, Seq const& high)
     {
-        std::lock_guard lock{mutex_};
+        std::lock_guard const lock{mutex_};
         XRPL_ASSERT(low < high, "xrpl::Validations::setSeqToKeep : valid inputs");
         toKeep_ = {low, high};
     }
@@ -689,7 +689,7 @@ public:
     {
         auto const start = std::chrono::steady_clock::now();
         {
-            std::lock_guard lock{mutex_};
+            std::lock_guard const lock{mutex_};
             if (toKeep_)
             {
                 // We only need to refresh the keep range when it's just about
@@ -746,7 +746,7 @@ public:
     void
     trustChanged(hash_set<NodeID> const& added, hash_set<NodeID> const& removed)
     {
-        std::lock_guard lock{mutex_};
+        std::lock_guard const lock{mutex_};
 
         for (auto& [nodeId, validation] : current_)
         {
@@ -782,7 +782,7 @@ public:
     Json::Value
     getJsonTrie() const
     {
-        std::lock_guard lock{mutex_};
+        std::lock_guard const lock{mutex_};
         return trie_.getJson();
     }
 
@@ -801,7 +801,7 @@ public:
     std::optional<std::pair<Seq, ID>>
     getPreferred(Ledger const& curr)
     {
-        std::lock_guard lock{mutex_};
+        std::lock_guard const lock{mutex_};
         std::optional<SpanTip<Ledger>> preferred = withTrie(lock, [this](LedgerTrie<Ledger>& trie) {
             return trie.getPreferred(localSeqEnforcer_.largest());
         });
@@ -913,7 +913,7 @@ public:
     std::size_t
     getNodesAfter(Ledger const& ledger, ID const& ledgerID)
     {
-        std::lock_guard lock{mutex_};
+        std::lock_guard const lock{mutex_};
 
         // Use trie if ledger is the right one
         if (ledger.id() == ledgerID)
@@ -936,7 +936,7 @@ public:
     currentTrusted()
     {
         std::vector<WrappedValidationType> ret;
-        std::lock_guard lock{mutex_};
+        std::lock_guard const lock{mutex_};
         current(
             lock,
             [&](std::size_t numValidations) { ret.reserve(numValidations); },
@@ -955,7 +955,7 @@ public:
     getCurrentNodeIDs() -> hash_set<NodeID>
     {
         hash_set<NodeID> ret;
-        std::lock_guard lock{mutex_};
+        std::lock_guard const lock{mutex_};
         current(
             lock,
             [&](std::size_t numValidations) { ret.reserve(numValidations); },
@@ -973,7 +973,7 @@ public:
     numTrustedForLedger(ID const& ledgerID)
     {
         std::size_t count = 0;
-        std::lock_guard lock{mutex_};
+        std::lock_guard const lock{mutex_};
         byLedger(
             lock,
             ledgerID,
@@ -995,7 +995,7 @@ public:
     getTrustedForLedger(ID const& ledgerID, Seq const& seq)
     {
         std::vector<WrappedValidationType> res;
-        std::lock_guard lock{mutex_};
+        std::lock_guard const lock{mutex_};
         byLedger(
             lock,
             ledgerID,
@@ -1018,7 +1018,7 @@ public:
     fees(ID const& ledgerID, std::uint32_t baseFee)
     {
         std::vector<std::uint32_t> res;
-        std::lock_guard lock{mutex_};
+        std::lock_guard const lock{mutex_};
         byLedger(
             lock,
             ledgerID,
@@ -1041,7 +1041,7 @@ public:
     void
     flush()
     {
-        std::lock_guard lock{mutex_};
+        std::lock_guard const lock{mutex_};
         current_.clear();
     }
 
@@ -1084,28 +1084,28 @@ public:
     std::size_t
     sizeOfCurrentCache() const
     {
-        std::lock_guard lock{mutex_};
+        std::lock_guard const lock{mutex_};
         return current_.size();
     }
 
     std::size_t
     sizeOfSeqEnforcersCache() const
     {
-        std::lock_guard lock{mutex_};
+        std::lock_guard const lock{mutex_};
         return seqEnforcers_.size();
     }
 
     std::size_t
     sizeOfByLedgerCache() const
     {
-        std::lock_guard lock{mutex_};
+        std::lock_guard const lock{mutex_};
         return byLedger_.size();
     }
 
     std::size_t
     sizeOfBySequenceCache() const
     {
-        std::lock_guard lock{mutex_};
+        std::lock_guard const lock{mutex_};
         return bySequence_.size();
     }
 };
diff --git a/src/xrpld/core/detail/Config.cpp b/src/xrpld/core/detail/Config.cpp
index 270764a17b..204b29ad30 100644
--- a/src/xrpld/core/detail/Config.cpp
+++ b/src/xrpld/core/detail/Config.cpp
@@ -390,10 +390,10 @@ Config::setup(std::string const& strConf, bool bQuiet, bool bSilent, bool bStand
     if (RUN_STANDALONE)
         LEDGER_HISTORY = 0;
 
-    Section ledgerTxTablesSection = section("ledger_tx_tables");
+    Section const ledgerTxTablesSection = section("ledger_tx_tables");
     get_if_exists(ledgerTxTablesSection, "use_tx_tables", USE_TX_TABLES);
 
-    Section& nodeDbSection{section(ConfigSection::nodeDatabase())};
+    Section const& nodeDbSection{section(ConfigSection::nodeDatabase())};
     get_if_exists(nodeDbSection, "fast_load", FAST_LOAD);
 }
 
@@ -471,7 +471,7 @@ Config::loadFromString(std::string const& fileContents)
                 if (std::count(line.begin(), line.end(), ':') != 1)
                     continue;
 
-                std::string result = std::regex_replace(line, e, " $1");
+                std::string const result = std::regex_replace(line, e, " $1");
                 // sanity check the result of the replace, should be same length
                 // as input
                 if (result.size() == line.size())
@@ -487,7 +487,7 @@ Config::loadFromString(std::string const& fileContents)
         std::string dbPath;
         if (getSingleSection(secConfig, "database_path", dbPath, j_))
         {
-            boost::filesystem::path p(dbPath);
+            boost::filesystem::path const p(dbPath);
             legacy("database_path", boost::filesystem::absolute(p).string());
         }
     }
@@ -890,7 +890,7 @@ Config::loadFromString(std::string const& fileContents)
                                       ", must be: [0-9]+ [minutes|hours|days|weeks]");
         }
 
-        std::uint32_t 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"))
         {
@@ -1226,7 +1226,7 @@ setup_DatabaseCon(Config const& c, std::optional<beast::Journal> j)
                     "Configuration file may not define both "
                     "\"safety_level\" and \"journal_mode\"");
             }
-            bool higherRisk =
+            bool const higherRisk =
                 boost::iequals(journal_mode, "memory") || boost::iequals(journal_mode, "off");
             showRiskWarning = showRiskWarning || higherRisk;
             if (higherRisk || boost::iequals(journal_mode, "delete") ||
@@ -1250,7 +1250,7 @@ setup_DatabaseCon(Config const& c, std::optional<beast::Journal> j)
                     "Configuration file may not define both "
                     "\"safety_level\" and \"synchronous\"");
             }
-            bool higherRisk = boost::iequals(synchronous, "off");
+            bool const higherRisk = boost::iequals(synchronous, "off");
             showRiskWarning = showRiskWarning || higherRisk;
             if (higherRisk || boost::iequals(synchronous, "normal") ||
                 boost::iequals(synchronous, "full") || boost::iequals(synchronous, "extra"))
@@ -1271,7 +1271,7 @@ setup_DatabaseCon(Config const& c, std::optional<beast::Journal> j)
                     "Configuration file may not define both "
                     "\"safety_level\" and \"temp_store\"");
             }
-            bool higherRisk = boost::iequals(temp_store, "memory");
+            bool const higherRisk = boost::iequals(temp_store, "memory");
             showRiskWarning = showRiskWarning || higherRisk;
             if (higherRisk || boost::iequals(temp_store, "default") ||
                 boost::iequals(temp_store, "file"))
diff --git a/src/xrpld/overlay/Overlay.h b/src/xrpld/overlay/Overlay.h
index f1d1104d4e..7d2508a584 100644
--- a/src/xrpld/overlay/Overlay.h
+++ b/src/xrpld/overlay/Overlay.h
@@ -18,7 +18,7 @@ namespace boost {
 namespace asio {
 namespace ssl {
 class context;
-}
+}  // namespace ssl
 }  // namespace asio
 }  // namespace boost
 
diff --git a/src/xrpld/overlay/Peer.h b/src/xrpld/overlay/Peer.h
index a0e4c040fd..df2cc5bcb7 100644
--- a/src/xrpld/overlay/Peer.h
+++ b/src/xrpld/overlay/Peer.h
@@ -11,7 +11,7 @@ namespace xrpl {
 
 namespace Resource {
 class Charge;
-}
+}  // namespace Resource
 
 enum class ProtocolFeature {
     ValidatorListPropagation,
diff --git a/src/xrpld/overlay/Slot.h b/src/xrpld/overlay/Slot.h
index 11cbd09e36..44a2e7afad 100644
--- a/src/xrpld/overlay/Slot.h
+++ b/src/xrpld/overlay/Slot.h
@@ -374,7 +374,7 @@ Slot<clock_type>::update(
                 if (journal_.trace())
                     str << k << " ";
                 v.state = PeerState::Squelched;
-                std::chrono::seconds duration =
+                std::chrono::seconds const duration =
                     getSquelchDuration(peers_.size() - maxSelectedPeers_);
                 v.expire = now + duration;
                 handler_.squelch(validator, k, duration.count());
diff --git a/src/xrpld/overlay/detail/Cluster.cpp b/src/xrpld/overlay/detail/Cluster.cpp
index 0ee633fb90..72b7ef5147 100644
--- a/src/xrpld/overlay/detail/Cluster.cpp
+++ b/src/xrpld/overlay/detail/Cluster.cpp
@@ -18,7 +18,7 @@ Cluster::Cluster(beast::Journal j) : j_(j)
 std::optional<std::string>
 Cluster::member(PublicKey const& identity) const
 {
-    std::lock_guard lock(mutex_);
+    std::lock_guard const lock(mutex_);
 
     auto iter = nodes_.find(identity);
     if (iter == nodes_.end())
@@ -29,7 +29,7 @@ Cluster::member(PublicKey const& identity) const
 std::size_t
 Cluster::size() const
 {
-    std::lock_guard lock(mutex_);
+    std::lock_guard const lock(mutex_);
 
     return nodes_.size();
 }
@@ -41,7 +41,7 @@ Cluster::update(
     std::uint32_t loadFee,
     NetClock::time_point reportTime)
 {
-    std::lock_guard lock(mutex_);
+    std::lock_guard const lock(mutex_);
 
     auto iter = nodes_.find(identity);
 
@@ -63,7 +63,7 @@ Cluster::update(
 void
 Cluster::for_each(std::function<void(ClusterNode const&)> func) const
 {
-    std::lock_guard lock(mutex_);
+    std::lock_guard const lock(mutex_);
     for (auto const& ni : nodes_)
         func(ni);
 }
diff --git a/src/xrpld/overlay/detail/ConnectAttempt.cpp b/src/xrpld/overlay/detail/ConnectAttempt.cpp
index 406370ff19..40466f19b9 100644
--- a/src/xrpld/overlay/detail/ConnectAttempt.cpp
+++ b/src/xrpld/overlay/detail/ConnectAttempt.cpp
@@ -143,7 +143,7 @@ ConnectAttempt::onShutdown(error_code ec)
         // occur if a peer does not perform a graceful disconnect
         // - broken_pipe: the peer is gone
         // - application data after close notify: benign SSL shutdown condition
-        bool shouldLog =
+        bool const shouldLog =
             (ec != boost::asio::error::eof && ec != boost::asio::error::operation_aborted &&
              ec.message().find("application data after close notify") == std::string::npos);
 
@@ -287,8 +287,8 @@ ConnectAttempt::onTimer(error_code ec)
 
     // Determine which timer expired by checking their expiry times
     auto const now = std::chrono::steady_clock::now();
-    bool globalExpired = (timer_.expiry() <= now);
-    bool stepExpired = (stepTimer_.expiry() <= now);
+    bool const globalExpired = (timer_.expiry() <= now);
+    bool const stepExpired = (stepTimer_.expiry() <= now);
 
     if (globalExpired)
     {
diff --git a/src/xrpld/overlay/detail/Handshake.cpp b/src/xrpld/overlay/detail/Handshake.cpp
index 0992d252b0..f70ec864da 100644
--- a/src/xrpld/overlay/detail/Handshake.cpp
+++ b/src/xrpld/overlay/detail/Handshake.cpp
@@ -23,7 +23,7 @@ getFeatureValue(boost::beast::http::fields const& headers, std::string const& fe
     if (header == headers.end())
         return {};
     boost::smatch match;
-    boost::regex rx(feature + "=([^;\\s]+)");
+    boost::regex const rx(feature + "=([^;\\s]+)");
     std::string const allFeatures(header->value());
     if (boost::regex_search(allFeatures, match, rx))
         return {match[1]};
@@ -107,12 +107,12 @@ hashLastMessage(SSL const* ssl, size_t (*get)(const SSL*, void*, size_t))
     constexpr std::size_t sslMinimumFinishedLength = 12;
 
     unsigned char buf[1024];
-    size_t len = get(ssl, buf, sizeof(buf));
+    size_t const len = get(ssl, buf, sizeof(buf));
 
     if (len < sslMinimumFinishedLength)
         return std::nullopt;
 
-    sha512_hasher h;
+    sha512_hasher const h;
 
     base_uint<512> cookie;
     SHA512(buf, len, cookie.data());
diff --git a/src/xrpld/overlay/detail/Message.cpp b/src/xrpld/overlay/detail/Message.cpp
index 4d043500c7..1f0c6f608d 100644
--- a/src/xrpld/overlay/detail/Message.cpp
+++ b/src/xrpld/overlay/detail/Message.cpp
@@ -202,7 +202,7 @@ Message::getBuffer(Compressed tryCompressed)
 int
 Message::getType(std::uint8_t const* in)
 {
-    int type = (static_cast<int>(*(in + 4)) << 8) + *(in + 5);
+    int const type = (static_cast<int>(*(in + 4)) << 8) + *(in + 5);
     return type;
 }
 
diff --git a/src/xrpld/overlay/detail/OverlayImpl.cpp b/src/xrpld/overlay/detail/OverlayImpl.cpp
index b4b0686ac8..a1edfe4e33 100644
--- a/src/xrpld/overlay/detail/OverlayImpl.cpp
+++ b/src/xrpld/overlay/detail/OverlayImpl.cpp
@@ -36,7 +36,7 @@ enum {
     ServerCounts = (1 << 2),
     Unl = (1 << 3)
 };
-}
+}  // namespace CrawlOptions
 
 //------------------------------------------------------------------------------
 
@@ -152,7 +152,7 @@ OverlayImpl::onHandoff(
     auto const id = next_id_++;
     auto peerJournal = app_.getJournal("Peer");
     beast::WrappedSink sink(peerJournal.sink(), makePrefix(id));
-    beast::Journal journal(sink);
+    beast::Journal const journal(sink);
 
     Handoff handoff;
     if (processRequest(request, handoff))
@@ -270,7 +270,7 @@ OverlayImpl::onHandoff(
             // As we are not on the strand, run() must be called
             // while holding the lock, otherwise new I/O can be
             // queued after a call to stop().
-            std::lock_guard<decltype(mutex_)> lock(mutex_);
+            std::lock_guard<decltype(mutex_)> const lock(mutex_);
             {
                 auto const result = m_peers.emplace(peer->slot(), peer);
                 XRPL_ASSERT(result.second, "xrpl::OverlayImpl::onHandoff : peer is inserted");
@@ -393,7 +393,7 @@ OverlayImpl::connect(beast::IP::Endpoint const& remote_endpoint)
         app_.getJournal("Peer"),
         *this);
 
-    std::lock_guard lock(mutex_);
+    std::lock_guard const lock(mutex_);
     list_.emplace(p.get(), p);
     p->run();
 }
@@ -405,9 +405,9 @@ void
 OverlayImpl::add_active(std::shared_ptr<PeerImp> const& peer)
 {
     beast::WrappedSink sink{journal_.sink(), peer->prefix()};
-    beast::Journal journal{sink};
+    beast::Journal const journal{sink};
 
-    std::lock_guard lock(mutex_);
+    std::lock_guard const lock(mutex_);
 
     {
         auto const result = m_peers.emplace(peer->slot(), peer);
@@ -435,7 +435,7 @@ OverlayImpl::add_active(std::shared_ptr<PeerImp> const& peer)
 void
 OverlayImpl::remove(std::shared_ptr<PeerFinder::Slot> const& slot)
 {
-    std::lock_guard lock(mutex_);
+    std::lock_guard const lock(mutex_);
     auto const iter = m_peers.find(slot);
     XRPL_ASSERT(iter != m_peers.end(), "xrpl::OverlayImpl::remove : valid input");
     m_peers.erase(iter);
@@ -444,7 +444,7 @@ OverlayImpl::remove(std::shared_ptr<PeerFinder::Slot> const& slot)
 void
 OverlayImpl::start()
 {
-    PeerFinder::Config config = PeerFinder::Config::makeConfig(
+    PeerFinder::Config const config = PeerFinder::Config::makeConfig(
         app_.config(),
         serverHandler_.setup().overlay.port(),
         app_.getValidationPublicKey().has_value(),
@@ -522,7 +522,7 @@ OverlayImpl::start()
             });
     }
     auto const timer = std::make_shared<Timer>(*this);
-    std::lock_guard lock(mutex_);
+    std::lock_guard const lock(mutex_);
     list_.emplace(timer.get(), timer);
     timer_ = timer;
     timer->async_wait();
@@ -571,11 +571,11 @@ void
 OverlayImpl::activate(std::shared_ptr<PeerImp> const& peer)
 {
     beast::WrappedSink sink{journal_.sink(), peer->prefix()};
-    beast::Journal journal{sink};
+    beast::Journal const journal{sink};
 
     // Now track this peer
     {
-        std::lock_guard lock(mutex_);
+        std::lock_guard const lock(mutex_);
         auto const result(ids_.emplace(
             std::piecewise_construct, std::make_tuple(peer->id()), std::make_tuple(peer)));
         XRPL_ASSERT(result.second, "xrpl::OverlayImpl::activate : peer ID is inserted");
@@ -591,7 +591,7 @@ OverlayImpl::activate(std::shared_ptr<PeerImp> const& peer)
 void
 OverlayImpl::onPeerDeactivate(Peer::id_t id)
 {
-    std::lock_guard lock(mutex_);
+    std::lock_guard const lock(mutex_);
     ids_.erase(id);
 }
 
@@ -669,7 +669,7 @@ OverlayImpl::reportOutboundTraffic(TrafficCount::category cat, int size)
 std::size_t
 OverlayImpl::size() const
 {
-    std::lock_guard lock(mutex_);
+    std::lock_guard const lock(mutex_);
     return ids_.size();
 }
 
@@ -916,8 +916,8 @@ OverlayImpl::processHealth(http_request_type const& req, Handoff& handoff)
     bool amendment_blocked = false;
     if (info.isMember(jss::amendment_blocked))
         amendment_blocked = true;
-    int number_peers = info[jss::peers].asInt();
-    std::string server_state = info[jss::server_state].asString();
+    int const number_peers = info[jss::peers].asInt();
+    std::string const server_state = info[jss::server_state].asString();
     auto load_factor = info[jss::load_factor_server].asDouble() / info[jss::load_base].asDouble();
 
     enum class HealthState { healthy, warning, critical };
@@ -1028,7 +1028,7 @@ OverlayImpl::getActivePeers(
     std::size_t& enabledInSkip) const
 {
     Overlay::PeerSequence ret;
-    std::lock_guard lock(mutex_);
+    std::lock_guard const lock(mutex_);
 
     active = ids_.size();
     disabled = enabledInSkip = 0;
@@ -1068,7 +1068,7 @@ OverlayImpl::checkTracking(std::uint32_t index)
 std::shared_ptr<Peer>
 OverlayImpl::findPeerByShortID(Peer::id_t const& id) const
 {
-    std::lock_guard lock(mutex_);
+    std::lock_guard const lock(mutex_);
     auto const iter = ids_.find(id);
     if (iter != ids_.end())
         return iter->second.lock();
@@ -1080,7 +1080,7 @@ OverlayImpl::findPeerByShortID(Peer::id_t const& id) const
 std::shared_ptr<Peer>
 OverlayImpl::findPeerByPublicKey(PublicKey const& pubKey)
 {
-    std::lock_guard lock(mutex_);
+    std::lock_guard const lock(mutex_);
     // NOTE The purpose of peer is to delay the destruction of PeerImp
     std::shared_ptr<PeerImp> peer;
     for (auto const& e : ids_)
@@ -1141,7 +1141,7 @@ OverlayImpl::relay(protocol::TMValidation& m, uint256 const& uid, PublicKey cons
 std::shared_ptr<Message>
 OverlayImpl::getManifestsMessage()
 {
-    std::lock_guard g(manifestLock_);
+    std::lock_guard const g(manifestLock_);
 
     if (auto seq = app_.getValidatorManifests().sequence(); seq != manifestListSeq_)
     {
@@ -1260,7 +1260,7 @@ OverlayImpl::relay(
 void
 OverlayImpl::remove(Child& child)
 {
-    std::lock_guard lock(mutex_);
+    std::lock_guard const lock(mutex_);
     list_.erase(&child);
     if (list_.empty())
         cond_.notify_all();
@@ -1279,7 +1279,7 @@ OverlayImpl::stopChildren()
     // won't be called until vector<> children leaves scope.
     std::vector<std::shared_ptr<Child>> children;
     {
-        std::lock_guard lock(mutex_);
+        std::lock_guard const lock(mutex_);
         if (!work_)
             return;
         work_ = std::nullopt;
@@ -1314,7 +1314,7 @@ OverlayImpl::sendEndpoints()
     {
         std::shared_ptr<PeerImp> peer;
         {
-            std::lock_guard lock(mutex_);
+            std::lock_guard const lock(mutex_);
             auto const iter = m_peers.find(e.first);
             if (iter != m_peers.end())
                 peer = iter->second.lock();
diff --git a/src/xrpld/overlay/detail/OverlayImpl.h b/src/xrpld/overlay/detail/OverlayImpl.h
index c816f24e0c..26b5a77371 100644
--- a/src/xrpld/overlay/detail/OverlayImpl.h
+++ b/src/xrpld/overlay/detail/OverlayImpl.h
@@ -255,7 +255,7 @@ public:
     {
         std::vector<std::weak_ptr<PeerImp>> wp;
         {
-            std::lock_guard lock(mutex_);
+            std::lock_guard const lock(mutex_);
 
             // Iterate over a copy of the peer list because peer
             // destruction can invalidate iterators.
@@ -573,7 +573,7 @@ private:
     collect_metrics()
     {
         auto counts = m_traffic.getCounts();
-        std::lock_guard lock(m_statsMutex);
+        std::lock_guard const lock(m_statsMutex);
         XRPL_ASSERT(
             counts.size() == m_stats.trafficGauges.size(),
             "xrpl::OverlayImpl::collect_metrics : counts size do match");
diff --git a/src/xrpld/overlay/detail/PeerImp.cpp b/src/xrpld/overlay/detail/PeerImp.cpp
index 92c5bcb221..13fe0c571c 100644
--- a/src/xrpld/overlay/detail/PeerImp.cpp
+++ b/src/xrpld/overlay/detail/PeerImp.cpp
@@ -172,7 +172,7 @@ PeerImp::run()
         fail("Malformed handshake data (3)");
 
     {
-        std::lock_guard<std::mutex> sl(recentLock_);
+        std::lock_guard<std::mutex> const sl(recentLock_);
         if (closed)
             closedLedgerHash_ = *closed;
         if (previous)
@@ -411,7 +411,7 @@ PeerImp::json()
     ret[jss::protocol] = to_string(protocol_);
 
     {
-        std::lock_guard sl(recentLock_);
+        std::lock_guard const sl(recentLock_);
         if (latency_)
             ret[jss::latency] = static_cast<Json::UInt>(latency_->count());
     }
@@ -443,7 +443,7 @@ PeerImp::json()
     uint256 closedLedgerHash;
     protocol::TMStatusChange last_status;
     {
-        std::lock_guard sl(recentLock_);
+        std::lock_guard const sl(recentLock_);
         closedLedgerHash = closedLedgerHash_;
         last_status = last_status_;
     }
@@ -510,7 +510,7 @@ bool
 PeerImp::hasLedger(uint256 const& hash, std::uint32_t seq) const
 {
     {
-        std::lock_guard sl(recentLock_);
+        std::lock_guard const sl(recentLock_);
         if ((seq != 0) && (seq >= minLedger_) && (seq <= maxLedger_) &&
             (tracking_.load() == Tracking::converged))
             return true;
@@ -523,7 +523,7 @@ PeerImp::hasLedger(uint256 const& hash, std::uint32_t seq) const
 void
 PeerImp::ledgerRange(std::uint32_t& minSeq, std::uint32_t& maxSeq) const
 {
-    std::lock_guard sl(recentLock_);
+    std::lock_guard const sl(recentLock_);
 
     minSeq = minLedger_;
     maxSeq = maxLedger_;
@@ -532,7 +532,7 @@ PeerImp::ledgerRange(std::uint32_t& minSeq, std::uint32_t& maxSeq) const
 bool
 PeerImp::hasTxSet(uint256 const& hash) const
 {
-    std::lock_guard sl(recentLock_);
+    std::lock_guard const sl(recentLock_);
     return std::find(recentTxSets_.begin(), recentTxSets_.end(), hash) != recentTxSets_.end();
 }
 
@@ -541,7 +541,7 @@ PeerImp::cycleStatus()
 {
     // Operations on closedLedgerHash_ and previousLedgerHash_ must be
     // guarded by recentLock_.
-    std::lock_guard sl(recentLock_);
+    std::lock_guard const sl(recentLock_);
     previousLedgerHash_ = closedLedgerHash_;
     closedLedgerHash_.zero();
 }
@@ -549,7 +549,7 @@ PeerImp::cycleStatus()
 bool
 PeerImp::hasRange(std::uint32_t uMin, std::uint32_t uMax)
 {
-    std::lock_guard sl(recentLock_);
+    std::lock_guard const sl(recentLock_);
     return (tracking_ != Tracking::diverged) && (uMin >= minLedger_) && (uMax <= maxLedger_);
 }
 
@@ -641,7 +641,7 @@ PeerImp::onShutdown(error_code ec)
         // - stream_truncated: the tcp connection closed (no handshake) it could
         // occur if a peer does not perform a graceful disconnect
         // - broken_pipe: the peer is gone
-        bool shouldLog =
+        bool const shouldLog =
             (ec != boost::asio::error::eof && ec != boost::asio::error::operation_aborted &&
              ec.message().find("application data after close notify") == std::string::npos);
 
@@ -746,7 +746,7 @@ PeerImp::onTimer(error_code const& ec)
         clock_type::duration duration;
 
         {
-            std::lock_guard sl(recentLock_);
+            std::lock_guard const sl(recentLock_);
             duration = clock_type::now() - trackingTime_;
         }
 
@@ -821,7 +821,7 @@ PeerImp::doAccept()
     if (auto member = app_.getCluster().member(publicKey_))
     {
         {
-            std::unique_lock lock{nameMutex_};
+            std::unique_lock const lock{nameMutex_};
             name_ = *member;
         }
         JLOG(journal_.info()) << "Cluster name: " << *member;
@@ -879,7 +879,7 @@ PeerImp::doAccept()
 std::string
 PeerImp::name() const
 {
-    std::shared_lock read_lock{nameMutex_};
+    std::shared_lock const read_lock{nameMutex_};
     return name_;
 }
 
@@ -1200,7 +1200,7 @@ PeerImp::onMessage(std::shared_ptr<protocol::TMPing> const& m)
             auto const rtt =
                 std::chrono::round<std::chrono::milliseconds>(clock_type::now() - lastPingTime_);
 
-            std::lock_guard sl(recentLock_);
+            std::lock_guard const sl(recentLock_);
 
             if (latency_)
             {
@@ -1246,7 +1246,7 @@ PeerImp::onMessage(std::shared_ptr<protocol::TMCluster> const& m)
         }
     }
 
-    int loadSources = m->loadsources().size();
+    int const loadSources = m->loadsources().size();
     if (loadSources != 0)
     {
         Resource::Gossip gossip;
@@ -1371,7 +1371,7 @@ PeerImp::handleTransaction(
     try
     {
         auto stx = std::make_shared<STTx const>(sit);
-        uint256 txID = stx->getTransactionID();
+        uint256 const txID = stx->getTransactionID();
 
         // Charge strongly for attempting to relay a txn with tfInnerBatchTxn
         // LCOV_EXCL_START
@@ -1581,7 +1581,7 @@ PeerImp::onMessage(std::shared_ptr<protocol::TMGetLedger> const& m)
     }
 
     // Queue a job to process the request
-    std::weak_ptr<PeerImp> weak = shared_from_this();
+    std::weak_ptr<PeerImp> const weak = shared_from_this();
     app_.getJobQueue().addJob(jtLEDGER_REQ, "RcvGetLedger", [weak, m]() {
         if (auto peer = weak.lock())
             peer->processLedgerRequest(m);
@@ -1599,7 +1599,7 @@ PeerImp::onMessage(std::shared_ptr<protocol::TMProofPathRequest> const& m)
     }
 
     fee_.update(Resource::feeModerateBurdenPeer, "received a proof path request");
-    std::weak_ptr<PeerImp> weak = shared_from_this();
+    std::weak_ptr<PeerImp> const weak = shared_from_this();
     app_.getJobQueue().addJob(jtREPLAY_REQ, "RcvProofPReq", [weak, m]() {
         if (auto peer = weak.lock())
         {
@@ -1649,7 +1649,7 @@ PeerImp::onMessage(std::shared_ptr<protocol::TMReplayDeltaRequest> const& m)
     }
 
     fee_.fee = Resource::feeModerateBurdenPeer;
-    std::weak_ptr<PeerImp> weak = shared_from_this();
+    std::weak_ptr<PeerImp> const weak = shared_from_this();
     app_.getJobQueue().addJob(jtREPLAY_REQ, "RcvReplDReq", [weak, m]() {
         if (auto peer = weak.lock())
         {
@@ -1769,7 +1769,7 @@ PeerImp::onMessage(std::shared_ptr<protocol::TMLedgerData> const& m)
     // Otherwise check if received data for a candidate transaction set
     if (m->type() == protocol::liTS_CANDIDATE)
     {
-        std::weak_ptr<PeerImp> weak{shared_from_this()};
+        std::weak_ptr<PeerImp> const weak{shared_from_this()};
         app_.getJobQueue().addJob(jtTXN_DATA, "RcvPeerData", [weak, ledgerHash, m]() {
             if (auto peer = weak.lock())
             {
@@ -1786,7 +1786,7 @@ PeerImp::onMessage(std::shared_ptr<protocol::TMLedgerData> const& m)
 void
 PeerImp::onMessage(std::shared_ptr<protocol::TMProposeSet> const& m)
 {
-    protocol::TMProposeSet& set = *m;
+    protocol::TMProposeSet const& set = *m;
 
     auto const sig = makeSlice(set.signature());
 
@@ -1880,7 +1880,7 @@ PeerImp::onMessage(std::shared_ptr<protocol::TMProposeSet> const& m)
             app_.getTimeKeeper().closeTime(),
             calcNodeID(app_.getValidatorManifests().getMasterKey(publicKey))});
 
-    std::weak_ptr<PeerImp> weak = shared_from_this();
+    std::weak_ptr<PeerImp> const weak = shared_from_this();
     app_.getJobQueue().addJob(
         isTrusted ? jtPROPOSAL_t : jtPROPOSAL_ut, "checkPropose", [weak, isTrusted, m, proposal]() {
             if (auto peer = weak.lock())
@@ -1897,7 +1897,7 @@ PeerImp::onMessage(std::shared_ptr<protocol::TMStatusChange> const& m)
         m->set_networktime(app_.getTimeKeeper().now().time_since_epoch().count());
 
     {
-        std::lock_guard sl(recentLock_);
+        std::lock_guard const sl(recentLock_);
         if (!last_status_.has_newstatus() || m->has_newstatus())
         {
             last_status_ = *m;
@@ -1905,7 +1905,7 @@ PeerImp::onMessage(std::shared_ptr<protocol::TMStatusChange> const& m)
         else
         {
             // preserve old status
-            protocol::NodeStatus status = last_status_.newstatus();
+            protocol::NodeStatus const status = last_status_.newstatus();
             last_status_ = *m;
             m->set_newstatus(status);
         }
@@ -1917,7 +1917,7 @@ PeerImp::onMessage(std::shared_ptr<protocol::TMStatusChange> const& m)
         {
             // Operations on closedLedgerHash_ and previousLedgerHash_ must be
             // guarded by recentLock_.
-            std::lock_guard sl(recentLock_);
+            std::lock_guard const sl(recentLock_);
             if (!closedLedgerHash_.isZero())
             {
                 outOfSync = true;
@@ -1939,7 +1939,7 @@ PeerImp::onMessage(std::shared_ptr<protocol::TMStatusChange> const& m)
         {
             // Operations on closedLedgerHash_ and previousLedgerHash_ must be
             // guarded by recentLock_.
-            std::lock_guard sl(recentLock_);
+            std::lock_guard const sl(recentLock_);
             if (peerChangedLedgers)
             {
                 closedLedgerHash_ = m->ledgerhash();
@@ -1973,7 +1973,7 @@ PeerImp::onMessage(std::shared_ptr<protocol::TMStatusChange> const& m)
 
     if (m->has_firstseq() && m->has_lastseq())
     {
-        std::lock_guard sl(recentLock_);
+        std::lock_guard const sl(recentLock_);
 
         minLedger_ = m->firstseq();
         maxLedger_ = m->lastseq();
@@ -2040,7 +2040,7 @@ PeerImp::onMessage(std::shared_ptr<protocol::TMStatusChange> const& m)
         {
             uint256 closedLedgerHash{};
             {
-                std::lock_guard sl(recentLock_);
+                std::lock_guard const sl(recentLock_);
                 closedLedgerHash = closedLedgerHash_;
             }
             j[jss::ledger_hash] = to_string(closedLedgerHash);
@@ -2068,7 +2068,7 @@ PeerImp::checkTracking(std::uint32_t validationSeq)
     {
         // Extract the sequence number of the highest
         // ledger this peer has
-        std::lock_guard sl(recentLock_);
+        std::lock_guard const sl(recentLock_);
 
         serverSeq = maxLedger_;
     }
@@ -2083,7 +2083,7 @@ PeerImp::checkTracking(std::uint32_t validationSeq)
 void
 PeerImp::checkTracking(std::uint32_t seq1, std::uint32_t seq2)
 {
-    int diff = std::max(seq1, seq2) - std::min(seq1, seq2);
+    int const diff = std::max(seq1, seq2) - std::min(seq1, seq2);
 
     if (diff < Tuning::convergedLedgerLimit)
     {
@@ -2094,7 +2094,7 @@ PeerImp::checkTracking(std::uint32_t seq1, std::uint32_t seq2)
     if ((diff > Tuning::divergedLedgerLimit) && (tracking_.load() != Tracking::diverged))
     {
         // The peer's ledger sequence is way off the validation's
-        std::lock_guard sl(recentLock_);
+        std::lock_guard const sl(recentLock_);
 
         tracking_ = Tracking::diverged;
         trackingTime_ = clock_type::now();
@@ -2114,7 +2114,7 @@ PeerImp::onMessage(std::shared_ptr<protocol::TMHaveTransactionSet> const& m)
 
     if (m->status() == protocol::tsHAVE)
     {
-        std::lock_guard sl(recentLock_);
+        std::lock_guard const sl(recentLock_);
 
         if (std::find(recentTxSets_.begin(), recentTxSets_.end(), hash) != recentTxSets_.end())
         {
@@ -2181,7 +2181,7 @@ PeerImp::onValidatorListMessage(
         case ListDisposition::expired:
         // Future list
         case ListDisposition::pending: {
-            std::lock_guard<std::mutex> sl(recentLock_);
+            std::lock_guard<std::mutex> const sl(recentLock_);
 
             XRPL_ASSERT(
                 applyResult.publisherKey,
@@ -2204,7 +2204,7 @@ PeerImp::onValidatorListMessage(
         case ListDisposition::known_sequence:
 #ifndef NDEBUG
         {
-            std::lock_guard<std::mutex> sl(recentLock_);
+            std::lock_guard<std::mutex> const sl(recentLock_);
             XRPL_ASSERT(
                 applyResult.sequence && applyResult.publisherKey,
                 "xrpl::PeerImp::onValidatorListMessage : nonzero sequence "
@@ -2464,7 +2464,7 @@ PeerImp::onMessage(std::shared_ptr<protocol::TMValidation> const& m)
         {
             std::string const name = isTrusted ? "ChkTrust" : "ChkUntrust";
 
-            std::weak_ptr<PeerImp> weak = shared_from_this();
+            std::weak_ptr<PeerImp> const weak = shared_from_this();
             app_.getJobQueue().addJob(
                 isTrusted ? jtVALIDATION_t : jtVALIDATION_ut, name, [weak, val, m, key]() {
                     if (auto peer = weak.lock())
@@ -2487,7 +2487,7 @@ PeerImp::onMessage(std::shared_ptr<protocol::TMValidation> const& m)
 void
 PeerImp::onMessage(std::shared_ptr<protocol::TMGetObjectByHash> const& m)
 {
-    protocol::TMGetObjectByHash& packet = *m;
+    protocol::TMGetObjectByHash const& packet = *m;
 
     JLOG(p_journal_.trace()) << "received TMGetObjectByHash " << packet.type() << " "
                              << packet.objects_size();
@@ -2516,7 +2516,7 @@ PeerImp::onMessage(std::shared_ptr<protocol::TMGetObjectByHash> const& m)
                 return;
             }
 
-            std::weak_ptr<PeerImp> weak = shared_from_this();
+            std::weak_ptr<PeerImp> const weak = shared_from_this();
             app_.getJobQueue().addJob(jtREQUESTED_TXN, "DoTxs", [weak, m]() {
                 if (auto peer = weak.lock())
                     peer->doTransactions(m);
@@ -2555,7 +2555,7 @@ PeerImp::onMessage(std::shared_ptr<protocol::TMGetObjectByHash> const& m)
                 uint256 const hash{obj.hash()};
                 // VFALCO TODO Move this someplace more sensible so we dont
                 //             need to inject the NodeStore interfaces.
-                std::uint32_t seq{obj.has_ledgerseq() ? obj.ledgerseq() : 0};
+                std::uint32_t const seq{obj.has_ledgerseq() ? obj.ledgerseq() : 0};
                 auto nodeObject{app_.getNodeStore().fetchNodeObject(hash, seq)};
                 if (nodeObject)
                 {
@@ -2651,7 +2651,7 @@ PeerImp::onMessage(std::shared_ptr<protocol::TMHaveTransactions> const& m)
         return;
     }
 
-    std::weak_ptr<PeerImp> weak = shared_from_this();
+    std::weak_ptr<PeerImp> const weak = shared_from_this();
     app_.getJobQueue().addJob(jtMISSING_TXN, "HandleHaveTxs", [weak, m]() {
         if (auto peer = weak.lock())
             peer->handleHaveTransactions(m);
@@ -2750,7 +2750,7 @@ PeerImp::onMessage(std::shared_ptr<protocol::TMSquelch> const& m)
         fee_.update(Resource::feeInvalidData, "squelch bad pubkey");
         return;
     }
-    PublicKey key(slice);
+    PublicKey const key(slice);
 
     // Ignore the squelch for validator's own messages.
     if (key == app_.getValidationPublicKey())
@@ -2759,7 +2759,7 @@ PeerImp::onMessage(std::shared_ptr<protocol::TMSquelch> const& m)
         return;
     }
 
-    std::uint32_t duration = m->has_squelchduration() ? m->squelchduration() : 0;
+    std::uint32_t const duration = m->has_squelchduration() ? m->squelchduration() : 0;
     if (!m->squelch())
     {
         squelch_.removeSquelch(key);
@@ -2812,7 +2812,7 @@ PeerImp::doFetchPack(std::shared_ptr<protocol::TMGetObjectByHash> const& packet)
 
     uint256 const hash{packet->ledgerhash()};
 
-    std::weak_ptr<PeerImp> weak = shared_from_this();
+    std::weak_ptr<PeerImp> const weak = shared_from_this();
     auto elapsed = UptimeClock::now();
     auto const pap = &app_;
     app_.getJobQueue().addJob(jtPACK, "MakeFetchPack", [pap, weak, packet, hash, elapsed]() {
@@ -3017,7 +3017,7 @@ PeerImp::checkPropose(
 
     if (!cluster() && !peerPos.checkSign())
     {
-        std::string desc{"Proposal fails sig check"};
+        std::string const desc{"Proposal fails sig check"};
         JLOG(p_journal_.warn()) << desc;
         charge(Resource::feeInvalidSignature, desc);
         return;
@@ -3061,7 +3061,7 @@ PeerImp::checkValidation(
 {
     if (!val->isValid())
     {
-        std::string desc{"Validation forwarded by peer is invalid"};
+        std::string const desc{"Validation forwarded by peer is invalid"};
         JLOG(p_journal_.debug()) << desc;
         charge(Resource::feeInvalidSignature, desc);
         return;
@@ -3493,7 +3493,7 @@ PeerImp::getScore(bool haveItem) const
 
     std::optional<std::chrono::milliseconds> latency;
     {
-        std::lock_guard sl(recentLock_);
+        std::lock_guard const sl(recentLock_);
         latency = latency_;
     }
 
@@ -3512,7 +3512,7 @@ PeerImp::getScore(bool haveItem) const
 bool
 PeerImp::isHighLatency() const
 {
-    std::lock_guard sl(recentLock_);
+    std::lock_guard const sl(recentLock_);
     return latency_ >= peerHighLatency;
 }
 
@@ -3520,7 +3520,7 @@ void
 PeerImp::Metrics::add_message(std::uint64_t bytes)
 {
     using namespace std::chrono_literals;
-    std::unique_lock lock{mutex_};
+    std::unique_lock const lock{mutex_};
 
     totalBytes_ += bytes;
     accumBytes_ += bytes;
@@ -3543,14 +3543,14 @@ PeerImp::Metrics::add_message(std::uint64_t bytes)
 std::uint64_t
 PeerImp::Metrics::average_bytes() const
 {
-    std::shared_lock lock{mutex_};
+    std::shared_lock const lock{mutex_};
     return rollingAvgBytes_;
 }
 
 std::uint64_t
 PeerImp::Metrics::total_bytes() const
 {
-    std::shared_lock lock{mutex_};
+    std::shared_lock const lock{mutex_};
     return totalBytes_;
 }
 
diff --git a/src/xrpld/overlay/detail/PeerImp.h b/src/xrpld/overlay/detail/PeerImp.h
index 5a687a9b2a..61b8e1e758 100644
--- a/src/xrpld/overlay/detail/PeerImp.h
+++ b/src/xrpld/overlay/detail/PeerImp.h
@@ -428,7 +428,7 @@ public:
     std::optional<std::size_t>
     publisherListSequence(PublicKey const& pubKey) const override
     {
-        std::lock_guard<std::mutex> sl(recentLock_);
+        std::lock_guard<std::mutex> const sl(recentLock_);
 
         auto iter = publisherListSequences_.find(pubKey);
         if (iter != publisherListSequences_.end())
@@ -439,7 +439,7 @@ public:
     void
     setPublisherListSequence(PublicKey const& pubKey, std::size_t const seq) override
     {
-        std::lock_guard<std::mutex> sl(recentLock_);
+        std::lock_guard<std::mutex> const sl(recentLock_);
 
         publisherListSequences_[pubKey] = seq;
     }
diff --git a/src/xrpld/overlay/detail/PeerReservationTable.cpp b/src/xrpld/overlay/detail/PeerReservationTable.cpp
index 78f29ad155..8f90848954 100644
--- a/src/xrpld/overlay/detail/PeerReservationTable.cpp
+++ b/src/xrpld/overlay/detail/PeerReservationTable.cpp
@@ -30,7 +30,7 @@ PeerReservationTable::list() const -> std::vector<PeerReservation>
 {
     std::vector<PeerReservation> list;
     {
-        std::lock_guard lock(mutex_);
+        std::lock_guard const lock(mutex_);
         list.reserve(table_.size());
         std::copy(table_.begin(), table_.end(), std::back_inserter(list));
     }
@@ -47,7 +47,7 @@ PeerReservationTable::list() const -> std::vector<PeerReservation>
 bool
 PeerReservationTable::load(DatabaseCon& connection)
 {
-    std::lock_guard lock(mutex_);
+    std::lock_guard const lock(mutex_);
 
     connection_ = &connection;
     auto db = connection.checkoutDb();
@@ -62,7 +62,7 @@ PeerReservationTable::insert_or_assign(PeerReservation const& reservation)
 {
     std::optional<PeerReservation> previous;
 
-    std::lock_guard lock(mutex_);
+    std::lock_guard const lock(mutex_);
 
     auto hint = table_.find(reservation);
     if (hint != table_.end())
@@ -96,7 +96,7 @@ PeerReservationTable::erase(PublicKey const& nodeId)
 {
     std::optional<PeerReservation> previous;
 
-    std::lock_guard lock(mutex_);
+    std::lock_guard const lock(mutex_);
 
     auto const it = table_.find({nodeId});
     if (it != table_.end())
diff --git a/src/xrpld/overlay/detail/PeerSet.cpp b/src/xrpld/overlay/detail/PeerSet.cpp
index 3329f67e7a..391fb6d3ca 100644
--- a/src/xrpld/overlay/detail/PeerSet.cpp
+++ b/src/xrpld/overlay/detail/PeerSet.cpp
@@ -152,7 +152,7 @@ public:
     std::set<Peer::id_t> const&
     getPeerIds() const override
     {
-        static std::set<Peer::id_t> emptyPeers;
+        static std::set<Peer::id_t> const emptyPeers;
         JLOG(j_.error()) << "DummyPeerSet getPeerIds should not be called";
         return emptyPeers;
     }
diff --git a/src/xrpld/overlay/detail/ProtocolVersion.cpp b/src/xrpld/overlay/detail/ProtocolVersion.cpp
index a8213f2824..1a55030cd4 100644
--- a/src/xrpld/overlay/detail/ProtocolVersion.cpp
+++ b/src/xrpld/overlay/detail/ProtocolVersion.cpp
@@ -58,7 +58,7 @@ to_string(ProtocolVersion const& p)
 std::vector<ProtocolVersion>
 parseProtocolVersions(boost::beast::string_view const& value)
 {
-    static boost::regex re(
+    static boost::regex const re(
         "^"                        // start of line
         "XRPL/"                    // The string "XRPL/"
         "([2-9]|(?:[1-9][0-9]+))"  // a number (greater than 2 with no leading
@@ -112,9 +112,8 @@ negotiateProtocolVersion(std::vector<ProtocolVersion> const& versions)
     // output of std::set_intersection is sorted, that item is always going
     // to be the last one. So we get a little clever and avoid the need for
     // a container:
-    std::function<void(ProtocolVersion const&)> pickVersion = [&result](ProtocolVersion const& v) {
-        result = v;
-    };
+    std::function<void(ProtocolVersion const&)> const pickVersion =
+        [&result](ProtocolVersion const& v) { result = v; };
 
     std::set_intersection(
         std::begin(versions),
diff --git a/src/xrpld/overlay/detail/TxMetrics.cpp b/src/xrpld/overlay/detail/TxMetrics.cpp
index 72cd9d6fa2..ee0e42e5d6 100644
--- a/src/xrpld/overlay/detail/TxMetrics.cpp
+++ b/src/xrpld/overlay/detail/TxMetrics.cpp
@@ -12,7 +12,7 @@ void
 TxMetrics::addMetrics(protocol::MessageType type, std::uint32_t val)
 {
     auto add = [&](auto& m, std::uint32_t val) {
-        std::lock_guard lock(mutex);
+        std::lock_guard const lock(mutex);
         m.addMetrics(val);
     };
 
@@ -41,7 +41,7 @@ TxMetrics::addMetrics(protocol::MessageType type, std::uint32_t val)
 void
 TxMetrics::addMetrics(std::uint32_t selected, std::uint32_t suppressed, std::uint32_t notenabled)
 {
-    std::lock_guard lock(mutex);
+    std::lock_guard const lock(mutex);
     selectedPeers.addMetrics(selected);
     suppressedPeers.addMetrics(suppressed);
     notEnabled.addMetrics(notenabled);
@@ -50,7 +50,7 @@ TxMetrics::addMetrics(std::uint32_t selected, std::uint32_t suppressed, std::uin
 void
 TxMetrics::addMetrics(std::uint32_t missing)
 {
-    std::lock_guard lock(mutex);
+    std::lock_guard const lock(mutex);
     missingTx.addMetrics(missing);
 }
 
@@ -94,7 +94,7 @@ SingleMetrics::addMetrics(std::uint32_t val)
 Json::Value
 TxMetrics::json() const
 {
-    std::lock_guard l(mutex);
+    std::lock_guard const l(mutex);
 
     Json::Value ret(Json::objectValue);
 
diff --git a/src/xrpld/peerfinder/detail/Checker.h b/src/xrpld/peerfinder/detail/Checker.h
index 3e67754db9..ccc395f053 100644
--- a/src/xrpld/peerfinder/detail/Checker.h
+++ b/src/xrpld/peerfinder/detail/Checker.h
@@ -154,7 +154,7 @@ template <class Protocol>
 void
 Checker<Protocol>::stop()
 {
-    std::lock_guard lock(mutex_);
+    std::lock_guard const lock(mutex_);
     if (!stop_)
     {
         stop_ = true;
@@ -180,7 +180,7 @@ Checker<Protocol>::async_connect(beast::IP::Endpoint const& endpoint, Handler&&
     auto const op =
         std::make_shared<async_op<Handler>>(*this, io_context_, std::forward<Handler>(handler));
     {
-        std::lock_guard lock(mutex_);
+        std::lock_guard const lock(mutex_);
         list_.push_back(*op);
     }
     op->socket_.async_connect(
@@ -192,7 +192,7 @@ template <class Protocol>
 void
 Checker<Protocol>::remove(basic_async_op& op)
 {
-    std::lock_guard lock(mutex_);
+    std::lock_guard const lock(mutex_);
     list_.erase(list_.iterator_to(op));
     if (list_.size() == 0)
         cond_.notify_all();
diff --git a/src/xrpld/peerfinder/detail/Logic.h b/src/xrpld/peerfinder/detail/Logic.h
index 8f49da6c4f..ad0a2f8b96 100644
--- a/src/xrpld/peerfinder/detail/Logic.h
+++ b/src/xrpld/peerfinder/detail/Logic.h
@@ -106,7 +106,7 @@ public:
     void
     load()
     {
-        std::lock_guard _(lock_);
+        std::lock_guard const _(lock_);
         bootcache_.load();
     }
 
@@ -119,7 +119,7 @@ public:
     void
     stop()
     {
-        std::lock_guard _(lock_);
+        std::lock_guard const _(lock_);
         stopping_ = true;
         if (fetchSource_ != nullptr)
             fetchSource_->cancel();
@@ -134,7 +134,7 @@ public:
     void
     config(Config const& c)
     {
-        std::lock_guard _(lock_);
+        std::lock_guard const _(lock_);
         config_ = c;
         counts_.onConfig(config_);
     }
@@ -142,7 +142,7 @@ public:
     Config
     config()
     {
-        std::lock_guard _(lock_);
+        std::lock_guard const _(lock_);
         return config_;
     }
 
@@ -155,7 +155,7 @@ public:
     void
     addFixedPeer(std::string const& name, std::vector<beast::IP::Endpoint> const& addresses)
     {
-        std::lock_guard _(lock_);
+        std::lock_guard const _(lock_);
 
         if (addresses.empty())
         {
@@ -197,7 +197,7 @@ public:
         if (ec == boost::asio::error::operation_aborted)
             return;
 
-        std::lock_guard _(lock_);
+        std::lock_guard const _(lock_);
         auto const iter(slots_.find(remoteAddress));
         if (iter == slots_.end())
         {
@@ -212,7 +212,7 @@ public:
         slot.connectivityCheckInProgress = false;
 
         beast::WrappedSink sink{m_journal.sink(), slot.prefix()};
-        beast::Journal journal{sink};
+        beast::Journal const journal{sink};
 
         if (ec)
         {
@@ -239,7 +239,7 @@ public:
         JLOG(m_journal.debug()) << beast::leftw(18) << "Logic accept" << remote_endpoint
                                 << " on local " << local_endpoint;
 
-        std::lock_guard _(lock_);
+        std::lock_guard const _(lock_);
 
         // Check for connection limit per address
         if (is_public(remote_endpoint))
@@ -287,7 +287,7 @@ public:
     {
         JLOG(m_journal.debug()) << beast::leftw(18) << "Logic connect " << remote_endpoint;
 
-        std::lock_guard _(lock_);
+        std::lock_guard const _(lock_);
 
         // Check for duplicate connection
         if (slots_.find(remote_endpoint) != slots_.end())
@@ -322,11 +322,11 @@ public:
     onConnected(SlotImp::ptr const& slot, beast::IP::Endpoint const& local_endpoint)
     {
         beast::WrappedSink sink{m_journal.sink(), slot->prefix()};
-        beast::Journal journal{sink};
+        beast::Journal const journal{sink};
 
         JLOG(journal.trace()) << "Logic connected on local " << local_endpoint;
 
-        std::lock_guard _(lock_);
+        std::lock_guard const _(lock_);
 
         // The object must exist in our table
         XRPL_ASSERT(
@@ -360,12 +360,12 @@ public:
     activate(SlotImp::ptr const& slot, PublicKey const& key, bool reserved)
     {
         beast::WrappedSink sink{m_journal.sink(), slot->prefix()};
-        beast::Journal journal{sink};
+        beast::Journal const journal{sink};
 
         JLOG(journal.debug()) << "Logic handshake " << slot->remote_endpoint() << " with "
                               << (reserved ? "reserved " : "") << "key " << key;
 
-        std::lock_guard _(lock_);
+        std::lock_guard const _(lock_);
 
         // The object must exist in our table
         XRPL_ASSERT(
@@ -436,7 +436,7 @@ public:
     std::vector<Endpoint>
     redirect(SlotImp::ptr const& slot)
     {
-        std::lock_guard _(lock_);
+        std::lock_guard const _(lock_);
         RedirectHandouts h(slot);
         livecache_.hops.shuffle();
         handout(&h, (&h) + 1, livecache_.hops.begin(), livecache_.hops.end());
@@ -454,7 +454,7 @@ public:
     {
         std::vector<beast::IP::Endpoint> none;
 
-        std::lock_guard _(lock_);
+        std::lock_guard const _(lock_);
 
         // Count how many more outbound attempts to make
         //
@@ -560,7 +560,7 @@ public:
     {
         std::vector<std::pair<std::shared_ptr<Slot>, std::vector<Endpoint>>> result;
 
-        std::lock_guard _(lock_);
+        std::lock_guard const _(lock_);
 
         clock_type::time_point const now = m_clock.now();
         if (m_whenBroadcast <= now)
@@ -624,7 +624,7 @@ public:
                 SlotImp::ptr const& slot = t.slot();
                 auto const& list = t.list();
                 beast::WrappedSink sink{m_journal.sink(), slot->prefix()};
-                beast::Journal journal{sink};
+                beast::Journal const journal{sink};
                 JLOG(journal.trace()) << "Logic sending " << list.size()
                                       << ((list.size() == 1) ? " endpoint" : " endpoints");
                 result.push_back(std::make_pair(slot, list));
@@ -639,7 +639,7 @@ public:
     void
     once_per_second()
     {
-        std::lock_guard _(lock_);
+        std::lock_guard const _(lock_);
 
         // Expire the Livecache
         livecache_.expire();
@@ -725,7 +725,7 @@ public:
     on_endpoints(SlotImp::ptr const& slot, Endpoints list)
     {
         beast::WrappedSink sink{m_journal.sink(), slot->prefix()};
-        beast::Journal journal{sink};
+        beast::Journal const journal{sink};
 
         // If we're sent too many endpoints, sample them at random:
         if (list.size() > Tuning::numberOfEndpointsMax)
@@ -737,7 +737,7 @@ public:
         JLOG(journal.trace()) << "Endpoints contained " << list.size()
                               << ((list.size() > 1) ? " entries" : " entry");
 
-        std::lock_guard _(lock_);
+        std::lock_guard const _(lock_);
 
         // The object must exist in our table
         XRPL_ASSERT(
@@ -863,12 +863,12 @@ public:
     void
     on_closed(SlotImp::ptr const& slot)
     {
-        std::lock_guard _(lock_);
+        std::lock_guard const _(lock_);
 
         remove(slot);
 
         beast::WrappedSink sink{m_journal.sink(), slot->prefix()};
-        beast::Journal journal{sink};
+        beast::Journal const journal{sink};
 
         // Mark fixed slot failure
         if (slot->fixed() && !slot->inbound() && slot->state() != Slot::active)
@@ -921,7 +921,7 @@ public:
     void
     on_failure(SlotImp::ptr const& slot)
     {
-        std::lock_guard _(lock_);
+        std::lock_guard const _(lock_);
 
         bootcache_.on_failure(slot->remote_endpoint());
     }
@@ -1010,7 +1010,7 @@ public:
     addBootcacheAddresses(IPAddresses const& list)
     {
         int count(0);
-        std::lock_guard _(lock_);
+        std::lock_guard const _(lock_);
         for (auto const& addr : list)
         {
             if (bootcache_.insertStatic(addr))
@@ -1027,7 +1027,7 @@ public:
 
         {
             {
-                std::lock_guard _(lock_);
+                std::lock_guard const _(lock_);
                 if (stopping_)
                     return;
                 fetchSource_ = source;
@@ -1039,7 +1039,7 @@ public:
             source->fetch(results, m_journal);
 
             {
-                std::lock_guard _(lock_);
+                std::lock_guard const _(lock_);
                 if (stopping_)
                     return;
                 fetchSource_ = nullptr;
@@ -1110,7 +1110,7 @@ public:
     void
     onWrite(beast::PropertyStream::Map& map)
     {
-        std::lock_guard _(lock_);
+        std::lock_guard const _(lock_);
 
         // VFALCO NOTE These ugly casts are needed because
         //             of how std::size_t is declared on some linuxes
@@ -1188,7 +1188,7 @@ Logic<Checker>::onRedirects(
     FwdIter last,
     boost::asio::ip::tcp::endpoint const& remote_address)
 {
-    std::lock_guard _(lock_);
+    std::lock_guard const _(lock_);
     std::size_t n = 0;
     for (; first != last && n < Tuning::maxRedirects; ++first, ++n)
         bootcache_.insert(beast::IPAddressConversion::from_asio(*first));
diff --git a/src/xrpld/peerfinder/detail/PeerfinderConfig.cpp b/src/xrpld/peerfinder/detail/PeerfinderConfig.cpp
index 4de03c6ca6..a94dbdfbd9 100644
--- a/src/xrpld/peerfinder/detail/PeerfinderConfig.cpp
+++ b/src/xrpld/peerfinder/detail/PeerfinderConfig.cpp
@@ -23,7 +23,7 @@ operator==(Config const& lhs, Config const& rhs)
     return lhs.autoConnect == rhs.autoConnect && lhs.peerPrivate == rhs.peerPrivate &&
         lhs.wantIncoming == rhs.wantIncoming && lhs.inPeers == rhs.inPeers &&
         lhs.maxPeers == rhs.maxPeers && lhs.outPeers == rhs.outPeers &&
-        lhs.features == lhs.features && lhs.ipLimit == rhs.ipLimit &&
+        lhs.features == rhs.features && lhs.ipLimit == rhs.ipLimit &&
         lhs.listeningPort == rhs.listeningPort;
 }
 
diff --git a/src/xrpld/peerfinder/detail/PeerfinderManager.cpp b/src/xrpld/peerfinder/detail/PeerfinderManager.cpp
index 70f082c0d5..e9c42b7eb5 100644
--- a/src/xrpld/peerfinder/detail/PeerfinderManager.cpp
+++ b/src/xrpld/peerfinder/detail/PeerfinderManager.cpp
@@ -117,21 +117,21 @@ public:
     void
     on_endpoints(std::shared_ptr<Slot> const& slot, Endpoints const& endpoints) override
     {
-        SlotImp::ptr impl(std::dynamic_pointer_cast<SlotImp>(slot));
+        SlotImp::ptr const impl(std::dynamic_pointer_cast<SlotImp>(slot));
         m_logic.on_endpoints(impl, endpoints);
     }
 
     void
     on_closed(std::shared_ptr<Slot> const& slot) override
     {
-        SlotImp::ptr impl(std::dynamic_pointer_cast<SlotImp>(slot));
+        SlotImp::ptr const impl(std::dynamic_pointer_cast<SlotImp>(slot));
         m_logic.on_closed(impl);
     }
 
     void
     on_failure(std::shared_ptr<Slot> const& slot) override
     {
-        SlotImp::ptr impl(std::dynamic_pointer_cast<SlotImp>(slot));
+        SlotImp::ptr const impl(std::dynamic_pointer_cast<SlotImp>(slot));
         m_logic.on_failure(impl);
     }
 
@@ -149,21 +149,21 @@ public:
     onConnected(std::shared_ptr<Slot> const& slot, beast::IP::Endpoint const& local_endpoint)
         override
     {
-        SlotImp::ptr impl(std::dynamic_pointer_cast<SlotImp>(slot));
+        SlotImp::ptr const impl(std::dynamic_pointer_cast<SlotImp>(slot));
         return m_logic.onConnected(impl, local_endpoint);
     }
 
     Result
     activate(std::shared_ptr<Slot> const& slot, PublicKey const& key, bool reserved) override
     {
-        SlotImp::ptr impl(std::dynamic_pointer_cast<SlotImp>(slot));
+        SlotImp::ptr const impl(std::dynamic_pointer_cast<SlotImp>(slot));
         return m_logic.activate(impl, key, reserved);
     }
 
     std::vector<Endpoint>
     redirect(std::shared_ptr<Slot> const& slot) override
     {
-        SlotImp::ptr impl(std::dynamic_pointer_cast<SlotImp>(slot));
+        SlotImp::ptr const impl(std::dynamic_pointer_cast<SlotImp>(slot));
         return m_logic.redirect(impl);
     }
 
@@ -226,7 +226,7 @@ private:
     void
     collect_metrics()
     {
-        std::lock_guard lock(m_statsMutex);
+        std::lock_guard const lock(m_statsMutex);
         m_stats.activeInboundPeers = m_logic.counts_.inboundActive();
         m_stats.activeOutboundPeers = m_logic.counts_.out_active();
     }
diff --git a/src/xrpld/perflog/detail/PerfLogImp.cpp b/src/xrpld/perflog/detail/PerfLogImp.cpp
index 960fdcb3ac..266c99a147 100644
--- a/src/xrpld/perflog/detail/PerfLogImp.cpp
+++ b/src/xrpld/perflog/detail/PerfLogImp.cpp
@@ -69,7 +69,7 @@ PerfLogImp::Counters::countersJson() const
     {
         Rpc value;
         {
-            std::lock_guard lock(proc.second.mutex);
+            std::lock_guard const lock(proc.second.mutex);
             if ((proc.second.value.started == 0u) && (proc.second.value.finished == 0u) &&
                 (proc.second.value.errored == 0u))
             {
@@ -107,7 +107,7 @@ PerfLogImp::Counters::countersJson() const
     {
         Jq value;
         {
-            std::lock_guard lock(proc.second.mutex);
+            std::lock_guard const lock(proc.second.mutex);
             if ((proc.second.value.queued == 0u) && (proc.second.value.started == 0u) &&
                 (proc.second.value.finished == 0u))
             {
@@ -156,7 +156,7 @@ PerfLogImp::Counters::currentJson() const
 
     Json::Value jobsArray(Json::arrayValue);
     auto const jobs = [this] {
-        std::lock_guard lock(jobsMutex_);
+        std::lock_guard const lock(jobsMutex_);
         return jobs_;
     }();
 
@@ -174,7 +174,7 @@ PerfLogImp::Counters::currentJson() const
     Json::Value methodsArray(Json::arrayValue);
     std::vector<MethodStart> methods;
     {
-        std::lock_guard lock(methodsMutex_);
+        std::lock_guard const lock(methodsMutex_);
         methods.reserve(methods_.size());
         for (auto const& m : methods_)
             methods.push_back(m.second);
@@ -270,7 +270,7 @@ PerfLogImp::report()
     Json::Value report(Json::objectValue);
     report[jss::time] = to_string(std::chrono::floor<microseconds>(present));
     {
-        std::lock_guard lock{counters_.jobsMutex_};
+        std::lock_guard const lock{counters_.jobsMutex_};
         report[jss::workers] = static_cast<unsigned int>(counters_.jobs_.size());
     }
     report[jss::hostid] = hostname_;
@@ -311,10 +311,10 @@ PerfLogImp::rpcStart(std::string const& method, std::uint64_t const requestId)
     }
 
     {
-        std::lock_guard lock(counter->second.mutex);
+        std::lock_guard const lock(counter->second.mutex);
         ++counter->second.value.started;
     }
-    std::lock_guard lock(counters_.methodsMutex_);
+    std::lock_guard const lock(counters_.methodsMutex_);
     counters_.methods_[requestId] = {counter->first.c_str(), steady_clock::now()};
 }
 
@@ -331,7 +331,7 @@ PerfLogImp::rpcEnd(std::string const& method, std::uint64_t const requestId, boo
     }
     steady_time_point startTime;
     {
-        std::lock_guard lock(counters_.methodsMutex_);
+        std::lock_guard const lock(counters_.methodsMutex_);
         auto const e = counters_.methods_.find(requestId);
         if (e != counters_.methods_.end())
         {
@@ -345,7 +345,7 @@ PerfLogImp::rpcEnd(std::string const& method, std::uint64_t const requestId, boo
             // LCOV_EXCL_STOP
         }
     }
-    std::lock_guard lock(counter->second.mutex);
+    std::lock_guard const lock(counter->second.mutex);
     if (finish)
     {
         ++counter->second.value.finished;
@@ -369,7 +369,7 @@ PerfLogImp::jobQueue(JobType const type)
         return;
         // LCOV_EXCL_STOP
     }
-    std::lock_guard lock(counter->second.mutex);
+    std::lock_guard const lock(counter->second.mutex);
     ++counter->second.value.queued;
 }
 
@@ -390,11 +390,11 @@ PerfLogImp::jobStart(
     }
 
     {
-        std::lock_guard lock(counter->second.mutex);
+        std::lock_guard const lock(counter->second.mutex);
         ++counter->second.value.started;
         counter->second.value.queuedDuration += dur;
     }
-    std::lock_guard lock(counters_.jobsMutex_);
+    std::lock_guard const lock(counters_.jobsMutex_);
     if (instance >= 0 && instance < counters_.jobs_.size())
         counters_.jobs_[instance] = {type, startTime};
 }
@@ -412,11 +412,11 @@ PerfLogImp::jobFinish(JobType const type, microseconds dur, int instance)
     }
 
     {
-        std::lock_guard lock(counter->second.mutex);
+        std::lock_guard const lock(counter->second.mutex);
         ++counter->second.value.finished;
         counter->second.value.runningDuration += dur;
     }
-    std::lock_guard lock(counters_.jobsMutex_);
+    std::lock_guard const lock(counters_.jobsMutex_);
     if (instance >= 0 && instance < counters_.jobs_.size())
         counters_.jobs_[instance] = {jtINVALID, steady_time_point()};
 }
@@ -424,7 +424,7 @@ PerfLogImp::jobFinish(JobType const type, microseconds dur, int instance)
 void
 PerfLogImp::resizeJobs(int const resize)
 {
-    std::lock_guard lock(counters_.jobsMutex_);
+    std::lock_guard const lock(counters_.jobsMutex_);
     if (resize > counters_.jobs_.size())
         counters_.jobs_.resize(resize, {jtINVALID, steady_time_point()});
 }
@@ -435,7 +435,7 @@ PerfLogImp::rotate()
     if (setup_.perfLog.empty())
         return;
 
-    std::lock_guard lock(mutex_);
+    std::lock_guard const lock(mutex_);
     rotate_ = true;
     cond_.notify_one();
 }
@@ -453,7 +453,7 @@ PerfLogImp::stop()
     if (thread_.joinable())
     {
         {
-            std::lock_guard lock(mutex_);
+            std::lock_guard const lock(mutex_);
             stop_ = true;
             cond_.notify_one();
         }
diff --git a/src/xrpld/rpc/BookChanges.h b/src/xrpld/rpc/BookChanges.h
index b2b1ae793b..a318c80221 100644
--- a/src/xrpld/rpc/BookChanges.h
+++ b/src/xrpld/rpc/BookChanges.h
@@ -11,7 +11,7 @@
 
 namespace Json {
 class Value;
-}
+}  // namespace Json
 
 namespace xrpl {
 
@@ -44,7 +44,7 @@ computeBookChanges(std::shared_ptr<L const> const& lpAccepted)
             continue;
 
         std::optional<uint32_t> offerCancel;
-        uint16_t tt = tx.first->getFieldU16(sfTransactionType);
+        uint16_t const tt = tx.first->getFieldU16(sfTransactionType);
         switch (tt)
         {
             case ttOFFER_CANCEL:
@@ -62,7 +62,7 @@ computeBookChanges(std::shared_ptr<L const> const& lpAccepted)
         for (auto const& node : tx.second->getFieldArray(sfAffectedNodes))
         {
             SField const& metaType = node.getFName();
-            uint16_t nodeType = node.getFieldU16(sfLedgerEntryType);
+            uint16_t const nodeType = node.getFieldU16(sfLedgerEntryType);
 
             // we only care about ltOFFER objects being modified or
             // deleted
@@ -94,13 +94,13 @@ computeBookChanges(std::shared_ptr<L const> const& lpAccepted)
 
             // compute the difference in gets and pays actually
             // affected onto the offer
-            STAmount deltaGets = finalFields.getFieldAmount(sfTakerGets) -
+            STAmount const deltaGets = finalFields.getFieldAmount(sfTakerGets) -
                 previousFields.getFieldAmount(sfTakerGets);
-            STAmount deltaPays = finalFields.getFieldAmount(sfTakerPays) -
+            STAmount const deltaPays = finalFields.getFieldAmount(sfTakerPays) -
                 previousFields.getFieldAmount(sfTakerPays);
 
-            std::string g{to_string(deltaGets.issue())};
-            std::string p{to_string(deltaPays.issue())};
+            std::string const g{to_string(deltaGets.issue())};
+            std::string const p{to_string(deltaPays.issue())};
 
             bool const noswap = isXRP(deltaGets) ? true : (isXRP(deltaPays) ? false : (g < p));
 
@@ -111,7 +111,7 @@ computeBookChanges(std::shared_ptr<L const> const& lpAccepted)
             if (second == beast::zero)
                 continue;
 
-            STAmount rate = divide(first, second, noIssue());
+            STAmount const rate = divide(first, second, noIssue());
 
             if (first < beast::zero)
                 first = -first;
@@ -125,9 +125,9 @@ computeBookChanges(std::shared_ptr<L const> const& lpAccepted)
             else
                 ss << p << "|" << g;
 
-            std::optional<uint256> domain = finalFields[~sfDomainID];
+            std::optional<uint256> const domain = finalFields[~sfDomainID];
 
-            std::string key{ss.str()};
+            std::string const key{ss.str()};
 
             if (tally.find(key) == tally.end())
                 tally[key] = {
@@ -174,8 +174,8 @@ computeBookChanges(std::shared_ptr<L const> const& lpAccepted)
     {
         Json::Value& inner = jvObj[jss::changes].append(Json::objectValue);
 
-        STAmount volA = std::get<0>(entry.second);
-        STAmount volB = std::get<1>(entry.second);
+        STAmount const volA = std::get<0>(entry.second);
+        STAmount const volB = std::get<1>(entry.second);
 
         inner[jss::currency_a] = (isXRP(volA) ? "XRP_drops" : to_string(volA.issue()));
         inner[jss::currency_b] = (isXRP(volB) ? "XRP_drops" : to_string(volB.issue()));
diff --git a/src/xrpld/rpc/CTID.h b/src/xrpld/rpc/CTID.h
index cbae1f4498..42efb4c157 100644
--- a/src/xrpld/rpc/CTID.h
+++ b/src/xrpld/rpc/CTID.h
@@ -39,7 +39,7 @@ encodeCTID(uint32_t ledgerSeq, uint32_t txnIndex, uint32_t networkID) noexcept
     if (ledgerSeq > maxLedgerSeq || txnIndex > maxTxnIndex || networkID > maxNetworkID)
         return std::nullopt;
 
-    uint64_t ctidValue = ((0xC000'0000ULL + static_cast<uint64_t>(ledgerSeq)) << 32) |
+    uint64_t const ctidValue = ((0xC000'0000ULL + static_cast<uint64_t>(ledgerSeq)) << 32) |
         ((static_cast<uint64_t>(txnIndex) << 16) | networkID);
 
     std::stringstream buffer;
@@ -101,9 +101,9 @@ decodeCTID(T const ctid) noexcept
     if ((ctidValue & ctidPrefixMask) != ctidPrefix)
         return std::nullopt;
 
-    uint32_t ledgerSeq = static_cast<uint32_t>((ctidValue >> 32) & 0x0FFF'FFFF);
-    uint16_t txnIndex = static_cast<uint16_t>((ctidValue >> 16) & 0xFFFF);
-    uint16_t 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/DeliveredAmount.h b/src/xrpld/rpc/DeliveredAmount.h
index c882190ade..65f11e9736 100644
--- a/src/xrpld/rpc/DeliveredAmount.h
+++ b/src/xrpld/rpc/DeliveredAmount.h
@@ -8,7 +8,7 @@
 
 namespace Json {
 class Value;
-}
+}  // namespace Json
 
 namespace xrpl {
 
diff --git a/src/xrpld/rpc/detail/Handler.h b/src/xrpld/rpc/detail/Handler.h
index 908cb67750..3628962a69 100644
--- a/src/xrpld/rpc/detail/Handler.h
+++ b/src/xrpld/rpc/detail/Handler.h
@@ -10,7 +10,7 @@
 
 namespace Json {
 class Object;
-}
+}  // namespace Json
 
 namespace xrpl {
 namespace RPC {
diff --git a/src/xrpld/rpc/detail/PathRequest.cpp b/src/xrpld/rpc/detail/PathRequest.cpp
index f02377381c..fe85c519eb 100644
--- a/src/xrpld/rpc/detail/PathRequest.cpp
+++ b/src/xrpld/rpc/detail/PathRequest.cpp
@@ -92,7 +92,7 @@ PathRequest::~PathRequest()
 bool
 PathRequest::isNew()
 {
-    std::lock_guard sl(mIndexLock);
+    std::lock_guard const sl(mIndexLock);
 
     // does this path request still need its first full path
     return mLastIndex == 0;
@@ -101,7 +101,7 @@ PathRequest::isNew()
 bool
 PathRequest::needsUpdate(bool newOnly, LedgerIndex index)
 {
-    std::lock_guard sl(mIndexLock);
+    std::lock_guard const sl(mIndexLock);
 
     if (mInProgress)
     {
@@ -133,7 +133,7 @@ PathRequest::hasCompletion()
 void
 PathRequest::updateComplete()
 {
-    std::lock_guard sl(mIndexLock);
+    std::lock_guard const sl(mIndexLock);
 
     XRPL_ASSERT(mInProgress, "xrpl::PathRequest::updateComplete : in progress");
     mInProgress = false;
@@ -416,7 +416,7 @@ Json::Value
 PathRequest::doClose()
 {
     JLOG(m_journal.debug()) << iIdentifier << " closed";
-    std::lock_guard sl(mLock);
+    std::lock_guard const sl(mLock);
     jvStatus[jss::closed] = true;
     return jvStatus;
 }
@@ -424,7 +424,7 @@ PathRequest::doClose()
 Json::Value
 PathRequest::doStatus(Json::Value const&)
 {
-    std::lock_guard sl(mLock);
+    std::lock_guard const sl(mLock);
     jvStatus[jss::status] = jss::success;
     return jvStatus;
 }
@@ -527,7 +527,7 @@ PathRequest::findPaths(
             return *raSrcAccount;
         }();
 
-        STAmount saMaxAmount =
+        STAmount const saMaxAmount =
             saSendMax.value_or(STAmount(Issue{issue.currency, sourceAccount}, 1u, 0, true));
 
         JLOG(m_journal.debug()) << iIdentifier << " Paths found, calling rippleCalc";
@@ -622,7 +622,7 @@ PathRequest::doUpdate(
     JLOG(m_journal.debug()) << iIdentifier << " update " << (fast ? "fast" : "normal");
 
     {
-        std::lock_guard sl(mLock);
+        std::lock_guard const sl(mLock);
 
         if (!isValid(cache))
             return jvStatus;
@@ -647,7 +647,7 @@ PathRequest::doUpdate(
     if (jvId)
         newStatus[jss::id] = jvId;
 
-    bool loaded = app_.getFeeTrack().isLoadedLocal();
+    bool const loaded = app_.getFeeTrack().isLoadedLocal();
 
     if (iLevel == 0)
     {
@@ -710,7 +710,7 @@ PathRequest::doUpdate(
     }
 
     {
-        std::lock_guard sl(mLock);
+        std::lock_guard const sl(mLock);
         jvStatus = newStatus;
     }
 
diff --git a/src/xrpld/rpc/detail/PathRequestManager.cpp b/src/xrpld/rpc/detail/PathRequestManager.cpp
index e953f1ca70..4455e304e5 100644
--- a/src/xrpld/rpc/detail/PathRequestManager.cpp
+++ b/src/xrpld/rpc/detail/PathRequestManager.cpp
@@ -17,7 +17,7 @@ namespace xrpl {
 std::shared_ptr<RippleLineCache>
 PathRequestManager::getLineCache(std::shared_ptr<ReadView const> const& ledger, bool authoritative)
 {
-    std::lock_guard sl(mLock);
+    std::lock_guard const sl(mLock);
 
     auto lineCache = lineCache_.lock();
 
@@ -51,7 +51,7 @@ PathRequestManager::updateAll(std::shared_ptr<ReadView const> const& inLedger)
 
     // Get the ledger and cache we should be using
     {
-        std::lock_guard sl(mLock);
+        std::lock_guard const sl(mLock);
         requests = requests_;
         cache = getLineCache(inLedger, true);
     }
@@ -130,7 +130,7 @@ PathRequestManager::updateAll(std::shared_ptr<ReadView const> const& inLedger)
 
             if (remove)
             {
-                std::lock_guard sl(mLock);
+                std::lock_guard const sl(mLock);
 
                 // Remove any dangling weak pointers or weak
                 // pointers that refer to this path request.
@@ -175,7 +175,7 @@ PathRequestManager::updateAll(std::shared_ptr<ReadView const> const& inLedger)
         std::shared_ptr<RippleLineCache> lastCache;
         {
             // Get the latest requests, cache, and ledger for next pass
-            std::lock_guard sl(mLock);
+            std::lock_guard const sl(mLock);
 
             if (requests_.empty())
                 break;
@@ -192,14 +192,14 @@ PathRequestManager::updateAll(std::shared_ptr<ReadView const> const& inLedger)
 bool
 PathRequestManager::requestsPending() const
 {
-    std::lock_guard sl(mLock);
+    std::lock_guard const sl(mLock);
     return !requests_.empty();
 }
 
 void
 PathRequestManager::insertPathRequest(PathRequest::pointer const& req)
 {
-    std::lock_guard sl(mLock);
+    std::lock_guard const sl(mLock);
 
     // Insert after any older unserviced requests but before
     // any serviced requests
diff --git a/src/xrpld/rpc/detail/Pathfinder.cpp b/src/xrpld/rpc/detail/Pathfinder.cpp
index 176c7f9529..4749caaccb 100644
--- a/src/xrpld/rpc/detail/Pathfinder.cpp
+++ b/src/xrpld/rpc/detail/Pathfinder.cpp
@@ -206,7 +206,7 @@ Pathfinder::findPaths(int searchLevel, std::function<bool(void)> const& continue
     m_loadEvent = app_.getJobQueue().makeLoadEvent(jtPATH_FIND, "FindPath");
     auto currencyIsXRP = isXRP(mSrcCurrency);
 
-    bool useIssuerAccount = mSrcIssuer && !currencyIsXRP && !isXRP(*mSrcIssuer);
+    bool const useIssuerAccount = mSrcIssuer && !currencyIsXRP && !isXRP(*mSrcIssuer);
     auto& account = useIssuerAccount ? *mSrcIssuer : mSrcAccount;
     auto issuer = currencyIsXRP ? AccountID() : account;
     mSource = STPathElement(account, mSrcCurrency, issuer);
@@ -222,8 +222,8 @@ Pathfinder::findPaths(int searchLevel, std::function<bool(void)> const& continue
         return false;
     }
 
-    bool bSrcXrp = isXRP(mSrcCurrency);
-    bool bDstXrp = isXRP(mDstAmount.getCurrency());
+    bool const bSrcXrp = isXRP(mSrcCurrency);
+    bool const bDstXrp = isXRP(mDstAmount.getCurrency());
 
     if (!mLedger->exists(keylet::account(mSrcAccount)))
     {
@@ -674,9 +674,9 @@ Pathfinder::getBestPaths(
 bool
 Pathfinder::issueMatchesOrigin(Issue const& issue)
 {
-    bool matchingCurrency = (issue.currency == mSrcCurrency);
-    bool matchingAccount = isXRP(issue.currency) || (mSrcIssuer && issue.account == mSrcIssuer) ||
-        issue.account == mSrcAccount;
+    bool const matchingCurrency = (issue.currency == mSrcCurrency);
+    bool const matchingAccount = isXRP(issue.currency) ||
+        (mSrcIssuer && issue.account == mSrcIssuer) || issue.account == mSrcAccount;
 
     return matchingCurrency && matchingAccount;
 }
@@ -703,7 +703,7 @@ Pathfinder::getPathsOut(
     if (!sleAccount)
         return 0;
 
-    int aFlags = sleAccount->getFieldU32(sfFlags);
+    int const aFlags = sleAccount->getFieldU32(sfFlags);
     bool const bAuthRequired = (aFlags & lsfRequireAuth) != 0;
     bool const bFrozen = ((aFlags & lsfGlobalFreeze) != 0);
 
@@ -794,7 +794,7 @@ Pathfinder::addPathsForType(
     JLOG(j_.debug()) << "getPaths< adding onto '" << pathTypeToString(parentPathType)
                      << "' to get '" << pathTypeToString(pathType) << "'";
 
-    int initialSize = mCompletePaths.size();
+    int const initialSize = mCompletePaths.size();
 
     // Add the last NodeType to the lists.
     auto nodeType = pathType.back();
@@ -956,7 +956,7 @@ Pathfinder::addLink(
                             continue;
                         }
 
-                        bool bToDestination = acct == mEffectiveDst;
+                        bool const bToDestination = acct == mEffectiveDst;
 
                         if (bDestOnly && !bToDestination)
                         {
@@ -1004,7 +1004,7 @@ Pathfinder::addLink(
                             else
                             {
                                 // save this candidate
-                                int out = getPathsOut(
+                                int const out = getPathsOut(
                                     uEndCurrency,
                                     acct,
                                     direction,
@@ -1045,7 +1045,7 @@ Pathfinder::addLink(
                             if (continueCallback && !continueCallback())
                                 return;
                             // Add accounts to incompletePaths
-                            STPathElement pathElement(
+                            STPathElement const pathElement(
                                 STPathElement::typeAccount, it->account, uEndCurrency, it->account);
                             incompletePaths.assembleAdd(currentPath, pathElement);
                             ++it;
@@ -1067,14 +1067,14 @@ Pathfinder::addLink(
             // to XRP only
             if (!bOnXRP && app_.getOrderBookDB().isBookToXRP({uEndCurrency, uEndIssuer}, mDomain))
             {
-                STPathElement pathElement(
+                STPathElement const pathElement(
                     STPathElement::typeCurrency, xrpAccount(), xrpCurrency(), xrpAccount());
                 incompletePaths.assembleAdd(currentPath, pathElement);
             }
         }
         else
         {
-            bool bDestOnly = (addFlags & afOB_LAST) != 0;
+            bool const bDestOnly = (addFlags & afOB_LAST) != 0;
             auto books =
                 app_.getOrderBookDB().getBooksByTakerPays({uEndCurrency, uEndIssuer}, mDomain);
             JLOG(j_.trace()) << books.size() << " books found from this currency/issuer";
diff --git a/src/xrpld/rpc/detail/RPCCall.cpp b/src/xrpld/rpc/detail/RPCCall.cpp
index 5c57f96d79..f4613a3e72 100644
--- a/src/xrpld/rpc/detail/RPCCall.cpp
+++ b/src/xrpld/rpc/detail/RPCCall.cpp
@@ -104,15 +104,15 @@ private:
         // optionally followed by a forward slash and some other characters
         // (the issuer).
         // https://www.boost.org/doc/libs/1_82_0/libs/regex/doc/html/boost_regex/syntax/perl_syntax.html
-        static boost::regex reCurIss("\\`([][:alnum:]<>(){}[|?!@#$%^&*]{3})(?:/(.+))?\\'");
+        static boost::regex const reCurIss("\\`([][:alnum:]<>(){}[|?!@#$%^&*]{3})(?:/(.+))?\\'");
 
         boost::smatch smMatch;
 
         if (boost::regex_match(strCurrencyIssuer, smMatch, reCurIss))
         {
             Json::Value jvResult(Json::objectValue);
-            std::string strCurrency = smMatch[1];
-            std::string strIssuer = smMatch[2];
+            std::string const strCurrency = smMatch[1];
+            std::string const strIssuer = smMatch[2];
 
             jvResult[jss::currency] = strCurrency;
 
@@ -203,7 +203,7 @@ private:
     parseFetchInfo(Json::Value const& jvParams)
     {
         Json::Value jvRequest(Json::objectValue);
-        unsigned int iParams = jvParams.size();
+        unsigned int const iParams = jvParams.size();
 
         if (iParams != 0)
             jvRequest[jvParams[0u].asString()] = true;
@@ -262,8 +262,8 @@ private:
         }
         else
         {
-            std::int64_t uLedgerMin = jvParams[1u].asInt();
-            std::int64_t uLedgerMax = jvParams[2u].asInt();
+            std::int64_t const uLedgerMin = jvParams[1u].asInt();
+            std::int64_t const uLedgerMax = jvParams[2u].asInt();
 
             if (uLedgerMax != -1 && uLedgerMax < uLedgerMin)
             {
@@ -324,7 +324,7 @@ private:
         {
             try
             {
-                int iLimit = jvParams[4u].asInt();
+                int const iLimit = jvParams[4u].asInt();
 
                 if (iLimit > 0)
                     jvRequest[jss::limit] = iLimit;
@@ -339,7 +339,7 @@ private:
         {
             try
             {
-                int bProof = jvParams[5u].asInt();
+                int const bProof = jvParams[5u].asInt();
                 if (bProof != 0)
                     jvRequest[jss::proof] = true;
             }
@@ -365,7 +365,7 @@ private:
         if (jvParams.size() == 0u)
             return jvRequest;
 
-        std::string input = jvParams[0u].asString();
+        std::string const input = jvParams[0u].asString();
         if (input.find_first_not_of("0123456789") == std::string::npos)
         {
             jvRequest["can_delete"] = jvParams[0u].asUInt();
@@ -395,7 +395,7 @@ private:
         // handle case where there is one argument of the form ip:port
         if (std::count(ip.begin(), ip.end(), ':') == 1)
         {
-            std::size_t colon = ip.find_last_of(':');
+            std::size_t const colon = ip.find_last_of(':');
             jvRequest[jss::ip] = std::string{ip, 0, colon};
             jvRequest[jss::port] = Json::Value{std::string{ip, colon + 1}}.asUInt();
             return jvRequest;
@@ -571,7 +571,7 @@ private:
     {
         Json::Reader reader;
         Json::Value jv;
-        bool valid_parse = reader.parse(jvParams[0u].asString(), jv);
+        bool const valid_parse = reader.parse(jvParams[0u].asString(), jv);
         if (valid_parse && isValidJson2(jv))
         {
             if (jv.isObject())
@@ -653,7 +653,7 @@ private:
     {
         Json::Value jvRequest(Json::objectValue);
 
-        std::string strLedger = jvParams[0u].asString();
+        std::string const strLedger = jvParams[0u].asString();
 
         if (strLedger.length() == 64)
         {
@@ -854,8 +854,8 @@ private:
     // NOLINTNEXTLINE(readability-convert-member-functions-to-static)
     parseAccountRaw1(Json::Value const& jvParams)
     {
-        std::string strIdent = jvParams[0u].asString();
-        unsigned int iCursor = jvParams.size();
+        std::string const strIdent = jvParams[0u].asString();
+        unsigned int const iCursor = jvParams.size();
 
         if (!parseBase58<AccountID>(strIdent))
             return rpcError(rpcACT_MALFORMED);
@@ -875,7 +875,7 @@ private:
     // NOLINTNEXTLINE(readability-convert-member-functions-to-static)
     parseVault(Json::Value const& jvParams)
     {
-        std::string strVaultID = jvParams[0u].asString();
+        std::string const strVaultID = jvParams[0u].asString();
         uint256 id = beast::zero;
         if (!id.parseHex(strVaultID))
             return rpcError(rpcINVALID_PARAMS);
@@ -919,7 +919,7 @@ private:
     {
         Json::Reader reader;
         Json::Value jvRequest{Json::objectValue};
-        bool bLedger = 2 == jvParams.size();
+        bool const bLedger = 2 == jvParams.size();
 
         JLOG(j_.trace()) << "RPC json: " << jvParams[0u];
 
@@ -985,7 +985,7 @@ private:
                 return std::nullopt;
             if (jvParams.size() < 4 && bOffline)
                 return std::nullopt;
-            Json::UInt index = bOffline ? 3u : 2u;
+            Json::UInt const index = bOffline ? 3u : 2u;
             return jvParams[index].asString();
         }();
 
@@ -1598,7 +1598,7 @@ rpcClient(
             else
             {
                 // Transport error.
-                Json::Value jvRpcError = jvOutput;
+                Json::Value const jvRpcError = jvOutput;
 
                 jvOutput = rpcError(rpcJSON_RPC);
                 jvOutput["result"] = jvRpcError;
diff --git a/src/xrpld/rpc/detail/RPCHandler.cpp b/src/xrpld/rpc/detail/RPCHandler.cpp
index eea24ab0c0..1d8e1168b4 100644
--- a/src/xrpld/rpc/detail/RPCHandler.cpp
+++ b/src/xrpld/rpc/detail/RPCHandler.cpp
@@ -129,7 +129,7 @@ fillHandler(JsonContext& context, Handler const*& result)
             return rpcUNKNOWN_COMMAND;
     }
 
-    std::string strCommand = context.params.isMember(jss::command)
+    std::string const strCommand = context.params.isMember(jss::command)
         ? context.params[jss::command].asString()
         : context.params[jss::method].asString();
 
@@ -143,7 +143,7 @@ fillHandler(JsonContext& context, Handler const*& result)
     if (handler->role_ == Role::ADMIN && context.role != Role::ADMIN)
         return rpcNO_PERMISSION;
 
-    error_code_i res = conditionMet(handler->condition_, context);
+    error_code_i const res = conditionMet(handler->condition_, context);
     if (res != rpcSUCCESS)
     {
         return res;
diff --git a/src/xrpld/rpc/detail/RPCLedgerHelpers.cpp b/src/xrpld/rpc/detail/RPCLedgerHelpers.cpp
index 2216affa6f..955533c776 100644
--- a/src/xrpld/rpc/detail/RPCLedgerHelpers.cpp
+++ b/src/xrpld/rpc/detail/RPCLedgerHelpers.cpp
@@ -166,7 +166,7 @@ ledgerFromSpecifier(
     ledger.reset();
 
     using LedgerCase = org::xrpl::rpc::v1::LedgerSpecifier::LedgerCase;
-    LedgerCase ledgerCase = specifier.ledger_case();
+    LedgerCase const ledgerCase = specifier.ledger_case();
     switch (ledgerCase)
     {
         case LedgerCase::kHash: {
diff --git a/src/xrpld/rpc/detail/RPCSub.cpp b/src/xrpld/rpc/detail/RPCSub.cpp
index 3aa5f75f6a..3b5b56d937 100644
--- a/src/xrpld/rpc/detail/RPCSub.cpp
+++ b/src/xrpld/rpc/detail/RPCSub.cpp
@@ -68,7 +68,7 @@ public:
     void
     send(Json::Value const& jvObj, bool broadcast) override
     {
-        std::lock_guard sl(mLock);
+        std::lock_guard const sl(mLock);
 
         auto jm = broadcast ? j_.debug() : j_.info();
         JLOG(jm) << "RPCCall::fromNetwork push: " << jvObj;
@@ -88,7 +88,7 @@ public:
     void
     setUsername(std::string const& strUsername) override
     {
-        std::lock_guard sl(mLock);
+        std::lock_guard const sl(mLock);
 
         mUsername = strUsername;
     }
@@ -96,7 +96,7 @@ public:
     void
     setPassword(std::string const& strPassword) override
     {
-        std::lock_guard sl(mLock);
+        std::lock_guard const sl(mLock);
 
         mPassword = strPassword;
     }
@@ -114,7 +114,7 @@ private:
         {
             {
                 // Obtain the lock to manipulate the queue and change sending.
-                std::lock_guard sl(mLock);
+                std::lock_guard const sl(mLock);
 
                 if (mDeque.empty())
                 {
diff --git a/src/xrpld/rpc/detail/RippleLineCache.cpp b/src/xrpld/rpc/detail/RippleLineCache.cpp
index d6ed7b1478..7cc77f9b8b 100644
--- a/src/xrpld/rpc/detail/RippleLineCache.cpp
+++ b/src/xrpld/rpc/detail/RippleLineCache.cpp
@@ -26,7 +26,7 @@ RippleLineCache::getRippleLines(AccountID const& accountID, LineDirection direct
         direction == LineDirection::outgoing ? LineDirection::incoming : LineDirection::outgoing,
         hash);
 
-    std::lock_guard sl(mLock);
+    std::lock_guard const sl(mLock);
 
     auto [it, inserted] =
         [&]() {
diff --git a/src/xrpld/rpc/detail/Role.cpp b/src/xrpld/rpc/detail/Role.cpp
index 499787cece..f832e43119 100644
--- a/src/xrpld/rpc/detail/Role.cpp
+++ b/src/xrpld/rpc/detail/Role.cpp
@@ -224,7 +224,7 @@ extractIpAddrFromField(std::string_view field)
 
     // If there's a port appended to the IP address, strip that by
     // terminating at the colon.
-    if (std::size_t colon = ret.find(':'); colon != std::string_view::npos)
+    if (std::size_t const colon = ret.find(':'); colon != std::string_view::npos)
         ret = ret.substr(0, colon);
 
     return ret;
@@ -256,7 +256,7 @@ forwardedFor(http_request_type const& request)
 
         // We found a "for=".  Scan for the end of the IP address.
         std::size_t const pos = [&found, &it]() {
-            std::size_t pos =
+            std::size_t const pos =
                 std::string_view(found, it->value().end() - found).find_first_of(",;");
             if (pos != std::string_view::npos)
                 return pos;
diff --git a/src/xrpld/rpc/detail/ServerHandler.cpp b/src/xrpld/rpc/detail/ServerHandler.cpp
index ca026104cf..e5cc7a83bf 100644
--- a/src/xrpld/rpc/detail/ServerHandler.cpp
+++ b/src/xrpld/rpc/detail/ServerHandler.cpp
@@ -78,12 +78,12 @@ authorized(Port const& port, std::map<std::string, std::string> const& h)
         return false;
     std::string strUserPass64 = it->second.substr(6);
     boost::trim(strUserPass64);
-    std::string strUserPass = base64_decode(strUserPass64);
-    std::string::size_type nColon = strUserPass.find(':');
+    std::string const strUserPass = base64_decode(strUserPass64);
+    std::string::size_type const nColon = strUserPass.find(':');
     if (nColon == std::string::npos)
         return false;
-    std::string strUser = strUserPass.substr(0, nColon);
-    std::string strPassword = strUserPass.substr(nColon + 1);
+    std::string const strUser = strUserPass.substr(0, nColon);
+    std::string const strPassword = strUserPass.substr(nColon + 1);
     return strUser == port.user && strPassword == port.password;
 }
 
@@ -158,7 +158,7 @@ ServerHandler::onAccept(Session& session, boost::asio::ip::tcp::endpoint endpoin
     auto const& port = session.port();
 
     auto const c = [this, &port]() {
-        std::lock_guard lock(mutex_);
+        std::lock_guard const lock(mutex_);
         return ++count_[port];
     }();
 
@@ -282,7 +282,7 @@ ServerHandler::onRequest(Session& session)
         return;
     }
 
-    std::shared_ptr<Session> detachedSession = session.detach();
+    std::shared_ptr<Session> const detachedSession = session.detach();
     auto const postResult = m_jobQueue.postCoro(
         jtCLIENT_RPC, "RPC-Client", [this, detachedSession](std::shared_ptr<JobQueue::Coro> coro) {
             processSession(detachedSession, coro);
@@ -343,14 +343,14 @@ ServerHandler::onWSMessage(
 void
 ServerHandler::onClose(Session& session, boost::system::error_code const&)
 {
-    std::lock_guard lock(mutex_);
+    std::lock_guard const lock(mutex_);
     --count_[session.port()];
 }
 
 void
 ServerHandler::onStopped(Server&)
 {
-    std::lock_guard lock(mutex_);
+    std::lock_guard const lock(mutex_);
     stopped_ = true;
     condition_.notify_one();
 }
@@ -732,7 +732,7 @@ ServerHandler::processRequest(
             continue;
         }
 
-        std::string strMethod = method.asString();
+        std::string const strMethod = method.asString();
         if (strMethod.empty())
         {
             usage.charge(Resource::feeMalformedRPC);
diff --git a/src/xrpld/rpc/detail/TransactionSign.cpp b/src/xrpld/rpc/detail/TransactionSign.cpp
index 1fb6fc291f..23c70b9def 100644
--- a/src/xrpld/rpc/detail/TransactionSign.cpp
+++ b/src/xrpld/rpc/detail/TransactionSign.cpp
@@ -251,7 +251,7 @@ checkPayment(
             return RPC::make_error(rpcINVALID_PARAMS, "Cannot build XRP to XRP paths.");
 
         {
-            LegacyPathFind lpf(isUnlimited(role), app);
+            LegacyPathFind const lpf(isUnlimited(role), app);
             if (!lpf.isOk())
                 return rpcError(rpcTOO_BUSY);
 
@@ -274,7 +274,7 @@ checkPayment(
                     // 4 is the maximum paths
                     pf.computePathRanks(4);
                     STPath fullLiquidityPath;
-                    STPathSet paths;
+                    STPathSet const paths;
                     result = pf.getBestPaths(4, fullLiquidityPath, paths, sendMax.issue().account);
                 }
             }
@@ -631,7 +631,7 @@ transactionPreProcessImpl(
     // If multisign then return multiSignature, else set TxnSignature field.
     if (signingArgs.isMultiSigning())
     {
-        Serializer s = buildMultiSigningData(*stTx, signingArgs.getSigner());
+        Serializer const s = buildMultiSigningData(*stTx, signingArgs.getSigner());
 
         auto multisig = xrpl::sign(pk, sk, s.slice());
 
@@ -673,7 +673,7 @@ transactionConstructImpl(
         {
             Serializer s;
             tpTrans->getSTransaction()->add(s);
-            Blob transBlob = s.getData();
+            Blob const transBlob = s.getData();
             SerialIter sit{makeSlice(transBlob)};
 
             // Check the signature if that's called for.
@@ -954,15 +954,15 @@ transactionSign(
 
     // Add and amend fields based on the transaction type.
     SigningForParams signForParams;
-    transactionPreProcessResult preprocResult =
+    transactionPreProcessResult const preprocResult =
         transactionPreProcessImpl(jvRequest, role, signForParams, validatedLedgerAge, app);
 
     if (!preprocResult.second)
         return preprocResult.first;
 
-    std::shared_ptr<ReadView const> ledger = app.getOpenLedger().current();
+    std::shared_ptr<ReadView const> const ledger = app.getOpenLedger().current();
     // Make sure the STTx makes a legitimate Transaction.
-    std::pair<Json::Value, Transaction::pointer> txn =
+    std::pair<Json::Value, Transaction::pointer> const txn =
         transactionConstructImpl(preprocResult.second, ledger->rules(), app);
 
     if (!txn.second)
@@ -990,7 +990,7 @@ transactionSubmit(
 
     // Add and amend fields based on the transaction type.
     SigningForParams signForParams;
-    transactionPreProcessResult preprocResult =
+    transactionPreProcessResult const preprocResult =
         transactionPreProcessImpl(jvRequest, role, signForParams, validatedLedgerAge, app);
 
     if (!preprocResult.second)
@@ -1150,7 +1150,7 @@ transactionSignFor(
     // Add and amend fields based on the transaction type.
     SigningForParams signForParams(*signerAccountID);
 
-    transactionPreProcessResult preprocResult =
+    transactionPreProcessResult const preprocResult =
         transactionPreProcessImpl(jvRequest, role, signForParams, validatedLedgerAge, app);
 
     if (!preprocResult.second)
@@ -1160,7 +1160,8 @@ transactionSignFor(
         signForParams.validMultiSign(), "xrpl::RPC::transactionSignFor : valid multi-signature");
 
     {
-        std::shared_ptr<SLE const> account_state = ledger->read(keylet::account(*signerAccountID));
+        std::shared_ptr<SLE const> const account_state =
+            ledger->read(keylet::account(*signerAccountID));
         // Make sure the account and secret belong together.
         auto const err =
             acctMatchesPubKey(account_state, *signerAccountID, signForParams.getPublicKey());
@@ -1198,7 +1199,7 @@ transactionSignFor(
     }
 
     // Make sure the STTx makes a legitimate Transaction.
-    std::pair<Json::Value, Transaction::pointer> txn =
+    std::pair<Json::Value, Transaction::pointer> const txn =
         transactionConstructImpl(sttx, ledger->rules(), app);
 
     if (!txn.second)
@@ -1245,7 +1246,7 @@ transactionSubmitMultiSigned(
     if (RPC::contains_error(txJsonResult))
         return std::move(txJsonResult);
 
-    std::shared_ptr<SLE const> sle = ledger->read(keylet::account(srcAddressID));
+    std::shared_ptr<SLE const> const sle = ledger->read(keylet::account(srcAddressID));
 
     if (!sle)
     {
@@ -1291,7 +1292,7 @@ transactionSubmitMultiSigned(
         }
         catch (std::exception& ex)
         {
-            std::string reason(ex.what());
+            std::string const reason(ex.what());
             return RPC::make_error(
                 rpcINTERNAL, "Exception while serializing transaction: " + reason);
         }
diff --git a/src/xrpld/rpc/handlers/AccountLines.cpp b/src/xrpld/rpc/handlers/AccountLines.cpp
index f7fc9bdd2d..24ebfaa446 100644
--- a/src/xrpld/rpc/handlers/AccountLines.cpp
+++ b/src/xrpld/rpc/handlers/AccountLines.cpp
@@ -105,7 +105,7 @@ doAccountLines(RPC::JsonContext& context)
 
     // this flag allows the requester to ask incoming trustlines in default
     // state be omitted
-    bool ignoreDefault =
+    bool const ignoreDefault =
         params.isMember(jss::ignore_default) && params[jss::ignore_default].asBool();
 
     Json::Value& jsonLines(result[jss::lines] = Json::arrayValue);
diff --git a/src/xrpld/rpc/handlers/AccountObjects.cpp b/src/xrpld/rpc/handlers/AccountObjects.cpp
index cd67391da8..12132122c1 100644
--- a/src/xrpld/rpc/handlers/AccountObjects.cpp
+++ b/src/xrpld/rpc/handlers/AccountObjects.cpp
@@ -131,7 +131,7 @@ doAccountNFTs(RPC::JsonContext& context)
                 obj[sfIssuer.jsonName] = to_string(nft::getIssuer(nftokenID));
                 obj[sfNFTokenTaxon.jsonName] = nft::toUInt32(nft::getTaxon(nftokenID));
                 obj[jss::nft_serial] = nft::getSerial(nftokenID);
-                if (std::uint16_t xferFee = {nft::getTransferFee(nftokenID)})
+                if (std::uint16_t const xferFee = {nft::getTransferFee(nftokenID)})
                     obj[sfTransferFee.jsonName] = xferFee;
             }
 
diff --git a/src/xrpld/rpc/handlers/AccountOffers.cpp b/src/xrpld/rpc/handlers/AccountOffers.cpp
index 517c0728e9..38cc7c1dc5 100644
--- a/src/xrpld/rpc/handlers/AccountOffers.cpp
+++ b/src/xrpld/rpc/handlers/AccountOffers.cpp
@@ -17,7 +17,7 @@ namespace xrpl {
 void
 appendOfferJson(std::shared_ptr<SLE const> const& offer, Json::Value& offers)
 {
-    STAmount dirRate = amountFromQuality(getQuality(offer->getFieldH256(sfBookDirectory)));
+    STAmount const dirRate = amountFromQuality(getQuality(offer->getFieldH256(sfBookDirectory)));
     Json::Value& obj(offers.append(Json::objectValue));
     offer->getFieldAmount(sfTakerPays).setJson(obj[jss::taker_pays]);
     offer->getFieldAmount(sfTakerGets).setJson(obj[jss::taker_gets]);
diff --git a/src/xrpld/rpc/handlers/AccountTx.cpp b/src/xrpld/rpc/handlers/AccountTx.cpp
index e120c98523..f46a71308c 100644
--- a/src/xrpld/rpc/handlers/AccountTx.cpp
+++ b/src/xrpld/rpc/handlers/AccountTx.cpp
@@ -41,18 +41,18 @@ parseLedgerArgs(RPC::Context& context, Json::Value const& params)
         if ((params.isMember(jss::ledger_index_min) || params.isMember(jss::ledger_index_max)) &&
             (params.isMember(jss::ledger_hash) || params.isMember(jss::ledger_index)))
         {
-            RPC::Status status{rpcINVALID_PARAMS, "invalidParams"};
+            RPC::Status const status{rpcINVALID_PARAMS, "invalidParams"};
             status.inject(response);
             return response;
         }
     }
     if (params.isMember(jss::ledger_index_min) || params.isMember(jss::ledger_index_max))
     {
-        uint32_t min =
+        uint32_t const min =
             params.isMember(jss::ledger_index_min) && params[jss::ledger_index_min].asInt() >= 0
             ? params[jss::ledger_index_min].asUInt()
             : 0;
-        uint32_t max =
+        uint32_t const max =
             params.isMember(jss::ledger_index_max) && params[jss::ledger_index_max].asInt() >= 0
             ? params[jss::ledger_index_max].asUInt()
             : UINT32_MAX;
@@ -64,7 +64,7 @@ parseLedgerArgs(RPC::Context& context, Json::Value const& params)
         auto& hashValue = params[jss::ledger_hash];
         if (!hashValue.isString())
         {
-            RPC::Status status{rpcINVALID_PARAMS, "ledgerHashNotString"};
+            RPC::Status const status{rpcINVALID_PARAMS, "ledgerHashNotString"};
             status.inject(response);
             return response;
         }
@@ -72,7 +72,7 @@ parseLedgerArgs(RPC::Context& context, Json::Value const& params)
         LedgerHash hash;
         if (!hash.parseHex(hashValue.asString()))
         {
-            RPC::Status status{rpcINVALID_PARAMS, "ledgerHashMalformed"};
+            RPC::Status const status{rpcINVALID_PARAMS, "ledgerHashMalformed"};
             status.inject(response);
             return response;
         }
@@ -87,7 +87,7 @@ parseLedgerArgs(RPC::Context& context, Json::Value const& params)
         }
         else
         {
-            std::string ledgerStr = params[jss::ledger_index].asString();
+            std::string const ledgerStr = params[jss::ledger_index].asString();
 
             if (ledgerStr == "current" || ledgerStr.empty())
             {
@@ -103,7 +103,7 @@ parseLedgerArgs(RPC::Context& context, Json::Value const& params)
             }
             else
             {
-                RPC::Status status{rpcINVALID_PARAMS, "ledger_index string malformed"};
+                RPC::Status const status{rpcINVALID_PARAMS, "ledger_index string malformed"};
                 status.inject(response);
                 return response;
             }
@@ -118,7 +118,7 @@ getLedgerRange(RPC::Context& context, std::optional<LedgerSpecifier> const& ledg
 {
     std::uint32_t uValidatedMin = 0;
     std::uint32_t uValidatedMax = 0;
-    bool bValidated = context.ledgerMaster.getValidatedRange(uValidatedMin, uValidatedMax);
+    bool const bValidated = context.ledgerMaster.getValidatedRange(uValidatedMin, uValidatedMax);
 
     if (!bValidated)
     {
@@ -173,7 +173,7 @@ getLedgerRange(RPC::Context& context, std::optional<LedgerSpecifier> const& ledg
                         return status;
                     }
 
-                    bool validated = context.ledgerMaster.isValidated(*ledgerView);
+                    bool const validated = context.ledgerMaster.isValidated(*ledgerView);
 
                     if (!validated || ledgerView->header().seq > uValidatedMax ||
                         ledgerView->header().seq < uValidatedMin)
@@ -210,7 +210,7 @@ doAccountTxHelp(RPC::Context& context, AccountTxArgs const& args)
 
     result.marker = args.marker;
 
-    RelationalDatabase::AccountTxPageOptions options = {
+    RelationalDatabase::AccountTxPageOptions const options = {
         args.account, result.ledgerRange, result.marker, args.limit, isUnlimited(context.role)};
 
     auto& db = context.app.getRelationalDatabase();
@@ -419,7 +419,7 @@ doAccountTxJson(RPC::JsonContext& context)
             !token[jss::ledger].isConvertibleTo(Json::ValueType::uintValue) ||
             !token[jss::seq].isConvertibleTo(Json::ValueType::uintValue))
         {
-            RPC::Status status{
+            RPC::Status const status{
                 rpcINVALID_PARAMS,
                 "invalid marker. Provide ledger index via ledger field, and "
                 "transaction sequence number via seq field"};
diff --git a/src/xrpld/rpc/handlers/CanDelete.cpp b/src/xrpld/rpc/handlers/CanDelete.cpp
index 052ebdf745..7d881e7d2e 100644
--- a/src/xrpld/rpc/handlers/CanDelete.cpp
+++ b/src/xrpld/rpc/handlers/CanDelete.cpp
@@ -22,7 +22,7 @@ doCanDelete(RPC::JsonContext& context)
 
     if (context.params.isMember(jss::can_delete))
     {
-        Json::Value canDelete = context.params.get(jss::can_delete, 0);
+        Json::Value const canDelete = context.params.get(jss::can_delete, 0);
         std::uint32_t canDeleteSeq = 0;
 
         if (canDelete.isUInt())
diff --git a/src/xrpld/rpc/handlers/GatewayBalances.cpp b/src/xrpld/rpc/handlers/GatewayBalances.cpp
index 8d03a3961d..20679e5f42 100644
--- a/src/xrpld/rpc/handlers/GatewayBalances.cpp
+++ b/src/xrpld/rpc/handlers/GatewayBalances.cpp
@@ -164,7 +164,7 @@ doGatewayBalances(RPC::JsonContext& context)
             if (!rs)
                 return;
 
-            int balSign = rs->getBalance().signum();
+            int const balSign = rs->getBalance().signum();
             if (balSign == 0)
                 return;
 
diff --git a/src/xrpld/rpc/handlers/GetAggregatePrice.cpp b/src/xrpld/rpc/handlers/GetAggregatePrice.cpp
index 4979c21f42..281f2d63a7 100644
--- a/src/xrpld/rpc/handlers/GetAggregatePrice.cpp
+++ b/src/xrpld/rpc/handlers/GetAggregatePrice.cpp
@@ -62,8 +62,8 @@ iteratePriceData(
         if (++history > maxHistory)
             return;
 
-        uint256 prevTx = chain->getFieldH256(sfPreviousTxnID);
-        std::uint32_t prevSeq = chain->getFieldU32(sfPreviousTxnLgrSeq);
+        uint256 const prevTx = chain->getFieldH256(sfPreviousTxnID);
+        std::uint32_t const prevSeq = chain->getFieldU32(sfPreviousTxnLgrSeq);
 
         auto const ledger = context.ledgerMaster.getLedgerBySeq(prevSeq);
         if (!ledger)
@@ -320,7 +320,7 @@ doGetAggregatePrice(RPC::JsonContext& context)
         auto const middle = size_ / 2;
         if ((size_ % 2) == 0)
         {
-            static STAmount two{noIssue(), 2, 0};
+            static STAmount const two{noIssue(), 2, 0};
             auto it = itAdvance(prices.right.begin(), middle - 1);
             auto const& a1 = it->first;
             auto const& a2 = (++it)->first;
diff --git a/src/xrpld/rpc/handlers/GetCounts.cpp b/src/xrpld/rpc/handlers/GetCounts.cpp
index 09a952e114..648d29a5fd 100644
--- a/src/xrpld/rpc/handlers/GetCounts.cpp
+++ b/src/xrpld/rpc/handlers/GetCounts.cpp
@@ -71,7 +71,7 @@ getCountsJson(Application& app, int minObjectCount)
             ret[jss::dbKBTransaction] = dbKB;
 
         {
-            std::size_t c = app.getOPs().getLocalTxCount();
+            std::size_t const c = app.getOPs().getLocalTxCount();
             if (c > 0)
                 ret[jss::local_txs] = static_cast<Json::UInt>(c);
         }
diff --git a/src/xrpld/rpc/handlers/GetCounts.h b/src/xrpld/rpc/handlers/GetCounts.h
index 60c7a3b693..286ad38af3 100644
--- a/src/xrpld/rpc/handlers/GetCounts.h
+++ b/src/xrpld/rpc/handlers/GetCounts.h
@@ -7,4 +7,4 @@ namespace xrpl {
 Json::Value
 getCountsJson(Application& app, int minObjectCount);
 
-}
+}  // namespace xrpl
diff --git a/src/xrpld/rpc/handlers/LedgerAccept.cpp b/src/xrpld/rpc/handlers/LedgerAccept.cpp
index c7a828863a..91e88b707f 100644
--- a/src/xrpld/rpc/handlers/LedgerAccept.cpp
+++ b/src/xrpld/rpc/handlers/LedgerAccept.cpp
@@ -22,7 +22,7 @@ doLedgerAccept(RPC::JsonContext& context)
     }
     else
     {
-        std::unique_lock lock{context.app.getMasterMutex()};
+        std::unique_lock const lock{context.app.getMasterMutex()};
         context.netOps.acceptLedger();
         jvResult[jss::ledger_current_index] = context.ledgerMaster.getCurrentLedgerIndex();
     }
diff --git a/src/xrpld/rpc/handlers/LedgerData.cpp b/src/xrpld/rpc/handlers/LedgerData.cpp
index 733d1c99c6..059c844e6e 100644
--- a/src/xrpld/rpc/handlers/LedgerData.cpp
+++ b/src/xrpld/rpc/handlers/LedgerData.cpp
@@ -116,9 +116,9 @@ doLedgerData(RPC::JsonContext& context)
 std::pair<org::xrpl::rpc::v1::GetLedgerDataResponse, grpc::Status>
 doLedgerDataGrpc(RPC::GRPCContext<org::xrpl::rpc::v1::GetLedgerDataRequest>& context)
 {
-    org::xrpl::rpc::v1::GetLedgerDataRequest& request = context.params;
+    org::xrpl::rpc::v1::GetLedgerDataRequest const& request = context.params;
     org::xrpl::rpc::v1::GetLedgerDataResponse response;
-    grpc::Status status = grpc::Status::OK;
+    grpc::Status const status = grpc::Status::OK;
 
     std::shared_ptr<ReadView const> ledger;
     if (auto status = RPC::ledgerFromRequest(ledger, context))
@@ -142,7 +142,7 @@ doLedgerDataGrpc(RPC::GRPCContext<org::xrpl::rpc::v1::GetLedgerDataRequest>& con
     }
     else if (!request.marker().empty())
     {
-        grpc::Status errorStatus{grpc::StatusCode::INVALID_ARGUMENT, "marker malformed"};
+        grpc::Status const errorStatus{grpc::StatusCode::INVALID_ARGUMENT, "marker malformed"};
         return {response, errorStatus};
     }
 
diff --git a/src/xrpld/rpc/handlers/LedgerDiff.cpp b/src/xrpld/rpc/handlers/LedgerDiff.cpp
index 2990315880..56a4d97b94 100644
--- a/src/xrpld/rpc/handlers/LedgerDiff.cpp
+++ b/src/xrpld/rpc/handlers/LedgerDiff.cpp
@@ -5,50 +5,50 @@ namespace xrpl {
 std::pair<org::xrpl::rpc::v1::GetLedgerDiffResponse, grpc::Status>
 doLedgerDiffGrpc(RPC::GRPCContext<org::xrpl::rpc::v1::GetLedgerDiffRequest>& context)
 {
-    org::xrpl::rpc::v1::GetLedgerDiffRequest& request = context.params;
+    org::xrpl::rpc::v1::GetLedgerDiffRequest const& request = context.params;
     org::xrpl::rpc::v1::GetLedgerDiffResponse response;
-    grpc::Status status = grpc::Status::OK;
+    grpc::Status const status = grpc::Status::OK;
 
     std::shared_ptr<ReadView const> baseLedgerRv;
     std::shared_ptr<ReadView const> desiredLedgerRv;
 
     if (RPC::ledgerFromSpecifier(baseLedgerRv, request.base_ledger(), context))
     {
-        grpc::Status errorStatus{grpc::StatusCode::NOT_FOUND, "base ledger not found"};
+        grpc::Status const errorStatus{grpc::StatusCode::NOT_FOUND, "base ledger not found"};
         return {response, errorStatus};
     }
 
     if (RPC::ledgerFromSpecifier(desiredLedgerRv, request.desired_ledger(), context))
     {
-        grpc::Status errorStatus{grpc::StatusCode::NOT_FOUND, "desired ledger not found"};
+        grpc::Status const errorStatus{grpc::StatusCode::NOT_FOUND, "desired ledger not found"};
         return {response, errorStatus};
     }
 
-    std::shared_ptr<Ledger const> baseLedger =
+    std::shared_ptr<Ledger const> const baseLedger =
         std::dynamic_pointer_cast<Ledger const>(baseLedgerRv);
     if (!baseLedger)
     {
-        grpc::Status errorStatus{grpc::StatusCode::NOT_FOUND, "base ledger not validated"};
+        grpc::Status const errorStatus{grpc::StatusCode::NOT_FOUND, "base ledger not validated"};
         return {response, errorStatus};
     }
 
-    std::shared_ptr<Ledger const> desiredLedger =
+    std::shared_ptr<Ledger const> const desiredLedger =
         std::dynamic_pointer_cast<Ledger const>(desiredLedgerRv);
     if (!desiredLedger)
     {
-        grpc::Status errorStatus{grpc::StatusCode::NOT_FOUND, "base ledger not validated"};
+        grpc::Status const errorStatus{grpc::StatusCode::NOT_FOUND, "base ledger not validated"};
         return {response, errorStatus};
     }
 
     SHAMap::Delta differences;
 
-    int maxDifferences = std::numeric_limits<int>::max();
+    int const maxDifferences = std::numeric_limits<int>::max();
 
-    bool res =
+    bool const res =
         baseLedger->stateMap().compare(desiredLedger->stateMap(), differences, maxDifferences);
     if (!res)
     {
-        grpc::Status errorStatus{
+        grpc::Status const errorStatus{
             grpc::StatusCode::RESOURCE_EXHAUSTED, "too many differences between specified ledgers"};
         return {response, errorStatus};
     }
diff --git a/src/xrpld/rpc/handlers/LedgerEntry.cpp b/src/xrpld/rpc/handlers/LedgerEntry.cpp
index c7a47a0517..d27574944d 100644
--- a/src/xrpld/rpc/handlers/LedgerEntry.cpp
+++ b/src/xrpld/rpc/handlers/LedgerEntry.cpp
@@ -370,7 +370,7 @@ parseDirectoryNode(
             "malformedRequest", "Must have exactly one of `owner` and `dir_root` fields.");
     }
 
-    std::uint64_t uSubIndex = params.get(jss::sub_index, 0).asUInt();
+    std::uint64_t const uSubIndex = params.get(jss::sub_index, 0).asUInt();
 
     if (params.isMember(jss::dir_root))
     {
@@ -956,9 +956,9 @@ doLedgerEntry(RPC::JsonContext& context)
 std::pair<org::xrpl::rpc::v1::GetLedgerEntryResponse, grpc::Status>
 doLedgerEntryGrpc(RPC::GRPCContext<org::xrpl::rpc::v1::GetLedgerEntryRequest>& context)
 {
-    org::xrpl::rpc::v1::GetLedgerEntryRequest& request = context.params;
+    org::xrpl::rpc::v1::GetLedgerEntryRequest const& request = context.params;
     org::xrpl::rpc::v1::GetLedgerEntryResponse response;
-    grpc::Status status = grpc::Status::OK;
+    grpc::Status const status = grpc::Status::OK;
 
     std::shared_ptr<ReadView const> ledger;
     if (auto status = RPC::ledgerFromRequest(ledger, context))
@@ -978,14 +978,14 @@ doLedgerEntryGrpc(RPC::GRPCContext<org::xrpl::rpc::v1::GetLedgerEntryRequest>& c
     auto const key = uint256::fromVoidChecked(request.key());
     if (!key)
     {
-        grpc::Status errorStatus{grpc::StatusCode::INVALID_ARGUMENT, "index malformed"};
+        grpc::Status const errorStatus{grpc::StatusCode::INVALID_ARGUMENT, "index malformed"};
         return {response, errorStatus};
     }
 
     auto const sleNode = ledger->read(keylet::unchecked(*key));
     if (!sleNode)
     {
-        grpc::Status errorStatus{grpc::StatusCode::NOT_FOUND, "object not found"};
+        grpc::Status const errorStatus{grpc::StatusCode::NOT_FOUND, "object not found"};
         return {response, errorStatus};
     }
 
diff --git a/src/xrpld/rpc/handlers/LedgerEntryHelpers.h b/src/xrpld/rpc/handlers/LedgerEntryHelpers.h
index 9182c9cfd7..17207d81e8 100644
--- a/src/xrpld/rpc/handlers/LedgerEntryHelpers.h
+++ b/src/xrpld/rpc/handlers/LedgerEntryHelpers.h
@@ -16,7 +16,7 @@ namespace xrpl {
 
 namespace LedgerEntryHelpers {
 
-Unexpected<Json::Value>
+inline Unexpected<Json::Value>
 missingFieldError(Json::StaticString const field, std::optional<std::string> err = std::nullopt)
 {
     Json::Value json = Json::objectValue;
@@ -26,7 +26,7 @@ missingFieldError(Json::StaticString const field, std::optional<std::string> err
     return Unexpected(json);
 }
 
-Unexpected<Json::Value>
+inline Unexpected<Json::Value>
 invalidFieldError(std::string const& err, Json::StaticString const field, std::string const& type)
 {
     Json::Value json = Json::objectValue;
@@ -36,7 +36,7 @@ invalidFieldError(std::string const& err, Json::StaticString const field, std::s
     return Unexpected(json);
 }
 
-Unexpected<Json::Value>
+inline Unexpected<Json::Value>
 malformedError(std::string const& err, std::string const& message)
 {
     Json::Value json = Json::objectValue;
@@ -46,7 +46,7 @@ malformedError(std::string const& err, std::string const& message)
     return Unexpected(json);
 }
 
-Expected<bool, Json::Value>
+inline Expected<bool, Json::Value>
 hasRequired(
     Json::Value const& params,
     std::initializer_list<Json::StaticString> fields,
@@ -86,7 +86,7 @@ required(
 }
 
 template <>
-std::optional<AccountID>
+inline std::optional<AccountID>
 parse(Json::Value const& param)
 {
     if (!param.isString())
@@ -101,7 +101,7 @@ parse(Json::Value const& param)
     return account;
 }
 
-Expected<AccountID, Json::Value>
+inline Expected<AccountID, Json::Value>
 requiredAccountID(
     Json::Value const& params,
     Json::StaticString const fieldName,
@@ -110,7 +110,7 @@ requiredAccountID(
     return required<AccountID>(params, fieldName, err, "AccountID");
 }
 
-std::optional<Blob>
+inline std::optional<Blob>
 parseHexBlob(Json::Value const& param, std::size_t maxLength)
 {
     if (!param.isString())
@@ -123,7 +123,7 @@ parseHexBlob(Json::Value const& param, std::size_t maxLength)
     return blob;
 }
 
-Expected<Blob, Json::Value>
+inline Expected<Blob, Json::Value>
 requiredHexBlob(
     Json::Value const& params,
     Json::StaticString const fieldName,
@@ -142,7 +142,7 @@ requiredHexBlob(
 }
 
 template <>
-std::optional<std::uint32_t>
+inline std::optional<std::uint32_t>
 parse(Json::Value const& param)
 {
     if (param.isUInt() || (param.isInt() && param.asInt() >= 0))
@@ -158,7 +158,7 @@ parse(Json::Value const& param)
     return std::nullopt;
 }
 
-Expected<std::uint32_t, Json::Value>
+inline Expected<std::uint32_t, Json::Value>
 requiredUInt32(
     Json::Value const& params,
     Json::StaticString const fieldName,
@@ -168,7 +168,7 @@ requiredUInt32(
 }
 
 template <>
-std::optional<uint256>
+inline std::optional<uint256>
 parse(Json::Value const& param)
 {
     uint256 uNodeIndex;
@@ -180,7 +180,7 @@ parse(Json::Value const& param)
     return uNodeIndex;
 }
 
-Expected<uint256, Json::Value>
+inline Expected<uint256, Json::Value>
 requiredUInt256(
     Json::Value const& params,
     Json::StaticString const fieldName,
@@ -190,7 +190,7 @@ requiredUInt256(
 }
 
 template <>
-std::optional<uint192>
+inline std::optional<uint192>
 parse(Json::Value const& param)
 {
     uint192 field;
@@ -202,7 +202,7 @@ parse(Json::Value const& param)
     return field;
 }
 
-Expected<uint192, Json::Value>
+inline Expected<uint192, Json::Value>
 requiredUInt192(
     Json::Value const& params,
     Json::StaticString const fieldName,
@@ -212,7 +212,7 @@ requiredUInt192(
 }
 
 template <>
-std::optional<Issue>
+inline std::optional<Issue>
 parse(Json::Value const& param)
 {
     try
@@ -225,13 +225,13 @@ parse(Json::Value const& param)
     }
 }
 
-Expected<Issue, Json::Value>
+inline Expected<Issue, Json::Value>
 requiredIssue(Json::Value const& params, Json::StaticString const fieldName, std::string const& err)
 {
     return required<Issue>(params, fieldName, err, "Issue");
 }
 
-Expected<STXChainBridge, Json::Value>
+inline Expected<STXChainBridge, Json::Value>
 parseBridgeFields(Json::Value const& params)
 {
     if (auto const value = hasRequired(
diff --git a/src/xrpld/rpc/handlers/LedgerHandler.cpp b/src/xrpld/rpc/handlers/LedgerHandler.cpp
index cd70cb064a..0707ad1ffe 100644
--- a/src/xrpld/rpc/handlers/LedgerHandler.cpp
+++ b/src/xrpld/rpc/handlers/LedgerHandler.cpp
@@ -21,7 +21,7 @@ Status
 LedgerHandler::check()
 {
     auto const& params = context_.params;
-    bool needsLedger = params.isMember(jss::ledger) || params.isMember(jss::ledger_hash) ||
+    bool const needsLedger = params.isMember(jss::ledger) || params.isMember(jss::ledger_hash) ||
         params.isMember(jss::ledger_index);
     if (!needsLedger)
         return Status::OK;
@@ -113,9 +113,9 @@ std::pair<org::xrpl::rpc::v1::GetLedgerResponse, grpc::Status>
 doLedgerGrpc(RPC::GRPCContext<org::xrpl::rpc::v1::GetLedgerRequest>& context)
 {
     auto begin = std::chrono::system_clock::now();
-    org::xrpl::rpc::v1::GetLedgerRequest& request = context.params;
+    org::xrpl::rpc::v1::GetLedgerRequest const& request = context.params;
     org::xrpl::rpc::v1::GetLedgerResponse response;
-    grpc::Status status = grpc::Status::OK;
+    grpc::Status const status = grpc::Status::OK;
 
     std::shared_ptr<ReadView const> ledger;
     if (auto status = RPC::ledgerFromRequest(ledger, context))
@@ -147,11 +147,11 @@ doLedgerGrpc(RPC::GRPCContext<org::xrpl::rpc::v1::GetLedgerRequest>& context)
                 if (request.expand())
                 {
                     auto txn = response.mutable_transactions_list()->add_transactions();
-                    Serializer sTxn = i.first->getSerializer();
+                    Serializer const sTxn = i.first->getSerializer();
                     txn->set_transaction_blob(sTxn.data(), sTxn.getLength());
                     if (i.second)
                     {
-                        Serializer sMeta = i.second->getSerializer();
+                        Serializer const sMeta = i.second->getSerializer();
                         txn->set_metadata_blob(sMeta.data(), sMeta.getLength());
                     }
                 }
@@ -173,30 +173,32 @@ doLedgerGrpc(RPC::GRPCContext<org::xrpl::rpc::v1::GetLedgerRequest>& context)
 
     if (request.get_objects())
     {
-        std::shared_ptr<ReadView const> parent =
+        std::shared_ptr<ReadView const> const parent =
             context.app.getLedgerMaster().getLedgerBySeq(ledger->seq() - 1);
 
-        std::shared_ptr<Ledger const> base = std::dynamic_pointer_cast<Ledger const>(parent);
+        std::shared_ptr<Ledger const> const base = std::dynamic_pointer_cast<Ledger const>(parent);
         if (!base)
         {
-            grpc::Status errorStatus{grpc::StatusCode::NOT_FOUND, "parent ledger not validated"};
+            grpc::Status const errorStatus{
+                grpc::StatusCode::NOT_FOUND, "parent ledger not validated"};
             return {response, errorStatus};
         }
 
-        std::shared_ptr<Ledger const> desired = std::dynamic_pointer_cast<Ledger const>(ledger);
+        std::shared_ptr<Ledger const> const desired =
+            std::dynamic_pointer_cast<Ledger const>(ledger);
         if (!desired)
         {
-            grpc::Status errorStatus{grpc::StatusCode::NOT_FOUND, "ledger not validated"};
+            grpc::Status const errorStatus{grpc::StatusCode::NOT_FOUND, "ledger not validated"};
             return {response, errorStatus};
         }
         SHAMap::Delta differences;
 
-        int maxDifferences = std::numeric_limits<int>::max();
+        int const maxDifferences = std::numeric_limits<int>::max();
 
-        bool res = base->stateMap().compare(desired->stateMap(), differences, maxDifferences);
+        bool const res = base->stateMap().compare(desired->stateMap(), differences, maxDifferences);
         if (!res)
         {
-            grpc::Status errorStatus{
+            grpc::Status const errorStatus{
                 grpc::StatusCode::RESOURCE_EXHAUSTED,
                 "too many differences between specified ledgers"};
             return {response, errorStatus};
diff --git a/src/xrpld/rpc/handlers/LedgerHandler.h b/src/xrpld/rpc/handlers/LedgerHandler.h
index 418958e9f1..f024241546 100644
--- a/src/xrpld/rpc/handlers/LedgerHandler.h
+++ b/src/xrpld/rpc/handlers/LedgerHandler.h
@@ -14,7 +14,7 @@
 
 namespace Json {
 class Object;
-}
+}  // namespace Json
 
 namespace xrpl {
 namespace RPC {
diff --git a/src/xrpld/rpc/handlers/LogLevel.cpp b/src/xrpld/rpc/handlers/LogLevel.cpp
index a932dfb198..e1e637435c 100644
--- a/src/xrpld/rpc/handlers/LogLevel.cpp
+++ b/src/xrpld/rpc/handlers/LogLevel.cpp
@@ -22,7 +22,7 @@ doLogLevel(RPC::JsonContext& context)
         Json::Value lev(Json::objectValue);
 
         lev[jss::base] = Logs::toString(Logs::fromSeverity(context.app.getLogs().threshold()));
-        std::vector<std::pair<std::string, std::string>> logTable(
+        std::vector<std::pair<std::string, std::string>> const logTable(
             context.app.getLogs().partition_severities());
         for (auto const& [k, v] : logTable)
             lev[k] = v;
@@ -49,7 +49,7 @@ doLogLevel(RPC::JsonContext& context)
     if (context.params.isMember(jss::partition))
     {
         // set partition threshold
-        std::string partition(context.params[jss::partition].asString());
+        std::string const partition(context.params[jss::partition].asString());
 
         if (boost::iequals(partition, "base"))
         {
diff --git a/src/xrpld/rpc/handlers/NoRippleCheck.cpp b/src/xrpld/rpc/handlers/NoRippleCheck.cpp
index c3e36280a6..d00a3e279b 100644
--- a/src/xrpld/rpc/handlers/NoRippleCheck.cpp
+++ b/src/xrpld/rpc/handlers/NoRippleCheck.cpp
@@ -88,7 +88,7 @@ doNoRippleCheck(RPC::JsonContext& context)
     if (!ledger)
         return result;
 
-    Json::Value dummy;
+    Json::Value dummy;  // NOLINT(misc-const-correctness)
     Json::Value& jvTransactions =
         transactions ? (result[jss::transactions] = Json::arrayValue) : dummy;
 
@@ -107,7 +107,7 @@ doNoRippleCheck(RPC::JsonContext& context)
 
     Json::Value& problems = (result["problems"] = Json::arrayValue);
 
-    bool bDefaultRipple = (sle->getFieldU32(sfFlags) & lsfDefaultRipple) != 0u;
+    bool const bDefaultRipple = (sle->getFieldU32(sfFlags) & lsfDefaultRipple) != 0u;
 
     if ((static_cast<int>(bDefaultRipple) & static_cast<int>(!roleGateway)) != 0)
     {
@@ -151,9 +151,10 @@ doNoRippleCheck(RPC::JsonContext& context)
                 }
                 if (needFix)
                 {
-                    AccountID peer =
+                    AccountID const peer =
                         ownedItem->getFieldAmount(bLow ? sfHighLimit : sfLowLimit).getIssuer();
-                    STAmount peerLimit = ownedItem->getFieldAmount(bLow ? sfHighLimit : sfLowLimit);
+                    STAmount const peerLimit =
+                        ownedItem->getFieldAmount(bLow ? sfHighLimit : sfLowLimit);
                     problem += to_string(peerLimit.getCurrency());
                     problem += " line to ";
                     problem += to_string(peerLimit.getIssuer());
diff --git a/src/xrpld/rpc/handlers/OwnerInfo.cpp b/src/xrpld/rpc/handlers/OwnerInfo.cpp
index 202d0e9b5b..659a149e20 100644
--- a/src/xrpld/rpc/handlers/OwnerInfo.cpp
+++ b/src/xrpld/rpc/handlers/OwnerInfo.cpp
@@ -20,7 +20,7 @@ doOwnerInfo(RPC::JsonContext& context)
         return RPC::missing_field_error(jss::account);
     }
 
-    std::string strIdent = context.params.isMember(jss::account)
+    std::string const strIdent = context.params.isMember(jss::account)
         ? context.params[jss::account].asString()
         : context.params[jss::ident].asString();
     Json::Value ret;
diff --git a/src/xrpld/rpc/handlers/PathFind.cpp b/src/xrpld/rpc/handlers/PathFind.cpp
index 1b180167ea..ced3625b4c 100644
--- a/src/xrpld/rpc/handlers/PathFind.cpp
+++ b/src/xrpld/rpc/handlers/PathFind.cpp
@@ -40,7 +40,7 @@ doPathFind(RPC::JsonContext& context)
 
     if (sSubCommand == "close")
     {
-        InfoSubRequest::pointer request = context.infoSub->getRequest();
+        InfoSubRequest::pointer const request = context.infoSub->getRequest();
 
         if (!request)
             return rpcError(rpcNO_PF_REQUEST);
@@ -51,7 +51,7 @@ doPathFind(RPC::JsonContext& context)
 
     if (sSubCommand == "status")
     {
-        InfoSubRequest::pointer request = context.infoSub->getRequest();
+        InfoSubRequest::pointer const request = context.infoSub->getRequest();
 
         if (!request)
             return rpcError(rpcNO_PF_REQUEST);
diff --git a/src/xrpld/rpc/handlers/Peers.cpp b/src/xrpld/rpc/handlers/Peers.cpp
index ddcb674b33..646aae7bc8 100644
--- a/src/xrpld/rpc/handlers/Peers.cpp
+++ b/src/xrpld/rpc/handlers/Peers.cpp
@@ -42,7 +42,7 @@ doPeers(RPC::JsonContext& context)
     auto const self = context.app.nodeIdentity().first;
 
     Json::Value& cluster = (jvResult[jss::cluster] = Json::objectValue);
-    std::uint32_t ref = context.app.getFeeTrack().getLoadBase();
+    std::uint32_t const ref = context.app.getFeeTrack().getLoadBase();
 
     context.app.getCluster().for_each([&cluster, now, ref, &self](ClusterNode const& node) {
         if (node.identity() == self)
diff --git a/src/xrpld/rpc/handlers/Random.cpp b/src/xrpld/rpc/handlers/Random.cpp
index 2fb8abf3c9..5ed4426940 100644
--- a/src/xrpld/rpc/handlers/Random.cpp
+++ b/src/xrpld/rpc/handlers/Random.cpp
@@ -10,7 +10,7 @@ namespace xrpl {
 
 namespace RPC {
 struct JsonContext;
-}
+}  // namespace RPC
 
 // Result:
 // {
diff --git a/src/xrpld/rpc/handlers/RipplePathFind.cpp b/src/xrpld/rpc/handlers/RipplePathFind.cpp
index cc695908fb..ac4f22a1aa 100644
--- a/src/xrpld/rpc/handlers/RipplePathFind.cpp
+++ b/src/xrpld/rpc/handlers/RipplePathFind.cpp
@@ -113,7 +113,7 @@ doRipplePathFind(RPC::JsonContext& context)
                 // captured reference could evaporate when we return from
                 // coroCopy->resume().  This is not strictly necessary, but
                 // will make maintenance easier.
-                std::shared_ptr<JobQueue::Coro> coroCopy{context.coro};
+                std::shared_ptr<JobQueue::Coro> const coroCopy{context.coro};
                 if (!coroCopy->post())
                 {
                     // The post() failed, so we won't get a thread to let
@@ -140,7 +140,7 @@ doRipplePathFind(RPC::JsonContext& context)
     if (!lpLedger)
         return jvResult;
 
-    RPC::LegacyPathFind lpf(isUnlimited(context.role), context.app);
+    RPC::LegacyPathFind const lpf(isUnlimited(context.role), context.app);
     if (!lpf.isOk())
         return rpcError(rpcTOO_BUSY);
 
diff --git a/src/xrpld/rpc/handlers/ServerDefinitions.cpp b/src/xrpld/rpc/handlers/ServerDefinitions.cpp
index 2f11e18efb..f99f427ca8 100644
--- a/src/xrpld/rpc/handlers/ServerDefinitions.cpp
+++ b/src/xrpld/rpc/handlers/ServerDefinitions.cpp
@@ -123,7 +123,7 @@ ServerDefinitions::ServerDefinitions() : defs_{Json::objectValue}
     std::map<int32_t, std::string> typeMap{{-1, "Done"}};
     for (auto const& [rawName, typeValue] : sTypeMap)
     {
-        std::string typeName = translate(std::string(rawName).substr(4) /* remove STI_ */);
+        std::string const typeName = translate(std::string(rawName).substr(4) /* remove STI_ */);
         defs_[jss::TYPES][typeName] = typeValue;
         typeMap[typeValue] = typeName;
     }
diff --git a/src/xrpld/rpc/handlers/Stop.cpp b/src/xrpld/rpc/handlers/Stop.cpp
index d2f1cd7a80..b47c35e21d 100644
--- a/src/xrpld/rpc/handlers/Stop.cpp
+++ b/src/xrpld/rpc/handlers/Stop.cpp
@@ -7,7 +7,7 @@ namespace xrpl {
 
 namespace RPC {
 struct JsonContext;
-}
+}  // namespace RPC
 
 Json::Value
 doStop(RPC::JsonContext& context)
diff --git a/src/xrpld/rpc/handlers/Subscribe.cpp b/src/xrpld/rpc/handlers/Subscribe.cpp
index fc5238b37b..af3e998a58 100644
--- a/src/xrpld/rpc/handlers/Subscribe.cpp
+++ b/src/xrpld/rpc/handlers/Subscribe.cpp
@@ -32,7 +32,7 @@ doSubscribe(RPC::JsonContext& context)
         if (context.role != Role::ADMIN)
             return rpcError(rpcNO_PERMISSION);
 
-        std::string strUrl = context.params[jss::url].asString();
+        std::string const strUrl = context.params[jss::url].asString();
         std::string strUsername = context.params.isMember(jss::url_username)
             ? context.params[jss::url_username].asString()
             : "";
@@ -106,7 +106,7 @@ doSubscribe(RPC::JsonContext& context)
             if (!it.isString())
                 return rpcError(rpcSTREAM_MALFORMED);
 
-            std::string streamName = it.asString();
+            std::string const streamName = it.asString();
             if (streamName == "server")
             {
                 context.netOps.subServer(ispSub, jvResult, context.role == Role::ADMIN);
diff --git a/src/xrpld/rpc/handlers/Tx.cpp b/src/xrpld/rpc/handlers/Tx.cpp
index 211372db45..a3ed788060 100644
--- a/src/xrpld/rpc/handlers/Tx.cpp
+++ b/src/xrpld/rpc/handlers/Tx.cpp
@@ -125,7 +125,8 @@ doTxHelp(RPC::Context& context, TxArgs args)
         return {result, rpcSUCCESS};
     }
 
-    std::shared_ptr<Ledger const> ledger = context.ledgerMaster.getLedgerBySeq(txn->getLedger());
+    std::shared_ptr<Ledger const> const ledger =
+        context.ledgerMaster.getLedgerBySeq(txn->getLedger());
 
     if (ledger && !ledger->open())
         result.ledgerHash = ledger->header().hash;
@@ -148,9 +149,9 @@ doTxHelp(RPC::Context& context, TxArgs args)
         // compute outgoing CTID
         if (meta->getAsObject().isFieldPresent(sfTransactionIndex))
         {
-            uint32_t lgrSeq = ledger->header().seq;
-            uint32_t txnIdx = meta->getAsObject().getFieldU32(sfTransactionIndex);
-            uint32_t netID = context.app.getNetworkIDService().getNetworkID();
+            uint32_t const lgrSeq = ledger->header().seq;
+            uint32_t const txnIdx = meta->getAsObject().getFieldU32(sfTransactionIndex);
+            uint32_t const netID = context.app.getNetworkIDService().getNetworkID();
 
             if (txnIdx <= 0xFFFFU && netID < 0xFFFFU && lgrSeq < 0x0FFF'FFFFUL)
                 result.ctid = RPC::encodeCTID(lgrSeq, txnIdx, netID);
@@ -310,7 +311,7 @@ doTxJson(RPC::JsonContext& context)
         }
     }
 
-    std::pair<TxResult, RPC::Status> res = doTxHelp(context, args);
+    std::pair<TxResult, RPC::Status> const res = doTxHelp(context, args);
     return populateJsonResponse(res, args, context);
 }
 
diff --git a/src/xrpld/rpc/handlers/TxHistory.cpp b/src/xrpld/rpc/handlers/TxHistory.cpp
index 02ff6fb43c..3467b1c990 100644
--- a/src/xrpld/rpc/handlers/TxHistory.cpp
+++ b/src/xrpld/rpc/handlers/TxHistory.cpp
@@ -27,7 +27,7 @@ doTxHistory(RPC::JsonContext& context)
     if (!context.params.isMember(jss::start))
         return rpcError(rpcINVALID_PARAMS);
 
-    unsigned int startIndex = context.params[jss::start].asUInt();
+    unsigned int const startIndex = context.params[jss::start].asUInt();
 
     if ((startIndex > 10000) && (!isUnlimited(context.role)))
         return rpcError(rpcNO_PERMISSION);
diff --git a/src/xrpld/rpc/handlers/Unsubscribe.cpp b/src/xrpld/rpc/handlers/Unsubscribe.cpp
index 824d57203c..d3e36cc612 100644
--- a/src/xrpld/rpc/handlers/Unsubscribe.cpp
+++ b/src/xrpld/rpc/handlers/Unsubscribe.cpp
@@ -28,7 +28,7 @@ doUnsubscribe(RPC::JsonContext& context)
         if (context.role != Role::ADMIN)
             return rpcError(rpcNO_PERMISSION);
 
-        std::string strUrl = context.params[jss::url].asString();
+        std::string const strUrl = context.params[jss::url].asString();
         ispSub = context.netOps.findRpcSub(strUrl);
         if (!ispSub)
             return jvResult;
@@ -49,7 +49,7 @@ doUnsubscribe(RPC::JsonContext& context)
             if (!it.isString())
                 return rpcError(rpcSTREAM_MALFORMED);
 
-            std::string streamName = it.asString();
+            std::string const streamName = it.asString();
             if (streamName == "server")
             {
                 context.netOps.unsubServer(ispSub->getSeq());
diff --git a/src/xrpld/shamap/NodeFamily.cpp b/src/xrpld/shamap/NodeFamily.cpp
index ec5e9eb1b2..3460c68608 100644
--- a/src/xrpld/shamap/NodeFamily.cpp
+++ b/src/xrpld/shamap/NodeFamily.cpp
@@ -39,7 +39,7 @@ void
 NodeFamily::reset()
 {
     {
-        std::lock_guard lock(maxSeqMutex_);
+        std::lock_guard const lock(maxSeqMutex_);
         maxSeq_ = 0;
     }