Merge branch 'develop' into ximinez/directory

* XRPLF/develop:
  refactor: Modularize app/tx (6228)
  refactor: Decouple app/tx from `Application` and `Config` (6227)
  chore: Update clang-format to 21.1.8 (6352)
  refactor: Modularize `HashRouter`, `Conditions`, and `OrderBookDB` (6226)
  chore: Fix minor issues in comments (6346)
  refactor: Modularize the NetworkOPs interface (6225)
  chore: Fix `gcov` lib coverage build failure on macOS (6350)
  refactor: Modularize RelationalDB (6224)
  refactor: Modularize WalletDB and Manifest (6223)
  fix: Update invariant checks for Permissioned Domains (6134)
  refactor: Change main thread name to `xrpld-main` (6336)
  refactor: Fix spelling issues in tests (6199)
  test: Add file and line location to Env (6276)
  chore: Remove CODEOWNERS (6337)
  perf: Remove unnecessary caches (5439)
  chore: Restore unity builds (6328)
  refactor: Update secp256k1 to 0.7.1 (6331)
  fix: Increment sequence when accepting new manifests (6059)
  fix typo in LendingHelpers unit-test (6215)

.clang-tidy

@@ -0,0 +1,191 @@
+---
+Checks: "-*,
+  bugprone-argument-comment
+  "
+# bugprone-assert-side-effect,
+# bugprone-bad-signal-to-kill-thread,
+# bugprone-bool-pointer-implicit-conversion,
+# bugprone-casting-through-void,
+# bugprone-chained-comparison,
+# bugprone-compare-pointer-to-member-virtual-function,
+# bugprone-copy-constructor-init,
+# bugprone-crtp-constructor-accessibility,
+# bugprone-dangling-handle,
+# bugprone-dynamic-static-initializers,
+# bugprone-empty-catch,
+# bugprone-fold-init-type,
+# bugprone-forward-declaration-namespace,
+# bugprone-inaccurate-erase,
+# bugprone-inc-dec-in-conditions,
+# bugprone-incorrect-enable-if,
+# bugprone-incorrect-roundings,
+# bugprone-infinite-loop,
+# bugprone-integer-division,
+# bugprone-lambda-function-name,
+# bugprone-macro-parentheses,
+# bugprone-macro-repeated-side-effects,
+# bugprone-misplaced-operator-in-strlen-in-alloc,
+# bugprone-misplaced-pointer-arithmetic-in-alloc,
+# bugprone-misplaced-widening-cast,
+# bugprone-move-forwarding-reference,
+# bugprone-multi-level-implicit-pointer-conversion,
+# bugprone-multiple-new-in-one-expression,
+# bugprone-multiple-statement-macro,
+# bugprone-no-escape,
+# bugprone-non-zero-enum-to-bool-conversion,
+# bugprone-optional-value-conversion,
+# bugprone-parent-virtual-call,
+# bugprone-pointer-arithmetic-on-polymorphic-object,
+# bugprone-posix-return,
+# bugprone-redundant-branch-condition,
+# bugprone-reserved-identifier,
+# bugprone-return-const-ref-from-parameter,
+# bugprone-shared-ptr-array-mismatch,
+# bugprone-signal-handler,
+# bugprone-signed-char-misuse,
+# bugprone-sizeof-container,
+# bugprone-sizeof-expression,
+# bugprone-spuriously-wake-up-functions,
+# bugprone-standalone-empty,
+# bugprone-string-constructor,
+# bugprone-string-integer-assignment,
+# bugprone-string-literal-with-embedded-nul,
+# bugprone-stringview-nullptr,
+# bugprone-suspicious-enum-usage,
+# bugprone-suspicious-include,
+# bugprone-suspicious-memory-comparison,
+# bugprone-suspicious-memset-usage,
+# bugprone-suspicious-missing-comma,
+# bugprone-suspicious-realloc-usage,
+# bugprone-suspicious-semicolon,
+# bugprone-suspicious-string-compare,
+# bugprone-suspicious-stringview-data-usage,
+# bugprone-swapped-arguments,
+# bugprone-switch-missing-default-case,
+# bugprone-terminating-continue,
+# bugprone-throw-keyword-missing,
+# bugprone-too-small-loop-variable,
+# bugprone-undefined-memory-manipulation,
+# bugprone-undelegated-constructor,
+# bugprone-unhandled-exception-at-new,
+# bugprone-unhandled-self-assignment,
+# bugprone-unique-ptr-array-mismatch,
+# bugprone-unsafe-functions,
+# bugprone-unused-local-non-trivial-variable,
+# bugprone-unused-raii,
+# bugprone-unused-return-value,
+# bugprone-use-after-move,
+# bugprone-virtual-near-miss,
+# cppcoreguidelines-init-variables,
+# cppcoreguidelines-misleading-capture-default-by-value,
+# cppcoreguidelines-no-suspend-with-lock,
+# cppcoreguidelines-pro-type-member-init,
+# cppcoreguidelines-pro-type-static-cast-downcast,
+# cppcoreguidelines-rvalue-reference-param-not-moved,
+# cppcoreguidelines-use-default-member-init,
+# cppcoreguidelines-virtual-class-destructor,
+# hicpp-ignored-remove-result,
+# llvm-namespace-comment,
+# misc-const-correctness,
+# misc-definitions-in-headers,
+# misc-header-include-cycle,
+# misc-include-cleaner,
+# misc-misplaced-const,
+# misc-redundant-expression,
+# misc-static-assert,
+# misc-throw-by-value-catch-by-reference,
+# misc-unused-alias-decls,
+# misc-unused-using-decls,
+# modernize-concat-nested-namespaces,
+# modernize-deprecated-headers,
+# modernize-make-shared,
+# modernize-make-unique,
+# modernize-pass-by-value,
+# modernize-type-traits,
+# modernize-use-designated-initializers,
+# modernize-use-emplace,
+# modernize-use-equals-default,
+# modernize-use-equals-delete,
+# modernize-use-override,
+# modernize-use-ranges,
+# modernize-use-starts-ends-with,
+# modernize-use-std-numbers,
+# modernize-use-using,
+# performance-faster-string-find,
+# performance-for-range-copy,
+# performance-implicit-conversion-in-loop,
+# performance-inefficient-vector-operation,
+# performance-move-const-arg,
+# performance-move-constructor-init,
+# performance-no-automatic-move,
+# performance-trivially-destructible,
+# readability-avoid-nested-conditional-operator,
+# readability-avoid-return-with-void-value,
+# readability-braces-around-statements,
+# readability-const-return-type,
+# readability-container-contains,
+# readability-container-size-empty,
+# readability-convert-member-functions-to-static,
+# readability-duplicate-include,
+# readability-else-after-return,
+# readability-enum-initial-value,
+# readability-implicit-bool-conversion,
+# readability-inconsistent-declaration-parameter-name,
+# readability-identifier-naming,
+# readability-make-member-function-const,
+# readability-math-missing-parentheses,
+# readability-misleading-indentation,
+# readability-non-const-parameter,
+# readability-redundant-casting,
+# readability-redundant-declaration,
+# readability-redundant-inline-specifier,
+# readability-redundant-member-init,
+# readability-redundant-string-init,
+# readability-reference-to-constructed-temporary,
+# readability-simplify-boolean-expr,
+# readability-static-accessed-through-instance,
+# readability-static-definition-in-anonymous-namespace,
+# readability-suspicious-call-argument,
+# readability-use-std-min-max
+#
+# CheckOptions:
+#   readability-braces-around-statements.ShortStatementLines: 2
+#   readability-identifier-naming.MacroDefinitionCase: UPPER_CASE
+#   readability-identifier-naming.ClassCase: CamelCase
+#   readability-identifier-naming.StructCase: CamelCase
+#   readability-identifier-naming.UnionCase: CamelCase
+#   readability-identifier-naming.EnumCase: CamelCase
+#   readability-identifier-naming.EnumConstantCase: CamelCase
+#   readability-identifier-naming.ScopedEnumConstantCase: CamelCase
+#   readability-identifier-naming.GlobalConstantCase: UPPER_CASE
+#   readability-identifier-naming.GlobalConstantPrefix: "k"
+#   readability-identifier-naming.GlobalVariableCase: CamelCase
+#   readability-identifier-naming.GlobalVariablePrefix: "g"
+#   readability-identifier-naming.ConstexprFunctionCase: camelBack
+#   readability-identifier-naming.ConstexprMethodCase: camelBack
+#   readability-identifier-naming.ClassMethodCase: camelBack
+#   readability-identifier-naming.ClassMemberCase: camelBack
+#   readability-identifier-naming.ClassConstantCase: UPPER_CASE
+#   readability-identifier-naming.ClassConstantPrefix: "k"
+#   readability-identifier-naming.StaticConstantCase: UPPER_CASE
+#   readability-identifier-naming.StaticConstantPrefix: "k"
+#   readability-identifier-naming.StaticVariableCase: UPPER_CASE
+#   readability-identifier-naming.StaticVariablePrefix: "k"
+#   readability-identifier-naming.ConstexprVariableCase: UPPER_CASE
+#   readability-identifier-naming.ConstexprVariablePrefix: "k"
+#   readability-identifier-naming.LocalConstantCase: camelBack
+#   readability-identifier-naming.LocalVariableCase: camelBack
+#   readability-identifier-naming.TemplateParameterCase: CamelCase
+#   readability-identifier-naming.ParameterCase: camelBack
+#   readability-identifier-naming.FunctionCase: camelBack
+#   readability-identifier-naming.MemberCase: camelBack
+#   readability-identifier-naming.PrivateMemberSuffix: _
+#   readability-identifier-naming.ProtectedMemberSuffix: _
+#   readability-identifier-naming.PublicMemberSuffix: ""
+#   readability-identifier-naming.FunctionIgnoredRegexp: ".*tag_invoke.*"
+#   bugprone-unsafe-functions.ReportMoreUnsafeFunctions: true
+#   bugprone-unused-return-value.CheckedReturnTypes: ::std::error_code;::std::error_condition;::std::errc
+#   misc-include-cleaner.IgnoreHeaders: '.*/(detail|impl)/.*;.*(expected|unexpected).*;.*ranges_lower_bound\.h;time.h;stdlib.h;__chrono/.*;fmt/chrono.h;boost/uuid/uuid_hash.hpp'
+#
+# HeaderFilterRegex: '^.*/(src|tests)/.*\.(h|hpp)$'
+WarningsAsErrors: "*"

.cmake-format.yaml

@@ -29,7 +29,7 @@ format:
   disable: false
   _help_line_width:
     - How wide to allow formatted cmake files
-  line_width: 120
+  line_width: 100
   _help_tab_size:
     - How many spaces to tab for indent
   tab_size: 4

.github/workflows/on-pr.yml

@@ -65,9 +65,12 @@ jobs:
             .github/workflows/reusable-build.yml
             .github/workflows/reusable-build-test-config.yml
             .github/workflows/reusable-build-test.yml
+            .github/workflows/reusable-clang-tidy.yml
+            .github/workflows/reusable-clang-tidy-files.yml
             .github/workflows/reusable-strategy-matrix.yml
             .github/workflows/reusable-test.yml
             .github/workflows/reusable-upload-recipe.yml
+            .clang-tidy
             .codecov.yml
             cmake/**
             conan/**
@@ -107,6 +110,17 @@ jobs:
     if: ${{ needs.should-run.outputs.go == 'true' }}
     uses: ./.github/workflows/reusable-check-rename.yml
 
+  clang-tidy:
+    needs: should-run
+    if: ${{ needs.should-run.outputs.go == 'true' }}
+    uses: ./.github/workflows/reusable-clang-tidy.yml
+    permissions:
+      issues: write
+      contents: read
+    with:
+      check_only_changed: true
+      create_issue_on_failure: false
+
   build-test:
     needs: should-run
     if: ${{ needs.should-run.outputs.go == 'true' }}
@@ -156,6 +170,7 @@ jobs:
     needs:
       - check-levelization
       - check-rename
+      - clang-tidy
       - build-test
       - upload-recipe
       - notify-clio

.github/workflows/on-trigger.yml

@@ -22,9 +22,12 @@ on:
       - ".github/workflows/reusable-build.yml"
       - ".github/workflows/reusable-build-test-config.yml"
       - ".github/workflows/reusable-build-test.yml"
+      - ".github/workflows/reusable-clang-tidy.yml"
+      - ".github/workflows/reusable-clang-tidy-files.yml"
       - ".github/workflows/reusable-strategy-matrix.yml"
       - ".github/workflows/reusable-test.yml"
       - ".github/workflows/reusable-upload-recipe.yml"
+      - ".clang-tidy"
       - ".codecov.yml"
       - "cmake/**"
       - "conan/**"
@@ -60,6 +63,15 @@ defaults:
     shell: bash
 
 jobs:
+  clang-tidy:
+    uses: ./.github/workflows/reusable-clang-tidy.yml
+    permissions:
+      issues: write
+      contents: read
+    with:
+      check_only_changed: false
+      create_issue_on_failure: ${{ github.event_name == 'schedule' }}
+
   build-test:
     uses: ./.github/workflows/reusable-build-test.yml
     strategy:

.github/workflows/reusable-clang-tidy-files.yml

@@ -0,0 +1,162 @@
+name: Run clang-tidy on files
+
+on:
+  workflow_call:
+    inputs:
+      files:
+        description: "List of files to check (empty means check all files)"
+        type: string
+        default: ""
+      create_issue_on_failure:
+        description: "Whether to create an issue if the check failed"
+        type: boolean
+        default: false
+
+defaults:
+  run:
+    shell: bash
+
+env:
+  # Conan installs the generators in the build/generators directory, see the
+  # layout() method in conanfile.py. We then run CMake from the build directory.
+  BUILD_DIR: build
+  BUILD_TYPE: Release
+
+jobs:
+  run-clang-tidy:
+    name: Run clang tidy
+    runs-on: ["self-hosted", "Linux", "X64", "heavy"]
+    container: "ghcr.io/xrplf/ci/debian-trixie:clang-21-sha-53033a2"
+    permissions:
+      issues: write
+      contents: read
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@08eba0b27e820071cde6df949e0beb9ba4906955 # v4.3.0
+
+      - name: Prepare runner
+        uses: XRPLF/actions/prepare-runner@2cbf481018d930656e9276fcc20dc0e3a0be5b6d
+        with:
+          enable_ccache: false
+
+      - name: Print build environment
+        uses: ./.github/actions/print-env
+
+      - name: Get number of processors
+        uses: XRPLF/actions/get-nproc@cf0433aa74563aead044a1e395610c96d65a37cf
+        id: nproc
+
+      - name: Setup Conan
+        uses: ./.github/actions/setup-conan
+
+      - name: Build dependencies
+        uses: ./.github/actions/build-deps
+        with:
+          build_nproc: ${{ steps.nproc.outputs.nproc }}
+          build_type: ${{ env.BUILD_TYPE }}
+          log_verbosity: verbose
+
+      - name: Configure CMake
+        working-directory: ${{ env.BUILD_DIR }}
+        run: |
+          cmake \
+            -G 'Ninja' \
+            -DCMAKE_TOOLCHAIN_FILE:FILEPATH=build/generators/conan_toolchain.cmake \
+            -DCMAKE_BUILD_TYPE="${BUILD_TYPE}" \
+            -Dtests=ON \
+            -Dwerr=ON \
+            -Dxrpld=ON \
+            ..
+
+      # clang-tidy needs headers generated from proto files
+      - name: Build libxrpl.libpb
+        working-directory: ${{ env.BUILD_DIR }}
+        run: |
+          ninja -j ${{ steps.nproc.outputs.nproc }} xrpl.libpb
+
+      - name: Run clang tidy
+        id: run_clang_tidy
+        continue-on-error: true
+        env:
+          FILES: ${{ inputs.files }}
+        run: |
+          run-clang-tidy -j ${{ steps.nproc.outputs.nproc }} -p "$BUILD_DIR" $FILES 2>&1 | tee clang-tidy-output.txt
+
+      - name: Upload clang-tidy output
+        if: steps.run_clang_tidy.outcome != 'success'
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        with:
+          name: clang-tidy-results
+          path: clang-tidy-output.txt
+          retention-days: 30
+
+      - name: Create an issue
+        if: steps.run_clang_tidy.outcome != 'success' && inputs.create_issue_on_failure
+        id: create_issue
+        shell: bash
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          # Prepare issue body with clang-tidy output
+          cat > issue.md <<EOF
+          ## Clang-tidy Check Failed
+
+          **Workflow:** ${{ github.workflow }}
+          **Run ID:** ${{ github.run_id }}
+          **Commit:** ${{ github.sha }}
+          **Branch/Ref:** ${{ github.ref }}
+          **Triggered by:** ${{ github.actor }}
+
+          ### Clang-tidy Output:
+          \`\`\`
+          EOF
+
+          # Append clang-tidy output (filter for errors and warnings)
+          if [ -f clang-tidy-output.txt ]; then
+            # Extract lines containing 'error:', 'warning:', or 'note:'
+            grep -E '(error:|warning:|note:)' clang-tidy-output.txt > filtered-output.txt || true
+
+            # If filtered output is empty, use original (might be a different error format)
+            if [ ! -s filtered-output.txt ]; then
+              cp clang-tidy-output.txt filtered-output.txt
+            fi
+
+            # Truncate if too large
+            head -c 60000 filtered-output.txt >> issue.md
+            if [ "$(wc -c < filtered-output.txt)" -gt 60000 ]; then
+              echo "" >> issue.md
+              echo "... (output truncated, see artifacts for full output)" >> issue.md
+            fi
+
+            rm filtered-output.txt
+          else
+            echo "No output file found" >> issue.md
+          fi
+
+          cat >> issue.md <<EOF
+          \`\`\`
+
+          **Workflow run:** ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
+
+          ---
+          *This issue was automatically created by the clang-tidy workflow.*
+          EOF
+
+          # Create the issue
+          gh issue create \
+            --label "Bug,Clang-tidy" \
+            --title "Clang-tidy check failed" \
+            --body-file ./issue.md \
+            > create_issue.log
+
+          created_issue="$(sed 's|.*/||' create_issue.log)"
+          echo "created_issue=$created_issue" >> $GITHUB_OUTPUT
+          echo "Created issue #$created_issue"
+
+          rm -f create_issue.log issue.md clang-tidy-output.txt
+
+      - name: Fail the workflow if clang-tidy failed
+        if: steps.run_clang_tidy.outcome != 'success'
+        run: |
+          echo "Clang-tidy check failed!"
+          exit 1

.github/workflows/reusable-clang-tidy.yml

@@ -0,0 +1,47 @@
+name: Clang-tidy check
+
+on:
+  workflow_call:
+    inputs:
+      check_only_changed:
+        description: "Check only changed files in PR. If false, checks all files in the repository."
+        type: boolean
+        default: false
+      create_issue_on_failure:
+        description: "Whether to create an issue if the check failed"
+        type: boolean
+        default: false
+
+defaults:
+  run:
+    shell: bash
+
+jobs:
+  determine-files:
+    name: Determine files to check
+    if: ${{ inputs.check_only_changed }}
+    runs-on: ubuntu-latest
+    outputs:
+      any_changed: ${{ steps.changed_files.outputs.any_changed }}
+      all_changed_files: ${{ steps.changed_files.outputs.all_changed_files }}
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+
+      - name: Get changed C++ files
+        id: changed_files
+        uses: tj-actions/changed-files@ed68ef82c095e0d48ec87eccea555d944a631a4c # v46.0.5
+        with:
+          files: |
+            **/*.cpp
+            **/*.h
+            **/*.ipp
+          separator: " "
+
+  run-clang-tidy:
+    needs: [determine-files]
+    if: ${{ always() && !cancelled() && (!inputs.check_only_changed || needs.determine-files.outputs.any_changed == 'true') }}
+    uses: ./.github/workflows/reusable-clang-tidy-files.yml
+    with:
+      files: ${{ inputs.check_only_changed && needs.determine-files.outputs.all_changed_files || '' }}
+      create_issue_on_failure: ${{ inputs.create_issue_on_failure }}

CMakeLists.txt

@@ -17,6 +17,7 @@ project(xrpl)
 set(CMAKE_CXX_EXTENSIONS OFF)
 set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 
 include(CompilationEnv)
 
@@ -38,16 +39,16 @@ include(Ccache)
 # make GIT_COMMIT_HASH define available to all sources
 find_package(Git)
 if (Git_FOUND)
-    execute_process(COMMAND ${GIT_EXECUTABLE} --git-dir=${CMAKE_CURRENT_SOURCE_DIR}/.git rev-parse HEAD
-                    OUTPUT_STRIP_TRAILING_WHITESPACE OUTPUT_VARIABLE gch)
+    execute_process(COMMAND ${GIT_EXECUTABLE} --git-dir=${CMAKE_CURRENT_SOURCE_DIR}/.git rev-parse
+                            HEAD OUTPUT_STRIP_TRAILING_WHITESPACE OUTPUT_VARIABLE gch)
     if (gch)
         set(GIT_COMMIT_HASH "${gch}")
         message(STATUS gch: ${GIT_COMMIT_HASH})
         add_definitions(-DGIT_COMMIT_HASH="${GIT_COMMIT_HASH}")
     endif ()
 
-    execute_process(COMMAND ${GIT_EXECUTABLE} --git-dir=${CMAKE_CURRENT_SOURCE_DIR}/.git rev-parse --abbrev-ref HEAD
-                    OUTPUT_STRIP_TRAILING_WHITESPACE OUTPUT_VARIABLE gb)
+    execute_process(COMMAND ${GIT_EXECUTABLE} --git-dir=${CMAKE_CURRENT_SOURCE_DIR}/.git rev-parse
+                            --abbrev-ref HEAD OUTPUT_STRIP_TRAILING_WHITESPACE OUTPUT_VARIABLE gb)
     if (gb)
         set(GIT_BRANCH "${gb}")
         message(STATUS gb: ${GIT_BRANCH})
@@ -67,7 +68,8 @@ include(FetchContent)
 include(ExternalProject)
 include(CMakeFuncs) # must come *after* ExternalProject b/c it overrides one function in EP
 if (target)
-    message(FATAL_ERROR "The target option has been removed - use native cmake options to control build")
+    message(FATAL_ERROR "The target option has been removed - use native cmake options to control build"
+    )
 endif ()
 
 include(XrplSanity)
@@ -76,7 +78,8 @@ include(XrplSettings)
 # this check has to remain in the top-level cmake because of the early return statement
 if (packages_only)
     if (NOT TARGET rpm)
-        message(FATAL_ERROR "packages_only requested, but targets were not created - is docker installed?")
+        message(FATAL_ERROR "packages_only requested, but targets were not created - is docker installed?"
+        )
     endif ()
     return()
 endif ()
@@ -118,7 +121,8 @@ target_link_libraries(
 option(rocksdb "Enable RocksDB" ON)
 if (rocksdb)
     find_package(RocksDB REQUIRED)
-    set_target_properties(RocksDB::rocksdb PROPERTIES INTERFACE_COMPILE_DEFINITIONS XRPL_ROCKSDB_AVAILABLE=1)
+    set_target_properties(RocksDB::rocksdb PROPERTIES INTERFACE_COMPILE_DEFINITIONS
+                                                      XRPL_ROCKSDB_AVAILABLE=1)
     target_link_libraries(xrpl_libs INTERFACE RocksDB::rocksdb)
 endif ()
 

cmake/Ccache.cmake

@@ -43,7 +43,8 @@ set(CMAKE_VS_GLOBALS "CLToolExe=cl.exe" "CLToolPath=${CMAKE_BINARY_DIR}" "TrackF
 # By default Visual Studio generators will use /Zi to capture debug information, which is not compatible with ccache, so
 # tell it to use /Z7 instead.
 if (MSVC)
-    foreach (var_ CMAKE_C_FLAGS_DEBUG CMAKE_C_FLAGS_RELEASE CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELEASE)
+    foreach (var_ CMAKE_C_FLAGS_DEBUG CMAKE_C_FLAGS_RELEASE CMAKE_CXX_FLAGS_DEBUG
+                  CMAKE_CXX_FLAGS_RELEASE)
         string(REPLACE "/Zi" "/Z7" ${var_} "${${var_}}")
     endforeach ()
 endif ()

cmake/CodeCoverage.cmake

@@ -180,7 +180,8 @@ elseif (DEFINED ENV{CODE_COVERAGE_GCOV_TOOL})
     set(GCOV_TOOL "$ENV{CODE_COVERAGE_GCOV_TOOL}")
 elseif ("${CMAKE_CXX_COMPILER_ID}" MATCHES "(Apple)?[Cc]lang")
     if (APPLE)
-        execute_process(COMMAND xcrun -f llvm-cov OUTPUT_VARIABLE LLVMCOV_PATH OUTPUT_STRIP_TRAILING_WHITESPACE)
+        execute_process(COMMAND xcrun -f llvm-cov OUTPUT_VARIABLE LLVMCOV_PATH
+                        OUTPUT_STRIP_TRAILING_WHITESPACE)
     else ()
         find_program(LLVMCOV_PATH llvm-cov)
     endif ()
@@ -199,8 +200,8 @@ foreach (LANG ${LANGUAGES})
         if ("${CMAKE_${LANG}_COMPILER_VERSION}" VERSION_LESS 3)
             message(FATAL_ERROR "Clang version must be 3.0.0 or greater! Aborting...")
         endif ()
-    elseif (NOT "${CMAKE_${LANG}_COMPILER_ID}" MATCHES "GNU" AND NOT "${CMAKE_${LANG}_COMPILER_ID}" MATCHES
-                                                                 "(LLVM)?[Ff]lang")
+    elseif (NOT "${CMAKE_${LANG}_COMPILER_ID}" MATCHES "GNU" AND NOT "${CMAKE_${LANG}_COMPILER_ID}"
+                                                                 MATCHES "(LLVM)?[Ff]lang")
         message(FATAL_ERROR "Compiler is not GNU or Flang! Aborting...")
     endif ()
 endforeach ()
@@ -321,14 +322,16 @@ function (setup_target_for_coverage_gcovr)
     endif ()
 
     if ("--output" IN_LIST GCOVR_ADDITIONAL_ARGS)
-        message(FATAL_ERROR "Unsupported --output option detected in GCOVR_ADDITIONAL_ARGS! Aborting...")
+        message(FATAL_ERROR "Unsupported --output option detected in GCOVR_ADDITIONAL_ARGS! Aborting..."
+        )
     else ()
         if ((Coverage_FORMAT STREQUAL "html-details") OR (Coverage_FORMAT STREQUAL "html-nested"))
             set(GCOVR_OUTPUT_FILE ${PROJECT_BINARY_DIR}/${Coverage_NAME}/index.html)
             set(GCOVR_CREATE_FOLDER ${PROJECT_BINARY_DIR}/${Coverage_NAME})
         elseif (Coverage_FORMAT STREQUAL "html-single")
             set(GCOVR_OUTPUT_FILE ${Coverage_NAME}.html)
-        elseif ((Coverage_FORMAT STREQUAL "json-summary") OR (Coverage_FORMAT STREQUAL "json-details")
+        elseif ((Coverage_FORMAT STREQUAL "json-summary") OR (Coverage_FORMAT STREQUAL
+                                                              "json-details")
                 OR (Coverage_FORMAT STREQUAL "coveralls"))
             set(GCOVR_OUTPUT_FILE ${Coverage_NAME}.json)
         elseif (Coverage_FORMAT STREQUAL "txt")
@@ -452,8 +455,10 @@ function (setup_target_for_coverage_gcovr)
                       COMMENT "Running gcovr to produce code coverage report.")
 
     # Show info where to find the report
-    add_custom_command(TARGET ${Coverage_NAME} POST_BUILD COMMAND echo
-                       COMMENT "Code coverage report saved in ${GCOVR_OUTPUT_FILE} formatted as ${Coverage_FORMAT}")
+    add_custom_command(
+        TARGET ${Coverage_NAME} POST_BUILD COMMAND echo
+        COMMENT "Code coverage report saved in ${GCOVR_OUTPUT_FILE} formatted as ${Coverage_FORMAT}"
+    )
 endfunction () # setup_target_for_coverage_gcovr
 
 function (add_code_coverage_to_target name scope)
@@ -463,8 +468,9 @@ function (add_code_coverage_to_target name scope)
     separate_arguments(COVERAGE_C_LINKER_FLAGS NATIVE_COMMAND "${COVERAGE_C_LINKER_FLAGS}")
 
     # Add compiler options to the target
-    target_compile_options(${name} ${scope} $<$<COMPILE_LANGUAGE:CXX>:${COVERAGE_CXX_COMPILER_FLAGS}>
-                           $<$<COMPILE_LANGUAGE:C>:${COVERAGE_C_COMPILER_FLAGS}>)
+    target_compile_options(
+        ${name} ${scope} $<$<COMPILE_LANGUAGE:CXX>:${COVERAGE_CXX_COMPILER_FLAGS}>
+        $<$<COMPILE_LANGUAGE:C>:${COVERAGE_C_COMPILER_FLAGS}>)
 
     target_link_libraries(${name} ${scope} $<$<LINK_LANGUAGE:CXX>:${COVERAGE_CXX_LINKER_FLAGS}>
                           $<$<LINK_LANGUAGE:C>:${COVERAGE_C_LINKER_FLAGS}>)

cmake/XrplCompiler.cmake

@@ -17,7 +17,8 @@ link_libraries(Xrpl::common)
 if (NOT DEFINED CMAKE_POSITION_INDEPENDENT_CODE)
     set(CMAKE_POSITION_INDEPENDENT_CODE ON)
 endif ()
-set_target_properties(common PROPERTIES INTERFACE_POSITION_INDEPENDENT_CODE ${CMAKE_POSITION_INDEPENDENT_CODE})
+set_target_properties(common PROPERTIES INTERFACE_POSITION_INDEPENDENT_CODE
+                                        ${CMAKE_POSITION_INDEPENDENT_CODE})
 set(CMAKE_CXX_EXTENSIONS OFF)
 target_compile_definitions(
     common
@@ -37,7 +38,8 @@ if (MSVC)
     # remove existing exception flag since we set it to -EHa
     string(REGEX REPLACE "[-/]EH[a-z]+" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
 
-    foreach (var_ CMAKE_C_FLAGS_DEBUG CMAKE_C_FLAGS_RELEASE CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELEASE)
+    foreach (var_ CMAKE_C_FLAGS_DEBUG CMAKE_C_FLAGS_RELEASE CMAKE_CXX_FLAGS_DEBUG
+                  CMAKE_CXX_FLAGS_RELEASE)
 
         # also remove dynamic runtime
         string(REGEX REPLACE "[-/]MD[d]*" " " ${var_} "${${var_}}")
@@ -143,20 +145,23 @@ if (voidstar)
     elseif (NOT is_linux)
         message(FATAL_ERROR "Antithesis instrumentation requires Linux, aborting...")
     elseif (NOT (is_clang AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 16.0))
-        message(FATAL_ERROR "Antithesis instrumentation requires Clang version 16 or later, aborting...")
+        message(FATAL_ERROR "Antithesis instrumentation requires Clang version 16 or later, aborting..."
+        )
     endif ()
 endif ()
 
 if (use_mold)
     # use mold linker if available
-    execute_process(COMMAND ${CMAKE_CXX_COMPILER} -fuse-ld=mold -Wl,--version ERROR_QUIET OUTPUT_VARIABLE LD_VERSION)
+    execute_process(COMMAND ${CMAKE_CXX_COMPILER} -fuse-ld=mold -Wl,--version ERROR_QUIET
+                    OUTPUT_VARIABLE LD_VERSION)
     if ("${LD_VERSION}" MATCHES "mold")
         target_link_libraries(common INTERFACE -fuse-ld=mold)
     endif ()
     unset(LD_VERSION)
 elseif (use_gold AND is_gcc)
     # use gold linker if available
-    execute_process(COMMAND ${CMAKE_CXX_COMPILER} -fuse-ld=gold -Wl,--version ERROR_QUIET OUTPUT_VARIABLE LD_VERSION)
+    execute_process(COMMAND ${CMAKE_CXX_COMPILER} -fuse-ld=gold -Wl,--version ERROR_QUIET
+                    OUTPUT_VARIABLE LD_VERSION)
     #[=========================================================[
        NOTE: THE gold linker inserts -rpath as DT_RUNPATH by
        default instead of DT_RPATH, so you might have slightly
@@ -186,7 +191,8 @@ elseif (use_gold AND is_gcc)
     unset(LD_VERSION)
 elseif (use_lld)
     # use lld linker if available
-    execute_process(COMMAND ${CMAKE_CXX_COMPILER} -fuse-ld=lld -Wl,--version ERROR_QUIET OUTPUT_VARIABLE LD_VERSION)
+    execute_process(COMMAND ${CMAKE_CXX_COMPILER} -fuse-ld=lld -Wl,--version ERROR_QUIET
+                    OUTPUT_VARIABLE LD_VERSION)
     if ("${LD_VERSION}" MATCHES "LLD")
         target_link_libraries(common INTERFACE -fuse-ld=lld)
     endif ()

cmake/XrplCore.cmake

@@ -14,7 +14,8 @@ target_protobuf_sources(xrpl.libpb xrpl/proto LANGUAGE cpp IMPORT_DIRS include/x
                         PROTOS include/xrpl/proto/xrpl.proto)
 
 file(GLOB_RECURSE protos "include/xrpl/proto/org/*.proto")
-target_protobuf_sources(xrpl.libpb xrpl/proto LANGUAGE cpp IMPORT_DIRS include/xrpl/proto PROTOS "${protos}")
+target_protobuf_sources(xrpl.libpb xrpl/proto LANGUAGE cpp IMPORT_DIRS include/xrpl/proto
+                        PROTOS "${protos}")
 target_protobuf_sources(
     xrpl.libpb xrpl/proto
     LANGUAGE grpc
@@ -24,8 +25,9 @@ target_protobuf_sources(
     GENERATE_EXTENSIONS .grpc.pb.h .grpc.pb.cc)
 
 target_compile_options(
-    xrpl.libpb PUBLIC $<$<BOOL:${is_msvc}>:-wd4996> $<$<BOOL:${is_xcode}>: --system-header-prefix="google/protobuf"
-                      -Wno-deprecated-dynamic-exception-spec >
+    xrpl.libpb
+    PUBLIC $<$<BOOL:${is_msvc}>:-wd4996> $<$<BOOL:${is_xcode}>:
+           --system-header-prefix="google/protobuf" -Wno-deprecated-dynamic-exception-spec >
     PRIVATE $<$<BOOL:${is_msvc}>:-wd4065> $<$<NOT:$<BOOL:${is_msvc}>>:-Wno-deprecated-declarations>)
 
 target_link_libraries(xrpl.libpb PUBLIC protobuf::libprotobuf gRPC::grpc++)
@@ -73,7 +75,8 @@ target_link_libraries(xrpl.libxrpl.protocol PUBLIC xrpl.libxrpl.crypto xrpl.libx
 
 # Level 05
 add_module(xrpl core)
-target_link_libraries(xrpl.libxrpl.core PUBLIC xrpl.libxrpl.basics xrpl.libxrpl.json xrpl.libxrpl.protocol)
+target_link_libraries(xrpl.libxrpl.core PUBLIC xrpl.libxrpl.basics xrpl.libxrpl.json
+                                               xrpl.libxrpl.protocol)
 
 # Level 06
 add_module(xrpl resource)
@@ -81,22 +84,23 @@ target_link_libraries(xrpl.libxrpl.resource PUBLIC xrpl.libxrpl.protocol)
 
 # Level 07
 add_module(xrpl net)
-target_link_libraries(xrpl.libxrpl.net PUBLIC xrpl.libxrpl.basics xrpl.libxrpl.json xrpl.libxrpl.protocol
-                                              xrpl.libxrpl.resource)
+target_link_libraries(xrpl.libxrpl.net PUBLIC xrpl.libxrpl.basics xrpl.libxrpl.json
+                                              xrpl.libxrpl.protocol xrpl.libxrpl.resource)
 
 add_module(xrpl nodestore)
-target_link_libraries(xrpl.libxrpl.nodestore PUBLIC xrpl.libxrpl.basics xrpl.libxrpl.json xrpl.libxrpl.protocol)
+target_link_libraries(xrpl.libxrpl.nodestore PUBLIC xrpl.libxrpl.basics xrpl.libxrpl.json
+                                                    xrpl.libxrpl.protocol)
 
 add_module(xrpl shamap)
-target_link_libraries(xrpl.libxrpl.shamap PUBLIC xrpl.libxrpl.basics xrpl.libxrpl.crypto xrpl.libxrpl.protocol
-                                                 xrpl.libxrpl.nodestore)
+target_link_libraries(xrpl.libxrpl.shamap PUBLIC xrpl.libxrpl.basics xrpl.libxrpl.crypto
+                                                 xrpl.libxrpl.protocol xrpl.libxrpl.nodestore)
 
 add_module(xrpl rdb)
 target_link_libraries(xrpl.libxrpl.rdb PUBLIC xrpl.libxrpl.basics xrpl.libxrpl.core)
 
 add_module(xrpl server)
-target_link_libraries(xrpl.libxrpl.server PUBLIC xrpl.libxrpl.protocol xrpl.libxrpl.core xrpl.libxrpl.rdb
-                                                 xrpl.libxrpl.resource)
+target_link_libraries(xrpl.libxrpl.server PUBLIC xrpl.libxrpl.protocol xrpl.libxrpl.core
+                                                 xrpl.libxrpl.rdb xrpl.libxrpl.resource)
 
 add_module(xrpl conditions)
 target_link_libraries(xrpl.libxrpl.conditions PUBLIC xrpl.libxrpl.server)

cmake/XrplDocs.cmake

@@ -65,8 +65,8 @@ add_custom_command(
     OUTPUT "${doxygen_index_file}"
     COMMAND "${CMAKE_COMMAND}" -E env "DOXYGEN_OUTPUT_DIRECTORY=${doxygen_output_directory}"
             "DOXYGEN_INCLUDE_PATH=${doxygen_include_path}" "DOXYGEN_TAGFILES=${doxygen_tagfiles}"
-            "DOXYGEN_PLANTUML_JAR_PATH=${doxygen_plantuml_jar_path}" "DOXYGEN_DOT_PATH=${doxygen_dot_path}"
-            "${DOXYGEN_EXECUTABLE}" "${doxyfile}"
+            "DOXYGEN_PLANTUML_JAR_PATH=${doxygen_plantuml_jar_path}"
+            "DOXYGEN_DOT_PATH=${doxygen_dot_path}" "${DOXYGEN_EXECUTABLE}" "${doxyfile}"
     WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
     DEPENDS "${dependencies}" "${tagfile}")
 add_custom_target(docs DEPENDS "${doxygen_index_file}" SOURCES "${dependencies}")

cmake/XrplInstall.cmake

@@ -41,11 +41,13 @@ install(TARGETS common
         INCLUDES
         DESTINATION include)
 
-install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/include/xrpl" DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}")
+install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/include/xrpl"
+        DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}")
 
 install(EXPORT XrplExports FILE XrplTargets.cmake NAMESPACE Xrpl:: DESTINATION lib/cmake/xrpl)
 include(CMakePackageConfigHelpers)
-write_basic_package_version_file(XrplConfigVersion.cmake VERSION ${xrpld_version} COMPATIBILITY SameMajorVersion)
+write_basic_package_version_file(XrplConfigVersion.cmake VERSION ${xrpld_version}
+                                 COMPATIBILITY SameMajorVersion)
 
 if (is_root_project AND TARGET xrpld)
     install(TARGETS xrpld RUNTIME DESTINATION bin)
@@ -72,5 +74,5 @@ if (is_root_project AND TARGET xrpld)
   ")
 endif ()
 
-install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/cmake/XrplConfig.cmake ${CMAKE_CURRENT_BINARY_DIR}/XrplConfigVersion.cmake
-        DESTINATION lib/cmake/xrpl)
+install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/cmake/XrplConfig.cmake
+              ${CMAKE_CURRENT_BINARY_DIR}/XrplConfigVersion.cmake DESTINATION lib/cmake/xrpl)

cmake/XrplInterface.cmake

@@ -33,10 +33,13 @@ target_compile_definitions(
 target_compile_options(
     opts
     INTERFACE $<$<AND:$<BOOL:${is_gcc}>,$<COMPILE_LANGUAGE:CXX>>:-Wsuggest-override>
-              $<$<BOOL:${is_gcc}>:-Wno-maybe-uninitialized> $<$<BOOL:${perf}>:-fno-omit-frame-pointer>
-              $<$<BOOL:${profile}>:-pg> $<$<AND:$<BOOL:${is_gcc}>,$<BOOL:${profile}>>:-p>)
+              $<$<BOOL:${is_gcc}>:-Wno-maybe-uninitialized>
+              $<$<BOOL:${perf}>:-fno-omit-frame-pointer>
+              $<$<BOOL:${profile}>:-pg>
+              $<$<AND:$<BOOL:${is_gcc}>,$<BOOL:${profile}>>:-p>)
 
-target_link_libraries(opts INTERFACE $<$<BOOL:${profile}>:-pg> $<$<AND:$<BOOL:${is_gcc}>,$<BOOL:${profile}>>:-p>)
+target_link_libraries(opts INTERFACE $<$<BOOL:${profile}>:-pg>
+                                     $<$<AND:$<BOOL:${is_gcc}>,$<BOOL:${profile}>>:-p>)
 
 if (jemalloc)
     find_package(jemalloc REQUIRED)

cmake/XrplSanity.cmake

@@ -19,7 +19,8 @@ if (NOT is_multiconfig)
 endif ()
 
 if (is_clang) # both Clang and AppleClang
-    if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 16.0)
+    if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS
+                                                        16.0)
         message(FATAL_ERROR "This project requires clang 16 or later")
     endif ()
 elseif (is_gcc)
@@ -32,7 +33,8 @@ endif ()
 if ("${CMAKE_CURRENT_SOURCE_DIR}" STREQUAL "${CMAKE_BINARY_DIR}")
     message(FATAL_ERROR "Builds (in-source) are not allowed in "
                         "${CMAKE_CURRENT_SOURCE_DIR}. Please remove CMakeCache.txt and the CMakeFiles "
-                        "directory from ${CMAKE_CURRENT_SOURCE_DIR} and try building in a separate directory.")
+                        "directory from ${CMAKE_CURRENT_SOURCE_DIR} and try building in a separate directory."
+    )
 endif ()
 
 if (MSVC AND CMAKE_GENERATOR_PLATFORM STREQUAL "Win32")

cmake/XrplSettings.cmake

@@ -70,7 +70,8 @@ if (is_linux AND NOT SANITIZER)
     else ()
         set(TRUNCATED_LOGS_DEFAULT OFF)
     endif ()
-    option(TRUNCATED_THREAD_NAME_LOGS "Show warnings about truncated thread names on Linux." ${TRUNCATED_LOGS_DEFAULT})
+    option(TRUNCATED_THREAD_NAME_LOGS "Show warnings about truncated thread names on Linux."
+           ${TRUNCATED_LOGS_DEFAULT})
     if (TRUNCATED_THREAD_NAME_LOGS)
         add_compile_definitions(TRUNCATED_THREAD_NAME_LOGS)
     endif ()
@@ -92,11 +93,13 @@ endif ()
 
 option(jemalloc "Enables jemalloc for heap profiling" OFF)
 option(werr "treat warnings as errors" OFF)
-option(local_protobuf "Force a local build of protobuf instead of looking for an installed version." OFF)
+option(local_protobuf
+       "Force a local build of protobuf instead of looking for an installed version." OFF)
 option(local_grpc "Force a local build of gRPC instead of looking for an installed version." OFF)
 
 # the remaining options are obscure and rarely used
-option(beast_no_unit_test_inline "Prevents unit test definitions from being inserted into global table" OFF)
+option(beast_no_unit_test_inline
+       "Prevents unit test definitions from being inserted into global table" OFF)
 option(single_io_service_thread "Restricts the number of threads calling io_context::run to one. \
   This can be useful when debugging." OFF)
 option(boost_show_deprecated "Allow boost to fail on deprecated usage. Only useful if you're trying\

cmake/XrplValidatorKeys.cmake

@@ -1,4 +1,6 @@
-option(validator_keys "Enables building of validator-keys tool as a separate target (imported via FetchContent)" OFF)
+option(validator_keys
+       "Enables building of validator-keys tool as a separate target (imported via FetchContent)"
+       OFF)
 
 if (validator_keys)
     git_branch(current_branch)
@@ -8,8 +10,9 @@ if (validator_keys)
     endif ()
     message(STATUS "Tracking ValidatorKeys branch: ${current_branch}")
 
-    FetchContent_Declare(validator_keys GIT_REPOSITORY https://github.com/ripple/validator-keys-tool.git
-                         GIT_TAG "${current_branch}")
+    FetchContent_Declare(
+        validator_keys GIT_REPOSITORY https://github.com/ripple/validator-keys-tool.git
+        GIT_TAG "${current_branch}")
     FetchContent_MakeAvailable(validator_keys)
     set_target_properties(validator-keys PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}")
     install(TARGETS validator-keys RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})

cmake/add_module.cmake

@@ -15,11 +15,12 @@ include(isolate_headers)
 function (add_module parent name)
     set(target ${PROJECT_NAME}.lib${parent}.${name})
     add_library(${target} OBJECT)
-    file(GLOB_RECURSE sources CONFIGURE_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/src/lib${parent}/${name}/*.cpp")
+    file(GLOB_RECURSE sources CONFIGURE_DEPENDS
+         "${CMAKE_CURRENT_SOURCE_DIR}/src/lib${parent}/${name}/*.cpp")
     target_sources(${target} PRIVATE ${sources})
     target_include_directories(${target} PUBLIC "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>")
     isolate_headers(${target} "${CMAKE_CURRENT_SOURCE_DIR}/include"
                     "${CMAKE_CURRENT_SOURCE_DIR}/include/${parent}/${name}" PUBLIC)
-    isolate_headers(${target} "${CMAKE_CURRENT_SOURCE_DIR}/src" "${CMAKE_CURRENT_SOURCE_DIR}/src/lib${parent}/${name}"
-                    PRIVATE)
+    isolate_headers(${target} "${CMAKE_CURRENT_SOURCE_DIR}/src"
+                    "${CMAKE_CURRENT_SOURCE_DIR}/src/lib${parent}/${name}" PRIVATE)
 endfunction ()

cmake/deps/Boost.cmake

@@ -39,6 +39,7 @@ if (SANITIZERS_ENABLED AND is_clang)
     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)
+    target_compile_options(
+        opts INTERFACE # ignore boost headers for sanitizing
+                       -fsanitize-blacklist=${CMAKE_CURRENT_BINARY_DIR}/san_bl.txt)
 endif ()

cspell.config.yaml

@@ -6,6 +6,7 @@ ignorePaths:
   - docs/**/*.puml
   - cmake/**
   - LICENSE.md
+  - .clang-tidy
 language: en
 allowCompoundWords: true # TODO (#6334)
 ignoreRandomStrings: true

include/xrpl/protocol/STAmount.h

@@ -42,8 +42,8 @@ private:
 public:
     using value_type = STAmount;
 
-    static int constexpr cMinOffset = -96;
-    static int constexpr cMaxOffset = 80;
+    static int const cMinOffset = -96;
+    static int const cMaxOffset = 80;
 
     // Maximum native value supported by the code
     constexpr static std::uint64_t cMinValue = 1'000'000'000'000'000ull;
@@ -720,22 +720,6 @@ canAdd(STAmount const& amt1, STAmount const& amt2);
 bool
 canSubtract(STAmount const& amt1, STAmount const& amt2);
 
-/** Get the scale of a Number for a given asset.
- *
- * "scale" is similar to "exponent", but from the perspective of STAmount, which has different rules and mantissa ranges
- * for determining the exponent than Number.
- *
- * @param number The Number to get the scale of.
- * @param asset The asset to use for determining the scale.
- * @return The scale of this Number for the given asset.
- */
-template <AssetType Asset>
-inline int
-numberScale(Number const& number, Asset const& asset)
-{
-    return STAmount{asset, number}.exponent();
-}
-
 }  // namespace xrpl
 
 //------------------------------------------------------------------------------

include/xrpl/protocol/detail/features.macro

@@ -16,7 +16,7 @@
 // Add new amendments to the top of this list.
 // Keep it sorted in reverse chronological order.
 
-XRPL_FIX    (LendingProtocolV1_1,        Supported::yes, VoteBehavior::DefaultNo)
+XRPL_FEATURE(DefragDirectories,          Supported::no,  VoteBehavior::DefaultNo)
 XRPL_FIX   (PermissionedDomainInvariant, Supported::yes, VoteBehavior::DefaultNo)
 XRPL_FIX    (ExpiredNFTokenOfferRemoval, Supported::yes, VoteBehavior::DefaultNo)
 XRPL_FIX    (BatchInnerSigs,             Supported::yes, VoteBehavior::DefaultNo)

include/xrpl/tx/InvariantCheck.h

@@ -8,6 +8,7 @@
 #include <xrpl/protocol/STTx.h>
 #include <xrpl/protocol/TER.h>
 
+#include <cstdint>
 #include <tuple>
 #include <unordered_set>
 
@@ -663,19 +664,11 @@ class ValidVault
         Shares static make(SLE const&);
     };
 
-public:
-    struct DeltaInfo final
-    {
-        Number delta = numZero;
-        std::optional<int> scale;
-    };
-
-private:
     std::vector<Vault> afterVault_ = {};
     std::vector<Shares> afterMPTs_ = {};
     std::vector<Vault> beforeVault_ = {};
     std::vector<Shares> beforeMPTs_ = {};
-    std::unordered_map<uint256, DeltaInfo> deltas_ = {};
+    std::unordered_map<uint256, Number> deltas_ = {};
 
 public:
     void
@@ -683,10 +676,6 @@ public:
 
     bool
     finalize(STTx const&, TER const, XRPAmount const, ReadView const&, beast::Journal const&);
-
-    // Compute the coarsest scale required to represent all numbers
-    [[nodiscard]] static std::int32_t
-    computeMinScale(Asset const& asset, std::vector<DeltaInfo> const& numbers);
 };
 
 // additional invariant checks can be declared above and then added to this

include/xrpl/tx/transactors/Lending/LendingHelpers.h

@@ -167,7 +167,7 @@ getAssetsTotalScale(SLE::const_ref vaultSle)
 {
     if (!vaultSle)
         return Number::minExponent - 1;  // LCOV_EXCL_LINE
-    return numberScale(vaultSle->at(sfAssetsTotal), vaultSle->at(sfAsset));
+    return STAmount{vaultSle->at(sfAsset), vaultSle->at(sfAssetsTotal)}.exponent();
 }
 
 TER

src/libxrpl/ledger/ApplyView.cpp

@@ -10,6 +10,14 @@ namespace xrpl {
 
 namespace directory {
 
+struct Gap
+{
+    uint64_t const page;
+    SLE::pointer node;
+    uint64_t const nextPage;
+    SLE::pointer next;
+};
+
 std::uint64_t
 createRoot(
     ApplyView& view,
@@ -111,7 +119,9 @@ insertPage(
     if (page == 0)
         return std::nullopt;
     if (!view.rules().enabled(fixDirectoryLimit) && page >= dirNodeMaxPages)  // Old pages limit
+    {
         return std::nullopt;
+    }
 
     // We are about to create a new node; we'll link it to
     // the chain first:
@@ -133,12 +143,8 @@ insertPage(
     // it's the default.
     if (page != 1)
         node->setFieldU64(sfIndexPrevious, page - 1);
-    XRPL_ASSERT_PARTS(!nextPage, "xrpl::directory::insertPage", "nextPage has default value");
-    /* Reserved for future use when directory pages may be inserted in
-     * between two other pages instead of only at the end of the chain.
     if (nextPage)
         node->setFieldU64(sfIndexNext, nextPage);
-    */
     describe(node);
     view.insert(node);
 
@@ -154,7 +160,7 @@ ApplyView::dirAdd(
     uint256 const& key,
     std::function<void(std::shared_ptr<SLE> const&)> const& describe)
 {
-    auto root = peek(directory);
+    auto const root = peek(directory);
 
     if (!root)
     {
@@ -164,6 +170,42 @@ ApplyView::dirAdd(
 
     auto [page, node, indexes] = directory::findPreviousPage(*this, directory, root);
 
+    if (rules().enabled(featureDefragDirectories))
+    {
+        // If there are more nodes than just the root, and there's no space in
+        // the last one, walk backwards to find one with space, or to find one
+        // missing.
+        std::optional<directory::Gap> gapPages;
+        while (page && indexes.size() >= dirNodeMaxEntries)
+        {
+            // Find a page with space, or a gap in pages.
+            auto [prevPage, prevNode, prevIndexes] = directory::findPreviousPage(*this, directory, node);
+            if (!gapPages && prevPage != page - 1)
+                gapPages.emplace(prevPage, prevNode, page, node);
+            page = prevPage;
+            node = prevNode;
+            indexes = prevIndexes;
+        }
+        // We looped through all the pages back to the root.
+        if (!page)
+        {
+            // If we found a gap, use it.
+            if (gapPages)
+            {
+                return directory::insertPage(
+                    *this,
+                    gapPages->page,
+                    gapPages->node,
+                    gapPages->nextPage,
+                    gapPages->next,
+                    key,
+                    directory,
+                    describe);
+            }
+            std::tie(page, node, indexes) = directory::findPreviousPage(*this, directory, root);
+        }
+    }
+
     // If there's space, we use it:
     if (indexes.size() < dirNodeMaxEntries)
     {

src/libxrpl/ledger/View.cpp

@@ -1289,14 +1289,14 @@ addEmptyHolding(
         dstId,
         index.key,
         sleDst,
-        /*auth=*/false,
-        /*noRipple=*/true,
-        /*freeze=*/false,
+        /*bAuth=*/false,
+        /*bNoRipple=*/true,
+        /*bFreeze=*/false,
         /*deepFreeze*/ false,
-        /*balance=*/STAmount{Issue{currency, noAccount()}},
-        /*limit=*/STAmount{Issue{currency, dstId}},
-        /*qualityIn=*/0,
-        /*qualityOut=*/0,
+        /*saBalance=*/STAmount{Issue{currency, noAccount()}},
+        /*saLimit=*/STAmount{Issue{currency, dstId}},
+        /*uSrcQualityIn=*/0,
+        /*uSrcQualityOut=*/0,
         journal);
 }
 

src/libxrpl/tx/InvariantCheck.cpp

@@ -13,6 +13,7 @@
 #include <xrpl/protocol/SystemParameters.h>
 #include <xrpl/protocol/TER.h>
 #include <xrpl/protocol/TxFormats.h>
+#include <xrpl/protocol/Units.h>
 #include <xrpl/protocol/nftPageMask.h>
 #include <xrpl/tx/InvariantCheck.h>
 #include <xrpl/tx/transactors/AMM/AMMHelpers.h>
@@ -20,9 +21,7 @@
 #include <xrpl/tx/transactors/NFT/NFTokenUtils.h>
 #include <xrpl/tx/transactors/PermissionedDomain/PermissionedDomainSet.h>
 
-#include <algorithm>
-#include <cstddef>
-#include <initializer_list>
+#include <cstdint>
 #include <optional>
 
 namespace xrpl {
@@ -2466,13 +2465,8 @@ ValidVault::visitEntry(bool isDelete, std::shared_ptr<SLE const> const& before,
     // Number balanceDelta will capture the difference (delta) between "before"
     // state (zero if created) and "after" state (zero if destroyed), so the
     // invariants can validate that the change in account balances matches the
-    // balanceDelta captures the difference (delta) between "before"
-    // state (zero if created) and "after" state (zero if destroyed), and
-    // preserves value scale (exponent) to round values to the same scale during
-    // validation. It is used to validate that the change in account
-    // balances matches the change in vault balances, stored to deltas_ at the
-    // end of this function.
-    DeltaInfo balanceDelta{numZero, std::nullopt};
+    // change in vault balances, stored to deltas_ at the end of this function.
+    Number balanceDelta{};
 
     std::int8_t sign = 0;
     if (before)
@@ -2486,33 +2480,18 @@ ValidVault::visitEntry(bool isDelete, std::shared_ptr<SLE const> const& before,
                 // At this moment we have no way of telling if this object holds
                 // vault shares or something else. Save it for finalize.
                 beforeMPTs_.push_back(Shares::make(*before));
-                balanceDelta.delta = static_cast<std::int64_t>(before->getFieldU64(sfOutstandingAmount));
-                // MPTs are ints, so the scale is always 0.
-                balanceDelta.scale = 0;
+                balanceDelta = static_cast<std::int64_t>(before->getFieldU64(sfOutstandingAmount));
                 sign = 1;
                 break;
             case ltMPTOKEN:
-                balanceDelta.delta = static_cast<std::int64_t>(before->getFieldU64(sfMPTAmount));
-                // MPTs are ints, so the scale is always 0.
-                balanceDelta.scale = 0;
+                balanceDelta = static_cast<std::int64_t>(before->getFieldU64(sfMPTAmount));
                 sign = -1;
                 break;
             case ltACCOUNT_ROOT:
-                balanceDelta.delta = before->getFieldAmount(sfBalance);
-                // Account balance is XRP, which is an int, so the scale is
-                // always 0.
-                balanceDelta.scale = 0;
+            case ltRIPPLE_STATE:
+                balanceDelta = before->getFieldAmount(sfBalance);
                 sign = -1;
                 break;
-            case ltRIPPLE_STATE: {
-                auto const amount = before->getFieldAmount(sfBalance);
-                balanceDelta.delta = amount;
-                // Trust Line balances are STAmounts, so we can use the exponent
-                // directly to get the scale.
-                balanceDelta.scale = amount.exponent();
-                sign = -1;
-                break;
-            }
             default:;
         }
     }
@@ -2528,34 +2507,18 @@ ValidVault::visitEntry(bool isDelete, std::shared_ptr<SLE const> const& before,
                 // At this moment we have no way of telling if this object holds
                 // vault shares or something else. Save it for finalize.
                 afterMPTs_.push_back(Shares::make(*after));
-                balanceDelta.delta -= Number(static_cast<std::int64_t>(after->getFieldU64(sfOutstandingAmount)));
-                // MPTs are ints, so the scale is always 0.
-                balanceDelta.scale = 0;
+                balanceDelta -= Number(static_cast<std::int64_t>(after->getFieldU64(sfOutstandingAmount)));
                 sign = 1;
                 break;
             case ltMPTOKEN:
-                balanceDelta.delta -= Number(static_cast<std::int64_t>(after->getFieldU64(sfMPTAmount)));
-                // MPTs are ints, so the scale is always 0.
-                balanceDelta.scale = 0;
+                balanceDelta -= Number(static_cast<std::int64_t>(after->getFieldU64(sfMPTAmount)));
                 sign = -1;
                 break;
             case ltACCOUNT_ROOT:
-                balanceDelta.delta -= Number(after->getFieldAmount(sfBalance));
-                // Account balance is XRP, which is an int, so the scale is
-                // always 0.
-                balanceDelta.scale = 0;
+            case ltRIPPLE_STATE:
+                balanceDelta -= Number(after->getFieldAmount(sfBalance));
                 sign = -1;
                 break;
-            case ltRIPPLE_STATE: {
-                auto const amount = after->getFieldAmount(sfBalance);
-                balanceDelta.delta -= Number(amount);
-                // Trust Line balances are STAmounts, so we can use the exponent
-                // directly to get the scale.
-                if (amount.exponent() > balanceDelta.scale)
-                    balanceDelta.scale = amount.exponent();
-                sign = -1;
-                break;
-            }
             default:;
         }
     }
@@ -2567,11 +2530,7 @@ ValidVault::visitEntry(bool isDelete, std::shared_ptr<SLE const> const& before,
     // transferred to the account. We intentionally do not compare balanceDelta
     // against zero, to avoid missing such updates.
     if (sign != 0)
-    {
-        XRPL_ASSERT_PARTS(balanceDelta.scale, "xrpl::ValidVault::visitEntry", "scale initialized");
-        balanceDelta.delta *= sign;
-        deltas_[key] = balanceDelta;
-    }
+        deltas_[key] = balanceDelta * sign;
 }
 
 bool
@@ -2827,13 +2786,13 @@ ValidVault::finalize(STTx const& tx, TER const ret, XRPAmount const fee, ReadVie
     }
 
     auto const& vaultAsset = afterVault.asset;
-    auto const deltaAssets = [&](AccountID const& id) -> std::optional<DeltaInfo> {
+    auto const deltaAssets = [&](AccountID const& id) -> std::optional<Number> {
         auto const get =  //
-            [&](auto const& it, std::int8_t sign = 1) -> std::optional<DeltaInfo> {
+            [&](auto const& it, std::int8_t sign = 1) -> std::optional<Number> {
             if (it == deltas_.end())
                 return std::nullopt;
 
-            return DeltaInfo{it->second.delta * sign, it->second.scale};
+            return it->second * sign;
         };
 
         return std::visit(
@@ -2851,7 +2810,7 @@ ValidVault::finalize(STTx const& tx, TER const ret, XRPAmount const fee, ReadVie
             },
             vaultAsset.value());
     };
-    auto const deltaAssetsTxAccount = [&]() -> std::optional<DeltaInfo> {
+    auto const deltaAssetsTxAccount = [&]() -> std::optional<Number> {
         auto ret = deltaAssets(tx[sfAccount]);
         // Nothing returned or not XRP transaction
         if (!ret.has_value() || !vaultAsset.native())
@@ -2861,20 +2820,20 @@ ValidVault::finalize(STTx const& tx, TER const ret, XRPAmount const fee, ReadVie
         if (auto const delegate = tx[~sfDelegate]; delegate.has_value() && *delegate != tx[sfAccount])
             return ret;
 
-        ret->delta += fee.drops();
-        if (ret->delta == zero)
+        *ret += fee.drops();
+        if (*ret == zero)
             return std::nullopt;
 
         return ret;
     };
-    auto const deltaShares = [&](AccountID const& id) -> std::optional<DeltaInfo> {
+    auto const deltaShares = [&](AccountID const& id) -> std::optional<Number> {
         auto const it = [&]() {
             if (id == afterVault.pseudoId)
                 return deltas_.find(keylet::mptIssuance(afterVault.shareMPTID).key);
             return deltas_.find(keylet::mptoken(afterVault.shareMPTID, id).key);
         }();
 
-        return it != deltas_.end() ? std::optional<DeltaInfo>(it->second) : std::nullopt;
+        return it != deltas_.end() ? std::optional<Number>(it->second) : std::nullopt;
     };
 
     auto const vaultHoldsNoAssets = [&](Vault const& vault) {
@@ -2996,37 +2955,16 @@ ValidVault::finalize(STTx const& tx, TER const ret, XRPAmount const fee, ReadVie
                     XRPL_ASSERT(!beforeVault_.empty(), "xrpl::ValidVault::finalize : deposit updated a vault");
                     auto const& beforeVault = beforeVault_[0];
 
-                    auto const maybeVaultDeltaAssets = deltaAssets(afterVault.pseudoId);
-                    if (!maybeVaultDeltaAssets)
+                    auto const vaultDeltaAssets = deltaAssets(afterVault.pseudoId);
+
+                    if (!vaultDeltaAssets)
                     {
                         JLOG(j.fatal()) <<  //
                             "Invariant failed: deposit must change vault balance";
                         return false;  // That's all we can do
                     }
 
-                    // Get the coarsest scale to round calculations to
-                    DeltaInfo totalDelta{
-                        afterVault.assetsTotal - beforeVault.assetsTotal,
-                        std::max(
-                            numberScale(afterVault.assetsTotal, vaultAsset),
-                            numberScale(beforeVault.assetsTotal, vaultAsset))};
-                    DeltaInfo availableDelta{
-                        afterVault.assetsAvailable - beforeVault.assetsAvailable,
-                        std::max(
-                            numberScale(afterVault.assetsAvailable, vaultAsset),
-                            numberScale(beforeVault.assetsAvailable, vaultAsset))};
-                    auto const minScale = computeMinScale(
-                        vaultAsset,
-                        {
-                            *maybeVaultDeltaAssets,
-                            totalDelta,
-                            availableDelta,
-                        });
-
-                    auto const vaultDeltaAssets = roundToAsset(vaultAsset, maybeVaultDeltaAssets->delta, minScale);
-                    auto const txAmount = roundToAsset(vaultAsset, tx[sfAmount], minScale);
-
-                    if (vaultDeltaAssets > txAmount)
+                    if (*vaultDeltaAssets > tx[sfAmount])
                     {
                         JLOG(j.fatal()) <<  //
                             "Invariant failed: deposit must not change vault "
@@ -3034,7 +2972,7 @@ ValidVault::finalize(STTx const& tx, TER const ret, XRPAmount const fee, ReadVie
                         result = false;
                     }
 
-                    if (vaultDeltaAssets <= zero)
+                    if (*vaultDeltaAssets <= zero)
                     {
                         JLOG(j.fatal()) <<  //
                             "Invariant failed: deposit must increase vault balance";
@@ -3051,22 +2989,16 @@ ValidVault::finalize(STTx const& tx, TER const ret, XRPAmount const fee, ReadVie
 
                     if (!issuerDeposit)
                     {
-                        auto const maybeAccDeltaAssets = deltaAssetsTxAccount();
-                        if (!maybeAccDeltaAssets)
+                        auto const accountDeltaAssets = deltaAssetsTxAccount();
+                        if (!accountDeltaAssets)
                         {
                             JLOG(j.fatal()) <<  //
                                 "Invariant failed: deposit must change depositor "
                                 "balance";
                             return false;
                         }
-                        auto const localMinScale =
-                            std::max(minScale, computeMinScale(vaultAsset, {*maybeAccDeltaAssets}));
 
-                        auto const accountDeltaAssets =
-                            roundToAsset(vaultAsset, maybeAccDeltaAssets->delta, localMinScale);
-                        auto const localVaultDeltaAssets = roundToAsset(vaultAsset, vaultDeltaAssets, localMinScale);
-
-                        if (accountDeltaAssets >= zero)
+                        if (*accountDeltaAssets >= zero)
                         {
                             JLOG(j.fatal()) <<  //
                                 "Invariant failed: deposit must decrease depositor "
@@ -3074,7 +3006,7 @@ ValidVault::finalize(STTx const& tx, TER const ret, XRPAmount const fee, ReadVie
                             result = false;
                         }
 
-                        if (localVaultDeltaAssets * -1 != accountDeltaAssets)
+                        if (*accountDeltaAssets * -1 != *vaultDeltaAssets)
                         {
                             JLOG(j.fatal()) <<  //
                                 "Invariant failed: deposit must change vault and "
@@ -3091,17 +3023,16 @@ ValidVault::finalize(STTx const& tx, TER const ret, XRPAmount const fee, ReadVie
                         result = false;
                     }
 
-                    auto const maybeAccDeltaShares = deltaShares(tx[sfAccount]);
-                    if (!maybeAccDeltaShares)
+                    auto const accountDeltaShares = deltaShares(tx[sfAccount]);
+                    if (!accountDeltaShares)
                     {
                         JLOG(j.fatal()) <<  //
                             "Invariant failed: deposit must change depositor "
                             "shares";
                         return false;  // That's all we can do
                     }
-                    // We don't need to round shares, they are integral MPT
-                    auto const& accountDeltaShares = *maybeAccDeltaShares;
-                    if (accountDeltaShares.delta <= zero)
+
+                    if (*accountDeltaShares <= zero)
                     {
                         JLOG(j.fatal()) <<  //
                             "Invariant failed: deposit must increase depositor "
@@ -3109,17 +3040,15 @@ ValidVault::finalize(STTx const& tx, TER const ret, XRPAmount const fee, ReadVie
                         result = false;
                     }
 
-                    auto const maybeVaultDeltaShares = deltaShares(afterVault.pseudoId);
-                    if (!maybeVaultDeltaShares || maybeVaultDeltaShares->delta == zero)
+                    auto const vaultDeltaShares = deltaShares(afterVault.pseudoId);
+                    if (!vaultDeltaShares || *vaultDeltaShares == zero)
                     {
                         JLOG(j.fatal()) <<  //
                             "Invariant failed: deposit must change vault shares";
                         return false;  // That's all we can do
                     }
 
-                    // We don't need to round shares, they are integral MPT
-                    auto const& vaultDeltaShares = *maybeVaultDeltaShares;
-                    if (vaultDeltaShares.delta * -1 != accountDeltaShares.delta)
+                    if (*vaultDeltaShares * -1 != *accountDeltaShares)
                     {
                         JLOG(j.fatal()) <<  //
                             "Invariant failed: deposit must change depositor and "
@@ -3127,18 +3056,13 @@ ValidVault::finalize(STTx const& tx, TER const ret, XRPAmount const fee, ReadVie
                         result = false;
                     }
 
-                    auto const assetTotalDelta =
-                        roundToAsset(vaultAsset, afterVault.assetsTotal - beforeVault.assetsTotal, minScale);
-                    if (assetTotalDelta != vaultDeltaAssets)
+                    if (beforeVault.assetsTotal + *vaultDeltaAssets != afterVault.assetsTotal)
                     {
                         JLOG(j.fatal()) << "Invariant failed: deposit and assets "
                                            "outstanding must add up";
                         result = false;
                     }
-
-                    auto const assetAvailableDelta =
-                        roundToAsset(vaultAsset, afterVault.assetsAvailable - beforeVault.assetsAvailable, minScale);
-                    if (assetAvailableDelta != vaultDeltaAssets)
+                    if (beforeVault.assetsAvailable + *vaultDeltaAssets != afterVault.assetsAvailable)
                     {
                         JLOG(j.fatal()) << "Invariant failed: deposit and assets "
                                            "available must add up";
@@ -3156,38 +3080,22 @@ ValidVault::finalize(STTx const& tx, TER const ret, XRPAmount const fee, ReadVie
                         "vault");
                     auto const& beforeVault = beforeVault_[0];
 
-                    auto const maybeVaultDeltaAssets = deltaAssets(afterVault.pseudoId);
+                    auto const vaultDeltaAssets = deltaAssets(afterVault.pseudoId);
 
-                    if (!maybeVaultDeltaAssets)
+                    if (!vaultDeltaAssets)
                     {
                         JLOG(j.fatal()) << "Invariant failed: withdrawal must "
                                            "change vault balance";
                         return false;  // That's all we can do
                     }
 
-                    // Get the most coarse scale to round calculations to
-                    auto const totalDelta = DeltaInfo{
-                        afterVault.assetsTotal - beforeVault.assetsTotal,
-                        std::max(
-                            numberScale(afterVault.assetsTotal, vaultAsset),
-                            numberScale(beforeVault.assetsTotal, vaultAsset))};
-                    auto const availableDelta = DeltaInfo{
-                        afterVault.assetsAvailable - beforeVault.assetsAvailable,
-                        std::max(
-                            numberScale(afterVault.assetsAvailable, vaultAsset),
-                            numberScale(beforeVault.assetsAvailable, vaultAsset))};
-                    auto const minScale =
-                        computeMinScale(vaultAsset, {*maybeVaultDeltaAssets, totalDelta, availableDelta});
-
-                    auto const vaultPseudoDeltaAssets =
-                        roundToAsset(vaultAsset, maybeVaultDeltaAssets->delta, minScale);
-
-                    if (vaultPseudoDeltaAssets >= zero)
+                    if (*vaultDeltaAssets >= zero)
                     {
                         JLOG(j.fatal()) << "Invariant failed: withdrawal must "
                                            "decrease vault balance";
                         result = false;
                     }
+
                     // Any payments (including withdrawal) going to the issuer
                     // do not change their balance, but destroy funds instead.
                     bool const issuerWithdrawal = [&]() -> bool {
@@ -3199,15 +3107,15 @@ ValidVault::finalize(STTx const& tx, TER const ret, XRPAmount const fee, ReadVie
 
                     if (!issuerWithdrawal)
                     {
-                        auto const maybeAccDelta = deltaAssetsTxAccount();
-                        auto const maybeOtherAccDelta = [&]() -> std::optional<DeltaInfo> {
+                        auto const accountDeltaAssets = deltaAssetsTxAccount();
+                        auto const otherAccountDelta = [&]() -> std::optional<Number> {
                             if (auto const destination = tx[~sfDestination];
                                 destination && *destination != tx[sfAccount])
                                 return deltaAssets(*destination);
                             return std::nullopt;
                         }();
 
-                        if (maybeAccDelta.has_value() == maybeOtherAccDelta.has_value())
+                        if (accountDeltaAssets.has_value() == otherAccountDelta.has_value())
                         {
                             JLOG(j.fatal()) <<  //
                                 "Invariant failed: withdrawal must change one "
@@ -3216,16 +3124,9 @@ ValidVault::finalize(STTx const& tx, TER const ret, XRPAmount const fee, ReadVie
                         }
 
                         auto const destinationDelta =  //
-                            maybeAccDelta ? *maybeAccDelta : *maybeOtherAccDelta;
+                            accountDeltaAssets ? *accountDeltaAssets : *otherAccountDelta;
 
-                        // the scale of destinationDelta can be coarser than
-                        // minScale, so we take that into account when rounding
-                        auto const localMinScale = std::max(minScale, computeMinScale(vaultAsset, {destinationDelta}));
-
-                        auto const roundedDestinationDelta =
-                            roundToAsset(vaultAsset, destinationDelta.delta, localMinScale);
-
-                        if (roundedDestinationDelta <= zero)
+                        if (destinationDelta <= zero)
                         {
                             JLOG(j.fatal()) <<  //
                                 "Invariant failed: withdrawal must increase "
@@ -3233,9 +3134,7 @@ ValidVault::finalize(STTx const& tx, TER const ret, XRPAmount const fee, ReadVie
                             result = false;
                         }
 
-                        auto const localPseudoDeltaAssets =
-                            roundToAsset(vaultAsset, vaultPseudoDeltaAssets, localMinScale);
-                        if (localPseudoDeltaAssets * -1 != roundedDestinationDelta)
+                        if (*vaultDeltaAssets * -1 != destinationDelta)
                         {
                             JLOG(j.fatal()) <<  //
                                 "Invariant failed: withdrawal must change vault "
@@ -3243,7 +3142,7 @@ ValidVault::finalize(STTx const& tx, TER const ret, XRPAmount const fee, ReadVie
                             result = false;
                         }
                     }
-                    // We don't need to round shares, they are integral MPT
+
                     auto const accountDeltaShares = deltaShares(tx[sfAccount]);
                     if (!accountDeltaShares)
                     {
@@ -3253,23 +3152,23 @@ ValidVault::finalize(STTx const& tx, TER const ret, XRPAmount const fee, ReadVie
                         return false;
                     }
 
-                    if (accountDeltaShares->delta >= zero)
+                    if (*accountDeltaShares >= zero)
                     {
                         JLOG(j.fatal()) <<  //
                             "Invariant failed: withdrawal must decrease depositor "
                             "shares";
                         result = false;
                     }
-                    // We don't need to round shares, they are integral MPT
+
                     auto const vaultDeltaShares = deltaShares(afterVault.pseudoId);
-                    if (!vaultDeltaShares || vaultDeltaShares->delta == zero)
+                    if (!vaultDeltaShares || *vaultDeltaShares == zero)
                     {
                         JLOG(j.fatal()) <<  //
                             "Invariant failed: withdrawal must change vault shares";
                         return false;  // That's all we can do
                     }
 
-                    if (vaultDeltaShares->delta * -1 != accountDeltaShares->delta)
+                    if (*vaultDeltaShares * -1 != *accountDeltaShares)
                     {
                         JLOG(j.fatal()) <<  //
                             "Invariant failed: withdrawal must change depositor "
@@ -3277,20 +3176,15 @@ ValidVault::finalize(STTx const& tx, TER const ret, XRPAmount const fee, ReadVie
                         result = false;
                     }
 
-                    auto const assetTotalDelta =
-                        roundToAsset(vaultAsset, afterVault.assetsTotal - beforeVault.assetsTotal, minScale);
                     // Note, vaultBalance is negative (see check above)
-                    if (assetTotalDelta != vaultPseudoDeltaAssets)
+                    if (beforeVault.assetsTotal + *vaultDeltaAssets != afterVault.assetsTotal)
                     {
                         JLOG(j.fatal()) << "Invariant failed: withdrawal and "
                                            "assets outstanding must add up";
                         result = false;
                     }
 
-                    auto const assetAvailableDelta =
-                        roundToAsset(vaultAsset, afterVault.assetsAvailable - beforeVault.assetsAvailable, minScale);
-
-                    if (assetAvailableDelta != vaultPseudoDeltaAssets)
+                    if (beforeVault.assetsAvailable + *vaultDeltaAssets != afterVault.assetsAvailable)
                     {
                         JLOG(j.fatal()) << "Invariant failed: withdrawal and "
                                            "assets available must add up";
@@ -3320,23 +3214,10 @@ ValidVault::finalize(STTx const& tx, TER const ret, XRPAmount const fee, ReadVie
                         }
                     }
 
-                    auto const maybeVaultDeltaAssets = deltaAssets(afterVault.pseudoId);
-                    if (maybeVaultDeltaAssets)
+                    auto const vaultDeltaAssets = deltaAssets(afterVault.pseudoId);
+                    if (vaultDeltaAssets)
                     {
-                        auto const totalDelta = DeltaInfo{
-                            afterVault.assetsTotal - beforeVault.assetsTotal,
-                            std::max(
-                                numberScale(afterVault.assetsTotal, vaultAsset),
-                                numberScale(beforeVault.assetsTotal, vaultAsset))};
-                        auto const availableDelta = DeltaInfo{
-                            afterVault.assetsAvailable - beforeVault.assetsAvailable,
-                            std::max(
-                                numberScale(afterVault.assetsAvailable, vaultAsset),
-                                numberScale(beforeVault.assetsAvailable, vaultAsset))};
-                        auto const minScale =
-                            computeMinScale(vaultAsset, {*maybeVaultDeltaAssets, totalDelta, availableDelta});
-                        auto const vaultDeltaAssets = roundToAsset(vaultAsset, maybeVaultDeltaAssets->delta, minScale);
-                        if (vaultDeltaAssets >= zero)
+                        if (*vaultDeltaAssets >= zero)
                         {
                             JLOG(j.fatal()) <<  //
                                 "Invariant failed: clawback must decrease vault "
@@ -3344,9 +3225,7 @@ ValidVault::finalize(STTx const& tx, TER const ret, XRPAmount const fee, ReadVie
                             result = false;
                         }
 
-                        auto const assetsTotalDelta =
-                            roundToAsset(vaultAsset, afterVault.assetsTotal - beforeVault.assetsTotal, minScale);
-                        if (assetsTotalDelta != vaultDeltaAssets)
+                        if (beforeVault.assetsTotal + *vaultDeltaAssets != afterVault.assetsTotal)
                         {
                             JLOG(j.fatal()) <<  //
                                 "Invariant failed: clawback and assets outstanding "
@@ -3354,9 +3233,7 @@ ValidVault::finalize(STTx const& tx, TER const ret, XRPAmount const fee, ReadVie
                             result = false;
                         }
 
-                        auto const assetAvailableDelta = roundToAsset(
-                            vaultAsset, afterVault.assetsAvailable - beforeVault.assetsAvailable, minScale);
-                        if (assetAvailableDelta != vaultDeltaAssets)
+                        if (beforeVault.assetsAvailable + *vaultDeltaAssets != afterVault.assetsAvailable)
                         {
                             JLOG(j.fatal()) <<  //
                                 "Invariant failed: clawback and assets available "
@@ -3371,15 +3248,15 @@ ValidVault::finalize(STTx const& tx, TER const ret, XRPAmount const fee, ReadVie
                         return false;  // That's all we can do
                     }
 
-                    // We don't need to round shares, they are integral MPT
-                    auto const maybeAccountDeltaShares = deltaShares(tx[sfHolder]);
-                    if (!maybeAccountDeltaShares)
+                    auto const accountDeltaShares = deltaShares(tx[sfHolder]);
+                    if (!accountDeltaShares)
                     {
                         JLOG(j.fatal()) <<  //
                             "Invariant failed: clawback must change holder shares";
                         return false;  // That's all we can do
                     }
-                    if (maybeAccountDeltaShares->delta >= zero)
+
+                    if (*accountDeltaShares >= zero)
                     {
                         JLOG(j.fatal()) <<  //
                             "Invariant failed: clawback must decrease holder "
@@ -3387,16 +3264,15 @@ ValidVault::finalize(STTx const& tx, TER const ret, XRPAmount const fee, ReadVie
                         result = false;
                     }
 
-                    // We don't need to round shares, they are integral MPT
                     auto const vaultDeltaShares = deltaShares(afterVault.pseudoId);
-                    if (!vaultDeltaShares || vaultDeltaShares->delta == zero)
+                    if (!vaultDeltaShares || *vaultDeltaShares == zero)
                     {
                         JLOG(j.fatal()) <<  //
                             "Invariant failed: clawback must change vault shares";
                         return false;  // That's all we can do
                     }
 
-                    if (vaultDeltaShares->delta * -1 != maybeAccountDeltaShares->delta)
+                    if (*vaultDeltaShares * -1 != *accountDeltaShares)
                     {
                         JLOG(j.fatal()) <<  //
                             "Invariant failed: clawback must change holder and "
@@ -3433,15 +3309,4 @@ ValidVault::finalize(STTx const& tx, TER const ret, XRPAmount const fee, ReadVie
     return true;
 }
 
-[[nodiscard]] std::int32_t
-ValidVault::computeMinScale(Asset const& asset, std::vector<DeltaInfo> const& numbers)
-{
-    if (numbers.size() == 0)
-        return 0;
-
-    auto const max = std::max_element(
-        numbers.begin(), numbers.end(), [](auto const& a, auto const& b) -> bool { return a.scale < b.scale; });
-    XRPL_ASSERT_PARTS(max->scale, "xrpl::ValidVault::computeMinScale", "scale set for destinationDelta");
-    return max->scale.value_or(STAmount::cMaxOffset);
-}
 }  // namespace xrpl

src/libxrpl/tx/transactors/Lending/LoanBrokerCoverWithdraw.cpp

@@ -121,7 +121,7 @@ LoanBrokerCoverWithdraw::preclaim(PreclaimContext const& ctx)
         return roundToAsset(
             vaultAsset,
             tenthBipsOfValue(currentDebtTotal, TenthBips32(sleBroker->at(sfCoverRateMinimum))),
-            numberScale(currentDebtTotal, vaultAsset));
+            currentDebtTotal.exponent());
     }();
     if (coverAvail < amount)
         return tecINSUFFICIENT_FUNDS;

src/test/app/Invariants_test.cpp

@@ -15,15 +15,10 @@
 #include <xrpl/protocol/TxFormats.h>
 #include <xrpl/protocol/XRPAmount.h>
 #include <xrpl/tx/ApplyContext.h>
-#include <xrpl/tx/InvariantCheck.h>
 #include <xrpl/tx/apply.h>
 
 #include <boost/algorithm/string/predicate.hpp>
 
-#include <initializer_list>
-#include <string>
-#include <vector>
-
 namespace xrpl {
 namespace test {
 
@@ -3711,124 +3706,6 @@ class Invariants_test : public beast::unit_test::suite
             precloseMpt);
     }
 
-    void
-    testVaultComputeMinScale()
-    {
-        using namespace jtx;
-
-        Account const issuer{"issuer"};
-        PrettyAsset const vaultAsset = issuer["IOU"];
-
-        struct TestCase
-        {
-            std::string name;
-            std::int32_t expectedMinScale;
-            std::vector<ValidVault::DeltaInfo> values;
-        };
-
-        NumberMantissaScaleGuard g{MantissaRange::large};
-
-        auto makeDelta = [&vaultAsset](Number const& n) -> ValidVault::DeltaInfo {
-            return {n, numberScale(n, vaultAsset.raw())};
-        };
-
-        auto const testCases = std::vector<TestCase>{
-            {
-                .name = "No values",
-                .expectedMinScale = 0,
-                .values = {},
-            },
-            {
-                .name = "Mixed integer and Number values",
-                .expectedMinScale = -15,
-                .values = {makeDelta(1), makeDelta(-1), makeDelta(Number{10, -1})},
-            },
-            {
-                .name = "Mixed scales",
-                .expectedMinScale = -17,
-                .values = {makeDelta(Number{1, -2}), makeDelta(Number{5, -3}), makeDelta(Number{3, -2})},
-            },
-            {
-                .name = "Equal scales",
-                .expectedMinScale = -16,
-                .values = {makeDelta(Number{1, -1}), makeDelta(Number{5, -1}), makeDelta(Number{1, -1})},
-            },
-            {
-                .name = "Mixed mantissa sizes",
-                .expectedMinScale = -12,
-                .values =
-                    {makeDelta(Number{1}),
-                     makeDelta(Number{1234, -3}),
-                     makeDelta(Number{12345, -6}),
-                     makeDelta(Number{123, 1})},
-            },
-        };
-
-        for (auto const& tc : testCases)
-        {
-            testcase("vault computeMinScale: " + tc.name);
-
-            auto const actualScale = ValidVault::computeMinScale(vaultAsset, tc.values);
-
-            BEAST_EXPECTS(
-                actualScale == tc.expectedMinScale,
-                "expected: " + std::to_string(tc.expectedMinScale) + ", actual: " + std::to_string(actualScale));
-            for (auto const& num : tc.values)
-            {
-                // None of these scales are far enough apart that rounding the
-                // values would lose information, so check that the rounded
-                // value matches the original.
-                auto const actualRounded = roundToAsset(vaultAsset, num.delta, actualScale);
-                BEAST_EXPECTS(
-                    actualRounded == num.delta,
-                    "number " + to_string(num.delta) + " rounded to scale " + std::to_string(actualScale) + " is " +
-                        to_string(actualRounded));
-            }
-        }
-
-        auto const testCases2 = std::vector<TestCase>{
-            {
-                .name = "False equivalence",
-                .expectedMinScale = -15,
-                .values =
-                    {
-                        makeDelta(Number{1234567890123456789, -18}),
-                        makeDelta(Number{12345, -4}),
-                        makeDelta(Number{1}),
-                    },
-            },
-        };
-
-        // Unlike the first set of test cases, the values in these test could
-        // look equivalent if using the wrong scale.
-        for (auto const& tc : testCases2)
-        {
-            testcase("vault computeMinScale: " + tc.name);
-
-            auto const actualScale = ValidVault::computeMinScale(vaultAsset, tc.values);
-
-            BEAST_EXPECTS(
-                actualScale == tc.expectedMinScale,
-                "expected: " + std::to_string(tc.expectedMinScale) + ", actual: " + std::to_string(actualScale));
-            std::optional<Number> first;
-            Number firstRounded;
-            for (auto const& num : tc.values)
-            {
-                if (!first)
-                {
-                    first = num.delta;
-                    firstRounded = roundToAsset(vaultAsset, num.delta, actualScale);
-                    continue;
-                }
-                auto const numRounded = roundToAsset(vaultAsset, num.delta, actualScale);
-                BEAST_EXPECTS(
-                    numRounded != firstRounded,
-                    "at a scale of " + std::to_string(actualScale) + " " + to_string(num.delta) +
-                        " == " + to_string(*first));
-            }
-        }
-    }
-
 public:
     void
     run() override
@@ -3854,7 +3731,6 @@ public:
         testValidPseudoAccounts();
         testValidLoanBroker();
         testVault();
-        testVaultComputeMinScale();
     }
 };
 

src/test/app/LendingHelpers_test.cpp

@@ -3,6 +3,7 @@
 #include <test/jtx.h>
 #include <test/jtx/Account.h>
 #include <test/jtx/amount.h>
+#include <test/jtx/mpt.h>
 
 #include <xrpl/beast/xor_shift_engine.h>
 #include <xrpl/protocol/SField.h>

src/test/app/LoanBroker_test.cpp

@@ -1700,21 +1700,10 @@ class LoanBroker_test : public beast::unit_test::suite
         testRIPD4274MPT();
     }
 
-    void
-    testFixAmendmentEnabled()
-    {
-        using namespace jtx;
-        testcase("testFixAmendmentEnabled");
-        Env env{*this};
-
-        BEAST_EXPECT(env.enabled(fixLendingProtocolV1_1));
-    }
-
 public:
     void
     run() override
     {
-        testFixAmendmentEnabled();
         testLoanBrokerSetDebtMaximum();
         testLoanBrokerCoverDepositNullVault();
 

src/test/app/Loan_test.cpp

@@ -6675,132 +6675,6 @@ protected:
         BEAST_EXPECT(afterSecondCoverAvailable == 0);
     }
 
-    // Tests that vault withdrawals work correctly when the vault has unrealized
-    // loss from an impaired loan, ensuring the invariant check properly
-    // accounts for the loss.
-    void
-    testWithdrawReflectsUnrealizedLoss()
-    {
-        using namespace jtx;
-        using namespace loan;
-        using namespace std::chrono_literals;
-
-        testcase("Vault withdraw reflects sfLossUnrealized");
-
-        // Test constants
-        static constexpr std::int64_t INITIAL_FUNDING = 1'000'000;
-        static constexpr std::int64_t LENDER_INITIAL_IOU = 5'000'000;
-        static constexpr std::int64_t DEPOSITOR_INITIAL_IOU = 1'000'000;
-        static constexpr std::int64_t BORROWER_INITIAL_IOU = 100'000;
-        static constexpr std::int64_t DEPOSIT_AMOUNT = 5'000;
-        static constexpr std::int64_t PRINCIPAL_AMOUNT = 99;
-        static constexpr std::uint64_t EXPECTED_SHARES_PER_DEPOSITOR = 5'000'000'000;
-        static constexpr std::uint32_t PAYMENT_INTERVAL = 600;
-        static constexpr std::uint32_t PAYMENT_TOTAL = 2;
-
-        Env env(*this, all);
-
-        // Setup accounts
-        Account const issuer{"issuer"};
-        Account const lender{"lender"};
-        Account const depositorA{"lpA"};
-        Account const depositorB{"lpB"};
-        Account const borrower{"borrowerA"};
-
-        env.fund(XRP(INITIAL_FUNDING), issuer, lender, depositorA, depositorB, borrower);
-        env.close();
-
-        // Setup trust lines
-        PrettyAsset const iouAsset = issuer[iouCurrency];
-        env(trust(lender, iouAsset(10'000'000)));
-        env(trust(depositorA, iouAsset(10'000'000)));
-        env(trust(depositorB, iouAsset(10'000'000)));
-        env(trust(borrower, iouAsset(10'000'000)));
-        env.close();
-
-        // Fund accounts with IOUs
-        env(pay(issuer, lender, iouAsset(LENDER_INITIAL_IOU)));
-        env(pay(issuer, depositorA, iouAsset(DEPOSITOR_INITIAL_IOU)));
-        env(pay(issuer, depositorB, iouAsset(DEPOSITOR_INITIAL_IOU)));
-        env(pay(issuer, borrower, iouAsset(BORROWER_INITIAL_IOU)));
-        env.close();
-
-        // Create vault and broker, then add deposits from two depositors
-        auto const broker = createVaultAndBroker(env, iouAsset, lender);
-        Vault v{env};
-
-        env(v.deposit({
-                .depositor = depositorA,
-                .id = broker.vaultKeylet().key,
-                .amount = iouAsset(DEPOSIT_AMOUNT),
-            }),
-            ter(tesSUCCESS));
-        env(v.deposit({
-                .depositor = depositorB,
-                .id = broker.vaultKeylet().key,
-                .amount = iouAsset(DEPOSIT_AMOUNT),
-            }),
-            ter(tesSUCCESS));
-        env.close();
-
-        // Create a loan
-        auto const sleBroker = env.le(keylet::loanbroker(broker.brokerID));
-        if (!BEAST_EXPECT(sleBroker))
-            return;
-
-        auto const loanKeylet = keylet::loan(broker.brokerID, sleBroker->at(sfLoanSequence));
-
-        env(set(borrower, broker.brokerID, PRINCIPAL_AMOUNT),
-            sig(sfCounterpartySignature, lender),
-            paymentTotal(PAYMENT_TOTAL),
-            paymentInterval(PAYMENT_INTERVAL),
-            fee(env.current()->fees().base * 2),
-            ter(tesSUCCESS));
-        env.close();
-
-        // Impair the loan to create unrealized loss
-        env(manage(lender, loanKeylet.key, tfLoanImpair), ter(tesSUCCESS));
-        env.close();
-
-        // Verify unrealized loss is recorded in the vault
-        auto const vaultAfterImpair = env.le(broker.vaultKeylet());
-        if (!BEAST_EXPECT(vaultAfterImpair))
-            return;
-
-        BEAST_EXPECT(vaultAfterImpair->at(sfLossUnrealized) == broker.asset(PRINCIPAL_AMOUNT).value());
-
-        // Helper to get share balance for a depositor
-        auto const shareAsset = vaultAfterImpair->at(sfShareMPTID);
-        auto const getShareBalance = [&](Account const& depositor) -> std::uint64_t {
-            auto const token = env.le(keylet::mptoken(shareAsset, depositor.id()));
-            return token ? token->getFieldU64(sfMPTAmount) : 0;
-        };
-
-        // Verify both depositors have equal shares
-        auto const sharesLpA = getShareBalance(depositorA);
-        auto const sharesLpB = getShareBalance(depositorB);
-        BEAST_EXPECT(sharesLpA == EXPECTED_SHARES_PER_DEPOSITOR);
-        BEAST_EXPECT(sharesLpB == EXPECTED_SHARES_PER_DEPOSITOR);
-        BEAST_EXPECT(sharesLpA == sharesLpB);
-
-        // Helper to attempt withdrawal
-        auto const attemptWithdrawShares = [&](Account const& depositor, std::uint64_t shareAmount, TER expected) {
-            STAmount const shareAmt{MPTIssue{shareAsset}, Number(shareAmount)};
-            env(v.withdraw({.depositor = depositor, .id = broker.vaultKeylet().key, .amount = shareAmt}),
-                ter(expected));
-            env.close();
-        };
-
-        // Regression test: Both depositors should successfully withdraw despite
-        // unrealized loss. Previously failed with invariant violation:
-        // "withdrawal must change vault and destination balance by equal
-        // amount". This was caused by sharesToAssetsWithdraw rounding down,
-        // creating a mismatch where vaultDeltaAssets * -1 != destinationDelta
-        // when unrealized loss exists.
-        attemptWithdrawShares(depositorA, sharesLpA, tesSUCCESS);
-        attemptWithdrawShares(depositorB, sharesLpB, tesSUCCESS);
-    }
-
 public:
     void
     run() override
@@ -6809,7 +6683,6 @@ public:
         testLoanPayLateFullPaymentBypassesPenalties();
         testLoanCoverMinimumRoundingExploit();
 #endif
-        testWithdrawReflectsUnrealizedLoss();
         testInvalidLoanSet();
 
         testCoverDepositWithdrawNonTransferableMPT();