Merge remote-tracking branch 'XRPLF/pratik/Fix_asan_lsan_flagged_issues' into ximinez/number_asan

* XRPLF/pratik/Fix_asan_lsan_flagged_issues: (61 commits)
  Apply suggestion from @pratikmankawde
  refactor: Modularize app/tx (6228)
  do not fix the stack size
  refactor: Decouple app/tx from `Application` and `Config` (6227)
  increase timeout
  chore: Update clang-format to 21.1.8 (6352)
  reverted change in Number
  halt on error  = 0
  remove printXXX from asan rt args
  remove symbolize option from asan
  only run asan
  supp. coro releated asan errors
  run sanitizer tests in parallel
  refactor: Modularize `HashRouter`, `Conditions`, and `OrderBookDB` (6226)
  increase timeout for sanitizer jobs
  chore: Fix minor issues in comments (6346)
  refactor: Modularize the NetworkOPs interface (6225)
  removing timeout changes
  increase timeout for sanitizer builds, since we are seeing timeouts
  increase stack size of coroutine
  ...

.clang-format

@@ -37,7 +37,7 @@ BinPackParameters: false
 BreakBeforeBinaryOperators: false
 BreakBeforeTernaryOperators: true
 BreakConstructorInitializersBeforeComma: true
-ColumnLimit: 100
+ColumnLimit: 120
 CommentPragmas: "^ IWYU pragma:"
 ConstructorInitializerAllOnOneLineOrOnePerLine: true
 ConstructorInitializerIndentWidth: 4

.github/scripts/levelization/results/ordering.txt

@@ -32,6 +32,14 @@ libxrpl.server > xrpl.server
 libxrpl.shamap > xrpl.basics
 libxrpl.shamap > xrpl.protocol
 libxrpl.shamap > xrpl.shamap
+libxrpl.tx > xrpl.basics
+libxrpl.tx > xrpl.conditions
+libxrpl.tx > xrpl.core
+libxrpl.tx > xrpl.json
+libxrpl.tx > xrpl.ledger
+libxrpl.tx > xrpl.protocol
+libxrpl.tx > xrpl.server
+libxrpl.tx > xrpl.tx
 test.app > test.jtx
 test.app > test.rpc
 test.app > test.toplevel
@@ -49,6 +57,7 @@ test.app > xrpl.protocol
 test.app > xrpl.rdb
 test.app > xrpl.resource
 test.app > xrpl.server
+test.app > xrpl.tx
 test.basics > test.jtx
 test.basics > test.unit_test
 test.basics > xrpl.basics
@@ -67,6 +76,7 @@ test.consensus > xrpld.app
 test.consensus > xrpld.consensus
 test.consensus > xrpl.json
 test.consensus > xrpl.ledger
+test.consensus > xrpl.tx
 test.core > test.jtx
 test.core > test.toplevel
 test.core > test.unit_test
@@ -93,6 +103,7 @@ test.jtx > xrpl.net
 test.jtx > xrpl.protocol
 test.jtx > xrpl.resource
 test.jtx > xrpl.server
+test.jtx > xrpl.tx
 test.ledger > test.jtx
 test.ledger > test.toplevel
 test.ledger > xrpl.basics
@@ -138,9 +149,11 @@ test.rpc > xrpld.core
 test.rpc > xrpld.overlay
 test.rpc > xrpld.rpc
 test.rpc > xrpl.json
+test.rpc > xrpl.ledger
 test.rpc > xrpl.protocol
 test.rpc > xrpl.resource
 test.rpc > xrpl.server
+test.rpc > xrpl.tx
 test.server > test.jtx
 test.server > test.toplevel
 test.server > test.unit_test
@@ -171,6 +184,7 @@ xrpl.json > xrpl.basics
 xrpl.ledger > xrpl.basics
 xrpl.ledger > xrpl.protocol
 xrpl.ledger > xrpl.server
+xrpl.ledger > xrpl.shamap
 xrpl.net > xrpl.basics
 xrpl.nodestore > xrpl.basics
 xrpl.nodestore > xrpl.protocol
@@ -192,9 +206,12 @@ xrpl.server > xrpl.shamap
 xrpl.shamap > xrpl.basics
 xrpl.shamap > xrpl.nodestore
 xrpl.shamap > xrpl.protocol
+xrpl.tx > xrpl.basics
+xrpl.tx > xrpl.core
+xrpl.tx > xrpl.ledger
+xrpl.tx > xrpl.protocol
 xrpld.app > test.unit_test
 xrpld.app > xrpl.basics
-xrpld.app > xrpl.conditions
 xrpld.app > xrpl.core
 xrpld.app > xrpld.consensus
 xrpld.app > xrpld.core
@@ -207,6 +224,7 @@ xrpld.app > xrpl.rdb
 xrpld.app > xrpl.resource
 xrpld.app > xrpl.server
 xrpld.app > xrpl.shamap
+xrpld.app > xrpl.tx
 xrpld.consensus > xrpl.basics
 xrpld.consensus > xrpl.json
 xrpld.consensus > xrpl.protocol
@@ -225,6 +243,7 @@ xrpld.overlay > xrpl.protocol
 xrpld.overlay > xrpl.rdb
 xrpld.overlay > xrpl.resource
 xrpld.overlay > xrpl.server
+xrpld.overlay > xrpl.tx
 xrpld.peerfinder > xrpl.basics
 xrpld.peerfinder > xrpld.core
 xrpld.peerfinder > xrpl.protocol
@@ -244,4 +263,5 @@ xrpld.rpc > xrpl.protocol
 xrpld.rpc > xrpl.rdb
 xrpld.rpc > xrpl.resource
 xrpld.rpc > xrpl.server
+xrpld.rpc > xrpl.tx
 xrpld.shamap > xrpl.shamap

.github/scripts/strategy-matrix/generate.py

@@ -236,21 +236,23 @@ def generate_strategy_matrix(all: bool, config: Config) -> list:
         # names get truncated.
         # Add Address and Thread (both coupled with UB) sanitizers for specific bookworm distros.
         # GCC-Asan rippled-embedded tests are failing because of https://github.com/google/sanitizers/issues/856
-        if (
-            os["distro_version"] == "bookworm"
-            and f"{os['compiler_name']}-{os['compiler_version']}" == "clang-20"
-        ):
+        if os[
+            "distro_version"
+        ] == "bookworm" and f"{os['compiler_name']}-{os['compiler_version']}" in [
+            "clang-20",
+            "gcc-13",
+        ]:
             # Add ASAN + UBSAN configuration.
             configurations.append(
                 {
-                    "config_name": config_name + "-asan-ubsan",
+                    "config_name": config_name + "-asan",
                     "cmake_args": cmake_args,
                     "cmake_target": cmake_target,
                     "build_only": build_only,
                     "build_type": build_type,
                     "os": os,
                     "architecture": architecture,
-                    "sanitizers": "address,undefinedbehavior",
+                    "sanitizers": "address",
                 }
             )
             # TSAN is deactivated due to seg faults with latest compilers.

.github/workflows/reusable-build-test-config.yml

@@ -76,7 +76,8 @@ jobs:
     name: ${{ inputs.config_name }}
     runs-on: ${{ fromJSON(inputs.runs_on) }}
     container: ${{ inputs.image != '' && inputs.image || null }}
-    timeout-minutes: 60
+    # Sanitizer builds on GCC are taking longer than 60mins. Hence increasing the timeout to 90mins.
+    timeout-minutes: ${{ inputs.sanitizers != '' && 150 || 60 }}
     env:
       # Use a namespace to keep the objects separate for each configuration.
       CCACHE_NAMESPACE: ${{ inputs.config_name }}
@@ -205,14 +206,18 @@ jobs:
       - name: Set sanitizer options
         if: ${{ !inputs.build_only && env.SANITIZERS_ENABLED == 'true' }}
         run: |
-          echo "ASAN_OPTIONS=print_stacktrace=1:detect_container_overflow=0:suppressions=${GITHUB_WORKSPACE}/sanitizers/suppressions/asan.supp" >> ${GITHUB_ENV}
-          echo "TSAN_OPTIONS=second_deadlock_stack=1:halt_on_error=0:suppressions=${GITHUB_WORKSPACE}/sanitizers/suppressions/tsan.supp" >> ${GITHUB_ENV}
-          echo "UBSAN_OPTIONS=suppressions=${GITHUB_WORKSPACE}/sanitizers/suppressions/ubsan.supp" >> ${GITHUB_ENV}
-          echo "LSAN_OPTIONS=suppressions=${GITHUB_WORKSPACE}/sanitizers/suppressions/lsan.supp" >> ${GITHUB_ENV}
+          echo "ASAN_OPTIONS=include=${GITHUB_WORKSPACE}/sanitizers/suppressions/runtime-asan-options.txt:suppressions=${GITHUB_WORKSPACE}/sanitizers/suppressions/asan.supp" >> ${GITHUB_ENV}
+          echo "TSAN_OPTIONS=include=${GITHUB_WORKSPACE}/sanitizers/suppressions/runtime-tsan-options.txt:suppressions=${GITHUB_WORKSPACE}/sanitizers/suppressions/tsan.supp" >> ${GITHUB_ENV}
+          echo "UBSAN_OPTIONS=include=${GITHUB_WORKSPACE}/sanitizers/suppressions/runtime-ubsan-options.txt:suppressions=${GITHUB_WORKSPACE}/sanitizers/suppressions/ubsan.supp" >> ${GITHUB_ENV}
+          echo "LSAN_OPTIONS=include=${GITHUB_WORKSPACE}/sanitizers/suppressions/runtime-lsan-options.txt:suppressions=${GITHUB_WORKSPACE}/sanitizers/suppressions/lsan.supp" >> ${GITHUB_ENV}
 
       - name: Run the separate tests
+        # We continue on error here because we want to try the Embedded tests before
+        # failing. This will give us details on all the failures at once.
+        continue-on-error: true
         if: ${{ !inputs.build_only }}
         working-directory: ${{ env.BUILD_DIR }}
+        id: separate_tests
         # Windows locks some of the build files while running tests, and parallel jobs can collide
         env:
           BUILD_TYPE: ${{ inputs.build_type }}
@@ -228,8 +233,14 @@ jobs:
         working-directory: ${{ runner.os == 'Windows' && format('{0}/{1}', env.BUILD_DIR, inputs.build_type) || env.BUILD_DIR }}
         env:
           BUILD_NPROC: ${{ steps.nproc.outputs.nproc }}
+          PARALLELISM: ${{ env.SANITIZERS_ENABLED == 'true' && steps.nproc.outputs.nproc || steps.nproc.outputs.nproc }}
         run: |
-          ./xrpld --unittest --unittest-jobs "${BUILD_NPROC}"
+          ./xrpld --unittest --unittest-jobs "${PARALLELISM}"
+
+        # Pipeline should fail if the separate tests failed.
+      - name: Check results of the SeparateTests
+        if: ${{ !inputs.build_only && steps.separate_tests.outcome == 'failure' }}
+        run: exit 1
 
       - name: Debug failure (Linux)
         if: ${{ failure() && runner.os == 'Linux' && !inputs.build_only }}

cmake/XrplConfig.cmake

@@ -17,12 +17,10 @@ find_dependency(Boost
                 chrono
                 container
                 context
-                coroutine
                 date_time
                 filesystem
                 program_options
                 regex
-                system
                 thread)
 #[=========================================================[
   OpenSSL

cmake/XrplCore.cmake

@@ -109,8 +109,12 @@ target_link_libraries(
            xrpl.libxrpl.protocol
            xrpl.libxrpl.rdb
            xrpl.libxrpl.server
+           xrpl.libxrpl.shamap
            xrpl.libxrpl.conditions)
 
+add_module(xrpl tx)
+target_link_libraries(xrpl.libxrpl.tx PUBLIC xrpl.libxrpl.ledger)
+
 add_library(xrpl.libxrpl)
 set_target_properties(xrpl.libxrpl PROPERTIES OUTPUT_NAME xrpl)
 
@@ -135,7 +139,8 @@ target_link_modules(
     rdb
     resource
     server
-    shamap)
+    shamap
+    tx)
 
 # All headers in libxrpl are in modules.
 # Uncomment this stanza if you have not yet moved new headers into a module.

cmake/XrplInstall.cmake

@@ -32,6 +32,7 @@ install(TARGETS common
                 xrpl.libxrpl.resource
                 xrpl.libxrpl.server
                 xrpl.libxrpl.shamap
+                xrpl.libxrpl.tx
                 antithesis-sdk-cpp
         EXPORT XrplExports
         LIBRARY DESTINATION lib

cmake/XrplInterface.cmake

@@ -22,7 +22,7 @@ target_compile_definitions(
               BOOST_FILESYSTEM_NO_DEPRECATED
               >
               $<$<NOT:$<BOOL:${boost_show_deprecated}>>:
-              BOOST_COROUTINES_NO_DEPRECATION_WARNING
+              BOOST_COROUTINES2_NO_DEPRECATION_WARNING
               BOOST_BEAST_ALLOW_DEPRECATED
               BOOST_FILESYSTEM_DEPRECATED
               >

cmake/deps/Boost.cmake

@@ -4,13 +4,12 @@ include(XrplSanitizers)
 find_package(Boost REQUIRED
              COMPONENTS chrono
                         container
-                        coroutine
+                        context
                         date_time
                         filesystem
                         json
                         program_options
                         regex
-                        system
                         thread)
 
 add_library(xrpl_boost INTERFACE)
@@ -21,7 +20,7 @@ target_link_libraries(
     INTERFACE Boost::headers
               Boost::chrono
               Boost::container
-              Boost::coroutine
+              Boost::context
               Boost::date_time
               Boost::filesystem
               Boost::json
@@ -32,13 +31,33 @@ target_link_libraries(
 if (Boost_COMPILER)
     target_link_libraries(xrpl_boost INTERFACE Boost::disable_autolinking)
 endif ()
-if (SANITIZERS_ENABLED AND is_clang)
-    # TODO: gcc does not support -fsanitize-blacklist...can we do something else for gcc ?
-    if (NOT Boost_INCLUDE_DIRS AND TARGET Boost::headers)
-        get_target_property(Boost_INCLUDE_DIRS Boost::headers INTERFACE_INCLUDE_DIRECTORIES)
-    endif ()
-    message(STATUS "Adding [${Boost_INCLUDE_DIRS}] to sanitizer blacklist")
-    file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/san_bl.txt "src:${Boost_INCLUDE_DIRS}/*")
-    target_compile_options(opts INTERFACE # ignore boost headers for sanitizing
-                                          -fsanitize-blacklist=${CMAKE_CURRENT_BINARY_DIR}/san_bl.txt)
+
+# GCC 14+ has a false positive -Wuninitialized warning in Boost.Coroutine2's
+# state.hpp when compiled with -O3. This is due to GCC's intentional behavior
+# change (Bug #98871, #119388) where warnings from inlined system header code
+# are no longer suppressed by -isystem. The warning occurs in operator|= in
+# boost/coroutine2/detail/state.hpp when inlined from push_control_block::destroy().
+# See: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=119388
+if (is_gcc AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 14)
+    target_compile_options(xrpl_boost INTERFACE -Wno-uninitialized)
 endif ()
+
+# Boost.Context's ucontext backend has ASAN fiber-switching annotations
+# (start/finish_switch_fiber) that are compiled in when BOOST_USE_ASAN is defined.
+# This tells ASAN about coroutine stack switches, preventing false positive
+# stack-use-after-scope errors. BOOST_USE_UCONTEXT ensures the ucontext backend
+# is selected (fcontext does not support ASAN annotations).
+# These defines must match what Boost was compiled with (see conan/profiles/sanitizers).
+if (enable_asan)
+    target_compile_definitions(xrpl_boost INTERFACE BOOST_USE_ASAN BOOST_USE_UCONTEXT)
+endif ()
+# if (SANITIZERS_ENABLED AND is_clang)
+#     # TODO: gcc does not support -fsanitize-blacklist...can we do something else for gcc ?
+#     if (NOT Boost_INCLUDE_DIRS AND TARGET Boost::headers)
+#         get_target_property(Boost_INCLUDE_DIRS Boost::headers INTERFACE_INCLUDE_DIRECTORIES)
+#     endif ()
+#     message(STATUS "Adding [${Boost_INCLUDE_DIRS}] to sanitizer blacklist")
+#     file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/san_bl.txt "src:${Boost_INCLUDE_DIRS}/*")
+#     target_compile_options(opts INTERFACE # ignore boost headers for sanitizing
+#                                           -fsanitize-blacklist=${CMAKE_CURRENT_BINARY_DIR}/san_bl.txt)
+# endif ()

conan/profiles/sanitizers

@@ -7,16 +7,21 @@ include(default)
     {% if compiler == "gcc" %}
         {% if "address" in sanitizers or "thread" in sanitizers or "undefinedbehavior" in sanitizers %}
             {% set sanitizer_list = [] %}
+            {% set defines = [] %}
             {% set model_code = "" %}
             {% set extra_cxxflags = ["-fno-omit-frame-pointer", "-O1", "-Wno-stringop-overflow"] %}
 
             {% if "address" in sanitizers %}
                 {% set _ = sanitizer_list.append("address") %}
                 {% set model_code = "-mcmodel=large" %}
+                {% set _ = defines.append("BOOST_USE_ASAN")%}
+                {% set _ = defines.append("BOOST_USE_UCONTEXT")%}
             {% elif "thread" in sanitizers %}
                 {% set _ = sanitizer_list.append("thread") %}
                 {% set model_code = "-mcmodel=medium" %}
                 {% set _ = extra_cxxflags.append("-Wno-tsan") %}
+                {% set _ = defines.append("BOOST_USE_TSAN")%}
+                {% set _ = defines.append("BOOST_USE_UCONTEXT")%}
             {% endif %}
 
             {% if "undefinedbehavior" in sanitizers %}
@@ -29,16 +34,22 @@ include(default)
             tools.build:cxxflags+=['{{sanitizer_flags}} {{" ".join(extra_cxxflags)}}']
             tools.build:sharedlinkflags+=['{{sanitizer_flags}}']
             tools.build:exelinkflags+=['{{sanitizer_flags}}']
+            tools.build:defines+={{defines}}
         {% endif %}
     {% elif compiler == "apple-clang" or compiler == "clang" %}
         {% if "address" in sanitizers or "thread" in sanitizers or "undefinedbehavior" in sanitizers %}
             {% set sanitizer_list = [] %}
+            {% set defines = [] %}
             {% set extra_cxxflags = ["-fno-omit-frame-pointer", "-O1"] %}
 
             {% if "address" in sanitizers %}
                 {% set _ = sanitizer_list.append("address") %}
+                {% set _ = defines.append("BOOST_USE_ASAN")%}
+                {% set _ = defines.append("BOOST_USE_UCONTEXT")%}
             {% elif "thread" in sanitizers %}
                 {% set _ = sanitizer_list.append("thread") %}
+                {% set _ = defines.append("BOOST_USE_TSAN")%}
+                {% set _ = defines.append("BOOST_USE_UCONTEXT")%}
             {% endif %}
 
             {% if "undefinedbehavior" in sanitizers %}
@@ -52,8 +63,24 @@ include(default)
             tools.build:cxxflags+=['{{sanitizer_flags}} {{" ".join(extra_cxxflags)}}']
             tools.build:sharedlinkflags+=['{{sanitizer_flags}}']
             tools.build:exelinkflags+=['{{sanitizer_flags}}']
+            tools.build:defines+={{defines}}
         {% endif %}
     {% endif %}
 {% endif %}
 
-tools.info.package_id:confs+=["tools.build:cxxflags", "tools.build:exelinkflags", "tools.build:sharedlinkflags"]
+tools.info.package_id:confs+=["tools.build:cxxflags", "tools.build:exelinkflags", "tools.build:sharedlinkflags", "tools.build:defines"]
+
+[options]
+{% if sanitizers %}
+    {% if "address" in sanitizers %}
+        # Build Boost.Context with ucontext backend (not fcontext) so that
+        # ASAN fiber-switching annotations (__sanitizer_start/finish_switch_fiber)
+        # are compiled into the library. fcontext (assembly) has no ASAN support.
+        # define=BOOST_USE_ASAN=1 is critical: it must be defined when building
+        # Boost.Context itself so the ucontext backend compiles in the ASAN annotations.
+        boost/*:extra_b2_flags=context-impl=ucontext address-sanitizer=on define=BOOST_USE_ASAN=1
+        boost/*:without_context=False
+        # Boost stacktrace fails to build with some sanitizers
+        boost/*:without_stacktrace=True
+    {% endif %}
+{% endif %}

conanfile.py

@@ -1,4 +1,5 @@
 import re
+import os
 
 from conan.tools.cmake import CMake, CMakeToolchain, cmake_layout
 
@@ -57,6 +58,9 @@ class Xrpl(ConanFile):
         "tests": False,
         "unity": False,
         "xrpld": False,
+        "boost/*:without_context": False,
+        "boost/*:without_coroutine": True,
+        "boost/*:without_coroutine2": False,
         "date/*:header_only": True,
         "ed25519/*:shared": False,
         "grpc/*:shared": False,
@@ -125,6 +129,14 @@ class Xrpl(ConanFile):
             self.options["boost"].visibility = "global"
         if self.settings.compiler in ["clang", "gcc"]:
             self.options["boost"].without_cobalt = True
+        self.options["boost"].without_context = False
+        self.options["boost"].without_coroutine = True
+        self.options["boost"].without_coroutine2 = False
+        # Check if environment variable exists
+        if "SANITIZERS" in os.environ:
+            sanitizers = os.environ["SANITIZERS"]
+            if "address" in sanitizers.lower():
+                self.default_options["fPIC"] = False
 
     def requirements(self):
         # Conan 2 requires transitive headers to be specified
@@ -196,7 +208,8 @@ class Xrpl(ConanFile):
             "boost::headers",
             "boost::chrono",
             "boost::container",
-            "boost::coroutine",
+            "boost::context",
+            "boost::coroutine2",
             "boost::date_time",
             "boost::filesystem",
             "boost::json",

cspell.config.yaml

@@ -98,8 +98,10 @@ words:
   - endmacro
   - exceptioned
   - Falco
+  - fcontext
   - finalizers
   - firewalled
+  - flackiness
   - fmtdur
   - fsanitize
   - funclets
@@ -110,6 +112,7 @@ words:
   - gpgcheck
   - gpgkey
   - hotwallet
+  - hwaddress
   - hwrap
   - ifndef
   - inequation
@@ -173,6 +176,7 @@ words:
   - nftpage
   - nikb
   - nonxrp
+  - norecover
   - noripple
   - nudb
   - nullptr
@@ -232,6 +236,7 @@ words:
   - soci
   - socidb
   - sslws
+  - stackful
   - statsd
   - STATSDCOLLECTOR
   - stissue

docs/build/sanitizers.md

@@ -89,8 +89,8 @@ cmake --build . --parallel 4
 **IMPORTANT**: ASAN with Boost produces many false positives. Use these options:
 
 ```bash
-export ASAN_OPTIONS="print_stacktrace=1:detect_container_overflow=0:suppressions=path/to/asan.supp:halt_on_error=0:log_path=asan.log"
-export LSAN_OPTIONS="suppressions=path/to/lsan.supp:halt_on_error=0:log_path=lsan.log"
+export ASAN_OPTIONS="include=sanitizers/suppressions/runtime-asan-options.txt:suppressions=sanitizers/suppressions/asan.supp"
+export LSAN_OPTIONS="include=sanitizers/suppressions/runtime-lsan-options.txt:suppressions=sanitizers/suppressions/lsan.supp"
 
 # Run tests
 ./xrpld --unittest --unittest-jobs=5
@@ -108,7 +108,7 @@ export LSAN_OPTIONS="suppressions=path/to/lsan.supp:halt_on_error=0:log_path=lsa
 ### ThreadSanitizer (TSan)
 
 ```bash
-export TSAN_OPTIONS="suppressions=path/to/tsan.supp halt_on_error=0 log_path=tsan.log"
+export TSAN_OPTIONS="include=sanitizers/suppressions/runtime-tsan-options.txt:suppressions=sanitizers/suppressions/tsan.supp"
 
 # Run tests
 ./xrpld --unittest --unittest-jobs=5
@@ -129,7 +129,7 @@ More details [here](https://github.com/google/sanitizers/wiki/AddressSanitizerLe
 ### UndefinedBehaviorSanitizer (UBSan)
 
 ```bash
-export UBSAN_OPTIONS="suppressions=path/to/ubsan.supp:print_stacktrace=1:halt_on_error=0:log_path=ubsan.log"
+export UBSAN_OPTIONS="include=sanitizers/suppressions/runtime-ubsan-options.txt:suppressions=sanitizers/suppressions/ubsan.supp"
 
 # Run tests
 ./xrpld --unittest --unittest-jobs=5

include/xrpl/basics/BasicConfig.h

@@ -84,8 +84,7 @@ public:
         if (lines_.empty())
             return "";
         if (lines_.size() > 1)
-            Throw<std::runtime_error>(
-                "A legacy value must have exactly one line. Section: " + name_);
+            Throw<std::runtime_error>("A legacy value must have exactly one line. Section: " + name_);
         return lines_[0];
     }
 
@@ -269,8 +268,7 @@ public:
     bool
     had_trailing_comments() const
     {
-        return std::any_of(
-            map_.cbegin(), map_.cend(), [](auto s) { return s.second.had_trailing_comments(); });
+        return std::any_of(map_.cbegin(), map_.cend(), [](auto s) { return s.second.had_trailing_comments(); });
     }
 
 protected:

include/xrpl/basics/CompressionAlgorithms.h

@@ -35,10 +35,7 @@ lz4Compress(void const* in, std::size_t inSize, BufferFactory&& bf)
     auto compressed = bf(outCapacity);
 
     auto compressedSize = LZ4_compress_default(
-        reinterpret_cast<char const*>(in),
-        reinterpret_cast<char*>(compressed),
-        inSize,
-        outCapacity);
+        reinterpret_cast<char const*>(in), reinterpret_cast<char*>(compressed), inSize, outCapacity);
     if (compressedSize == 0)
         Throw<std::runtime_error>("lz4 compress: failed");
 
@@ -69,10 +66,8 @@ lz4Decompress(
         Throw<std::runtime_error>("lz4Decompress: integer overflow (output)");
 
     if (LZ4_decompress_safe(
-            reinterpret_cast<char const*>(in),
-            reinterpret_cast<char*>(decompressed),
-            inSize,
-            decompressedSize) != decompressedSize)
+            reinterpret_cast<char const*>(in), reinterpret_cast<char*>(decompressed), inSize, decompressedSize) !=
+        decompressedSize)
         Throw<std::runtime_error>("lz4Decompress: failed");
 
     return decompressedSize;
@@ -88,11 +83,7 @@ lz4Decompress(
  */
 template <typename InputStream>
 std::size_t
-lz4Decompress(
-    InputStream& in,
-    std::size_t inSize,
-    std::uint8_t* decompressed,
-    std::size_t decompressedSize)
+lz4Decompress(InputStream& in, std::size_t inSize, std::uint8_t* decompressed, std::size_t decompressedSize)
 {
     std::vector<std::uint8_t> compressed;
     std::uint8_t const* chunk = nullptr;

include/xrpl/basics/DecayingSample.h

@@ -55,8 +55,7 @@ private:
 
         if (m_value != value_type())
         {
-            std::size_t elapsed =
-                std::chrono::duration_cast<std::chrono::seconds>(now - m_when).count();
+            std::size_t elapsed = std::chrono::duration_cast<std::chrono::seconds>(now - m_when).count();
 
             // A span larger than four times the window decays the
             // value to an insignificant amount so just reset it.

include/xrpl/basics/Expected.h

@@ -120,8 +120,7 @@ public:
 
     template <typename U>
         requires std::convertible_to<U, E> && (!std::is_reference_v<U>)
-    constexpr Expected(Unexpected<U> e)
-        : Base(boost::outcome_v2::in_place_type_t<E>{}, std::move(e.value()))
+    constexpr Expected(Unexpected<U> e) : Base(boost::outcome_v2::in_place_type_t<E>{}, std::move(e.value()))
     {
     }
 
@@ -192,8 +191,7 @@ public:
 // Specialization of Expected<void, E>.  Allows returning either success
 // (without a value) or the reason for the failure.
 template <class E>
-class [[nodiscard]]
-Expected<void, E> : private boost::outcome_v2::result<void, E, detail::throw_policy>
+class [[nodiscard]] Expected<void, E> : private boost::outcome_v2::result<void, E, detail::throw_policy>
 {
     using Base = boost::outcome_v2::result<void, E, detail::throw_policy>;
 

include/xrpl/basics/FileUtilities.h

@@ -14,9 +14,6 @@ getFileContents(
     std::optional<std::size_t> maxSize = std::nullopt);
 
 void
-writeFileContents(
-    boost::system::error_code& ec,
-    boost::filesystem::path const& destPath,
-    std::string const& contents);
+writeFileContents(boost::system::error_code& ec, boost::filesystem::path const& destPath, std::string const& contents);
 
 }  // namespace xrpl

include/xrpl/basics/IntrusivePointer.h

@@ -44,8 +44,8 @@ struct SharedIntrusiveAdoptNoIncrementTag
 //
 
 template <class T>
-concept CAdoptTag = std::is_same_v<T, SharedIntrusiveAdoptIncrementStrongTag> ||
-    std::is_same_v<T, SharedIntrusiveAdoptNoIncrementTag>;
+concept CAdoptTag =
+    std::is_same_v<T, SharedIntrusiveAdoptIncrementStrongTag> || std::is_same_v<T, SharedIntrusiveAdoptNoIncrementTag>;
 
 //------------------------------------------------------------------------------
 
@@ -443,8 +443,7 @@ make_SharedIntrusive(Args&&... args)
     auto p = new TT(std::forward<Args>(args)...);
 
     static_assert(
-        noexcept(SharedIntrusive<TT>(
-            std::declval<TT*>(), std::declval<SharedIntrusiveAdoptNoIncrementTag>())),
+        noexcept(SharedIntrusive<TT>(std::declval<TT*>(), std::declval<SharedIntrusiveAdoptNoIncrementTag>())),
         "SharedIntrusive constructor should not throw or this can leak "
         "memory");
 

include/xrpl/basics/IntrusiveRefCounts.h

@@ -184,8 +184,7 @@ private:
 
     /** Mask that will zero out everything except the weak count.
      */
-    static constexpr FieldType weakMask =
-        (((one << WeakCountNumBits) - 1) << StrongCountNumBits) & valueMask;
+    static constexpr FieldType weakMask = (((one << WeakCountNumBits) - 1) << StrongCountNumBits) & valueMask;
 
     /** Unpack the count and tag fields from the packed atomic integer form. */
     struct RefCountPair
@@ -210,10 +209,8 @@ private:
         FieldType
         combinedValue() const noexcept;
 
-        static constexpr CountType maxStrongValue =
-            static_cast<CountType>((one << StrongCountNumBits) - 1);
-        static constexpr CountType maxWeakValue =
-            static_cast<CountType>((one << WeakCountNumBits) - 1);
+        static constexpr CountType maxStrongValue = static_cast<CountType>((one << StrongCountNumBits) - 1);
+        static constexpr CountType maxWeakValue = static_cast<CountType>((one << WeakCountNumBits) - 1);
         /**  Put an extra margin to detect when running up against limits.
              This is only used in debug code, and is useful if we reduce the
              number of bits in the strong and weak counts (to 16 and 14 bits).
@@ -398,8 +395,7 @@ inline IntrusiveRefCounts::~IntrusiveRefCounts() noexcept
 {
 #ifndef NDEBUG
     auto v = refCounts.load(std::memory_order_acquire);
-    XRPL_ASSERT(
-        (!(v & valueMask)), "xrpl::IntrusiveRefCounts::~IntrusiveRefCounts : count must be zero");
+    XRPL_ASSERT((!(v & valueMask)), "xrpl::IntrusiveRefCounts::~IntrusiveRefCounts : count must be zero");
     auto t = v & tagMask;
     XRPL_ASSERT((!t || t == tagMask), "xrpl::IntrusiveRefCounts::~IntrusiveRefCounts : valid tag");
 #endif
@@ -437,10 +433,8 @@ IntrusiveRefCounts::RefCountPair::combinedValue() const noexcept
         (strong < checkStrongMaxValue && weak < checkWeakMaxValue),
         "xrpl::IntrusiveRefCounts::RefCountPair::combinedValue : inputs "
         "inside range");
-    return (static_cast<IntrusiveRefCounts::FieldType>(weak)
-            << IntrusiveRefCounts::StrongCountNumBits) |
-        static_cast<IntrusiveRefCounts::FieldType>(strong) | partialDestroyStartedBit |
-        partialDestroyFinishedBit;
+    return (static_cast<IntrusiveRefCounts::FieldType>(weak) << IntrusiveRefCounts::StrongCountNumBits) |
+        static_cast<IntrusiveRefCounts::FieldType>(strong) | partialDestroyStartedBit | partialDestroyFinishedBit;
 }
 
 template <class T>
@@ -448,8 +442,7 @@ inline void
 partialDestructorFinished(T** o)
 {
     T& self = **o;
-    IntrusiveRefCounts::RefCountPair p =
-        self.refCounts.fetch_or(IntrusiveRefCounts::partialDestroyFinishedMask);
+    IntrusiveRefCounts::RefCountPair p = self.refCounts.fetch_or(IntrusiveRefCounts::partialDestroyFinishedMask);
     XRPL_ASSERT(
         (!p.partialDestroyFinishedBit && p.partialDestroyStartedBit && !p.strong),
         "xrpl::partialDestructorFinished : not a weak ref");

include/xrpl/basics/LocalValue.h

@@ -103,7 +103,6 @@ LocalValue<T>::operator*()
     }
 
     return *reinterpret_cast<T*>(
-        lvs->values.emplace(this, std::make_unique<detail::LocalValues::Value<T>>(t_))
-            .first->second->get());
+        lvs->values.emplace(this, std::make_unique<detail::LocalValues::Value<T>>(t_)).first->second->get());
 }
 }  // namespace xrpl

include/xrpl/basics/Log.h

@@ -170,11 +170,7 @@ public:
     partition_severities() const;
 
     void
-    write(
-        beast::severities::Severity level,
-        std::string const& partition,
-        std::string const& text,
-        bool console);
+    write(beast::severities::Severity level, std::string const& partition, std::string const& text, bool console);
 
     std::string
     rotate();

include/xrpl/basics/Number.h

@@ -9,6 +9,10 @@
 #include <ostream>
 #include <string>
 
+#ifdef _MSC_VER
+#include <boost/multiprecision/cpp_int.hpp>
+#endif  // !defined(_MSC_VER)
+
 namespace xrpl {
 
 class Number;
@@ -16,18 +20,37 @@ class Number;
 std::string
 to_string(Number const& amount);
 
+/** Returns a rough estimate of log10(value).
+ *
+ * The return value is a pair (log, rem), where log is the estimated log10,
+ * and rem is value divided by 10^log. If rem is 1, then value is an exact
+ * power of ten, and log is the exact log10(value).
+ *
+ * This function only works for positive values.
+ */
+template <typename T>
+constexpr std::pair<int, T>
+logTenEstimate(T value)
+{
+    int log = 0;
+    T remainder = value;
+    while (value >= 10)
+    {
+        if (value % 10 == 0)
+            remainder = remainder / 10;
+        value /= 10;
+        ++log;
+    }
+    return {log, remainder};
+}
+
 template <typename T>
 constexpr std::optional<int>
 logTen(T value)
 {
-    int log = 0;
-    while (value >= 10 && value % 10 == 0)
-    {
-        value /= 10;
-        ++log;
-    }
-    if (value == 1)
-        return log;
+    auto const est = logTenEstimate(value);
+    if (est.second == 1)
+        return est.first;
     return std::nullopt;
 }
 
@@ -41,12 +64,10 @@ isPowerOfTen(T value)
 /** MantissaRange defines a range for the mantissa of a normalized Number.
  *
  * The mantissa is in the range [min, max], where
- * * min is a power of 10, and
- * * max = min * 10 - 1.
  *
  * The mantissa_scale enum indicates whether the range is "small" or "large".
  * This intentionally restricts the number of MantissaRanges that can be
- * instantiated to two: one for each scale.
+ * used to two: one for each scale.
  *
  * The "small" scale is based on the behavior of STAmount for IOUs. It has a min
  * value of 10^15, and a max value of 10^16-1. This was sufficient for
@@ -60,8 +81,8 @@ isPowerOfTen(T value)
  * "large" scale.
  *
  * The "large" scale is intended to represent all values that can be represented
- * by an STAmount - IOUs, XRP, and MPTs. It has a min value of 10^18, and a max
- * value of 10^19-1.
+ * by an STAmount - IOUs, XRP, and MPTs. It has a min value of 2^63/10+1
+ * (truncated), and a max value of 2^63-1.
  *
  * Note that if the mentioned amendments are eventually retired, this class
  * should be left in place, but the "small" scale option should be removed. This
@@ -73,25 +94,50 @@ struct MantissaRange
     enum mantissa_scale { small, large };
 
     explicit constexpr MantissaRange(mantissa_scale scale_)
-        : min(getMin(scale_)), max(min * 10 - 1), log(logTen(min).value_or(-1)), scale(scale_)
+        : max(getMax(scale_))
+        , min(computeMin(max))
+        , referenceMin(getReferenceMin(scale_, min))
+        , log(computeLog(min))
+        , scale(scale_)
     {
+        // Since this is constexpr, if any of these throw, it won't compile
+        if (min * 10 <= max)
+            throw std::out_of_range("min * 10 <= max");
+        if (max / 10 >= min)
+            throw std::out_of_range("max / 10 >= min");
+        if ((min - 1) * 10 > max)
+            throw std::out_of_range("(min - 1) * 10 > max");
+        // This is a little hacky
+        if ((max + 10) / 10 < min)
+            throw std::out_of_range("(max + 10) / 10 < min");
     }
 
-    rep min;
+    // Explicitly delete copy and move operations
+    MantissaRange(MantissaRange const&) = delete;
+    MantissaRange(MantissaRange&&) = delete;
+    MantissaRange&
+    operator=(MantissaRange const&) = delete;
+    MantissaRange&
+    operator=(MantissaRange&&) = delete;
+
     rep max;
+    rep min;
+    // This is not a great name. Used to determine if mantissas are in range,
+    // but have fewer digits than max
+    rep referenceMin;
     int log;
     mantissa_scale scale;
 
 private:
     static constexpr rep
-    getMin(mantissa_scale scale_)
+    getMax(mantissa_scale scale)
     {
-        switch (scale_)
+        switch (scale)
         {
             case small:
-                return 1'000'000'000'000'000ULL;
+                return 9'999'999'999'999'999ULL;
             case large:
-                return 1'000'000'000'000'000'000ULL;
+                return std::numeric_limits<std::int64_t>::max();
             default:
                 // Since this can never be called outside a non-constexpr
                 // context, this throw assures that the build fails if an
@@ -99,12 +145,52 @@ private:
                 throw std::runtime_error("Unknown mantissa scale");
         }
     }
+
+    static constexpr rep
+    computeMin(rep max)
+    {
+        return max / 10 + 1;
+    }
+
+    static constexpr rep
+    getReferenceMin(mantissa_scale scale, rep min)
+    {
+        switch (scale)
+        {
+            case large:
+                return 1'000'000'000'000'000'000ULL;
+            default:
+                if (isPowerOfTen(min))
+                    return min;
+                throw std::runtime_error("Unknown/bad mantissa scale");
+        }
+    }
+
+    static constexpr rep
+    computeLog(rep min)
+    {
+        auto const estimate = logTenEstimate(min);
+        return estimate.first + (estimate.second == 1 ? 0 : 1);
+    }
 };
 
 // Like std::integral, but only 64-bit integral types.
 template <class T>
 concept Integral64 = std::is_same_v<T, std::int64_t> || std::is_same_v<T, std::uint64_t>;
 
+namespace detail {
+#ifdef _MSC_VER
+using uint128_t = boost::multiprecision::uint128_t;
+using int128_t = boost::multiprecision::int128_t;
+#else   // !defined(_MSC_VER)
+using uint128_t = __uint128_t;
+using int128_t = __int128_t;
+#endif  // !defined(_MSC_VER)
+
+template <class T>
+concept UnsignedMantissa = std::is_unsigned_v<T> || std::is_same_v<T, uint128_t>;
+}  // namespace detail
+
 /** Number is a floating point type that can represent a wide range of values.
  *
  * It can represent all values that can be represented by an STAmount -
@@ -132,9 +218,7 @@ concept Integral64 = std::is_same_v<T, std::int64_t> || std::is_same_v<T, std::u
  *   1. Normalization can be disabled by using the "unchecked" ctor tag. This
  *      should only be used at specific conversion points, some constexpr
  *      values, and in unit tests.
- *   2. The max of the "large" range, 10^19-1, is the largest 10^X-1 value that
- *      fits in an unsigned 64-bit number. (10^19-1 < 2^64-1 and
- *      10^20-1 > 2^64-1). This avoids under- and overflows.
+ *   2. The max of the "large" range, 2^63-1, TODO: explain the large range.
  *
  * ---- External Interface ----
  *
@@ -148,7 +232,7 @@ concept Integral64 = std::is_same_v<T, std::int64_t> || std::is_same_v<T, std::u
  *
  * Note:
  *   1. 2^63-1 is between 10^18 and 10^19-1, which are the limits of the "large"
- *      mantissa range.
+ *      mantissa range. TODO: update this explanation.
  *   2. The functions mantissa() and exponent() return the external view of the
  *      Number value, specifically using a signed 63-bit mantissa. This may
  *      require altering the internal representation to fit into that range
@@ -208,8 +292,7 @@ class Number
     using rep = std::int64_t;
     using internalrep = MantissaRange::rep;
 
-    bool negative_{false};
-    internalrep mantissa_{0};
+    rep mantissa_{0};
     int exponent_{std::numeric_limits<int>::lowest()};
 
 public:
@@ -217,9 +300,11 @@ public:
     constexpr static int minExponent = -32768;
     constexpr static int maxExponent = 32768;
 
+#if MAXREP
     constexpr static internalrep maxRep = std::numeric_limits<rep>::max();
     static_assert(maxRep == 9'223'372'036'854'775'807);
     static_assert(-maxRep == std::numeric_limits<rep>::min() + 1);
+#endif
 
     // May need to make unchecked private
     struct unchecked
@@ -240,11 +325,7 @@ public:
 
     Number(rep mantissa);
     explicit Number(rep mantissa, int exponent);
-    explicit constexpr Number(
-        bool negative,
-        internalrep mantissa,
-        int exponent,
-        unchecked) noexcept;
+    explicit constexpr Number(bool negative, internalrep mantissa, int exponent, unchecked) noexcept;
     // Assume unsigned values are... unsigned. i.e. positive
     explicit constexpr Number(internalrep mantissa, int exponent, unchecked) noexcept;
     // Only unit tests are expected to use this ctor
@@ -298,8 +379,7 @@ public:
     friend constexpr bool
     operator==(Number const& x, Number const& y) noexcept
     {
-        return x.negative_ == y.negative_ && x.mantissa_ == y.mantissa_ &&
-            x.exponent_ == y.exponent_;
+        return x.mantissa_ == y.mantissa_ && x.exponent_ == y.exponent_;
     }
 
     friend constexpr bool
@@ -313,8 +393,8 @@ public:
     {
         // If the two amounts have different signs (zero is treated as positive)
         // then the comparison is true iff the left is negative.
-        bool const lneg = x.negative_;
-        bool const rneg = y.negative_;
+        bool const lneg = x.mantissa_ < 0;
+        bool const rneg = y.mantissa_ < 0;
 
         if (lneg != rneg)
             return lneg;
@@ -342,7 +422,7 @@ public:
     constexpr int
     signum() const noexcept
     {
-        return negative_ ? -1 : (mantissa_ ? 1 : 0);
+        return mantissa_ < 0 ? -1 : (mantissa_ ? 1 : 0);
     }
 
     Number
@@ -381,6 +461,9 @@ public:
     friend Number
     root2(Number f);
 
+    friend Number
+    power(Number const& f, unsigned n, unsigned d);
+
     // Thread local rounding control.  Default is to_nearest
     enum rounding_mode { to_nearest, towards_zero, downward, upward };
     static rounding_mode
@@ -445,22 +528,48 @@ private:
     static_assert(isPowerOfTen(smallRange.min));
     static_assert(smallRange.min == 1'000'000'000'000'000LL);
     static_assert(smallRange.max == 9'999'999'999'999'999LL);
+    static_assert(smallRange.referenceMin == smallRange.min);
     static_assert(smallRange.log == 15);
+#if MAXREP
     static_assert(smallRange.min < maxRep);
     static_assert(smallRange.max < maxRep);
+#endif
     constexpr static MantissaRange largeRange{MantissaRange::large};
-    static_assert(isPowerOfTen(largeRange.min));
-    static_assert(largeRange.min == 1'000'000'000'000'000'000ULL);
-    static_assert(largeRange.max == internalrep(9'999'999'999'999'999'999ULL));
+    static_assert(!isPowerOfTen(largeRange.min));
+    static_assert(largeRange.min == 922'337'203'685'477'581ULL);
+    static_assert(largeRange.max == internalrep(9'223'372'036'854'775'807ULL));
+    static_assert(largeRange.max == std::numeric_limits<rep>::max());
+    static_assert(largeRange.referenceMin == 1'000'000'000'000'000'000ULL);
     static_assert(largeRange.log == 18);
+    // There are 2 values that will not fit in largeRange without some extra
+    // work
+    // * 9223372036854775808
+    // * 9223372036854775809
+    // They both end up < min, but with a leftover. If they round up, everything
+    // will be fine. If they don't, well need to bring them up into range.
+    // Guard::bringIntoRange handles this situation.
+
+#if MAXREP
     static_assert(largeRange.min < maxRep);
     static_assert(largeRange.max > maxRep);
+#endif
 
     // The range for the mantissa when normalized.
     // Use reference_wrapper to avoid making copies, and prevent accidentally
     // changing the values inside the range.
     static thread_local std::reference_wrapper<MantissaRange const> range_;
 
+    // And one is needed because it needs to choose between oneSmall and
+    // oneLarge based on the current range
+    static Number
+    one(MantissaRange const& range);
+
+    static Number
+    root(MantissaRange const& range, Number f, unsigned d);
+
+    void
+    normalize(MantissaRange const& range);
+
     void
     normalize();
 
@@ -483,11 +592,14 @@ private:
     friend void
     doNormalize(
         bool& negative,
-        T& mantissa_,
-        int& exponent_,
+        T& mantissa,
+        int& exponent,
         MantissaRange::rep const& minMantissa,
         MantissaRange::rep const& maxMantissa);
 
+    bool
+    isnormal(MantissaRange const& range) const noexcept;
+
     bool
     isnormal() const noexcept;
 
@@ -504,15 +616,60 @@ private:
     static internalrep
     externalToInternal(rep mantissa);
 
+    /** Breaks down the number into components, potentially de-normalizing it.
+     *
+     * Ensures that the mantissa always has range_.log + 1 digits.
+     *
+     */
+    template <detail::UnsignedMantissa Rep = internalrep>
+    std::tuple<bool, Rep, int>
+    toInternal(MantissaRange const& range) const;
+
+    /** Breaks down the number into components, potentially de-normalizing it.
+     *
+     * Ensures that the mantissa always has range_.log + 1 digits.
+     *
+     */
+    template <detail::UnsignedMantissa Rep = internalrep>
+    std::tuple<bool, Rep, int>
+    toInternal() const;
+
+    /** Rebuilds the number from components.
+     *
+     * If "normalized" is true, the values are expected to be normalized - all
+     * in their valid ranges.
+     *
+     * If "normalized" is false, the values are expected to be "near
+     * normalized", meaning that the mantissa has to be modified at most once to
+     * bring it back into range.
+     *
+     */
+    template <bool expectNormal = true, detail::UnsignedMantissa Rep = internalrep>
+    void
+    fromInternal(bool negative, Rep mantissa, int exponent, MantissaRange const* pRange);
+
+    /** Rebuilds the number from components.
+     *
+     * If "normalized" is true, the values are expected to be normalized - all
+     * in their valid ranges.
+     *
+     * If "normalized" is false, the values are expected to be "near
+     * normalized", meaning that the mantissa has to be modified at most once to
+     * bring it back into range.
+     *
+     */
+    template <bool expectNormal = true, detail::UnsignedMantissa Rep = internalrep>
+    void
+    fromInternal(bool negative, Rep mantissa, int exponent);
+
     class Guard;
+
+public:
+    constexpr static internalrep largestMantissa = largeRange.max;
 };
 
-inline constexpr Number::Number(
-    bool negative,
-    internalrep mantissa,
-    int exponent,
-    unchecked) noexcept
-    : negative_(negative), mantissa_{mantissa}, exponent_{exponent}
+inline constexpr Number::Number(bool negative, internalrep mantissa, int exponent, unchecked) noexcept
+    : mantissa_{(negative ? -1 : 1) * static_cast<rep>(mantissa)}, exponent_{exponent}
 {
 }
 
@@ -523,14 +680,7 @@ inline constexpr Number::Number(internalrep mantissa, int exponent, unchecked) n
 
 constexpr static Number numZero{};
 
-inline Number::Number(bool negative, internalrep mantissa, int exponent, normalized)
-    : Number(negative, mantissa, exponent, unchecked{})
-{
-    normalize();
-}
-
-inline Number::Number(internalrep mantissa, int exponent, normalized)
-    : Number(false, mantissa, exponent, normalized{})
+inline Number::Number(internalrep mantissa, int exponent, normalized) : Number(false, mantissa, exponent, normalized{})
 {
 }
 
@@ -551,17 +701,7 @@ inline Number::Number(rep mantissa) : Number{mantissa, 0}
 inline constexpr Number::rep
 Number::mantissa() const noexcept
 {
-    auto m = mantissa_;
-    if (m > maxRep)
-    {
-        XRPL_ASSERT_PARTS(
-            !isnormal() || (m % 10 == 0 && m / 10 <= maxRep),
-            "xrpl::Number::mantissa",
-            "large normalized mantissa has no remainder");
-        m /= 10;
-    }
-    auto const sign = negative_ ? -1 : 1;
-    return sign * static_cast<Number::rep>(m);
+    return mantissa_;
 }
 
 /** Returns the exponent of the external view of the Number.
@@ -572,16 +712,7 @@ Number::mantissa() const noexcept
 inline constexpr int
 Number::exponent() const noexcept
 {
-    auto e = exponent_;
-    if (mantissa_ > maxRep)
-    {
-        XRPL_ASSERT_PARTS(
-            !isnormal() || (mantissa_ % 10 == 0 && mantissa_ / 10 <= maxRep),
-            "xrpl::Number::exponent",
-            "large normalized mantissa has no remainder");
-        ++e;
-    }
-    return e;
+    return exponent_;
 }
 
 inline constexpr Number
@@ -596,7 +727,7 @@ Number::operator-() const noexcept
     if (mantissa_ == 0)
         return Number{};
     auto x = *this;
-    x.negative_ = !x.negative_;
+    x.mantissa_ = -1 * x.mantissa_;
     return x;
 }
 
@@ -677,42 +808,58 @@ Number::min() noexcept
 inline Number
 Number::max() noexcept
 {
-    return Number{false, std::min(range_.get().max, maxRep), maxExponent, unchecked{}};
+    return Number{false, range_.get().max, maxExponent, unchecked{}};
 }
 
 inline Number
 Number::lowest() noexcept
 {
-    return Number{true, std::min(range_.get().max, maxRep), maxExponent, unchecked{}};
+    return Number{true, range_.get().max, maxExponent, unchecked{}};
+}
+
+inline bool
+Number::isnormal(MantissaRange const& range) const noexcept
+{
+    auto const abs_m = mantissa_ < 0 ? -mantissa_ : mantissa_;
+
+    return *this == Number{} ||
+        (range.min <= abs_m && abs_m <= range.max &&  //
+         minExponent <= exponent_ && exponent_ <= maxExponent);
 }
 
 inline bool
 Number::isnormal() const noexcept
 {
-    MantissaRange const& range = range_;
-    auto const abs_m = mantissa_;
-    return *this == Number{} ||
-        (range.min <= abs_m && abs_m <= range.max && (abs_m <= maxRep || abs_m % 10 == 0) &&
-         minExponent <= exponent_ && exponent_ <= maxExponent);
+    return isnormal(range_);
 }
 
 template <Integral64 T>
 std::pair<T, int>
 Number::normalizeToRange(T minMantissa, T maxMantissa) const
 {
-    bool negative = negative_;
-    internalrep mantissa = mantissa_;
+    bool negative = mantissa_ < 0;
+    auto const sign = negative ? -1 : 1;
+    internalrep mantissa = sign * mantissa_;
     int exponent = exponent_;
 
     if constexpr (std::is_unsigned_v<T>)
-        XRPL_ASSERT_PARTS(
-            !negative,
-            "xrpl::Number::normalizeToRange",
-            "Number is non-negative for unsigned range.");
+    {
+        XRPL_ASSERT_PARTS(!negative, "xrpl::Number::normalizeToRange", "Number is non-negative for unsigned range.");
+        // To avoid logical errors in release builds, throw if the Number is
+        // negative for an unsigned range.
+        if (negative)
+            throw std::runtime_error(
+                "Number::normalizeToRange: Number is negative for "
+                "unsigned range.");
+    }
     Number::normalize(negative, mantissa, exponent, minMantissa, maxMantissa);
 
-    auto const sign = negative ? -1 : 1;
-    return std::make_pair(static_cast<T>(sign * mantissa), exponent);
+    // Cast mantissa to signed type first (if T is a signed type) to avoid
+    // unsigned integer overflow when multiplying by negative sign
+    T signedMantissa = static_cast<T>(mantissa);
+    if (negative)
+        signedMantissa = -signedMantissa;
+    return std::make_pair(signedMantissa, exponent);
 }
 
 inline constexpr Number
@@ -794,8 +941,7 @@ class NumberRoundModeGuard
     saveNumberRoundMode saved_;
 
 public:
-    explicit NumberRoundModeGuard(Number::rounding_mode mode) noexcept
-        : saved_{Number::setround(mode)}
+    explicit NumberRoundModeGuard(Number::rounding_mode mode) noexcept : saved_{Number::setround(mode)}
     {
     }
 
@@ -815,8 +961,7 @@ class NumberMantissaScaleGuard
     MantissaRange::mantissa_scale const saved_;
 
 public:
-    explicit NumberMantissaScaleGuard(MantissaRange::mantissa_scale scale) noexcept
-        : saved_{Number::getMantissaScale()}
+    explicit NumberMantissaScaleGuard(MantissaRange::mantissa_scale scale) noexcept : saved_{Number::getMantissaScale()}
     {
         Number::setMantissaScale(scale);
     }

include/xrpl/basics/SharedWeakCachePointer.ipp

@@ -19,8 +19,7 @@ SharedWeakCachePointer<T>::SharedWeakCachePointer(SharedWeakCachePointer&& rhs)
 template <class T>
 template <class TT>
     requires std::convertible_to<TT*, T*>
-SharedWeakCachePointer<T>::SharedWeakCachePointer(std::shared_ptr<TT>&& rhs)
-    : combo_{std::move(rhs)}
+SharedWeakCachePointer<T>::SharedWeakCachePointer(std::shared_ptr<TT>&& rhs) : combo_{std::move(rhs)}
 {
 }
 

include/xrpl/basics/SlabAllocator.h

@@ -155,17 +155,13 @@ public:
                      contexts (e.g. when minimal memory usage is needed) and
                      allows for graceful failure.
      */
-    constexpr explicit SlabAllocator(
-        std::size_t extra,
-        std::size_t alloc = 0,
-        std::size_t align = 0)
+    constexpr explicit SlabAllocator(std::size_t extra, std::size_t alloc = 0, std::size_t align = 0)
         : itemAlignment_(align ? align : alignof(Type))
         , itemSize_(boost::alignment::align_up(sizeof(Type) + extra, itemAlignment_))
         , slabSize_(alloc)
     {
         XRPL_ASSERT(
-            (itemAlignment_ & (itemAlignment_ - 1)) == 0,
-            "xrpl::SlabAllocator::SlabAllocator : valid alignment");
+            (itemAlignment_ & (itemAlignment_ - 1)) == 0, "xrpl::SlabAllocator::SlabAllocator : valid alignment");
     }
 
     SlabAllocator(SlabAllocator const& other) = delete;
@@ -232,8 +228,7 @@ public:
 
         // We need to carve out a bit of memory for the slab header
         // and then align the rest appropriately:
-        auto slabData =
-            reinterpret_cast<void*>(reinterpret_cast<std::uint8_t*>(buf) + sizeof(SlabBlock));
+        auto slabData = reinterpret_cast<void*>(reinterpret_cast<std::uint8_t*>(buf) + sizeof(SlabBlock));
         auto slabSize = size - sizeof(SlabBlock);
 
         // This operation is essentially guaranteed not to fail but
@@ -244,12 +239,10 @@ public:
             return nullptr;
         }
 
-        slab = new (buf) SlabBlock(
-            slabs_.load(), reinterpret_cast<std::uint8_t*>(slabData), slabSize, itemSize_);
+        slab = new (buf) SlabBlock(slabs_.load(), reinterpret_cast<std::uint8_t*>(slabData), slabSize, itemSize_);
 
         // Link the new slab
-        while (!slabs_.compare_exchange_weak(
-            slab->next_, slab, std::memory_order_release, std::memory_order_relaxed))
+        while (!slabs_.compare_exchange_weak(slab->next_, slab, std::memory_order_release, std::memory_order_relaxed))
         {
             ;  // Nothing to do
         }
@@ -306,10 +299,7 @@ public:
         std::size_t align;
 
     public:
-        constexpr SlabConfig(
-            std::size_t extra_,
-            std::size_t alloc_ = 0,
-            std::size_t align_ = alignof(Type))
+        constexpr SlabConfig(std::size_t extra_, std::size_t alloc_ = 0, std::size_t align_ = alignof(Type))
             : extra(extra_), alloc(alloc_), align(align_)
         {
         }
@@ -319,18 +309,15 @@ public:
     {
         // Ensure that the specified allocators are sorted from smallest to
         // largest by size:
-        std::sort(std::begin(cfg), std::end(cfg), [](SlabConfig const& a, SlabConfig const& b) {
-            return a.extra < b.extra;
-        });
+        std::sort(
+            std::begin(cfg), std::end(cfg), [](SlabConfig const& a, SlabConfig const& b) { return a.extra < b.extra; });
 
         // We should never have two slabs of the same size
-        if (std::adjacent_find(
-                std::begin(cfg), std::end(cfg), [](SlabConfig const& a, SlabConfig const& b) {
-                    return a.extra == b.extra;
-                }) != cfg.end())
+        if (std::adjacent_find(std::begin(cfg), std::end(cfg), [](SlabConfig const& a, SlabConfig const& b) {
+                return a.extra == b.extra;
+            }) != cfg.end())
         {
-            throw std::runtime_error(
-                "SlabAllocatorSet<" + beast::type_name<Type>() + ">: duplicate slab size");
+            throw std::runtime_error("SlabAllocatorSet<" + beast::type_name<Type>() + ">: duplicate slab size");
         }
 
         for (auto const& c : cfg)

include/xrpl/basics/Slice.h

@@ -40,8 +40,7 @@ public:
     operator=(Slice const&) noexcept = default;
 
     /** Create a slice pointing to existing memory. */
-    Slice(void const* data, std::size_t size) noexcept
-        : data_(reinterpret_cast<std::uint8_t const*>(data)), size_(size)
+    Slice(void const* data, std::size_t size) noexcept : data_(reinterpret_cast<std::uint8_t const*>(data)), size_(size)
     {
     }
 
@@ -198,8 +197,7 @@ operator!=(Slice const& lhs, Slice const& rhs) noexcept
 inline bool
 operator<(Slice const& lhs, Slice const& rhs) noexcept
 {
-    return std::lexicographical_compare(
-        lhs.data(), lhs.data() + lhs.size(), rhs.data(), rhs.data() + rhs.size());
+    return std::lexicographical_compare(lhs.data(), lhs.data() + lhs.size(), rhs.data(), rhs.data() + rhs.size());
 }
 
 template <class Stream>

include/xrpl/basics/StringUtilities.h

@@ -108,8 +108,7 @@ struct parsedURL
     bool
     operator==(parsedURL const& other) const
     {
-        return scheme == other.scheme && domain == other.domain && port == other.port &&
-            path == other.path;
+        return scheme == other.scheme && domain == other.domain && port == other.port && path == other.path;
     }
 };
 

include/xrpl/basics/TaggedCache.h

@@ -175,10 +175,7 @@ private:
     struct Stats
     {
         template <class Handler>
-        Stats(
-            std::string const& prefix,
-            Handler const& handler,
-            beast::insight::Collector::ptr const& collector)
+        Stats(std::string const& prefix, Handler const& handler, beast::insight::Collector::ptr const& collector)
             : hook(collector->make_hook(handler))
             , size(collector->make_gauge(prefix, "size"))
             , hit_rate(collector->make_gauge(prefix, "hit_rate"))
@@ -200,8 +197,7 @@ private:
     public:
         clock_type::time_point last_access;
 
-        explicit KeyOnlyEntry(clock_type::time_point const& last_access_)
-            : last_access(last_access_)
+        explicit KeyOnlyEntry(clock_type::time_point const& last_access_) : last_access(last_access_)
         {
         }
 

include/xrpl/basics/TaggedCache.ipp

@@ -14,22 +14,13 @@ template <
     class Hash,
     class KeyEqual,
     class Mutex>
-inline TaggedCache<
-    Key,
-    T,
-    IsKeyCache,
-    SharedWeakUnionPointer,
-    SharedPointerType,
-    Hash,
-    KeyEqual,
-    Mutex>::
-    TaggedCache(
-        std::string const& name,
-        int size,
-        clock_type::duration expiration,
-        clock_type& clock,
-        beast::Journal journal,
-        beast::insight::Collector::ptr const& collector)
+inline TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::TaggedCache(
+    std::string const& name,
+    int size,
+    clock_type::duration expiration,
+    clock_type& clock,
+    beast::Journal journal,
+    beast::insight::Collector::ptr const& collector)
     : m_journal(journal)
     , m_clock(clock)
     , m_stats(name, std::bind(&TaggedCache::collect_metrics, this), collector)
@@ -52,8 +43,8 @@ template <
     class KeyEqual,
     class Mutex>
 inline auto
-TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
-    clock() -> clock_type&
+TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::clock()
+    -> clock_type&
 {
     return m_clock;
 }
@@ -68,8 +59,7 @@ template <
     class KeyEqual,
     class Mutex>
 inline std::size_t
-TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
-    size() const
+TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::size() const
 {
     std::lock_guard lock(m_mutex);
     return m_cache.size();
@@ -85,8 +75,7 @@ template <
     class KeyEqual,
     class Mutex>
 inline int
-TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
-    getCacheSize() const
+TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::getCacheSize() const
 {
     std::lock_guard lock(m_mutex);
     return m_cache_count;
@@ -102,8 +91,7 @@ template <
     class KeyEqual,
     class Mutex>
 inline int
-TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
-    getTrackSize() const
+TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::getTrackSize() const
 {
     std::lock_guard lock(m_mutex);
     return m_cache.size();
@@ -119,8 +107,7 @@ template <
     class KeyEqual,
     class Mutex>
 inline float
-TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
-    getHitRate()
+TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::getHitRate()
 {
     std::lock_guard lock(m_mutex);
     auto const total = static_cast<float>(m_hits + m_misses);
@@ -137,8 +124,7 @@ template <
     class KeyEqual,
     class Mutex>
 inline void
-TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
-    clear()
+TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::clear()
 {
     std::lock_guard lock(m_mutex);
     m_cache.clear();
@@ -155,8 +141,7 @@ template <
     class KeyEqual,
     class Mutex>
 inline void
-TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
-    reset()
+TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::reset()
 {
     std::lock_guard lock(m_mutex);
     m_cache.clear();
@@ -176,8 +161,8 @@ template <
     class Mutex>
 template <class KeyComparable>
 inline bool
-TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
-    touch_if_exists(KeyComparable const& key)
+TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::touch_if_exists(
+    KeyComparable const& key)
 {
     std::lock_guard lock(m_mutex);
     auto const iter(m_cache.find(key));
@@ -201,8 +186,7 @@ template <
     class KeyEqual,
     class Mutex>
 inline void
-TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
-    sweep()
+TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::sweep()
 {
     // Keep references to all the stuff we sweep
     // For performance, each worker thread should exit before the swept data
@@ -228,9 +212,8 @@ TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash,
             if (when_expire > (now - minimumAge))
                 when_expire = now - minimumAge;
 
-            JLOG(m_journal.trace())
-                << m_name << " is growing fast " << m_cache.size() << " of " << m_target_size
-                << " aging at " << (now - when_expire).count() << " of " << m_target_age.count();
+            JLOG(m_journal.trace()) << m_name << " is growing fast " << m_cache.size() << " of " << m_target_size
+                                    << " aging at " << (now - when_expire).count() << " of " << m_target_age.count();
         }
 
         std::vector<std::thread> workers;
@@ -239,8 +222,7 @@ TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash,
 
         for (std::size_t p = 0; p < m_cache.partitions(); ++p)
         {
-            workers.push_back(sweepHelper(
-                when_expire, now, m_cache.map()[p], allStuffToSweep[p], allRemovals, lock));
+            workers.push_back(sweepHelper(when_expire, now, m_cache.map()[p], allStuffToSweep[p], allRemovals, lock));
         }
         for (std::thread& worker : workers)
             worker.join();
@@ -249,11 +231,10 @@ TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash,
     }
     // At this point allStuffToSweep will go out of scope outside the lock
     // and decrement the reference count on each strong pointer.
-    JLOG(m_journal.debug()) << m_name << " TaggedCache sweep lock duration "
-                            << std::chrono::duration_cast<std::chrono::milliseconds>(
-                                   std::chrono::steady_clock::now() - start)
-                                   .count()
-                            << "ms";
+    JLOG(m_journal.debug())
+        << m_name << " TaggedCache sweep lock duration "
+        << std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now() - start).count()
+        << "ms";
 }
 
 template <
@@ -266,8 +247,9 @@ template <
     class KeyEqual,
     class Mutex>
 inline bool
-TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
-    del(key_type const& key, bool valid)
+TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::del(
+    key_type const& key,
+    bool valid)
 {
     // Remove from cache, if !valid, remove from map too. Returns true if
     // removed from cache
@@ -306,8 +288,10 @@ template <
     class Mutex>
 template <class R>
 inline bool
-TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
-    canonicalize(key_type const& key, SharedPointerType& data, R&& replaceCallback)
+TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::canonicalize(
+    key_type const& key,
+    SharedPointerType& data,
+    R&& replaceCallback)
 {
     // Return canonical value, store if needed, refresh in cache
     // Return values: true=we had the data already
@@ -318,9 +302,7 @@ TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash,
     if (cit == m_cache.end())
     {
         m_cache.emplace(
-            std::piecewise_construct,
-            std::forward_as_tuple(key),
-            std::forward_as_tuple(m_clock.now(), data));
+            std::piecewise_construct, std::forward_as_tuple(key), std::forward_as_tuple(m_clock.now(), data));
         ++m_cache_count;
         return false;
     }
@@ -422,8 +404,8 @@ template <
     class KeyEqual,
     class Mutex>
 inline SharedPointerType
-TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
-    fetch(key_type const& key)
+TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::fetch(
+    key_type const& key)
 {
     std::lock_guard<mutex_type> l(m_mutex);
     auto ret = initialFetch(key, l);
@@ -443,8 +425,9 @@ template <
     class Mutex>
 template <class ReturnType>
 inline auto
-TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
-    insert(key_type const& key, T const& value) -> std::enable_if_t<!IsKeyCache, ReturnType>
+TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::insert(
+    key_type const& key,
+    T const& value) -> std::enable_if_t<!IsKeyCache, ReturnType>
 {
     static_assert(
         std::is_same_v<std::shared_ptr<T>, SharedPointerType> ||
@@ -473,13 +456,13 @@ template <
     class Mutex>
 template <class ReturnType>
 inline auto
-TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
-    insert(key_type const& key) -> std::enable_if_t<IsKeyCache, ReturnType>
+TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::insert(
+    key_type const& key) -> std::enable_if_t<IsKeyCache, ReturnType>
 {
     std::lock_guard lock(m_mutex);
     clock_type::time_point const now(m_clock.now());
-    auto [it, inserted] = m_cache.emplace(
-        std::piecewise_construct, std::forward_as_tuple(key), std::forward_as_tuple(now));
+    auto [it, inserted] =
+        m_cache.emplace(std::piecewise_construct, std::forward_as_tuple(key), std::forward_as_tuple(now));
     if (!inserted)
         it->second.last_access = now;
     return inserted;
@@ -495,8 +478,9 @@ template <
     class KeyEqual,
     class Mutex>
 inline bool
-TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
-    retrieve(key_type const& key, T& data)
+TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::retrieve(
+    key_type const& key,
+    T& data)
 {
     // retrieve the value of the stored data
     auto entry = fetch(key);
@@ -518,8 +502,8 @@ template <
     class KeyEqual,
     class Mutex>
 inline auto
-TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
-    peekMutex() -> mutex_type&
+TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::peekMutex()
+    -> mutex_type&
 {
     return m_mutex;
 }
@@ -534,8 +518,8 @@ template <
     class KeyEqual,
     class Mutex>
 inline auto
-TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
-    getKeys() const -> std::vector<key_type>
+TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::getKeys() const
+    -> std::vector<key_type>
 {
     std::vector<key_type> v;
 
@@ -559,8 +543,7 @@ template <
     class KeyEqual,
     class Mutex>
 inline double
-TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
-    rate() const
+TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::rate() const
 {
     std::lock_guard lock(m_mutex);
     auto const tot = m_hits + m_misses;
@@ -580,8 +563,9 @@ template <
     class Mutex>
 template <class Handler>
 inline SharedPointerType
-TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
-    fetch(key_type const& digest, Handler const& h)
+TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::fetch(
+    key_type const& digest,
+    Handler const& h)
 {
     {
         std::lock_guard l(m_mutex);
@@ -612,8 +596,9 @@ template <
     class KeyEqual,
     class Mutex>
 inline SharedPointerType
-TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
-    initialFetch(key_type const& key, std::lock_guard<mutex_type> const& l)
+TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::initialFetch(
+    key_type const& key,
+    std::lock_guard<mutex_type> const& l)
 {
     auto cit = m_cache.find(key);
     if (cit == m_cache.end())
@@ -649,8 +634,7 @@ template <
     class KeyEqual,
     class Mutex>
 inline void
-TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
-    collect_metrics()
+TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::collect_metrics()
 {
     m_stats.size.set(getCacheSize());
 
@@ -676,14 +660,13 @@ template <
     class KeyEqual,
     class Mutex>
 inline std::thread
-TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
-    sweepHelper(
-        clock_type::time_point const& when_expire,
-        [[maybe_unused]] clock_type::time_point const& now,
-        typename KeyValueCacheType::map_type& partition,
-        SweptPointersVector& stuffToSweep,
-        std::atomic<int>& allRemovals,
-        std::lock_guard<std::recursive_mutex> const&)
+TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::sweepHelper(
+    clock_type::time_point const& when_expire,
+    [[maybe_unused]] clock_type::time_point const& now,
+    typename KeyValueCacheType::map_type& partition,
+    SweptPointersVector& stuffToSweep,
+    std::atomic<int>& allRemovals,
+    std::lock_guard<std::recursive_mutex> const&)
 {
     return std::thread([&, this]() {
         int cacheRemovals = 0;
@@ -737,9 +720,8 @@ TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash,
 
         if (mapRemovals || cacheRemovals)
         {
-            JLOG(m_journal.debug())
-                << "TaggedCache partition sweep " << m_name << ": cache = " << partition.size()
-                << "-" << cacheRemovals << ", map-=" << mapRemovals;
+            JLOG(m_journal.debug()) << "TaggedCache partition sweep " << m_name << ": cache = " << partition.size()
+                                    << "-" << cacheRemovals << ", map-=" << mapRemovals;
         }
 
         allRemovals += cacheRemovals;
@@ -756,14 +738,13 @@ template <
     class KeyEqual,
     class Mutex>
 inline std::thread
-TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
-    sweepHelper(
-        clock_type::time_point const& when_expire,
-        clock_type::time_point const& now,
-        typename KeyOnlyCacheType::map_type& partition,
-        SweptPointersVector&,
-        std::atomic<int>& allRemovals,
-        std::lock_guard<std::recursive_mutex> const&)
+TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::sweepHelper(
+    clock_type::time_point const& when_expire,
+    clock_type::time_point const& now,
+    typename KeyOnlyCacheType::map_type& partition,
+    SweptPointersVector&,
+    std::atomic<int>& allRemovals,
+    std::lock_guard<std::recursive_mutex> const&)
 {
     return std::thread([&, this]() {
         int cacheRemovals = 0;
@@ -793,9 +774,8 @@ TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash,
 
         if (mapRemovals || cacheRemovals)
         {
-            JLOG(m_journal.debug())
-                << "TaggedCache partition sweep " << m_name << ": cache = " << partition.size()
-                << "-" << cacheRemovals << ", map-=" << mapRemovals;
+            JLOG(m_journal.debug()) << "TaggedCache partition sweep " << m_name << ": cache = " << partition.size()
+                                    << "-" << cacheRemovals << ", map-=" << mapRemovals;
         }
 
         allRemovals += cacheRemovals;

include/xrpl/basics/algorithm.h

@@ -51,13 +51,7 @@ generalized_set_intersection(
 // std::set_intersection.
 template <class FwdIter1, class InputIter2, class Pred, class Comp>
 FwdIter1
-remove_if_intersect_or_match(
-    FwdIter1 first1,
-    FwdIter1 last1,
-    InputIter2 first2,
-    InputIter2 last2,
-    Pred pred,
-    Comp comp)
+remove_if_intersect_or_match(FwdIter1 first1, FwdIter1 last1, InputIter2 first2, InputIter2 last2, Pred pred, Comp comp)
 {
     // [original-first1, current-first1) is the set of elements to be preserved.
     // [current-first1, i) is the set of elements that have been removed.

include/xrpl/basics/base_uint.h

@@ -214,8 +214,7 @@ private:
             std::uint32_t accum = {};
             for (std::uint32_t shift : {4u, 0u, 12u, 8u, 20u, 16u, 28u, 24u})
             {
-                if (auto const result = hexCharToUInt(*in++, shift, accum);
-                    result != ParseResult::okay)
+                if (auto const result = hexCharToUInt(*in++, shift, accum); result != ParseResult::okay)
                     return Unexpected(result);
             }
             ret[i++] = accum;
@@ -254,8 +253,7 @@ public:
     // This constructor is intended to be used at compile time since it might
     // throw at runtime.  Consider declaring this constructor consteval once
     // we get to C++23.
-    explicit constexpr base_uint(std::string_view sv) noexcept(false)
-        : data_(parseFromStringViewThrows(sv))
+    explicit constexpr base_uint(std::string_view sv) noexcept(false) : data_(parseFromStringViewThrows(sv))
     {
     }
 
@@ -359,6 +357,7 @@ public:
     base_uint&
     operator&=(base_uint const& b)
     {
+        XRPL_ASSERT(WIDTH == b.WIDTH, "input size mismatch");
         for (int i = 0; i < WIDTH; i++)
             data_[i] &= b.data_[i];
 
@@ -444,8 +443,7 @@ public:
 
         for (int i = WIDTH; i--;)
         {
-            std::uint64_t n = carry + boost::endian::big_to_native(data_[i]) +
-                boost::endian::big_to_native(b.data_[i]);
+            std::uint64_t 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));
             carry = n >> 32;

include/xrpl/basics/chrono.h

@@ -15,8 +15,7 @@ namespace xrpl {
 
 // A few handy aliases
 
-using days =
-    std::chrono::duration<int, std::ratio_multiply<std::chrono::hours::period, std::ratio<24>>>;
+using days = std::chrono::duration<int, std::ratio_multiply<std::chrono::hours::period, std::ratio<24>>>;
 
 using weeks = std::chrono::duration<int, std::ratio_multiply<days::period, std::ratio<7>>>;
 

include/xrpl/basics/contract.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <xrpl/basics/sanitizers.h>
 #include <xrpl/beast/type_name.h>
 
 #include <exception>
@@ -24,7 +25,7 @@ LogThrow(std::string const& title);
     control to the next matching exception handler, if any.
     Otherwise, std::terminate will be called.
 */
-[[noreturn]] inline void
+[[noreturn]] XRPL_NO_SANITIZE_ADDRESS inline void
 Rethrow()
 {
     LogThrow("Re-throwing exception");
@@ -32,12 +33,10 @@ Rethrow()
 }
 
 template <class E, class... Args>
-[[noreturn]] inline void
+[[noreturn]] XRPL_NO_SANITIZE_ADDRESS inline void
 Throw(Args&&... args)
 {
-    static_assert(
-        std::is_convertible<E*, std::exception*>::value,
-        "Exception must derive from std::exception.");
+    static_assert(std::is_convertible<E*, std::exception*>::value, "Exception must derive from std::exception.");
 
     E e(std::forward<Args>(args)...);
     LogThrow(std::string("Throwing exception of type " + beast::type_name<E>() + ": ") + e.what());

include/xrpl/basics/join.h

@@ -23,8 +23,7 @@ public:
     Collection const& collection;
     std::string const delimiter;
 
-    explicit CollectionAndDelimiter(Collection const& c, std::string delim)
-        : collection(c), delimiter(std::move(delim))
+    explicit CollectionAndDelimiter(Collection const& c, std::string delim) : collection(c), delimiter(std::move(delim))
     {
     }
 
@@ -64,8 +63,7 @@ public:
     char const* collection;
     std::string const delimiter;
 
-    explicit CollectionAndDelimiter(char const c[N], std::string delim)
-        : collection(c), delimiter(std::move(delim))
+    explicit CollectionAndDelimiter(char const c[N], std::string delim) : collection(c), delimiter(std::move(delim))
     {
     }
 

include/xrpl/basics/partitioned_unordered_map.h

@@ -330,8 +330,8 @@ public:
         auto const& key = std::get<0>(keyTuple);
         iterator it(&map_);
         it.ait_ = it.map_->begin() + partitioner(key);
-        auto [eit, inserted] = it.ait_->emplace(
-            std::piecewise_construct, std::forward<T>(keyTuple), std::forward<U>(valueTuple));
+        auto [eit, inserted] =
+            it.ait_->emplace(std::piecewise_construct, std::forward<T>(keyTuple), std::forward<U>(valueTuple));
         it.mit_ = eit;
         return {it, inserted};
     }

include/xrpl/basics/random.h

@@ -19,8 +19,7 @@ static_assert(
     "The Ripple default PRNG engine must return an unsigned integral type.");
 
 static_assert(
-    std::numeric_limits<beast::xor_shift_engine::result_type>::max() >=
-        std::numeric_limits<std::uint64_t>::max(),
+    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.");
 #endif
 
@@ -145,14 +144,12 @@ std::enable_if_t<
     Byte>
 rand_byte(Engine& engine)
 {
-    return static_cast<Byte>(rand_int<Engine, std::uint32_t>(
-        engine, std::numeric_limits<Byte>::min(), std::numeric_limits<Byte>::max()));
+    return static_cast<Byte>(
+        rand_int<Engine, std::uint32_t>(engine, std::numeric_limits<Byte>::min(), std::numeric_limits<Byte>::max()));
 }
 
 template <class Byte = std::uint8_t>
-std::enable_if_t<
-    (std::is_same<Byte, unsigned char>::value || std::is_same<Byte, std::uint8_t>::value),
-    Byte>
+std::enable_if_t<(std::is_same<Byte, unsigned char>::value || std::is_same<Byte, std::uint8_t>::value), Byte>
 rand_byte()
 {
     return rand_byte<Byte>(default_prng());

include/xrpl/basics/safe_cast.h

@@ -18,12 +18,9 @@ template <class Dest, class Src>
 inline constexpr std::enable_if_t<std::is_integral_v<Dest> && std::is_integral_v<Src>, Dest>
 safe_cast(Src s) noexcept
 {
-    static_assert(
-        std::is_signed_v<Dest> || std::is_unsigned_v<Src>, "Cannot cast signed to unsigned");
+    static_assert(std::is_signed_v<Dest> || std::is_unsigned_v<Src>, "Cannot cast signed to unsigned");
     constexpr unsigned not_same = std::is_signed_v<Dest> != std::is_signed_v<Src>;
-    static_assert(
-        sizeof(Dest) >= sizeof(Src) + not_same,
-        "Destination is too small to hold all values of source");
+    static_assert(sizeof(Dest) >= sizeof(Src) + not_same, "Destination is too small to hold all values of source");
     return static_cast<Dest>(s);
 }
 

include/xrpl/basics/sanitizers.h

@@ -0,0 +1,6 @@
+// Helper to disable ASan/HwASan for specific functions
+#if defined(__GNUC__) || defined(__clang__)
+#define XRPL_NO_SANITIZE_ADDRESS __attribute__((no_sanitize("address", "hwaddress")))
+#else
+#define XRPL_NO_SANITIZE_ADDRESS
+#endif

include/xrpl/basics/scope.h

@@ -36,8 +36,7 @@ public:
 
     scope_exit(scope_exit&& rhs) noexcept(
         std::is_nothrow_move_constructible_v<EF> || std::is_nothrow_copy_constructible_v<EF>)
-        : exit_function_{std::forward<EF>(rhs.exit_function_)}
-        , execute_on_destruction_{rhs.execute_on_destruction_}
+        : exit_function_{std::forward<EF>(rhs.exit_function_)}, execute_on_destruction_{rhs.execute_on_destruction_}
     {
         rhs.release();
     }
@@ -48,9 +47,8 @@ public:
     template <class EFP>
     explicit scope_exit(
         EFP&& f,
-        std::enable_if_t<
-            !std::is_same_v<std::remove_cv_t<EFP>, scope_exit> &&
-            std::is_constructible_v<EF, EFP>>* = 0) noexcept
+        std::enable_if_t<!std::is_same_v<std::remove_cv_t<EFP>, scope_exit> && std::is_constructible_v<EF, EFP>>* =
+            0) noexcept
         : exit_function_{std::forward<EFP>(f)}
     {
         static_assert(std::is_nothrow_constructible_v<EF, decltype(std::forward<EFP>(f))>);
@@ -95,9 +93,8 @@ public:
     template <class EFP>
     explicit scope_fail(
         EFP&& f,
-        std::enable_if_t<
-            !std::is_same_v<std::remove_cv_t<EFP>, scope_fail> &&
-            std::is_constructible_v<EF, EFP>>* = 0) noexcept
+        std::enable_if_t<!std::is_same_v<std::remove_cv_t<EFP>, scope_fail> && std::is_constructible_v<EF, EFP>>* =
+            0) noexcept
         : exit_function_{std::forward<EFP>(f)}
     {
         static_assert(std::is_nothrow_constructible_v<EF, decltype(std::forward<EFP>(f))>);
@@ -142,9 +139,7 @@ public:
     template <class EFP>
     explicit scope_success(
         EFP&& f,
-        std::enable_if_t<
-            !std::is_same_v<std::remove_cv_t<EFP>, scope_success> &&
-            std::is_constructible_v<EF, EFP>>* =
+        std::enable_if_t<!std::is_same_v<std::remove_cv_t<EFP>, scope_success> && std::is_constructible_v<EF, EFP>>* =
             0) noexcept(std::is_nothrow_constructible_v<EF, EFP> || std::is_nothrow_constructible_v<EF, EFP&>)
         : exit_function_{std::forward<EFP>(f)}
     {

include/xrpl/basics/spinlock.h

@@ -99,12 +99,9 @@ public:
         @note For performance reasons, you should strive to have `lock` be
               on a cacheline by itself.
      */
-    packed_spinlock(std::atomic<T>& lock, int index)
-        : bits_(lock), mask_(static_cast<T>(1) << index)
+    packed_spinlock(std::atomic<T>& lock, int index) : bits_(lock), mask_(static_cast<T>(1) << index)
     {
-        XRPL_ASSERT(
-            index >= 0 && (mask_ != 0),
-            "xrpl::packed_spinlock::packed_spinlock : valid index and mask");
+        XRPL_ASSERT(index >= 0 && (mask_ != 0), "xrpl::packed_spinlock::packed_spinlock : valid index and mask");
     }
 
     [[nodiscard]] bool
@@ -177,10 +174,7 @@ public:
         T expected = 0;
 
         return lock_.compare_exchange_weak(
-            expected,
-            std::numeric_limits<T>::max(),
-            std::memory_order_acquire,
-            std::memory_order_relaxed);
+            expected, std::numeric_limits<T>::max(), std::memory_order_acquire, std::memory_order_relaxed);
     }
 
     void

include/xrpl/basics/strHex.h

@@ -10,9 +10,7 @@ std::string
 strHex(FwdIt begin, FwdIt end)
 {
     static_assert(
-        std::is_convertible<
-            typename std::iterator_traits<FwdIt>::iterator_category,
-            std::forward_iterator_tag>::value,
+        std::is_convertible<typename std::iterator_traits<FwdIt>::iterator_category, std::forward_iterator_tag>::value,
         "FwdIt must be a forward iterator");
     std::string result;
     result.reserve(2 * std::distance(begin, end));

include/xrpl/basics/tagged_integer.h

@@ -23,15 +23,14 @@ namespace xrpl {
     allowed arithmetic operations.
 */
 template <class Int, class Tag>
-class tagged_integer : boost::totally_ordered<
-                           tagged_integer<Int, Tag>,
-                           boost::integer_arithmetic<
-                               tagged_integer<Int, Tag>,
-                               boost::bitwise<
-                                   tagged_integer<Int, Tag>,
-                                   boost::unit_steppable<
-                                       tagged_integer<Int, Tag>,
-                                       boost::shiftable<tagged_integer<Int, Tag>>>>>>
+class tagged_integer
+    : boost::totally_ordered<
+          tagged_integer<Int, Tag>,
+          boost::integer_arithmetic<
+              tagged_integer<Int, Tag>,
+              boost::bitwise<
+                  tagged_integer<Int, Tag>,
+                  boost::unit_steppable<tagged_integer<Int, Tag>, boost::shiftable<tagged_integer<Int, Tag>>>>>>
 {
 private:
     Int m_value;
@@ -44,8 +43,7 @@ public:
 
     template <
         class OtherInt,
-        class = typename std::enable_if<
-            std::is_integral<OtherInt>::value && sizeof(OtherInt) <= sizeof(Int)>::type>
+        class = typename std::enable_if<std::is_integral<OtherInt>::value && sizeof(OtherInt) <= sizeof(Int)>::type>
     explicit constexpr tagged_integer(OtherInt value) noexcept : m_value(value)
     {
         static_assert(sizeof(tagged_integer) == sizeof(Int), "tagged_integer is adding padding");

include/xrpl/beast/asio/io_latency_probe.h

@@ -86,8 +86,7 @@ public:
         std::lock_guard lock(m_mutex);
         if (m_cancel)
             throw std::logic_error("io_latency_probe is canceled");
-        boost::asio::post(
-            m_ios, sample_op<Handler>(std::forward<Handler>(handler), Clock::now(), false, this));
+        boost::asio::post(m_ios, sample_op<Handler>(std::forward<Handler>(handler), Clock::now(), false, this));
     }
 
     /** Initiate continuous i/o latency sampling.
@@ -101,8 +100,7 @@ public:
         std::lock_guard lock(m_mutex);
         if (m_cancel)
             throw std::logic_error("io_latency_probe is canceled");
-        boost::asio::post(
-            m_ios, sample_op<Handler>(std::forward<Handler>(handler), Clock::now(), true, this));
+        boost::asio::post(m_ios, sample_op<Handler>(std::forward<Handler>(handler), Clock::now(), true, this));
     }
 
 private:
@@ -142,11 +140,7 @@ private:
         bool m_repeat;
         io_latency_probe* m_probe;
 
-        sample_op(
-            Handler const& handler,
-            time_point const& start,
-            bool repeat,
-            io_latency_probe* probe)
+        sample_op(Handler const& handler, time_point const& start, bool repeat, io_latency_probe* probe)
             : m_handler(handler), m_start(start), m_repeat(repeat), m_probe(probe)
         {
             XRPL_ASSERT(
@@ -209,14 +203,12 @@ private:
                     // The latency is too high to maintain the desired
                     // period so don't bother with a timer.
                     //
-                    boost::asio::post(
-                        m_probe->m_ios, sample_op<Handler>(m_handler, now, m_repeat, m_probe));
+                    boost::asio::post(m_probe->m_ios, sample_op<Handler>(m_handler, now, m_repeat, m_probe));
                 }
                 else
                 {
                     m_probe->m_timer.expires_after(when - now);
-                    m_probe->m_timer.async_wait(
-                        sample_op<Handler>(m_handler, now, m_repeat, m_probe));
+                    m_probe->m_timer.async_wait(sample_op<Handler>(m_handler, now, m_repeat, m_probe));
                 }
             }
         }
@@ -227,8 +219,7 @@ private:
             if (!m_probe)
                 return;
             typename Clock::time_point const now(Clock::now());
-            boost::asio::post(
-                m_probe->m_ios, sample_op<Handler>(m_handler, now, m_repeat, m_probe));
+            boost::asio::post(m_probe->m_ios, sample_op<Handler>(m_handler, now, m_repeat, m_probe));
         }
     };
 };

include/xrpl/beast/clock/manual_clock.h

@@ -42,9 +42,7 @@ public:
     void
     set(time_point const& when)
     {
-        XRPL_ASSERT(
-            !Clock::is_steady || when >= now_,
-            "beast::manual_clock::set(time_point) : forward input");
+        XRPL_ASSERT(!Clock::is_steady || when >= now_, "beast::manual_clock::set(time_point) : forward input");
         now_ = when;
     }
 
@@ -62,8 +60,7 @@ public:
     advance(std::chrono::duration<Rep, Period> const& elapsed)
     {
         XRPL_ASSERT(
-            !Clock::is_steady || (now_ + elapsed) >= now_,
-            "beast::manual_clock::advance(duration) : forward input");
+            !Clock::is_steady || (now_ + elapsed) >= now_, "beast::manual_clock::advance(duration) : forward input");
         now_ += elapsed;
     }
 

include/xrpl/beast/container/aged_container_utility.h

@@ -14,8 +14,7 @@ expire(AgedContainer& c, std::chrono::duration<Rep, Period> const& age)
 {
     std::size_t n(0);
     auto const expired(c.clock().now() - age);
-    for (auto iter(c.chronological.cbegin());
-         iter != c.chronological.cend() && iter.when() <= expired;)
+    for (auto iter(c.chronological.cbegin()); iter != c.chronological.cend() && iter.when() <= expired;)
     {
         iter = c.erase(iter);
         ++n;

include/xrpl/beast/container/aged_multiset.h

@@ -13,7 +13,6 @@ template <
     class Clock = std::chrono::steady_clock,
     class Compare = std::less<Key>,
     class Allocator = std::allocator<Key>>
-using aged_multiset =
-    detail::aged_ordered_container<true, false, Key, void, Clock, Compare, Allocator>;
+using aged_multiset = detail::aged_ordered_container<true, false, Key, void, Clock, Compare, Allocator>;
 
 }

include/xrpl/beast/container/aged_unordered_map.h

@@ -15,7 +15,6 @@ template <
     class Hash = std::hash<Key>,
     class KeyEqual = std::equal_to<Key>,
     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>;
+using aged_unordered_map = detail::aged_unordered_container<false, true, Key, T, Clock, Hash, KeyEqual, Allocator>;
 
 }

include/xrpl/beast/container/aged_unordered_multimap.h

@@ -15,7 +15,6 @@ template <
     class Hash = std::hash<Key>,
     class KeyEqual = std::equal_to<Key>,
     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>;
+using aged_unordered_multimap = detail::aged_unordered_container<true, true, Key, T, Clock, Hash, KeyEqual, Allocator>;
 
 }

include/xrpl/beast/container/aged_unordered_set.h

@@ -14,7 +14,6 @@ template <
     class Hash = std::hash<Key>,
     class KeyEqual = std::equal_to<Key>,
     class Allocator = std::allocator<Key>>
-using aged_unordered_set =
-    detail::aged_unordered_container<false, false, Key, void, Clock, Hash, KeyEqual, Allocator>;
+using aged_unordered_set = detail::aged_unordered_container<false, false, Key, void, Clock, Hash, KeyEqual, Allocator>;
 
 }

include/xrpl/beast/container/detail/aged_container_iterator.h

@@ -35,26 +35,22 @@ public:
         class = typename std::enable_if<
             (other_is_const == false || is_const == true) &&
             std::is_same<Iterator, OtherIterator>::value == false>::type>
-    explicit aged_container_iterator(
-        aged_container_iterator<other_is_const, OtherIterator> const& other)
+    explicit aged_container_iterator(aged_container_iterator<other_is_const, OtherIterator> const& other)
         : m_iter(other.m_iter)
     {
     }
 
     // Disable constructing a const_iterator from a non-const_iterator.
-    template <
-        bool other_is_const,
-        class = typename std::enable_if<other_is_const == false || is_const == true>::type>
-    aged_container_iterator(aged_container_iterator<other_is_const, Iterator> const& other)
-        : m_iter(other.m_iter)
+    template <bool other_is_const, class = typename std::enable_if<other_is_const == false || is_const == true>::type>
+    aged_container_iterator(aged_container_iterator<other_is_const, Iterator> const& other) : m_iter(other.m_iter)
     {
     }
 
     // Disable assigning a const_iterator to a non-const iterator
     template <bool other_is_const, class OtherIterator>
     auto
-    operator=(aged_container_iterator<other_is_const, OtherIterator> const& other) -> typename std::
-        enable_if<other_is_const == false || is_const == true, aged_container_iterator&>::type
+    operator=(aged_container_iterator<other_is_const, OtherIterator> const& other) ->
+        typename std::enable_if<other_is_const == false || is_const == true, aged_container_iterator&>::type
     {
         m_iter = other.m_iter;
         return *this;

include/xrpl/beast/container/detail/aged_ordered_container.h

@@ -57,8 +57,7 @@ template <
     class T,
     class Clock = std::chrono::steady_clock,
     class Compare = std::less<Key>,
-    class Allocator =
-        std::allocator<typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>
+    class Allocator = std::allocator<typename std::conditional<IsMap, std::pair<Key const, T>, Key>::type>>
 class aged_ordered_container
 {
 public:
@@ -84,10 +83,8 @@ private:
     }
 
     // VFALCO TODO hoist to remove template argument dependencies
-    struct element : boost::intrusive::set_base_hook<
-                         boost::intrusive::link_mode<boost::intrusive::normal_link>>,
-                     boost::intrusive::list_base_hook<
-                         boost::intrusive::link_mode<boost::intrusive::normal_link>>
+    struct element : boost::intrusive::set_base_hook<boost::intrusive::link_mode<boost::intrusive::normal_link>>,
+                     boost::intrusive::list_base_hook<boost::intrusive::link_mode<boost::intrusive::normal_link>>
     {
         // Stash types here so the iterator doesn't
         // need to see the container declaration.
@@ -103,17 +100,14 @@ private:
         {
         }
 
-        element(time_point const& when_, value_type&& value_)
-            : value(std::move(value_)), when(when_)
+        element(time_point const& when_, value_type&& value_) : value(std::move(value_)), when(when_)
         {
         }
 
         template <
             class... Args,
-            class =
-                typename std::enable_if<std::is_constructible<value_type, Args...>::value>::type>
-        element(time_point const& when_, Args&&... args)
-            : value(std::forward<Args>(args)...), when(when_)
+            class = typename std::enable_if<std::is_constructible<value_type, Args...>::value>::type>
+        element(time_point const& when_, Args&&... args) : value(std::forward<Args>(args)...), when(when_)
         {
         }
 
@@ -197,8 +191,7 @@ private:
         }
     };
 
-    using list_type = typename boost::intrusive::
-        make_list<element, boost::intrusive::constant_time_size<false>>::type;
+    using list_type = typename boost::intrusive::make_list<element, boost::intrusive::constant_time_size<false>>::type;
 
     using cont_type = typename std::conditional<
         IsMulti,
@@ -206,18 +199,15 @@ private:
             element,
             boost::intrusive::constant_time_size<true>,
             boost::intrusive::compare<KeyValueCompare>>::type,
-        typename boost::intrusive::make_set<
-            element,
-            boost::intrusive::constant_time_size<true>,
-            boost::intrusive::compare<KeyValueCompare>>::type>::type;
+        typename boost::intrusive::
+            make_set<element, boost::intrusive::constant_time_size<true>, boost::intrusive::compare<KeyValueCompare>>::
+                type>::type;
 
-    using ElementAllocator =
-        typename std::allocator_traits<Allocator>::template rebind_alloc<element>;
+    using ElementAllocator = typename std::allocator_traits<Allocator>::template rebind_alloc<element>;
 
     using ElementAllocatorTraits = std::allocator_traits<ElementAllocator>;
 
-    class config_t : private KeyValueCompare,
-                     public beast::detail::empty_base_optimization<ElementAllocator>
+    class config_t : private KeyValueCompare, public beast::detail::empty_base_optimization<ElementAllocator>
     {
     public:
         explicit config_t(clock_type& clock_) : clock(clock_)
@@ -234,9 +224,7 @@ private:
         }
 
         config_t(clock_type& clock_, Compare const& comp, Allocator const& alloc_)
-            : KeyValueCompare(comp)
-            , beast::detail::empty_base_optimization<ElementAllocator>(alloc_)
-            , clock(clock_)
+            : KeyValueCompare(comp), beast::detail::empty_base_optimization<ElementAllocator>(alloc_), clock(clock_)
         {
         }
 
@@ -349,8 +337,7 @@ private:
 
         std::unique_ptr<element, Deleter> p(
             ElementAllocatorTraits::allocate(m_config.alloc(), 1), Deleter(m_config.alloc()));
-        ElementAllocatorTraits::construct(
-            m_config.alloc(), p.get(), clock().now(), std::forward<Args>(args)...);
+        ElementAllocatorTraits::construct(m_config.alloc(), p.get(), clock().now(), std::forward<Args>(args)...);
         return p.release();
     }
 
@@ -381,12 +368,9 @@ public:
     // A set iterator (IsMap==false) is always const
     // because the elements of a set are immutable.
     using iterator = beast::detail::aged_container_iterator<!IsMap, typename cont_type::iterator>;
-    using const_iterator =
-        beast::detail::aged_container_iterator<true, typename cont_type::iterator>;
-    using reverse_iterator =
-        beast::detail::aged_container_iterator<!IsMap, typename cont_type::reverse_iterator>;
-    using const_reverse_iterator =
-        beast::detail::aged_container_iterator<true, typename cont_type::reverse_iterator>;
+    using const_iterator = beast::detail::aged_container_iterator<true, typename cont_type::iterator>;
+    using reverse_iterator = beast::detail::aged_container_iterator<!IsMap, typename cont_type::reverse_iterator>;
+    using const_reverse_iterator = beast::detail::aged_container_iterator<true, typename cont_type::reverse_iterator>;
 
     //--------------------------------------------------------------------------
     //
@@ -402,12 +386,9 @@ public:
     public:
         // A set iterator (IsMap==false) is always const
         // because the elements of a set are immutable.
-        using iterator =
-            beast::detail::aged_container_iterator<!IsMap, typename list_type::iterator>;
-        using const_iterator =
-            beast::detail::aged_container_iterator<true, typename list_type::iterator>;
-        using reverse_iterator =
-            beast::detail::aged_container_iterator<!IsMap, typename list_type::reverse_iterator>;
+        using iterator = beast::detail::aged_container_iterator<!IsMap, typename list_type::iterator>;
+        using const_iterator = beast::detail::aged_container_iterator<true, typename list_type::iterator>;
+        using reverse_iterator = beast::detail::aged_container_iterator<!IsMap, typename list_type::reverse_iterator>;
         using const_reverse_iterator =
             beast::detail::aged_container_iterator<true, typename list_type::reverse_iterator>;
 
@@ -488,8 +469,7 @@ public:
         {
             static_assert(std::is_standard_layout<element>::value, "must be standard layout");
             return list.iterator_to(*reinterpret_cast<element*>(
-                reinterpret_cast<uint8_t*>(&value) -
-                ((std::size_t)std::addressof(((element*)0)->member))));
+                reinterpret_cast<uint8_t*>(&value) - ((std::size_t)std::addressof(((element*)0)->member))));
         }
 
         const_iterator
@@ -497,8 +477,7 @@ public:
         {
             static_assert(std::is_standard_layout<element>::value, "must be standard layout");
             return list.iterator_to(*reinterpret_cast<element const*>(
-                reinterpret_cast<uint8_t const*>(&value) -
-                ((std::size_t)std::addressof(((element*)0)->member))));
+                reinterpret_cast<uint8_t const*>(&value) - ((std::size_t)std::addressof(((element*)0)->member))));
         }
 
     private:
@@ -539,12 +518,7 @@ public:
     aged_ordered_container(InputIt first, InputIt last, clock_type& clock, Allocator const& alloc);
 
     template <class InputIt>
-    aged_ordered_container(
-        InputIt first,
-        InputIt last,
-        clock_type& clock,
-        Compare const& comp,
-        Allocator const& alloc);
+    aged_ordered_container(InputIt first, InputIt last, clock_type& clock, Compare const& comp, Allocator const& alloc);
 
     aged_ordered_container(aged_ordered_container const& other);
 
@@ -556,15 +530,9 @@ public:
 
     aged_ordered_container(std::initializer_list<value_type> init, clock_type& clock);
 
-    aged_ordered_container(
-        std::initializer_list<value_type> init,
-        clock_type& clock,
-        Compare const& comp);
+    aged_ordered_container(std::initializer_list<value_type> init, clock_type& clock, Compare const& comp);
 
-    aged_ordered_container(
-        std::initializer_list<value_type> init,
-        clock_type& clock,
-        Allocator const& alloc);
+    aged_ordered_container(std::initializer_list<value_type> init, clock_type& clock, Allocator const& alloc);
 
     aged_ordered_container(
         std::initializer_list<value_type> init,
@@ -720,8 +688,7 @@ public:
     {
         static_assert(std::is_standard_layout<element>::value, "must be standard layout");
         return m_cont.iterator_to(*reinterpret_cast<element*>(
-            reinterpret_cast<uint8_t*>(&value) -
-            ((std::size_t)std::addressof(((element*)0)->member))));
+            reinterpret_cast<uint8_t*>(&value) - ((std::size_t)std::addressof(((element*)0)->member))));
     }
 
     const_iterator
@@ -729,8 +696,7 @@ public:
     {
         static_assert(std::is_standard_layout<element>::value, "must be standard layout");
         return m_cont.iterator_to(*reinterpret_cast<element const*>(
-            reinterpret_cast<uint8_t const*>(&value) -
-            ((std::size_t)std::addressof(((element*)0)->member))));
+            reinterpret_cast<uint8_t const*>(&value) - ((std::size_t)std::addressof(((element*)0)->member))));
     }
 
     //--------------------------------------------------------------------------
@@ -769,8 +735,7 @@ public:
     // map, set
     template <bool maybe_multi = IsMulti>
     auto
-    insert(value_type const& value) ->
-        typename std::enable_if<!maybe_multi, std::pair<iterator, bool>>::type;
+    insert(value_type const& value) -> typename std::enable_if<!maybe_multi, std::pair<iterator, bool>>::type;
 
     // multimap, multiset
     template <bool maybe_multi = IsMulti>
@@ -780,22 +745,19 @@ public:
     // set
     template <bool maybe_multi = IsMulti, bool maybe_map = IsMap>
     auto
-    insert(value_type&& value) ->
-        typename std::enable_if<!maybe_multi && !maybe_map, std::pair<iterator, bool>>::type;
+    insert(value_type&& value) -> typename std::enable_if<!maybe_multi && !maybe_map, std::pair<iterator, bool>>::type;
 
     // multiset
     template <bool maybe_multi = IsMulti, bool maybe_map = IsMap>
     auto
-    insert(value_type&& value) ->
-        typename std::enable_if<maybe_multi && !maybe_map, iterator>::type;
+    insert(value_type&& value) -> typename std::enable_if<maybe_multi && !maybe_map, iterator>::type;
 
     //---
 
     // map, set
     template <bool maybe_multi = IsMulti>
     auto
-    insert(const_iterator hint, value_type const& value) ->
-        typename std::enable_if<!maybe_multi, iterator>::type;
+    insert(const_iterator hint, value_type const& value) -> typename std::enable_if<!maybe_multi, iterator>::type;
 
     // multimap, multiset
     template <bool maybe_multi = IsMulti>
@@ -809,8 +771,7 @@ public:
     // map, set
     template <bool maybe_multi = IsMulti>
     auto
-    insert(const_iterator hint, value_type&& value) ->
-        typename std::enable_if<!maybe_multi, iterator>::type;
+    insert(const_iterator hint, value_type&& value) -> typename std::enable_if<!maybe_multi, iterator>::type;
 
     // multimap, multiset
     template <bool maybe_multi = IsMulti>
@@ -858,8 +819,7 @@ public:
     // map, set
     template <bool maybe_multi = IsMulti, class... Args>
     auto
-    emplace(Args&&... args) ->
-        typename std::enable_if<!maybe_multi, std::pair<iterator, bool>>::type;
+    emplace(Args&&... args) -> typename std::enable_if<!maybe_multi, std::pair<iterator, bool>>::type;
 
     // multiset, multimap
     template <bool maybe_multi = IsMulti, class... Args>
@@ -882,19 +842,13 @@ public:
     }
 
     // enable_if prevents erase (reverse_iterator pos) from compiling
-    template <
-        bool is_const,
-        class Iterator,
-        class = std::enable_if_t<!is_boost_reverse_iterator<Iterator>::value>>
+    template <bool is_const, class Iterator, class = std::enable_if_t<!is_boost_reverse_iterator<Iterator>::value>>
     beast::detail::aged_container_iterator<false, Iterator>
     erase(beast::detail::aged_container_iterator<is_const, Iterator> pos);
 
     // enable_if prevents erase (reverse_iterator first, reverse_iterator last)
     // from compiling
-    template <
-        bool is_const,
-        class Iterator,
-        class = std::enable_if_t<!is_boost_reverse_iterator<Iterator>::value>>
+    template <bool is_const, class Iterator, class = std::enable_if_t<!is_boost_reverse_iterator<Iterator>::value>>
     beast::detail::aged_container_iterator<false, Iterator>
     erase(
         beast::detail::aged_container_iterator<is_const, Iterator> first,
@@ -910,10 +864,7 @@ public:
     //--------------------------------------------------------------------------
 
     // enable_if prevents touch (reverse_iterator pos) from compiling
-    template <
-        bool is_const,
-        class Iterator,
-        class = std::enable_if_t<!is_boost_reverse_iterator<Iterator>::value>>
+    template <bool is_const, class Iterator, class = std::enable_if_t<!is_boost_reverse_iterator<Iterator>::value>>
     void
     touch(beast::detail::aged_container_iterator<is_const, Iterator> pos)
     {
@@ -1033,136 +984,69 @@ public:
     // is only done on the key portion of the value type, ignoring
     // the mapped type.
     //
-    template <
-        bool OtherIsMulti,
-        bool OtherIsMap,
-        class OtherT,
-        class OtherDuration,
-        class OtherAllocator>
+    template <bool OtherIsMulti, bool OtherIsMap, class OtherT, class OtherDuration, class OtherAllocator>
     bool
-    operator==(aged_ordered_container<
-               OtherIsMulti,
-               OtherIsMap,
-               Key,
-               OtherT,
-               OtherDuration,
-               Compare,
-               OtherAllocator> const& other) const;
+    operator==(
+        aged_ordered_container<OtherIsMulti, OtherIsMap, Key, OtherT, OtherDuration, Compare, OtherAllocator> const&
+            other) const;
 
-    template <
-        bool OtherIsMulti,
-        bool OtherIsMap,
-        class OtherT,
-        class OtherDuration,
-        class OtherAllocator>
+    template <bool OtherIsMulti, bool OtherIsMap, class OtherT, class OtherDuration, class OtherAllocator>
     bool
-    operator!=(aged_ordered_container<
-               OtherIsMulti,
-               OtherIsMap,
-               Key,
-               OtherT,
-               OtherDuration,
-               Compare,
-               OtherAllocator> const& other) const
+    operator!=(
+        aged_ordered_container<OtherIsMulti, OtherIsMap, Key, OtherT, OtherDuration, Compare, OtherAllocator> const&
+            other) const
     {
         return !(this->operator==(other));
     }
 
-    template <
-        bool OtherIsMulti,
-        bool OtherIsMap,
-        class OtherT,
-        class OtherDuration,
-        class OtherAllocator>
+    template <bool OtherIsMulti, bool OtherIsMap, class OtherT, class OtherDuration, class OtherAllocator>
     bool
-    operator<(aged_ordered_container<
-              OtherIsMulti,
-              OtherIsMap,
-              Key,
-              OtherT,
-              OtherDuration,
-              Compare,
-              OtherAllocator> const& other) const
+    operator<(
+        aged_ordered_container<OtherIsMulti, OtherIsMap, Key, OtherT, OtherDuration, Compare, OtherAllocator> const&
+            other) const
     {
         value_compare const comp(value_comp());
         return std::lexicographical_compare(cbegin(), cend(), other.cbegin(), other.cend(), comp);
     }
 
-    template <
-        bool OtherIsMulti,
-        bool OtherIsMap,
-        class OtherT,
-        class OtherDuration,
-        class OtherAllocator>
+    template <bool OtherIsMulti, bool OtherIsMap, class OtherT, class OtherDuration, class OtherAllocator>
     bool
-    operator<=(aged_ordered_container<
-               OtherIsMulti,
-               OtherIsMap,
-               Key,
-               OtherT,
-               OtherDuration,
-               Compare,
-               OtherAllocator> const& other) const
+    operator<=(
+        aged_ordered_container<OtherIsMulti, OtherIsMap, Key, OtherT, OtherDuration, Compare, OtherAllocator> const&
+            other) const
     {
         return !(other < *this);
     }
 
-    template <
-        bool OtherIsMulti,
-        bool OtherIsMap,
-        class OtherT,
-        class OtherDuration,
-        class OtherAllocator>
+    template <bool OtherIsMulti, bool OtherIsMap, class OtherT, class OtherDuration, class OtherAllocator>
     bool
-    operator>(aged_ordered_container<
-              OtherIsMulti,
-              OtherIsMap,
-              Key,
-              OtherT,
-              OtherDuration,
-              Compare,
-              OtherAllocator> const& other) const
+    operator>(
+        aged_ordered_container<OtherIsMulti, OtherIsMap, Key, OtherT, OtherDuration, Compare, OtherAllocator> const&
+            other) const
     {
         return other < *this;
     }
 
-    template <
-        bool OtherIsMulti,
-        bool OtherIsMap,
-        class OtherT,
-        class OtherDuration,
-        class OtherAllocator>
+    template <bool OtherIsMulti, bool OtherIsMap, class OtherT, class OtherDuration, class OtherAllocator>
     bool
-    operator>=(aged_ordered_container<
-               OtherIsMulti,
-               OtherIsMap,
-               Key,
-               OtherT,
-               OtherDuration,
-               Compare,
-               OtherAllocator> const& other) const
+    operator>=(
+        aged_ordered_container<OtherIsMulti, OtherIsMap, Key, OtherT, OtherDuration, Compare, OtherAllocator> const&
+            other) const
     {
         return !(*this < other);
     }
 
 private:
     // enable_if prevents erase (reverse_iterator pos, now) from compiling
-    template <
-        bool is_const,
-        class Iterator,
-        class = std::enable_if_t<!is_boost_reverse_iterator<Iterator>::value>>
+    template <bool is_const, class Iterator, class = std::enable_if_t<!is_boost_reverse_iterator<Iterator>::value>>
     void
-    touch(
-        beast::detail::aged_container_iterator<is_const, Iterator> pos,
-        typename clock_type::time_point const& now);
+    touch(beast::detail::aged_container_iterator<is_const, Iterator> pos, typename clock_type::time_point const& now);
 
-    template <
-        bool maybe_propagate = std::allocator_traits<Allocator>::propagate_on_container_swap::value>
+    template <bool maybe_propagate = std::allocator_traits<Allocator>::propagate_on_container_swap::value>
     typename std::enable_if<maybe_propagate>::type
     swap_data(aged_ordered_container& other) noexcept;
 
-    template <
-        bool maybe_propagate = std::allocator_traits<Allocator>::propagate_on_container_swap::value>
+    template <bool maybe_propagate = std::allocator_traits<Allocator>::propagate_on_container_swap::value>
     typename std::enable_if<!maybe_propagate>::type
     swap_data(aged_ordered_container& other) noexcept;
 
@@ -1174,8 +1058,7 @@ private:
 //------------------------------------------------------------------------------
 
 template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
-aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::aged_ordered_container(
-    clock_type& clock)
+aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::aged_ordered_container(clock_type& clock)
     : m_config(clock)
 {
 }
@@ -1366,8 +1249,8 @@ aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::opera
 
 template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
 auto
-aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::operator=(
-    aged_ordered_container&& other) -> aged_ordered_container&
+aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::operator=(aged_ordered_container&& other)
+    -> aged_ordered_container&
 {
     clear();
     this->m_config = std::move(other.m_config);
@@ -1413,15 +1296,13 @@ aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::at(K
 template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
 template <bool maybe_multi, bool maybe_map, class>
 typename std::conditional<IsMap, T, void*>::type&
-aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::operator[](
-    Key const& key)
+aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::operator[](Key const& key)
 {
     typename cont_type::insert_commit_data d;
     auto const result(m_cont.insert_check(key, std::cref(m_config.key_compare()), d));
     if (result.second)
     {
-        element* const p(new_element(
-            std::piecewise_construct, std::forward_as_tuple(key), std::forward_as_tuple()));
+        element* const p(new_element(std::piecewise_construct, std::forward_as_tuple(key), std::forward_as_tuple()));
         m_cont.insert_commit(*p, d);
         chronological.list.push_back(*p);
         return p->value.second;
@@ -1438,10 +1319,8 @@ aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::opera
     auto const result(m_cont.insert_check(key, std::cref(m_config.key_compare()), d));
     if (result.second)
     {
-        element* const p(new_element(
-            std::piecewise_construct,
-            std::forward_as_tuple(std::move(key)),
-            std::forward_as_tuple()));
+        element* const p(
+            new_element(std::piecewise_construct, std::forward_as_tuple(std::move(key)), std::forward_as_tuple()));
         m_cont.insert_commit(*p, d);
         chronological.list.push_back(*p);
         return p->value.second;
@@ -1465,8 +1344,7 @@ aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::clear
 template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
 template <bool maybe_multi>
 auto
-aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::insert(
-    value_type const& value) ->
+aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::insert(value_type const& value) ->
     typename std::enable_if<!maybe_multi, std::pair<iterator, bool>>::type
 {
     typename cont_type::insert_commit_data d;
@@ -1485,8 +1363,8 @@ aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::inser
 template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
 template <bool maybe_multi>
 auto
-aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::insert(
-    value_type const& value) -> typename std::enable_if<maybe_multi, iterator>::type
+aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::insert(value_type const& value) ->
+    typename std::enable_if<maybe_multi, iterator>::type
 {
     auto const before(m_cont.upper_bound(extract(value), std::cref(m_config.key_compare())));
     element* const p(new_element(value));
@@ -1499,8 +1377,7 @@ aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::inser
 template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
 template <bool maybe_multi, bool maybe_map>
 auto
-aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::insert(
-    value_type&& value) ->
+aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::insert(value_type&& value) ->
     typename std::enable_if<!maybe_multi && !maybe_map, std::pair<iterator, bool>>::type
 {
     typename cont_type::insert_commit_data d;
@@ -1519,8 +1396,8 @@ aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::inser
 template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
 template <bool maybe_multi, bool maybe_map>
 auto
-aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::insert(
-    value_type&& value) -> typename std::enable_if<maybe_multi && !maybe_map, iterator>::type
+aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::insert(value_type&& value) ->
+    typename std::enable_if<maybe_multi && !maybe_map, iterator>::type
 {
     auto const before(m_cont.upper_bound(extract(value), std::cref(m_config.key_compare())));
     element* const p(new_element(std::move(value)));
@@ -1540,8 +1417,7 @@ aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::inser
     value_type const& value) -> typename std::enable_if<!maybe_multi, iterator>::type
 {
     typename cont_type::insert_commit_data d;
-    auto const result(
-        m_cont.insert_check(hint.iterator(), extract(value), std::cref(m_config.key_compare()), d));
+    auto const result(m_cont.insert_check(hint.iterator(), extract(value), std::cref(m_config.key_compare()), d));
     if (result.second)
     {
         element* const p(new_element(value));
@@ -1561,8 +1437,7 @@ aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::inser
     value_type&& value) -> typename std::enable_if<!maybe_multi, iterator>::type
 {
     typename cont_type::insert_commit_data d;
-    auto const result(
-        m_cont.insert_check(hint.iterator(), extract(value), std::cref(m_config.key_compare()), d));
+    auto const result(m_cont.insert_check(hint.iterator(), extract(value), std::cref(m_config.key_compare()), d));
     if (result.second)
     {
         element* const p(new_element(std::move(value)));
@@ -1577,8 +1452,8 @@ aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::inser
 template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
 template <bool maybe_multi, class... Args>
 auto
-aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::emplace(Args&&... args)
-    -> typename std::enable_if<!maybe_multi, std::pair<iterator, bool>>::type
+aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::emplace(Args&&... args) ->
+    typename std::enable_if<!maybe_multi, std::pair<iterator, bool>>::type
 {
     // VFALCO NOTE Its unfortunate that we need to
     //             construct element here
@@ -1599,8 +1474,8 @@ aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::empla
 template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
 template <bool maybe_multi, class... Args>
 auto
-aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::emplace(Args&&... args)
-    -> typename std::enable_if<maybe_multi, iterator>::type
+aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::emplace(Args&&... args) ->
+    typename std::enable_if<maybe_multi, iterator>::type
 {
     element* const p(new_element(std::forward<Args>(args)...));
     auto const before(m_cont.upper_bound(extract(p->value), std::cref(m_config.key_compare())));
@@ -1621,8 +1496,7 @@ aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::empla
     //             construct element here
     element* const p(new_element(std::forward<Args>(args)...));
     typename cont_type::insert_commit_data d;
-    auto const result(m_cont.insert_check(
-        hint.iterator(), extract(p->value), std::cref(m_config.key_compare()), d));
+    auto const result(m_cont.insert_check(hint.iterator(), extract(p->value), std::cref(m_config.key_compare()), d));
     if (result.second)
     {
         auto const iter(m_cont.insert_commit(*p, d));
@@ -1659,8 +1533,7 @@ aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::erase
 template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
 template <class K>
 auto
-aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::erase(K const& k)
-    -> size_type
+aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::erase(K const& k) -> size_type
 {
     auto iter(m_cont.find(k, std::cref(m_config.key_compare())));
     if (iter == m_cont.end())
@@ -1680,8 +1553,7 @@ aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::erase
 
 template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
 void
-aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::swap(
-    aged_ordered_container& other) noexcept
+aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::swap(aged_ordered_container& other) noexcept
 {
     swap_data(other);
     std::swap(chronological, other.chronological);
@@ -1693,8 +1565,7 @@ aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::swap(
 template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
 template <class K>
 auto
-aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::touch(K const& k)
-    -> size_type
+aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::touch(K const& k) -> size_type
 {
     auto const now(clock().now());
     size_type n(0);
@@ -1710,31 +1581,13 @@ aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::touch
 //------------------------------------------------------------------------------
 
 template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
-template <
-    bool OtherIsMulti,
-    bool OtherIsMap,
-    class OtherT,
-    class OtherDuration,
-    class OtherAllocator>
+template <bool OtherIsMulti, bool OtherIsMap, class OtherT, class OtherDuration, class OtherAllocator>
 bool
 aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::operator==(
-    aged_ordered_container<
-        OtherIsMulti,
-        OtherIsMap,
-        Key,
-        OtherT,
-        OtherDuration,
-        Compare,
-        OtherAllocator> const& other) const
+    aged_ordered_container<OtherIsMulti, OtherIsMap, Key, OtherT, OtherDuration, Compare, OtherAllocator> const& other)
+    const
 {
-    using Other = aged_ordered_container<
-        OtherIsMulti,
-        OtherIsMap,
-        Key,
-        OtherT,
-        OtherDuration,
-        Compare,
-        OtherAllocator>;
+    using Other = aged_ordered_container<OtherIsMulti, OtherIsMap, Key, OtherT, OtherDuration, Compare, OtherAllocator>;
     if (size() != other.size())
         return false;
     std::equal_to<void> eq;
@@ -1789,8 +1642,7 @@ aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::swap_
 //------------------------------------------------------------------------------
 
 template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
-struct is_aged_container<
-    beast::detail::aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>>
+struct is_aged_container<beast::detail::aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>>
     : std::true_type
 {
     explicit is_aged_container() = default;
@@ -1802,8 +1654,7 @@ template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compa
 void
 swap(
     beast::detail::aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>& lhs,
-    beast::detail::aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>&
-        rhs) noexcept
+    beast::detail::aged_ordered_container<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>& rhs) noexcept
 {
     lhs.swap(rhs);
 }
@@ -1826,8 +1677,7 @@ expire(
 {
     std::size_t n(0);
     auto const expired(c.clock().now() - age);
-    for (auto iter(c.chronological.cbegin());
-         iter != c.chronological.cend() && iter.when() <= expired;)
+    for (auto iter(c.chronological.cbegin()); iter != c.chronological.cend() && iter.when() <= expired;)
     {
         iter = c.erase(iter);
         ++n;

include/xrpl/beast/core/LexicalCast.h

@@ -50,9 +50,7 @@ struct LexicalCast<Out, std::string_view>
 {
     explicit LexicalCast() = default;
 
-    static_assert(
-        std::is_integral_v<Out>,
-        "beast::LexicalCast can only be used with integral types");
+    static_assert(std::is_integral_v<Out>, "beast::LexicalCast can only be used with integral types");
 
     template <class Integral = Out>
     std::enable_if_t<std::is_integral_v<Integral> && !std::is_same_v<Integral, bool>, bool>

include/xrpl/beast/core/LockFreeStack.h

@@ -19,12 +19,10 @@ public:
     using iterator_category = std::forward_iterator_tag;
     using value_type = typename Container::value_type;
     using difference_type = typename Container::difference_type;
-    using pointer = typename std::
-        conditional<IsConst, typename Container::const_pointer, typename Container::pointer>::type;
-    using reference = typename std::conditional<
-        IsConst,
-        typename Container::const_reference,
-        typename Container::reference>::type;
+    using pointer =
+        typename std::conditional<IsConst, typename Container::const_pointer, typename Container::pointer>::type;
+    using reference =
+        typename std::conditional<IsConst, typename Container::const_reference, typename Container::reference>::type;
 
     LockFreeStackIterator() : m_node()
     {
@@ -35,8 +33,7 @@ public:
     }
 
     template <bool OtherIsConst>
-    explicit LockFreeStackIterator(LockFreeStackIterator<Container, OtherIsConst> const& other)
-        : m_node(other.m_node)
+    explicit LockFreeStackIterator(LockFreeStackIterator<Container, OtherIsConst> const& other) : m_node(other.m_node)
     {
     }
 
@@ -193,8 +190,7 @@ public:
         {
             first = (old_head == &m_end);
             node->m_next = old_head;
-        } while (!m_head.compare_exchange_strong(
-            old_head, node, std::memory_order_release, std::memory_order_relaxed));
+        } while (!m_head.compare_exchange_strong(old_head, node, std::memory_order_release, std::memory_order_relaxed));
         return first;
     }
 
@@ -217,8 +213,7 @@ public:
             if (node == &m_end)
                 return nullptr;
             new_head = node->m_next.load();
-        } while (!m_head.compare_exchange_strong(
-            node, new_head, std::memory_order_release, std::memory_order_relaxed));
+        } while (!m_head.compare_exchange_strong(node, new_head, std::memory_order_release, std::memory_order_relaxed));
         return static_cast<Element*>(node);
     }
 

include/xrpl/beast/hash/hash_append.h

@@ -26,8 +26,7 @@ template <class T>
 inline void
 reverse_bytes(T& t)
 {
-    unsigned char* bytes =
-        static_cast<unsigned char*>(std::memmove(std::addressof(t), std::addressof(t), sizeof(T)));
+    unsigned char* bytes = static_cast<unsigned char*>(std::memmove(std::addressof(t), std::addressof(t), sizeof(T)));
     for (unsigned i = 0; i < sizeof(T) / 2; ++i)
         std::swap(bytes[i], bytes[sizeof(T) - 1 - i]);
 }
@@ -52,8 +51,7 @@ template <class T, class Hasher>
 inline void
 maybe_reverse_bytes(T& t, Hasher&)
 {
-    maybe_reverse_bytes(
-        t, std::integral_constant<bool, Hasher::endian != boost::endian::order::native>{});
+    maybe_reverse_bytes(t, std::integral_constant<bool, Hasher::endian != boost::endian::order::native>{});
 }
 
 }  // namespace detail
@@ -67,9 +65,8 @@ maybe_reverse_bytes(T& t, Hasher&)
 
 template <class T>
 struct is_uniquely_represented
-    : public std::integral_constant<
-          bool,
-          std::is_integral<T>::value || std::is_enum<T>::value || std::is_pointer<T>::value>
+    : public std::
+          integral_constant<bool, std::is_integral<T>::value || std::is_enum<T>::value || std::is_pointer<T>::value>
 {
     explicit is_uniquely_represented() = default;
 };
@@ -110,8 +107,7 @@ template <class... T>
 struct is_uniquely_represented<std::tuple<T...>>
     : public std::integral_constant<
           bool,
-          std::conjunction_v<is_uniquely_represented<T>...> &&
-              sizeof(std::tuple<T...>) == (sizeof(T) + ...)>
+          std::conjunction_v<is_uniquely_represented<T>...> && sizeof(std::tuple<T...>) == (sizeof(T) + ...)>
 {
     explicit is_uniquely_represented() = default;
 };
@@ -128,9 +124,8 @@ struct is_uniquely_represented<T[N]> : public is_uniquely_represented<T>
 
 template <class T, std::size_t N>
 struct is_uniquely_represented<std::array<T, N>>
-    : public std::integral_constant<
-          bool,
-          is_uniquely_represented<T>::value && sizeof(T) * N == sizeof(std::array<T, N>)>
+    : public std::
+          integral_constant<bool, is_uniquely_represented<T>::value && sizeof(T) * N == sizeof(std::array<T, N>)>
 {
     explicit is_uniquely_represented() = default;
 };
@@ -150,11 +145,10 @@ struct is_uniquely_represented<std::array<T, N>>
 */
 /** @{ */
 template <class T, class HashAlgorithm>
-struct is_contiguously_hashable
-    : public std::integral_constant<
-          bool,
-          is_uniquely_represented<T>::value &&
-              (sizeof(T) == 1 || HashAlgorithm::endian == boost::endian::order::native)>
+struct is_contiguously_hashable : public std::integral_constant<
+                                      bool,
+                                      is_uniquely_represented<T>::value &&
+                                          (sizeof(T) == 1 || HashAlgorithm::endian == boost::endian::order::native)>
 {
     explicit is_contiguously_hashable() = default;
 };

include/xrpl/beast/rfc2616.h

@@ -25,8 +25,7 @@ struct ci_equal_pred
     operator()(char c1, char c2)
     {
         // VFALCO TODO Use a table lookup here
-        return std::tolower(static_cast<unsigned char>(c1)) ==
-            std::tolower(static_cast<unsigned char>(c2));
+        return std::tolower(static_cast<unsigned char>(c1)) == std::tolower(static_cast<unsigned char>(c2));
     }
 };
 
@@ -170,9 +169,7 @@ split(FwdIt first, FwdIt last, Char delim)
     return result;
 }
 
-template <
-    class FwdIt,
-    class Result = std::vector<std::basic_string<typename std::iterator_traits<FwdIt>::value_type>>>
+template <class FwdIt, class Result = std::vector<std::basic_string<typename std::iterator_traits<FwdIt>::value_type>>>
 Result
 split_commas(FwdIt first, FwdIt last)
 {
@@ -359,10 +356,8 @@ bool
 is_keep_alive(boost::beast::http::message<isRequest, Body, Fields> const& m)
 {
     if (m.version() <= 10)
-        return boost::beast::http::token_list{m[boost::beast::http::field::connection]}.exists(
-            "keep-alive");
-    return !boost::beast::http::token_list{m[boost::beast::http::field::connection]}.exists(
-        "close");
+        return boost::beast::http::token_list{m[boost::beast::http::field::connection]}.exists("keep-alive");
+    return !boost::beast::http::token_list{m[boost::beast::http::field::connection]}.exists("close");
 }
 
 }  // namespace rfc2616

include/xrpl/beast/test/yield_to.h

@@ -40,8 +40,7 @@ public:
     /// The type of yield context passed to functions.
     using yield_context = boost::asio::yield_context;
 
-    explicit enable_yield_to(std::size_t concurrency = 1)
-        : work_(boost::asio::make_work_guard(ios_))
+    explicit enable_yield_to(std::size_t concurrency = 1) : work_(boost::asio::make_work_guard(ios_))
     {
         threads_.reserve(concurrency);
         while (concurrency--)

include/xrpl/beast/unit_test/global_suites.h

@@ -22,12 +22,7 @@ global_suites()
 template <class Suite>
 struct insert_suite
 {
-    insert_suite(
-        char const* name,
-        char const* module,
-        char const* library,
-        bool manual,
-        int priority)
+    insert_suite(char const* name, char const* module, char const* library, bool manual, int priority)
     {
         global_suites().insert<Suite>(name, module, library, manual, priority);
     }

include/xrpl/beast/unit_test/reporter.h

@@ -139,10 +139,7 @@ reporter<_>::results::add(suite_results const& r)
     if (elapsed >= std::chrono::seconds{1})
     {
         auto const iter = std::lower_bound(
-            top.begin(),
-            top.end(),
-            elapsed,
-            [](run_time const& t1, typename clock_type::duration const& t2) {
+            top.begin(), top.end(), elapsed, [](run_time const& t1, typename clock_type::duration const& t2) {
                 return t1.second > t2;
             });
         if (iter != top.end())
@@ -175,9 +172,8 @@ reporter<_>::~reporter()
             os_ << std::setw(8) << fmtdur(i.second) << " " << i.first << '\n';
     }
     auto const elapsed = clock_type::now() - results_.start;
-    os_ << fmtdur(elapsed) << ", " << amount{results_.suites, "suite"} << ", "
-        << amount{results_.cases, "case"} << ", " << amount{results_.total, "test"} << " total, "
-        << amount{results_.failed, "failure"} << std::endl;
+    os_ << fmtdur(elapsed) << ", " << amount{results_.suites, "suite"} << ", " << amount{results_.cases, "case"} << ", "
+        << amount{results_.total, "test"} << " total, " << amount{results_.failed, "failure"} << std::endl;
 }
 
 template <class _>
@@ -212,8 +208,7 @@ void
 reporter<_>::on_case_begin(std::string const& name)
 {
     case_results_ = case_results(name);
-    os_ << suite_results_.name << (case_results_.name.empty() ? "" : (" " + case_results_.name))
-        << std::endl;
+    os_ << suite_results_.name << (case_results_.name.empty() ? "" : (" " + case_results_.name)) << std::endl;
 }
 
 template <class _>
@@ -236,8 +231,7 @@ reporter<_>::on_fail(std::string const& reason)
 {
     ++case_results_.failed;
     ++case_results_.total;
-    os_ << "#" << case_results_.total << " failed" << (reason.empty() ? "" : ": ") << reason
-        << std::endl;
+    os_ << "#" << case_results_.total << " failed" << (reason.empty() ? "" : ": ") << reason << std::endl;
 }
 
 template <class _>

include/xrpl/beast/unit_test/suite.h

@@ -91,10 +91,7 @@ private:
         }
     };
 
-    template <
-        class CharT,
-        class Traits = std::char_traits<CharT>,
-        class Allocator = std::allocator<CharT>>
+    template <class CharT, class Traits = std::char_traits<CharT>, class Allocator = std::allocator<CharT>>
     class log_os : public std::basic_ostream<CharT, Traits>
     {
         log_buf<CharT, Traits, Allocator> buf_;
@@ -565,8 +562,7 @@ suite::run(runner& r)
 
     If the condition is false, the file and line number are reported.
 */
-#define BEAST_EXPECTS(cond, reason) \
-    ((cond) ? (pass(), true) : (fail((reason), __FILE__, __LINE__), false))
+#define BEAST_EXPECTS(cond, reason) ((cond) ? (pass(), true) : (fail((reason), __FILE__, __LINE__), false))
 #endif
 
 }  // namespace unit_test
@@ -576,9 +572,9 @@ suite::run(runner& r)
 
 // detail:
 // This inserts the suite with the given manual flag
-#define BEAST_DEFINE_TESTSUITE_INSERT(Class, Module, Library, manual, priority) \
-    static beast::unit_test::detail::insert_suite<Class##_test>                 \
-        Library##Module##Class##_test_instance(#Class, #Module, #Library, manual, priority)
+#define BEAST_DEFINE_TESTSUITE_INSERT(Class, Module, Library, manual, priority)                         \
+    static beast::unit_test::detail::insert_suite<Class##_test> Library##Module##Class##_test_instance( \
+        #Class, #Module, #Library, manual, priority)
 
 //------------------------------------------------------------------------------
 
@@ -633,8 +629,7 @@ suite::run(runner& r)
 
 #else
 #include <xrpl/beast/unit_test/global_suites.h>
-#define BEAST_DEFINE_TESTSUITE(Class, Module, Library) \
-    BEAST_DEFINE_TESTSUITE_INSERT(Class, Module, Library, false, 0)
+#define BEAST_DEFINE_TESTSUITE(Class, Module, Library) BEAST_DEFINE_TESTSUITE_INSERT(Class, Module, Library, false, 0)
 #define BEAST_DEFINE_TESTSUITE_MANUAL(Class, Module, Library) \
     BEAST_DEFINE_TESTSUITE_INSERT(Class, Module, Library, true, 0)
 #define BEAST_DEFINE_TESTSUITE_PRIO(Class, Module, Library, Priority) \

include/xrpl/beast/unit_test/suite_info.h

@@ -27,13 +27,7 @@ class suite_info
     run_type run_;
 
 public:
-    suite_info(
-        std::string name,
-        std::string module,
-        std::string library,
-        bool manual,
-        int priority,
-        run_type run)
+    suite_info(std::string name, std::string module, std::string library, bool manual, int priority, run_type run)
         : name_(std::move(name))
         , module_(std::move(module))
         , library_(std::move(library))
@@ -97,17 +91,10 @@ public:
 /// Convenience for producing suite_info for a given test type.
 template <class Suite>
 suite_info
-make_suite_info(
-    std::string name,
-    std::string module,
-    std::string library,
-    bool manual,
-    int priority)
+make_suite_info(std::string name, std::string module, std::string library, bool manual, int priority)
 {
     return suite_info(
-        std::move(name), std::move(module), std::move(library), manual, priority, [](runner& r) {
-            Suite{}(r);
-        });
+        std::move(name), std::move(module), std::move(library), manual, priority, [](runner& r) { Suite{}(r); });
 }
 
 }  // namespace unit_test

include/xrpl/beast/unit_test/suite_list.h

@@ -39,12 +39,7 @@ public:
 
 template <class Suite>
 void
-suite_list::insert(
-    char const* name,
-    char const* module,
-    char const* library,
-    bool manual,
-    int priority)
+suite_list::insert(char const* name, char const* module, char const* library, bool manual, int priority)
 {
 #ifndef NDEBUG
     {

include/xrpl/beast/utility/Journal.h

@@ -190,8 +190,7 @@ public:
         */
         Stream(Sink& sink, Severity level) : m_sink(sink), m_level(level)
         {
-            XRPL_ASSERT(
-                m_level < severities::kDisabled, "beast::Journal::Stream::Stream : maximum level");
+            XRPL_ASSERT(m_level < severities::kDisabled, "beast::Journal::Stream::Stream : maximum level");
         }
 
         /** Construct or copy another Stream. */
@@ -422,8 +421,7 @@ class basic_logstream : public std::basic_ostream<CharT, Traits>
     detail::logstream_buf<CharT, Traits> buf_;
 
 public:
-    explicit basic_logstream(beast::Journal::Stream const& strm)
-        : std::basic_ostream<CharT, Traits>(&buf_), buf_(strm)
+    explicit basic_logstream(beast::Journal::Stream const& strm) : std::basic_ostream<CharT, Traits>(&buf_), buf_(strm)
     {
     }
 };

include/xrpl/beast/utility/instrumentation.h

@@ -19,8 +19,7 @@
 #endif
 
 #define XRPL_ASSERT ALWAYS_OR_UNREACHABLE
-#define XRPL_ASSERT_PARTS(cond, function, description, ...) \
-    XRPL_ASSERT(cond, function " : " description)
+#define XRPL_ASSERT_PARTS(cond, function, description, ...) XRPL_ASSERT(cond, function " : " description)
 
 // How to use the instrumentation macros:
 //

include/xrpl/beast/utility/maybe_const.h

@@ -9,10 +9,8 @@ template <bool IsConst, class T>
 struct maybe_const
 {
     explicit maybe_const() = default;
-    using type = typename std::conditional<
-        IsConst,
-        typename std::remove_const<T>::type const,
-        typename std::remove_const<T>::type>::type;
+    using type = typename std::
+        conditional<IsConst, typename std::remove_const<T>::type const, typename std::remove_const<T>::type>::type;
 };
 
 /** Alias for omitting `typename`. */

include/xrpl/beast/utility/rngfill.h

@@ -35,10 +35,7 @@ rngfill(void* const buffer, std::size_t const bytes, Generator& g)
     }
 }
 
-template <
-    class Generator,
-    std::size_t N,
-    class = std::enable_if_t<N % sizeof(typename Generator::result_type) == 0>>
+template <class Generator, std::size_t N, class = std::enable_if_t<N % sizeof(typename Generator::result_type) == 0>>
 void
 rngfill(std::array<std::uint8_t, N>& a, Generator& g)
 {

include/xrpl/conditions/Fulfillment.h

@@ -76,8 +76,7 @@ inline bool
 operator==(Fulfillment const& lhs, Fulfillment const& rhs)
 {
     // FIXME: for compound conditions, need to also check subtypes
-    return lhs.type() == rhs.type() && lhs.cost() == rhs.cost() &&
-        lhs.fingerprint() == rhs.fingerprint();
+    return lhs.type() == rhs.type() && lhs.cost() == rhs.cost() && lhs.fingerprint() == rhs.fingerprint();
 }
 
 inline bool

include/xrpl/core/Coro.ipp

@@ -1,7 +1,5 @@
 #pragma once
 
-#include <xrpl/basics/ByteUtilities.h>
-
 namespace xrpl {
 
 template <class F>
@@ -10,17 +8,14 @@ JobQueue::Coro::Coro(Coro_create_t, JobQueue& jq, JobType type, std::string cons
     , type_(type)
     , name_(name)
     , running_(false)
-    , coro_(
-          [this, fn = std::forward<F>(f)](
-              boost::coroutines::asymmetric_coroutine<void>::push_type& do_yield) {
-              yield_ = &do_yield;
-              yield();
-              fn(shared_from_this());
+    , coro_([this, fn = std::forward<F>(f)](boost::coroutines2::coroutine<void>::push_type& do_yield) {
+        yield_ = &do_yield;
+        yield();
+        fn(shared_from_this());
 #ifndef NDEBUG
-              finished_ = true;
+        finished_ = true;
 #endif
-          },
-          boost::coroutines::attributes(megabytes(1)))
+    })
 {
 }
 
@@ -80,6 +75,7 @@ JobQueue::Coro::resume()
     coro_();
     detail::getLocalValues().release();
     detail::getLocalValues().reset(saved);
+
     std::lock_guard lk(mutex_run_);
     running_ = false;
     cv_.notify_all();

include/xrpl/core/HashRouter.h

@@ -210,11 +210,7 @@ public:
 
     // Add a peer suppression and return whether the entry should be processed
     bool
-    shouldProcess(
-        uint256 const& key,
-        PeerShortID peer,
-        HashRouterFlags& flags,
-        std::chrono::seconds tx_interval);
+    shouldProcess(uint256 const& key, PeerShortID peer, HashRouterFlags& flags, std::chrono::seconds tx_interval);
 
     /** Set the flags on a hash.
 
@@ -252,8 +248,7 @@ private:
     Setup const setup_;
 
     // Stores all suppressed hashes and their expiration time
-    beast::aged_unordered_map<uint256, Entry, Stopwatch::clock_type, hardened_hash<strong_hash>>
-        suppressionMap_;
+    beast::aged_unordered_map<uint256, Entry, Stopwatch::clock_type, hardened_hash<strong_hash>> suppressionMap_;
 };
 
 }  // namespace xrpl

include/xrpl/core/Job.h

@@ -92,11 +92,7 @@ public:
     Job(JobType type, std::uint64_t index);
 
     // VFALCO TODO try to remove the dependency on LoadMonitor.
-    Job(JobType type,
-        std::string const& name,
-        std::uint64_t index,
-        LoadMonitor& lm,
-        std::function<void()> const& job);
+    Job(JobType type, std::string const& name, std::uint64_t index, LoadMonitor& lm, std::function<void()> const& job);
 
     JobType
     getType() const;

include/xrpl/core/JobQueue.h

@@ -7,7 +7,7 @@
 #include <xrpl/core/detail/Workers.h>
 #include <xrpl/json/json_value.h>
 
-#include <boost/coroutine/all.hpp>
+#include <boost/coroutine2/all.hpp>
 
 #include <set>
 
@@ -48,8 +48,8 @@ public:
         std::mutex mutex_;
         std::mutex mutex_run_;
         std::condition_variable cv_;
-        boost::coroutines::asymmetric_coroutine<void>::pull_type coro_;
-        boost::coroutines::asymmetric_coroutine<void>::push_type* yield_;
+        boost::coroutines2::coroutine<void>::pull_type coro_;
+        boost::coroutines2::coroutine<void>::push_type* yield_;
 #ifndef NDEBUG
         bool finished_ = false;
 #endif
@@ -140,8 +140,7 @@ public:
     */
     template <
         typename JobHandler,
-        typename =
-            std::enable_if_t<std::is_same<decltype(std::declval<JobHandler&&>()()), void>::value>>
+        typename = std::enable_if_t<std::is_same<decltype(std::declval<JobHandler&&>()()), void>::value>>
     bool
     addJob(JobType type, std::string const& name, JobHandler&& jobHandler)
     {

include/xrpl/core/JobTypeData.h

@@ -31,16 +31,8 @@ public:
     beast::insight::Event dequeue;
     beast::insight::Event execute;
 
-    JobTypeData(
-        JobTypeInfo const& info_,
-        beast::insight::Collector::ptr const& collector,
-        Logs& logs) noexcept
-        : m_load(logs.journal("LoadMonitor"))
-        , m_collector(collector)
-        , info(info_)
-        , waiting(0)
-        , running(0)
-        , deferred(0)
+    JobTypeData(JobTypeInfo const& info_, beast::insight::Collector::ptr const& collector, Logs& logs) noexcept
+        : m_load(logs.journal("LoadMonitor")), m_collector(collector), info(info_), waiting(0), running(0), deferred(0)
     {
         m_load.setTargetLatency(info.getAverageLatency(), info.getPeakLatency());
 

include/xrpl/core/JobTypeInfo.h

@@ -32,11 +32,7 @@ public:
         int limit,
         std::chrono::milliseconds avgLatency,
         std::chrono::milliseconds peakLatency)
-        : m_type(type)
-        , m_name(std::move(name))
-        , m_limit(limit)
-        , m_avgLatency(avgLatency)
-        , m_peakLatency(peakLatency)
+        : m_type(type), m_name(std::move(name)), m_limit(limit), m_avgLatency(avgLatency), m_peakLatency(peakLatency)
     {
     }
 

include/xrpl/core/JobTypes.h

@@ -15,13 +15,7 @@ public:
     using const_iterator = Map::const_iterator;
 
 private:
-    JobTypes()
-        : m_unknown(
-              jtINVALID,
-              "invalid",
-              0,
-              std::chrono::milliseconds{0},
-              std::chrono::milliseconds{0})
+    JobTypes() : m_unknown(jtINVALID, "invalid", 0, std::chrono::milliseconds{0}, std::chrono::milliseconds{0})
     {
         using namespace std::chrono_literals;
         int maxLimit = std::numeric_limits<int>::max();
@@ -32,9 +26,7 @@ private:
                        int limit,
                        std::chrono::milliseconds avgLatency,
                        std::chrono::milliseconds peakLatency) {
-            XRPL_ASSERT(
-                m_map.find(jt) == m_map.end(),
-                "xrpl::JobTypes::JobTypes::add : unique job type input");
+            XRPL_ASSERT(m_map.find(jt) == m_map.end(), "xrpl::JobTypes::JobTypes::add : unique job type input");
 
             [[maybe_unused]] auto const inserted =
                 m_map

include/xrpl/core/PeerReservationTable.h

@@ -55,8 +55,7 @@ struct KeyEqual final
 class PeerReservationTable final
 {
 public:
-    explicit PeerReservationTable(
-        beast::Journal journal = beast::Journal(beast::Journal::getNullSink()))
+    explicit PeerReservationTable(beast::Journal journal = beast::Journal(beast::Journal::getNullSink()))
         : journal_(journal)
     {
     }

include/xrpl/core/PerfLog.h

@@ -151,11 +151,7 @@ PerfLog::Setup
 setup_PerfLog(Section const& section, boost::filesystem::path const& configDir);
 
 std::unique_ptr<PerfLog>
-make_PerfLog(
-    PerfLog::Setup const& setup,
-    Application& app,
-    beast::Journal journal,
-    std::function<void()>&& signalStop);
+make_PerfLog(PerfLog::Setup const& setup, Application& app, beast::Journal journal, std::function<void()>&& signalStop);
 
 template <typename Func, class Rep, class Period>
 auto

include/xrpl/core/detail/Workers.h

@@ -160,8 +160,7 @@ private:
         Idle:   Active, but blocked on waiting for a task.
         Paused: Blocked waiting to exit or become active.
     */
-    class Worker : public beast::LockFreeStack<Worker>::Node,
-                   public beast::LockFreeStack<Worker, PausedTag>::Node
+    class Worker : public beast::LockFreeStack<Worker>::Node, public beast::LockFreeStack<Worker, PausedTag>::Node
     {
     public:
         Worker(Workers& workers, std::string const& threadName, int const instance);

include/xrpl/json/json_reader.h

@@ -145,11 +145,7 @@ private:
     bool
     decodeUnicodeCodePoint(Token& token, Location& current, Location end, unsigned int& unicode);
     bool
-    decodeUnicodeEscapeSequence(
-        Token& token,
-        Location& current,
-        Location end,
-        unsigned int& unicode);
+    decodeUnicodeEscapeSequence(Token& token, Location& current, Location end, unsigned int& unicode);
     bool
     addError(std::string const& message, Token& token, Location extra = 0);
     bool

include/xrpl/json/json_writer.h

@@ -315,8 +315,7 @@ public:
     operator<<(std::ostream& o, Compact const& cJv)
     {
         detail::write_value(
-            [&o](void const* data, std::size_t n) { o.write(static_cast<char const*>(data), n); },
-            cJv.jv_);
+            [&o](void const* data, std::size_t n) { o.write(static_cast<char const*>(data), n); }, cJv.jv_);
         return o;
     }
 };

include/xrpl/ledger/AmendmentTable.h

@@ -1,17 +1,18 @@
 #pragma once
 
-#include <xrpld/app/ledger/Ledger.h>
-#include <xrpld/core/ConfigSections.h>
-
-#include <xrpl/core/ServiceRegistry.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/ledger/View.h>
 #include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/Protocol.h>
 #include <xrpl/protocol/STValidation.h>
+#include <xrpl/shamap/SHAMap.h>
 
 #include <optional>
 
 namespace xrpl {
 
+class ServiceRegistry;
+
 /** The amendment table stores the list of enabled and potential amendments.
     Individuals amendments are voted on by validators during the consensus
     process.
@@ -22,8 +23,7 @@ public:
     struct FeatureInfo
     {
         FeatureInfo() = delete;
-        FeatureInfo(std::string const& n, uint256 const& f, VoteBehavior v)
-            : name(n), feature(f), vote(v)
+        FeatureInfo(std::string const& n, uint256 const& f, VoteBehavior v) : name(n), feature(f), vote(v)
         {
         }
 
@@ -154,13 +154,11 @@ public:
             Serializer s;
             amendTx.add(s);
 
-            JLOG(j.debug()) << "Amendments: Adding pseudo-transaction: "
-                            << amendTx.getTransactionID() << ": " << strHex(s.slice()) << ": "
-                            << amendTx;
+            JLOG(j.debug()) << "Amendments: Adding pseudo-transaction: " << amendTx.getTransactionID() << ": "
+                            << strHex(s.slice()) << ": " << amendTx;
 
             initialPosition->addGiveItem(
-                SHAMapNodeType::tnTRANSACTION_NM,
-                make_shamapitem(amendTx.getTransactionID(), s.slice()));
+                SHAMapNodeType::tnTRANSACTION_NM, make_shamapitem(amendTx.getTransactionID(), s.slice()));
         }
     }
 };

include/xrpl/ledger/ApplyView.h

@@ -33,8 +33,7 @@ constexpr ApplyFlags
 operator|(ApplyFlags const& lhs, ApplyFlags const& rhs)
 {
     return safe_cast<ApplyFlags>(
-        safe_cast<std::underlying_type_t<ApplyFlags>>(lhs) |
-        safe_cast<std::underlying_type_t<ApplyFlags>>(rhs));
+        safe_cast<std::underlying_type_t<ApplyFlags>>(lhs) | safe_cast<std::underlying_type_t<ApplyFlags>>(rhs));
 }
 
 static_assert((tapFAIL_HARD | tapRETRY) == safe_cast<ApplyFlags>(0x30u), "ApplyFlags operator |");
@@ -44,8 +43,7 @@ constexpr ApplyFlags
 operator&(ApplyFlags const& lhs, ApplyFlags const& rhs)
 {
     return safe_cast<ApplyFlags>(
-        safe_cast<std::underlying_type_t<ApplyFlags>>(lhs) &
-        safe_cast<std::underlying_type_t<ApplyFlags>>(rhs));
+        safe_cast<std::underlying_type_t<ApplyFlags>>(lhs) & safe_cast<std::underlying_type_t<ApplyFlags>>(rhs));
 }
 
 static_assert((tapFAIL_HARD & tapRETRY) == tapNONE, "ApplyFlags operator &");
@@ -213,11 +211,7 @@ public:
     // Called when a credit is made to an account
     // This is required to support PaymentSandbox
     virtual void
-    creditHook(
-        AccountID const& from,
-        AccountID const& to,
-        STAmount const& amount,
-        STAmount const& preCreditBalance)
+    creditHook(AccountID const& from, AccountID const& to, STAmount const& amount, STAmount const& preCreditBalance)
     {
     }
 

include/xrpl/ledger/ApplyViewImpl.h

@@ -33,13 +33,7 @@ public:
         destructor.
     */
     std::optional<TxMeta>
-    apply(
-        OpenView& to,
-        STTx const& tx,
-        TER ter,
-        std::optional<uint256> parentBatchId,
-        bool isDryRun,
-        beast::Journal j);
+    apply(OpenView& to, STTx const& tx, TER ter, std::optional<uint256> parentBatchId, bool isDryRun, beast::Journal j);
 
     /** Set the amount of currency delivered.
 

include/xrpl/ledger/Credit.h

@@ -15,11 +15,7 @@ namespace xrpl {
 */
 /** @{ */
 STAmount
-creditLimit(
-    ReadView const& view,
-    AccountID const& account,
-    AccountID const& issuer,
-    Currency const& currency);
+creditLimit(ReadView const& view, AccountID const& account, AccountID const& issuer, Currency const& currency);
 
 IOUAmount
 creditLimit2(ReadView const& v, AccountID const& acc, AccountID const& iss, Currency const& cur);
@@ -33,11 +29,7 @@ creditLimit2(ReadView const& v, AccountID const& acc, AccountID const& iss, Curr
 */
 /** @{ */
 STAmount
-creditBalance(
-    ReadView const& view,
-    AccountID const& account,
-    AccountID const& issuer,
-    Currency const& currency);
+creditBalance(ReadView const& view, AccountID const& account, AccountID const& issuer, Currency const& currency);
 /** @} */
 
 }  // namespace xrpl

include/xrpl/ledger/OpenView.h

@@ -57,9 +57,7 @@ private:
         std::shared_ptr<Serializer const> meta;
 
         // Constructor needed for emplacement in std::map
-        txData(
-            std::shared_ptr<Serializer const> const& txn_,
-            std::shared_ptr<Serializer const> const& meta_)
+        txData(std::shared_ptr<Serializer const> const& txn_, std::shared_ptr<Serializer const> const& meta_)
             : txn(txn_), meta(meta_)
         {
         }
@@ -132,11 +130,7 @@ public:
         The tx list starts empty and will contain
         all newly inserted tx.
     */
-    OpenView(
-        open_ledger_t,
-        ReadView const* base,
-        Rules const& rules,
-        std::shared_ptr<void const> hold = nullptr);
+    OpenView(open_ledger_t, ReadView const* base, Rules const& rules, std::shared_ptr<void const> hold = nullptr);
 
     OpenView(open_ledger_t, Rules const& rules, std::shared_ptr<ReadView const> const& base)
         : OpenView(open_ledger, &*base, rules, base)

include/xrpl/ledger/PaymentSandbox.h

@@ -18,8 +18,7 @@ class DeferredCredits
 public:
     struct Adjustment
     {
-        Adjustment(STAmount const& d, STAmount const& c, STAmount const& b)
-            : debits(d), credits(c), origBalance(b)
+        Adjustment(STAmount const& d, STAmount const& c, STAmount const& b) : debits(d), credits(c), origBalance(b)
         {
         }
         STAmount debits;
@@ -120,8 +119,7 @@ public:
     //        or a PaymentSandbox-derived class, we MUST go through
     //        one of these constructors or invariants will be broken.
     /** @{ */
-    explicit PaymentSandbox(PaymentSandbox const* base)
-        : ApplyViewBase(base, base->flags()), ps_(base)
+    explicit PaymentSandbox(PaymentSandbox const* base) : ApplyViewBase(base, base->flags()), ps_(base)
     {
     }
 
@@ -131,15 +129,11 @@ public:
     /** @} */
 
     STAmount
-    balanceHook(AccountID const& account, AccountID const& issuer, STAmount const& amount)
-        const override;
+    balanceHook(AccountID const& account, AccountID const& issuer, STAmount const& amount) const override;
 
     void
-    creditHook(
-        AccountID const& from,
-        AccountID const& to,
-        STAmount const& amount,
-        STAmount const& preCreditBalance) override;
+    creditHook(AccountID const& from, AccountID const& to, STAmount const& amount, STAmount const& preCreditBalance)
+        override;
 
     void
     adjustOwnerCountHook(AccountID const& account, std::uint32_t cur, std::uint32_t next) override;

include/xrpl/ledger/ReadView.h

@@ -247,9 +247,7 @@ Rules
 makeRulesGivenLedger(DigestAwareReadView const& ledger, Rules const& current);
 
 Rules
-makeRulesGivenLedger(
-    DigestAwareReadView const& ledger,
-    std::unordered_set<uint256, beast::uhash<>> const& presets);
+makeRulesGivenLedger(DigestAwareReadView const& ledger, std::unordered_set<uint256, beast::uhash<>> const& presets);
 
 }  // namespace xrpl
 

include/xrpl/ledger/View.h

@@ -74,18 +74,10 @@ isGlobalFrozen(ReadView const& view, Asset const& asset);
 
 // Note, depth parameter is used to limit the recursion depth
 [[nodiscard]] bool
-isVaultPseudoAccountFrozen(
-    ReadView const& view,
-    AccountID const& account,
-    MPTIssue const& mptShare,
-    int depth);
+isVaultPseudoAccountFrozen(ReadView const& view, AccountID const& account, MPTIssue const& mptShare, int depth);
 
 [[nodiscard]] bool
-isIndividualFrozen(
-    ReadView const& view,
-    AccountID const& account,
-    Currency const& currency,
-    AccountID const& issuer);
+isIndividualFrozen(ReadView const& view, AccountID const& account, Currency const& currency, AccountID const& issuer);
 
 [[nodiscard]] inline bool
 isIndividualFrozen(ReadView const& view, AccountID const& account, Issue const& issue)
@@ -99,16 +91,11 @@ isIndividualFrozen(ReadView const& view, AccountID const& account, MPTIssue cons
 [[nodiscard]] inline bool
 isIndividualFrozen(ReadView const& view, AccountID const& account, Asset const& asset)
 {
-    return std::visit(
-        [&](auto const& issue) { return isIndividualFrozen(view, account, issue); }, asset.value());
+    return std::visit([&](auto const& issue) { return isIndividualFrozen(view, account, issue); }, asset.value());
 }
 
 [[nodiscard]] bool
-isFrozen(
-    ReadView const& view,
-    AccountID const& account,
-    Currency const& currency,
-    AccountID const& issuer);
+isFrozen(ReadView const& view, AccountID const& account, Currency const& currency, AccountID const& issuer);
 
 [[nodiscard]] inline bool
 isFrozen(ReadView const& view, AccountID const& account, Issue const& issue, int = 0 /*ignored*/)
@@ -127,8 +114,7 @@ isFrozen(ReadView const& view, AccountID const& account, MPTIssue const& mptIssu
 [[nodiscard]] inline bool
 isFrozen(ReadView const& view, AccountID const& account, Asset const& asset, int depth = 0)
 {
-    return std::visit(
-        [&](auto const& issue) { return isFrozen(view, account, issue, depth); }, asset.value());
+    return std::visit([&](auto const& issue) { return isFrozen(view, account, issue, depth); }, asset.value());
 }
 
 [[nodiscard]] inline TER
@@ -146,8 +132,7 @@ checkFrozen(ReadView const& view, AccountID const& account, MPTIssue const& mptI
 [[nodiscard]] inline TER
 checkFrozen(ReadView const& view, AccountID const& account, Asset const& asset)
 {
-    return std::visit(
-        [&](auto const& issue) { return checkFrozen(view, account, issue); }, asset.value());
+    return std::visit([&](auto const& issue) { return checkFrozen(view, account, issue); }, asset.value());
 }
 
 [[nodiscard]] bool
@@ -158,10 +143,7 @@ isAnyFrozen(
     int depth = 0);
 
 [[nodiscard]] inline bool
-isAnyFrozen(
-    ReadView const& view,
-    std::initializer_list<AccountID> const& accounts,
-    Issue const& issue)
+isAnyFrozen(ReadView const& view, std::initializer_list<AccountID> const& accounts, Issue const& issue)
 {
     for (auto const& account : accounts)
     {
@@ -172,11 +154,7 @@ isAnyFrozen(
 }
 
 [[nodiscard]] inline bool
-isAnyFrozen(
-    ReadView const& view,
-    std::initializer_list<AccountID> const& accounts,
-    Asset const& asset,
-    int depth = 0)
+isAnyFrozen(ReadView const& view, std::initializer_list<AccountID> const& accounts, Asset const& asset, int depth = 0)
 {
     return std::visit(
         [&]<ValidIssueType TIss>(TIss const& issue) {
@@ -189,28 +167,16 @@ isAnyFrozen(
 }
 
 [[nodiscard]] bool
-isDeepFrozen(
-    ReadView const& view,
-    AccountID const& account,
-    Currency const& currency,
-    AccountID const& issuer);
+isDeepFrozen(ReadView const& view, AccountID const& account, Currency const& currency, AccountID const& issuer);
 
 [[nodiscard]] inline bool
-isDeepFrozen(
-    ReadView const& view,
-    AccountID const& account,
-    Issue const& issue,
-    int = 0 /*ignored*/)
+isDeepFrozen(ReadView const& view, AccountID const& account, Issue const& issue, int = 0 /*ignored*/)
 {
     return isDeepFrozen(view, account, issue.currency, issue.account);
 }
 
 [[nodiscard]] inline bool
-isDeepFrozen(
-    ReadView const& view,
-    AccountID const& account,
-    MPTIssue const& mptIssue,
-    int depth = 0)
+isDeepFrozen(ReadView const& view, AccountID const& account, MPTIssue const& mptIssue, int depth = 0)
 {
     // Unlike IOUs, frozen / locked MPTs are not allowed to send or receive
     // funds, so checking "deep frozen" is the same as checking "frozen".
@@ -225,9 +191,7 @@ isDeepFrozen(
 [[nodiscard]] inline bool
 isDeepFrozen(ReadView const& view, AccountID const& account, Asset const& asset, int depth = 0)
 {
-    return std::visit(
-        [&](auto const& issue) { return isDeepFrozen(view, account, issue, depth); },
-        asset.value());
+    return std::visit([&](auto const& issue) { return isDeepFrozen(view, account, issue, depth); }, asset.value());
 }
 
 [[nodiscard]] inline TER
@@ -245,16 +209,11 @@ checkDeepFrozen(ReadView const& view, AccountID const& account, MPTIssue const&
 [[nodiscard]] inline TER
 checkDeepFrozen(ReadView const& view, AccountID const& account, Asset const& asset)
 {
-    return std::visit(
-        [&](auto const& issue) { return checkDeepFrozen(view, account, issue); }, asset.value());
+    return std::visit([&](auto const& issue) { return checkDeepFrozen(view, account, issue); }, asset.value());
 }
 
 [[nodiscard]] bool
-isLPTokenFrozen(
-    ReadView const& view,
-    AccountID const& account,
-    Issue const& asset,
-    Issue const& asset2);
+isLPTokenFrozen(ReadView const& view, AccountID const& account, Issue const& asset, Issue const& asset2);
 
 // Returns the amount an account can spend.
 //
@@ -332,10 +291,7 @@ xrpLiquid(ReadView const& view, AccountID const& id, std::int32_t ownerCountAdj,
 
 /** Iterate all items in the given directory. */
 void
-forEachItem(
-    ReadView const& view,
-    Keylet const& root,
-    std::function<void(std::shared_ptr<SLE const> const&)> const& f);
+forEachItem(ReadView const& view, Keylet const& root, std::function<void(std::shared_ptr<SLE const> const&)> const& f);
 
 /** Iterate all items after an item in the given directory.
     @param after The key of the item to start after
@@ -354,10 +310,7 @@ forEachItemAfter(
 
 /** Iterate all items in an account's owner directory. */
 inline void
-forEachItem(
-    ReadView const& view,
-    AccountID const& id,
-    std::function<void(std::shared_ptr<SLE const> const&)> const& f)
+forEachItem(ReadView const& view, AccountID const& id, std::function<void(std::shared_ptr<SLE const> const&)> const& f)
 {
     return forEachItem(view, keylet::ownerDir(id), f);
 }
@@ -454,11 +407,7 @@ getCandidateLedger(LedgerIndex requested)
     use the second form if you have not acquired the valid ledger yet
 */
 [[nodiscard]] bool
-areCompatible(
-    ReadView const& validLedger,
-    ReadView const& testLedger,
-    beast::Journal::Stream& s,
-    char const* reason);
+areCompatible(ReadView const& validLedger, ReadView const& testLedger, beast::Journal::Stream& s, char const* reason);
 
 [[nodiscard]] bool
 areCompatible(
@@ -476,11 +425,7 @@ areCompatible(
 
 /** Adjust the owner count up or down. */
 void
-adjustOwnerCount(
-    ApplyView& view,
-    std::shared_ptr<SLE> const& sle,
-    std::int32_t amount,
-    beast::Journal j);
+adjustOwnerCount(ApplyView& view, std::shared_ptr<SLE> const& sle, std::int32_t amount, beast::Journal j);
 
 /** @{ */
 /** Returns the first entry in the directory, advancing the index
@@ -506,12 +451,7 @@ cdirFirst(
     uint256& entry);
 
 bool
-dirFirst(
-    ApplyView& view,
-    uint256 const& root,
-    std::shared_ptr<SLE>& page,
-    unsigned int& index,
-    uint256& entry);
+dirFirst(ApplyView& view, uint256 const& root, std::shared_ptr<SLE>& page, unsigned int& index, uint256& entry);
 /** @} */
 
 /** @{ */
@@ -538,23 +478,14 @@ cdirNext(
     uint256& entry);
 
 bool
-dirNext(
-    ApplyView& view,
-    uint256 const& root,
-    std::shared_ptr<SLE>& page,
-    unsigned int& index,
-    uint256& entry);
+dirNext(ApplyView& view, uint256 const& root, std::shared_ptr<SLE>& page, unsigned int& index, uint256& entry);
 /** @} */
 
 [[nodiscard]] std::function<void(SLE::ref)>
 describeOwnerDir(AccountID const& account);
 
 [[nodiscard]] TER
-dirLink(
-    ApplyView& view,
-    AccountID const& owner,
-    std::shared_ptr<SLE>& object,
-    SF_UINT64 const& node = sfOwnerNode);
+dirLink(ApplyView& view, AccountID const& owner, std::shared_ptr<SLE>& object, SF_UINT64 const& node = sfOwnerNode);
 
 AccountID
 pseudoAccountAddress(ReadView const& view, uint256 const& pseudoOwnerKey);
@@ -578,9 +509,7 @@ createPseudoAccount(ApplyView& view, uint256 const& pseudoOwnerKey, SField const
 // * NOT a ltACCOUNT_ROOT OR
 // * null pointer
 [[nodiscard]] bool
-isPseudoAccount(
-    std::shared_ptr<SLE const> sleAcct,
-    std::set<SField const*> const& pseudoFieldFilter = {});
+isPseudoAccount(std::shared_ptr<SLE const> sleAcct, std::set<SField const*> const& pseudoFieldFilter = {});
 
 // Returns the list of fields that define an ACCOUNT_ROOT as a pseudo-account if
 // set
@@ -594,10 +523,7 @@ isPseudoAccount(
 getPseudoAccountFields();
 
 [[nodiscard]] inline bool
-isPseudoAccount(
-    ReadView const& view,
-    AccountID const& accountId,
-    std::set<SField const*> const& pseudoFieldFilter = {})
+isPseudoAccount(ReadView const& view, AccountID const& accountId, std::set<SField const*> const& pseudoFieldFilter = {})
 {
     return isPseudoAccount(view.read(keylet::account(accountId)), pseudoFieldFilter);
 }
@@ -757,25 +683,13 @@ trustCreate(
     beast::Journal j);
 
 [[nodiscard]] TER
-removeEmptyHolding(
-    ApplyView& view,
-    AccountID const& accountID,
-    Issue const& issue,
-    beast::Journal journal);
+removeEmptyHolding(ApplyView& view, AccountID const& accountID, Issue const& issue, beast::Journal journal);
 
 [[nodiscard]] TER
-removeEmptyHolding(
-    ApplyView& view,
-    AccountID const& accountID,
-    MPTIssue const& mptIssue,
-    beast::Journal journal);
+removeEmptyHolding(ApplyView& view, AccountID const& accountID, MPTIssue const& mptIssue, beast::Journal journal);
 
 [[nodiscard]] inline TER
-removeEmptyHolding(
-    ApplyView& view,
-    AccountID const& accountID,
-    Asset const& asset,
-    beast::Journal journal)
+removeEmptyHolding(ApplyView& view, AccountID const& accountID, Asset const& asset, beast::Journal journal)
 {
     return std::visit(
         [&]<ValidIssueType TIss>(TIss const& issue) -> TER {
@@ -827,11 +741,7 @@ rippleCredit(
     beast::Journal j);
 
 TER
-rippleLockEscrowMPT(
-    ApplyView& view,
-    AccountID const& uGrantorID,
-    STAmount const& saAmount,
-    beast::Journal j);
+rippleLockEscrowMPT(ApplyView& view, AccountID const& uGrantorID, STAmount const& saAmount, beast::Journal j);
 
 TER
 rippleUnlockEscrowMPT(
@@ -871,28 +781,13 @@ accountSendMulti(
     WaiveTransferFee waiveFee = WaiveTransferFee::No);
 
 [[nodiscard]] TER
-issueIOU(
-    ApplyView& view,
-    AccountID const& account,
-    STAmount const& amount,
-    Issue const& issue,
-    beast::Journal j);
+issueIOU(ApplyView& view, AccountID const& account, STAmount const& amount, Issue const& issue, beast::Journal j);
 
 [[nodiscard]] TER
-redeemIOU(
-    ApplyView& view,
-    AccountID const& account,
-    STAmount const& amount,
-    Issue const& issue,
-    beast::Journal j);
+redeemIOU(ApplyView& view, AccountID const& account, STAmount const& amount, Issue const& issue, beast::Journal j);
 
 [[nodiscard]] TER
-transferXRP(
-    ApplyView& view,
-    AccountID const& from,
-    AccountID const& to,
-    STAmount const& amount,
-    beast::Journal j);
+transferXRP(ApplyView& view, AccountID const& from, AccountID const& to, STAmount const& amount, beast::Journal j);
 
 /* Check if MPToken (for MPT) or trust line (for IOU) exists:
  * - StrongAuth - before checking if authorization is required
@@ -923,11 +818,7 @@ enum class AuthType { StrongAuth, WeakAuth, Legacy };
  * The default "Legacy" auth type is equivalent to WeakAuth.
  */
 [[nodiscard]] TER
-requireAuth(
-    ReadView const& view,
-    Issue const& issue,
-    AccountID const& account,
-    AuthType authType = AuthType::Legacy);
+requireAuth(ReadView const& view, Issue const& issue, AccountID const& account, AuthType authType = AuthType::Legacy);
 
 /** Check if the account lacks required authorization.
  *
@@ -967,9 +858,7 @@ requireAuth(
     AuthType authType = AuthType::Legacy)
 {
     return std::visit(
-        [&]<ValidIssueType TIss>(TIss const& issue_) {
-            return requireAuth(view, issue_, account, authType);
-        },
+        [&]<ValidIssueType TIss>(TIss const& issue_) { return requireAuth(view, issue_, account, authType); },
         asset.value());
 }
 
@@ -1009,11 +898,7 @@ enforceMPTokenAuthorization(
  *  and tesSUCCESS otherwise.
  */
 [[nodiscard]] TER
-canTransfer(
-    ReadView const& view,
-    MPTIssue const& mptIssue,
-    AccountID const& from,
-    AccountID const& to);
+canTransfer(ReadView const& view, MPTIssue const& mptIssue, AccountID const& from, AccountID const& to);
 
 [[nodiscard]] TER
 canTransfer(ReadView const& view, Issue const& issue, AccountID const& from, AccountID const& to);
@@ -1025,9 +910,7 @@ canTransfer(ReadView const& view, Issue const& issue, AccountID const& from, Acc
     AccountID const& to)
 {
     return std::visit(
-        [&]<ValidIssueType TIss>(TIss const& issue) -> TER {
-            return canTransfer(view, issue, from, to);
-        },
+        [&]<ValidIssueType TIss>(TIss const& issue) -> TER { return canTransfer(view, issue, from, to); },
         asset.value());
 }
 
@@ -1035,8 +918,7 @@ canTransfer(ReadView const& view, Issue const& issue, AccountID const& from, Acc
  * (if should not be skipped) and if the entry should be skipped. The status
  * is always tesSUCCESS if the entry should be skipped.
  */
-using EntryDeleter = std::function<
-    std::pair<TER, SkipEntry>(LedgerEntryType, uint256 const&, std::shared_ptr<SLE>&)>;
+using EntryDeleter = std::function<std::pair<TER, SkipEntry>(LedgerEntryType, uint256 const&, std::shared_ptr<SLE>&)>;
 /** Cleanup owner directory entries on account delete.
  * Used for a regular and AMM accounts deletion. The caller
  * has to provide the deleter function, which handles details of

include/xrpl/ledger/detail/ApplyStateTable.h

@@ -64,6 +64,11 @@ public:
     std::shared_ptr<SLE const>
     read(ReadView const& base, Keylet const& k) const;
 
+    /** Check only local items without delegating to base.
+        Returns std::nullopt if key not found locally. */
+    std::optional<std::shared_ptr<SLE const>>
+    readLocal(Keylet const& k) const;
+
     std::shared_ptr<SLE>
     peek(ReadView const& base, Keylet const& k);
 

include/xrpl/ledger/detail/RawStateTable.h

@@ -23,13 +23,11 @@ public:
     static constexpr size_t initialBufferSize = kilobytes(256);
 
     RawStateTable()
-        : monotonic_resource_{std::make_unique<boost::container::pmr::monotonic_buffer_resource>(
-              initialBufferSize)}
+        : monotonic_resource_{std::make_unique<boost::container::pmr::monotonic_buffer_resource>(initialBufferSize)}
         , items_{monotonic_resource_.get()} {};
 
     RawStateTable(RawStateTable const& rhs)
-        : monotonic_resource_{std::make_unique<boost::container::pmr::monotonic_buffer_resource>(
-              initialBufferSize)}
+        : monotonic_resource_{std::make_unique<boost::container::pmr::monotonic_buffer_resource>(initialBufferSize)}
         , items_{rhs.items_, monotonic_resource_.get()}
         , dropsDestroyed_{rhs.dropsDestroyed_} {};
 

include/xrpl/ledger/detail/ReadViewFwdRange.ipp

@@ -16,9 +16,7 @@ ReadViewFwdRange<ValueType>::iterator::iterator(iterator&& other) noexcept
 }
 
 template <class ValueType>
-ReadViewFwdRange<ValueType>::iterator::iterator(
-    ReadView const* view,
-    std::unique_ptr<iter_base> impl)
+ReadViewFwdRange<ValueType>::iterator::iterator(ReadView const* view, std::unique_ptr<iter_base> impl)
     : view_(view), impl_(std::move(impl))
 {
 }

include/xrpl/net/AutoSocket.h

@@ -26,20 +26,13 @@ public:
     using callback = std::function<void(error_code)>;
 
 public:
-    AutoSocket(
-        boost::asio::io_context& s,
-        boost::asio::ssl::context& c,
-        bool secureOnly,
-        bool plainOnly)
-        : mSecure(secureOnly)
-        , mBuffer((plainOnly || secureOnly) ? 0 : 4)
-        , j_{beast::Journal::getNullSink()}
+    AutoSocket(boost::asio::io_context& s, boost::asio::ssl::context& c, bool secureOnly, bool plainOnly)
+        : mSecure(secureOnly), mBuffer((plainOnly || secureOnly) ? 0 : 4), j_{beast::Journal::getNullSink()}
     {
         mSocket = std::make_unique<ssl_socket>(s, c);
     }
 
-    AutoSocket(boost::asio::io_context& s, boost::asio::ssl::context& c)
-        : AutoSocket(s, c, false, false)
+    AutoSocket(boost::asio::io_context& s, boost::asio::ssl::context& c) : AutoSocket(s, c, false, false)
     {
     }
 
@@ -112,12 +105,7 @@ public:
             mSocket->next_layer().async_receive(
                 boost::asio::buffer(mBuffer),
                 boost::asio::socket_base::message_peek,
-                std::bind(
-                    &AutoSocket::handle_autodetect,
-                    this,
-                    cbFunc,
-                    std::placeholders::_1,
-                    std::placeholders::_2));
+                std::bind(&AutoSocket::handle_autodetect, this, cbFunc, std::placeholders::_1, std::placeholders::_2));
         }
     }
 
@@ -164,10 +152,7 @@ public:
 
     template <typename Allocator, typename Handler>
     void
-    async_read_until(
-        boost::asio::basic_streambuf<Allocator>& buffers,
-        std::string const& delim,
-        Handler handler)
+    async_read_until(boost::asio::basic_streambuf<Allocator>& buffers, std::string const& delim, Handler handler)
     {
         if (isSecure())
             boost::asio::async_read_until(*mSocket, buffers, delim, handler);
@@ -177,10 +162,7 @@ public:
 
     template <typename Allocator, typename MatchCondition, typename Handler>
     void
-    async_read_until(
-        boost::asio::basic_streambuf<Allocator>& buffers,
-        MatchCondition cond,
-        Handler handler)
+    async_read_until(boost::asio::basic_streambuf<Allocator>& buffers, MatchCondition cond, Handler handler)
     {
         if (isSecure())
             boost::asio::async_read_until(*mSocket, buffers, cond, handler);

include/xrpl/net/HTTPClient.h

@@ -29,6 +29,9 @@ public:
         bool sslVerify,
         beast::Journal j);
 
+    static void
+    cleanupSSLContext();
+
     static void
     get(bool bSSL,
         boost::asio::io_context& io_context,
@@ -37,10 +40,8 @@ public:
         std::string const& strPath,
         std::size_t responseMax,  // if no Content-Length header
         std::chrono::seconds timeout,
-        std::function<bool(
-            boost::system::error_code const& ecResult,
-            int iStatus,
-            std::string const& strData)> complete,
+        std::function<bool(boost::system::error_code const& ecResult, int iStatus, std::string const& strData)>
+            complete,
         beast::Journal& j);
 
     static void
@@ -51,10 +52,8 @@ public:
         std::string const& strPath,
         std::size_t responseMax,  // if no Content-Length header
         std::chrono::seconds timeout,
-        std::function<bool(
-            boost::system::error_code const& ecResult,
-            int iStatus,
-            std::string const& strData)> complete,
+        std::function<bool(boost::system::error_code const& ecResult, int iStatus, std::string const& strData)>
+            complete,
         beast::Journal& j);
 
     static void
@@ -66,10 +65,8 @@ public:
         std::function<void(boost::asio::streambuf& sb, std::string const& strHost)> build,
         std::size_t responseMax,  // if no Content-Length header
         std::chrono::seconds timeout,
-        std::function<bool(
-            boost::system::error_code const& ecResult,
-            int iStatus,
-            std::string const& strData)> complete,
+        std::function<bool(boost::system::error_code const& ecResult, int iStatus, std::string const& strData)>
+            complete,
         beast::Journal& j);
 };
 

include/xrpl/net/HTTPClientSSLContext.h

@@ -30,8 +30,8 @@ public:
             registerSSLCerts(ssl_context_, ec, j_);
 
             if (ec && sslVerifyDir.empty())
-                Throw<std::runtime_error>(boost::str(
-                    boost::format("Failed to set_default_verify_paths: %s") % ec.message()));
+                Throw<std::runtime_error>(
+                    boost::str(boost::format("Failed to set_default_verify_paths: %s") % ec.message()));
         }
         else
         {
@@ -43,8 +43,7 @@ public:
             ssl_context_.add_verify_path(sslVerifyDir, ec);
 
             if (ec)
-                Throw<std::runtime_error>(
-                    boost::str(boost::format("Failed to add verify path: %s") % ec.message()));
+                Throw<std::runtime_error>(boost::str(boost::format("Failed to add verify path: %s") % ec.message()));
         }
     }
 
@@ -115,9 +114,7 @@ public:
             if (!ec)
             {
                 strm.set_verify_callback(
-                    std::bind(
-                        &rfc6125_verify, host, std::placeholders::_1, std::placeholders::_2, j_),
-                    ec);
+                    std::bind(&rfc6125_verify, host, std::placeholders::_1, std::placeholders::_2, j_), ec);
             }
         }
 
@@ -134,17 +131,12 @@ public:
      * @param j journal for logging
      */
     static bool
-    rfc6125_verify(
-        std::string const& domain,
-        bool preverified,
-        boost::asio::ssl::verify_context& ctx,
-        beast::Journal j)
+    rfc6125_verify(std::string const& domain, bool preverified, boost::asio::ssl::verify_context& ctx, beast::Journal j)
     {
         if (boost::asio::ssl::host_name_verification(domain)(preverified, ctx))
             return true;
 
-        JLOG(j.warn()) << "Outbound SSL connection to " << domain
-                       << " fails certificate verification";
+        JLOG(j.warn()) << "Outbound SSL connection to " << domain << " fails certificate verification";
         return false;
     }
 

include/xrpl/nodestore/Backend.h

@@ -63,8 +63,7 @@ public:
     virtual void
     open(bool createIfMissing, uint64_t appType, uint64_t uid, uint64_t salt)
     {
-        Throw<std::runtime_error>(
-            "Deterministic appType/uid/salt not supported by backend " + getName());
+        Throw<std::runtime_error>("Deterministic appType/uid/salt not supported by backend " + getName());
     }
 
     /** Close the backend.

include/xrpl/nodestore/Database.h

@@ -243,10 +243,7 @@ private:
     std::condition_variable readCondVar_;
 
     // reads to do
-    std::map<
-        uint256,
-        std::vector<
-            std::pair<std::uint32_t, std::function<void(std::shared_ptr<NodeObject> const&)>>>>
+    std::map<uint256, std::vector<std::pair<std::uint32_t, std::function<void(std::shared_ptr<NodeObject> const&)>>>>
         read_;
 
     std::atomic<bool> readStopping_ = false;
@@ -254,11 +251,7 @@ private:
     std::atomic<int> runningThreads_ = 0;
 
     virtual std::shared_ptr<NodeObject>
-    fetchNodeObject(
-        uint256 const& hash,
-        std::uint32_t ledgerSeq,
-        FetchReport& fetchReport,
-        bool duplicate) = 0;
+    fetchNodeObject(uint256 const& hash, std::uint32_t ledgerSeq, FetchReport& fetchReport, bool duplicate) = 0;
 
     /** Visit every object in the database
         This is usually called during import.

include/xrpl/nodestore/DatabaseRotating.h

@@ -13,11 +13,7 @@ namespace NodeStore {
 class DatabaseRotating : public Database
 {
 public:
-    DatabaseRotating(
-        Scheduler& scheduler,
-        int readThreads,
-        Section const& config,
-        beast::Journal journal)
+    DatabaseRotating(Scheduler& scheduler, int readThreads, Section const& config, beast::Journal journal)
         : Database(scheduler, readThreads, config, journal)
     {
     }
@@ -32,8 +28,7 @@ public:
     virtual void
     rotate(
         std::unique_ptr<NodeStore::Backend>&& newBackend,
-        std::function<void(std::string const& writableName, std::string const& archiveName)> const&
-            f) = 0;
+        std::function<void(std::string const& writableName, std::string const& archiveName)> const& f) = 0;
 };
 
 }  // namespace NodeStore

include/xrpl/nodestore/Manager.h

@@ -38,11 +38,7 @@ public:
 
     /** Create a backend. */
     virtual std::unique_ptr<Backend>
-    make_Backend(
-        Section const& parameters,
-        std::size_t burstSize,
-        Scheduler& scheduler,
-        beast::Journal journal) = 0;
+    make_Backend(Section const& parameters, std::size_t burstSize, Scheduler& scheduler, beast::Journal journal) = 0;
 
     /** Construct a NodeStore database.
 

include/xrpl/nodestore/detail/DatabaseNodeImp.h

@@ -82,8 +82,7 @@ private:
     std::shared_ptr<Backend> backend_;
 
     std::shared_ptr<NodeObject>
-    fetchNodeObject(uint256 const& hash, std::uint32_t, FetchReport& fetchReport, bool duplicate)
-        override;
+    fetchNodeObject(uint256 const& hash, std::uint32_t, FetchReport& fetchReport, bool duplicate) override;
 
     void
     for_each(std::function<void(std::shared_ptr<NodeObject>)> f) override

include/xrpl/nodestore/detail/DatabaseRotatingImp.h

@@ -31,8 +31,7 @@ public:
     void
     rotate(
         std::unique_ptr<NodeStore::Backend>&& newBackend,
-        std::function<void(std::string const& writableName, std::string const& archiveName)> const&
-            f) override;
+        std::function<void(std::string const& writableName, std::string const& archiveName)> const& f) override;
 
     std::string
     getName() const override;
@@ -62,8 +61,7 @@ private:
     mutable std::mutex mutex_;
 
     std::shared_ptr<NodeObject>
-    fetchNodeObject(uint256 const& hash, std::uint32_t, FetchReport& fetchReport, bool duplicate)
-        override;
+    fetchNodeObject(uint256 const& hash, std::uint32_t, FetchReport& fetchReport, bool duplicate) override;
 
     void
     for_each(std::function<void(std::shared_ptr<NodeObject>)> f) override;

include/xrpl/nodestore/detail/ManagerImp.h

@@ -33,11 +33,8 @@ public:
     erase(Factory& factory) override;
 
     std::unique_ptr<Backend>
-    make_Backend(
-        Section const& parameters,
-        std::size_t burstSize,
-        Scheduler& scheduler,
-        beast::Journal journal) override;
+    make_Backend(Section const& parameters, std::size_t burstSize, Scheduler& scheduler, beast::Journal journal)
+        override;
 
     std::unique_ptr<Database>
     make_Database(