experiment

.clang-tidy

@@ -1,100 +1,168 @@
 ---
 Checks: "-*,
-  bugprone-*,
-  -bugprone-easily-swappable-parameters,
-  -bugprone-exception-escape,
-  -bugprone-implicit-widening-of-multiplication-result,
-  -bugprone-narrowing-conversions,
-  -bugprone-throwing-static-initialization,
-
-  cppcoreguidelines-*,
-  -cppcoreguidelines-avoid-c-arrays,
-  -cppcoreguidelines-avoid-const-or-ref-data-members,
-  -cppcoreguidelines-avoid-do-while,
-  -cppcoreguidelines-avoid-magic-numbers,
-  -cppcoreguidelines-avoid-non-const-global-variables,
-  -cppcoreguidelines-c-copy-assignment-signature,
-  -cppcoreguidelines-interfaces-global-init,
-  -cppcoreguidelines-macro-usage,
-  -cppcoreguidelines-missing-std-forward,
-  -cppcoreguidelines-narrowing-conversions,
-  -cppcoreguidelines-noexcept-move-operations,
-  -cppcoreguidelines-non-private-member-variables-in-classes,
-  -cppcoreguidelines-owning-memory,
-  -cppcoreguidelines-pro-bounds-array-to-pointer-decay,
-  -cppcoreguidelines-pro-bounds-avoid-unchecked-container-access,
-  -cppcoreguidelines-pro-bounds-constant-array-index,
-  -cppcoreguidelines-pro-bounds-pointer-arithmetic,
-  -cppcoreguidelines-pro-type-reinterpret-cast,
-  -cppcoreguidelines-pro-type-union-access,
-  -cppcoreguidelines-special-member-functions,
-
+  bugprone-argument-comment,
+  bugprone-assert-side-effect,
+  bugprone-bad-signal-to-kill-thread,
+  bugprone-bool-pointer-implicit-conversion,
+  bugprone-capturing-this-in-member-variable,
+  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-misleading-setter-of-reference,
+  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-unchecked-optional-access,
+  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-use-enum-class,
+  cppcoreguidelines-virtual-class-destructor,
+  hicpp-ignored-remove-result,
   llvm-namespace-comment,
-
-  misc-*,
-  -misc-multiple-inheritance,
-  -misc-no-recursion,
-  -misc-non-private-member-variables-in-classes,
-  -misc-override-with-different-visibility,
-  -misc-unused-parameters,
-  -misc-use-anonymous-namespace,
-  -misc-use-internal-linkage,
-
-  modernize-*,
-  -modernize-avoid-c-arrays,
-  -modernize-avoid-c-style-cast,
-  -modernize-return-braced-init-list,
-  -modernize-use-integer-sign-comparison,
-  -modernize-use-trailing-return-type,
-
-  performance-*,
-  -performance-avoid-endl,
-  -performance-enum-size,
-  -performance-noexcept-move-constructor,
-  -performance-unnecessary-copy-initialization,
-  -performance-unnecessary-value-param,
-
-  readability-*,
-  -readability-avoid-const-params-in-decls,
-  -readability-avoid-unconditional-preprocessor-if,
-  -readability-container-data-pointer,
-  -readability-delete-null-pointer,
-  -readability-function-cognitive-complexity,
-  -readability-function-size,
-  -readability-identifier-length,
-  -readability-inconsistent-declaration-parameter-name,
-  -readability-isolate-declaration,
-  -readability-magic-numbers,
-  -readability-misplaced-array-index,
-  -readability-named-parameter,
-  -readability-operators-representation,
-  -readability-qualified-auto,
-  -readability-redundant-access-specifiers,
-  -readability-redundant-control-flow,
-  -readability-redundant-function-ptr-dereference,
-  -readability-redundant-preprocessor,
-  -readability-redundant-smartptr-get,
-  -readability-redundant-string-cstr,
-  -readability-simplify-subscript-expr,
-  -readability-static-accessed-through-instance,
-  -readability-string-compare,
-  -readability-uniqueptr-delete-release,
-  -readability-uppercase-literal-suffix,
-  -readability-use-anyofallof,
-  -readability-use-concise-preprocessor-directives
+  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-nodiscard,
+  modernize-use-override,
+  modernize-use-ranges,
+  modernize-use-scoped-lock,
+  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-ambiguous-smartptr-reset-call,
+  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-identifier-naming,
+  readability-implicit-bool-conversion,
+  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-definition-in-anonymous-namespace,
+  readability-suspicious-call-argument,
+  readability-use-std-min-max
   "
 # ---
-# bugprone-narrowing-conversions,                      # This will break a lot of code but we should enable it in the future because it can eliminate a lot of bugs
-# misc-override-with-different-visibility,             # Will be addressed in a future PR, but for now it generates too many warnings
-# readability-inconsistent-declaration-parameter-name, # In this codebase this check will break a lot of arg names
-# readability-static-accessed-through-instance,        # this check is probably unnecessary. It makes the code less readable
+# bugprone-narrowing-conversions,                      # this will break a lot of code but we should enable it in the future because it can eliminate a lot of bugs
+# readability-inconsistent-declaration-parameter-name, # in this codebase this check will break a lot of arg names
+# readability-static-accessed-through-instance,        # this check is probably unnecessary. it makes the code less readable
 # ---
 
 CheckOptions:
   bugprone-unsafe-functions.ReportMoreUnsafeFunctions: true
   bugprone-unused-return-value.CheckedReturnTypes: ::std::error_code;::std::error_condition;::std::errc
 
-  misc-include-cleaner.IgnoreHeaders: ".*/(detail|impl)/.*;.*fwd\\.h(pp)?;time.h;stdlib.h;sqlite3.h;netinet/in\\.h;sys/resource\\.h;sys/sysinfo\\.h;linux/sysinfo\\.h;__chrono/.*;bits/.*;_abort\\.h;boost/.*;openssl/obj_mac\\.h"
+  misc-include-cleaner.IgnoreHeaders: ".*/(detail|impl)/.*;.*fwd\\.h(pp)?;time.h;stdlib.h;sqlite3.h;netinet/in\\.h;sys/resource\\.h;sys/sysinfo\\.h;linux/sysinfo\\.h;__chrono/.*;bits/.*;_abort\\.h;boost/uuid/uuid_hash.hpp;boost/beast/core/flat_buffer\\.hpp;boost/beast/http/field\\.hpp;boost/beast/http/dynamic_body\\.hpp;boost/beast/http/message\\.hpp;boost/beast/http/read\\.hpp;boost/beast/http/write\\.hpp;openssl/obj_mac\\.h"
 
   readability-braces-around-statements.ShortStatementLines: 2
   readability-identifier-naming.MacroDefinitionCase: UPPER_CASE

.envrc

@@ -1 +0,0 @@
-use flake

.gersemi/definitions.cmake

@@ -11,6 +11,9 @@ endfunction()
 function(create_symbolic_link target link)
 endfunction()
 
+function(xrpl_add_test name)
+endfunction()
+
 macro(exclude_from_default target_)
 endmacro()
 
@@ -48,12 +51,6 @@ endfunction()
 function(add_module parent name)
 endfunction()
 
-function(verify_target_headers target headers_dir)
-endfunction()
-
-function(_verify_add_headers target dir)
-endfunction()
-
 function(setup_protocol_autogen)
 endfunction()
 
@@ -102,6 +99,3 @@ function(verbose_find_path variable name)
         ${ARGN}
     )
 endfunction()
-
-function(patch_nix_binary target)
-endfunction()

.github/actions/build-deps/action.yml

@@ -35,8 +35,9 @@ runs:
         LOG_VERBOSITY: ${{ inputs.log_verbosity }}
         SANITIZERS: ${{ inputs.sanitizers }}
       run: |
+        echo 'Installing dependencies.'
         conan install \
-            --profile:all ci \
+            --profile ci \
             --build="${BUILD_OPTION}" \
             --options:host='&:tests=True' \
             --options:host='&:xrpld=True' \

.github/actions/set-compiler-env/action.yml

@@ -1,34 +0,0 @@
-name: Set compiler environment
-description: "Set CC and CXX environment variables for the given compiler."
-
-inputs:
-  compiler:
-    description: 'The compiler to use ("gcc" or "clang").'
-    required: true
-
-runs:
-  using: composite
-
-  steps:
-    - name: Set CC and CXX for gcc
-      if: ${{ inputs.compiler == 'gcc' }}
-      shell: bash
-      run: |
-        echo "CC=gcc" >>"${GITHUB_ENV}"
-        echo "CXX=g++" >>"${GITHUB_ENV}"
-
-    - name: Set CC and CXX for clang
-      if: ${{ inputs.compiler == 'clang' }}
-      shell: bash
-      run: |
-        echo "CC=clang" >>"${GITHUB_ENV}"
-        echo "CXX=clang++" >>"${GITHUB_ENV}"
-
-    - name: Fail on unknown compiler
-      if: ${{ inputs.compiler != 'gcc' && inputs.compiler != 'clang' }}
-      shell: bash
-      env:
-        COMPILER: ${{ inputs.compiler }}
-      run: |
-        echo "Unknown compiler: $COMPILER" >&2
-        exit 1

.github/actions/setup-conan/action.yml

@@ -9,41 +9,38 @@ inputs:
   remote_url:
     description: "The URL of the Conan endpoint to use."
     required: false
-    default: https://conan.xrplf.org/repository/conan/
+    default: https://conan.ripplex.io
 
 runs:
   using: composite
 
   steps:
-    - name: Apply custom configuration to global.conf
+    - name: Set up Conan configuration
       shell: bash
       run: |
+        echo 'Installing configuration.'
         cat conan/global.conf ${{ runner.os == 'Linux' && '>>' || '>' }} $(conan config home)/global.conf
 
-    - name: Show global configuration
-      shell: bash
-      run: |
+        echo 'Conan configuration:'
         conan config show '*'
 
-    - name: Install profiles
+    - name: Set up Conan profile
       shell: bash
       run: |
+        echo 'Installing profile.'
         conan config install conan/profiles/ -tf $(conan config home)/profiles/
 
-    - name: Show CI profile
-      shell: bash
-      run: |
+        echo 'Conan profile:'
         conan profile show --profile ci
 
-    - name: Add a remote
+    - name: Set up Conan remote
       shell: bash
       env:
         REMOTE_NAME: ${{ inputs.remote_name }}
         REMOTE_URL: ${{ inputs.remote_url }}
       run: |
+        echo "Adding Conan remote '${REMOTE_NAME}' at '${REMOTE_URL}'."
         conan remote add --index 0 --force "${REMOTE_NAME}" "${REMOTE_URL}"
 
-    - name: List remotes
-      shell: bash
-      run: |
+        echo 'Listing Conan remotes.'
         conan remote list

.github/dependabot.yml

@@ -1,12 +1,40 @@
 version: 2
 updates:
   - package-ecosystem: github-actions
-    directories:
-      - /
-      - .github/actions/build-deps/
-      - .github/actions/generate-version/
-      - .github/actions/set-compiler-env/
-      - .github/actions/setup-conan/
+    directory: /
+    schedule:
+      interval: weekly
+      day: monday
+      time: "04:00"
+      timezone: Etc/GMT
+    commit-message:
+      prefix: "ci: [DEPENDABOT] "
+    target-branch: develop
+
+  - package-ecosystem: github-actions
+    directory: .github/actions/build-deps/
+    schedule:
+      interval: weekly
+      day: monday
+      time: "04:00"
+      timezone: Etc/GMT
+    commit-message:
+      prefix: "ci: [DEPENDABOT] "
+    target-branch: develop
+
+  - package-ecosystem: github-actions
+    directory: .github/actions/generate-version/
+    schedule:
+      interval: weekly
+      day: monday
+      time: "04:00"
+      timezone: Etc/GMT
+    commit-message:
+      prefix: "ci: [DEPENDABOT] "
+    target-branch: develop
+
+  - package-ecosystem: github-actions
+    directory: .github/actions/setup-conan/
     schedule:
       interval: weekly
       day: monday

.github/scripts/levelization/results/loops.txt

@@ -1,3 +1,9 @@
+Loop: test.jtx test.toplevel
+  test.toplevel > test.jtx
+
+Loop: test.jtx test.unit_test
+  test.unit_test ~= test.jtx
+
 Loop: xrpld.app xrpld.overlay
   xrpld.app > xrpld.overlay
 

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

@@ -1,8 +1,6 @@
 libxrpl.basics > xrpl.basics
 libxrpl.conditions > xrpl.basics
 libxrpl.conditions > xrpl.conditions
-libxrpl.config > xrpl.basics
-libxrpl.config > xrpl.config
 libxrpl.core > xrpl.basics
 libxrpl.core > xrpl.core
 libxrpl.core > xrpl.json
@@ -18,7 +16,6 @@ libxrpl.ledger > xrpl.shamap
 libxrpl.net > xrpl.basics
 libxrpl.net > xrpl.net
 libxrpl.nodestore > xrpl.basics
-libxrpl.nodestore > xrpl.config
 libxrpl.nodestore > xrpl.json
 libxrpl.nodestore > xrpl.nodestore
 libxrpl.nodestore > xrpl.protocol
@@ -26,7 +23,6 @@ libxrpl.protocol > xrpl.basics
 libxrpl.protocol > xrpl.json
 libxrpl.protocol > xrpl.protocol
 libxrpl.rdb > xrpl.basics
-libxrpl.rdb > xrpl.config
 libxrpl.rdb > xrpl.core
 libxrpl.rdb > xrpl.rdb
 libxrpl.resource > xrpl.basics
@@ -34,7 +30,6 @@ libxrpl.resource > xrpl.json
 libxrpl.resource > xrpl.protocol
 libxrpl.resource > xrpl.resource
 libxrpl.server > xrpl.basics
-libxrpl.server > xrpl.config
 libxrpl.server > xrpl.core
 libxrpl.server > xrpl.json
 libxrpl.server > xrpl.protocol
@@ -56,7 +51,6 @@ libxrpl.tx > xrpl.tx
 test.app > test.jtx
 test.app > test.unit_test
 test.app > xrpl.basics
-test.app > xrpl.config
 test.app > xrpl.core
 test.app > xrpld.app
 test.app > xrpld.consensus
@@ -72,6 +66,7 @@ test.app > xrpl.server
 test.app > xrpl.shamap
 test.app > xrpl.tx
 test.basics > test.jtx
+test.basics > test.unit_test
 test.basics > xrpl.basics
 test.basics > xrpl.core
 test.basics > xrpld.rpc
@@ -82,6 +77,7 @@ test.conditions > xrpl.basics
 test.conditions > xrpl.conditions
 test.consensus > test.csf
 test.consensus > test.jtx
+test.consensus > test.toplevel
 test.consensus > test.unit_test
 test.consensus > xrpl.basics
 test.consensus > xrpld.app
@@ -93,7 +89,6 @@ test.consensus > xrpl.tx
 test.core > test.jtx
 test.core > test.unit_test
 test.core > xrpl.basics
-test.core > xrpl.config
 test.core > xrpl.core
 test.core > xrpld.core
 test.core > xrpl.json
@@ -104,11 +99,10 @@ test.csf > xrpl.basics
 test.csf > xrpld.consensus
 test.csf > xrpl.json
 test.csf > xrpl.ledger
+test.csf > xrpl.protocol
 test.json > test.jtx
 test.json > xrpl.json
-test.jtx > test.unit_test
 test.jtx > xrpl.basics
-test.jtx > xrpl.config
 test.jtx > xrpl.core
 test.jtx > xrpld.app
 test.jtx > xrpld.core
@@ -131,7 +125,6 @@ test.ledger > xrpl.protocol
 test.nodestore > test.jtx
 test.nodestore > test.unit_test
 test.nodestore > xrpl.basics
-test.nodestore > xrpl.config
 test.nodestore > xrpld.core
 test.nodestore > xrpl.nodestore
 test.nodestore > xrpl.protocol
@@ -139,7 +132,6 @@ test.nodestore > xrpl.rdb
 test.overlay > test.jtx
 test.overlay > test.unit_test
 test.overlay > xrpl.basics
-test.overlay > xrpl.config
 test.overlay > xrpld.app
 test.overlay > xrpld.core
 test.overlay > xrpld.overlay
@@ -161,9 +153,11 @@ test.protocol > test.unit_test
 test.protocol > xrpl.basics
 test.protocol > xrpl.json
 test.protocol > xrpl.protocol
+test.resource > test.unit_test
+test.resource > xrpl.basics
+test.resource > xrpl.resource
 test.rpc > test.jtx
 test.rpc > xrpl.basics
-test.rpc > xrpl.config
 test.rpc > xrpl.core
 test.rpc > xrpld.app
 test.rpc > xrpld.core
@@ -178,16 +172,21 @@ test.rpc > xrpl.tx
 test.server > test.jtx
 test.server > test.unit_test
 test.server > xrpl.basics
-test.server > xrpl.config
 test.server > xrpld.app
 test.server > xrpld.core
 test.server > xrpl.json
 test.server > xrpl.protocol
 test.server > xrpl.server
+test.shamap > test.unit_test
+test.shamap > xrpl.basics
+test.shamap > xrpl.nodestore
+test.shamap > xrpl.protocol
+test.shamap > xrpl.shamap
+test.toplevel > test.csf
+test.toplevel > xrpl.json
 test.unit_test > xrpl.basics
 test.unit_test > xrpl.protocol
 tests.libxrpl > xrpl.basics
-tests.libxrpl > xrpl.config
 tests.libxrpl > xrpl.core
 tests.libxrpl > xrpl.json
 tests.libxrpl > xrpl.ledger
@@ -195,26 +194,20 @@ tests.libxrpl > xrpl.net
 tests.libxrpl > xrpl.nodestore
 tests.libxrpl > xrpl.protocol
 tests.libxrpl > xrpl.protocol_autogen
-tests.libxrpl > xrpl.resource
 tests.libxrpl > xrpl.server
 tests.libxrpl > xrpl.shamap
 tests.libxrpl > xrpl.tx
 xrpl.conditions > xrpl.basics
 xrpl.conditions > xrpl.protocol
-xrpl.config > xrpl.basics
 xrpl.core > xrpl.basics
 xrpl.core > xrpl.json
 xrpl.core > xrpl.protocol
 xrpl.json > xrpl.basics
 xrpl.ledger > xrpl.basics
-xrpl.ledger > xrpl.json
-xrpl.ledger > xrpl.nodestore
 xrpl.ledger > xrpl.protocol
 xrpl.ledger > xrpl.shamap
 xrpl.net > xrpl.basics
 xrpl.nodestore > xrpl.basics
-xrpl.nodestore > xrpl.config
-xrpl.nodestore > xrpl.json
 xrpl.nodestore > xrpl.protocol
 xrpl.protocol > xrpl.basics
 xrpl.protocol > xrpl.json
@@ -232,6 +225,7 @@ xrpl.server > xrpl.json
 xrpl.server > xrpl.protocol
 xrpl.server > xrpl.rdb
 xrpl.server > xrpl.resource
+xrpl.server > xrpl.shamap
 xrpl.shamap > xrpl.basics
 xrpl.shamap > xrpl.nodestore
 xrpl.shamap > xrpl.protocol
@@ -241,7 +235,6 @@ xrpl.tx > xrpl.ledger
 xrpl.tx > xrpl.protocol
 xrpld.app > test.unit_test
 xrpld.app > xrpl.basics
-xrpld.app > xrpl.config
 xrpld.app > xrpl.core
 xrpld.app > xrpld.consensus
 xrpld.app > xrpld.core
@@ -260,13 +253,11 @@ xrpld.consensus > xrpl.json
 xrpld.consensus > xrpl.ledger
 xrpld.consensus > xrpl.protocol
 xrpld.core > xrpl.basics
-xrpld.core > xrpl.config
 xrpld.core > xrpl.core
 xrpld.core > xrpl.net
 xrpld.core > xrpl.protocol
 xrpld.core > xrpl.rdb
 xrpld.overlay > xrpl.basics
-xrpld.overlay > xrpl.config
 xrpld.overlay > xrpl.core
 xrpld.overlay > xrpld.consensus
 xrpld.overlay > xrpld.core
@@ -279,20 +270,15 @@ xrpld.overlay > xrpl.server
 xrpld.overlay > xrpl.shamap
 xrpld.overlay > xrpl.tx
 xrpld.peerfinder > xrpl.basics
-xrpld.peerfinder > xrpl.config
 xrpld.peerfinder > xrpld.core
 xrpld.peerfinder > xrpl.protocol
 xrpld.peerfinder > xrpl.rdb
 xrpld.perflog > xrpl.basics
-xrpld.perflog > xrpl.config
 xrpld.perflog > xrpl.core
-xrpld.perflog > xrpld.app
 xrpld.perflog > xrpld.rpc
 xrpld.perflog > xrpl.json
-xrpld.perflog > xrpl.nodestore
 xrpld.perflog > xrpl.protocol
 xrpld.rpc > xrpl.basics
-xrpld.rpc > xrpl.config
 xrpld.rpc > xrpl.core
 xrpld.rpc > xrpld.core
 xrpld.rpc > xrpl.json
@@ -307,6 +293,5 @@ xrpld.rpc > xrpl.shamap
 xrpld.rpc > xrpl.tx
 xrpld.shamap > xrpl.basics
 xrpld.shamap > xrpld.core
-xrpld.shamap > xrpl.nodestore
 xrpld.shamap > xrpl.protocol
 xrpld.shamap > xrpl.shamap

.github/scripts/rename/cmake.sh

@@ -43,6 +43,9 @@ pushd "${DIRECTORY}"
 # Rename the files.
 find cmake -type f -name 'Rippled*.cmake' -exec bash -c 'mv "${1}" "${1/Rippled/Xrpl}"' - {} \;
 find cmake -type f -name 'Ripple*.cmake' -exec bash -c 'mv "${1}" "${1/Ripple/Xrpl}"' - {} \;
+if [ -e cmake/xrpl_add_test.cmake ]; then
+    mv cmake/xrpl_add_test.cmake cmake/XrplAddTest.cmake
+fi
 if [ -e include/xrpl/proto/ripple.proto ]; then
     mv include/xrpl/proto/ripple.proto include/xrpl/proto/xrpl.proto
 fi
@@ -57,6 +60,7 @@ find cmake -type f -name '*.cmake' | while read -r FILE; do
 done
 ${SED_COMMAND} -i -E 's/Rippled?/Xrpl/g' CMakeLists.txt
 ${SED_COMMAND} -i 's/ripple/xrpl/g' CMakeLists.txt
+${SED_COMMAND} -i 's/include(xrpl_add_test)/include(XrplAddTest)/' src/tests/libxrpl/CMakeLists.txt
 ${SED_COMMAND} -i 's/ripple.pb.h/xrpl.pb.h/' include/xrpl/protocol/messages.h
 ${SED_COMMAND} -i 's/ripple.pb.h/xrpl.pb.h/' BUILD.md
 ${SED_COMMAND} -i 's/ripple.pb.h/xrpl.pb.h/' BUILD.md

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

@@ -1,322 +1,384 @@
 #!/usr/bin/env python3
 import argparse
-import dataclasses
 import itertools
 import json
+from dataclasses import dataclass
 from pathlib import Path
 
 THIS_DIR = Path(__file__).parent.resolve()
 
-_BASE_CMAKE_ARGS = ["-Dtests=ON", "-Dwerr=ON", "-Dxrpld=ON", "-Dwextra=ON"]
 
-# Maps sanitizer names (as used in cmake) to short config-name suffixes.
-_SANITIZER_SUFFIX: dict[str, str] = {
-    "address": "asan",
-    "undefinedbehavior": "ubsan",
-    "thread": "tsan",
-}
-
-
-def get_cmake_args(build_type: str, extra_args: str) -> str:
-    """Get the full list of CMake arguments for a config."""
-    args = _BASE_CMAKE_ARGS.copy()
-    if extra_args:
-        args.extend(extra_args.split())
-    return " ".join(args)
-
-
-def runs_on_event(exclude_event_types: list[str], event: str | None) -> bool:
-    """Whether a config should run for the current event.
-
-    'exclude_event_types' is a list of GitHub event names (e.g.
-    ["pull_request"]) on which the config should NOT run; an empty list means
-    the config runs on every event. When no event is given (event is None), no
-    filtering is applied.
-    """
-    if event is None:
-        return True
-    return event not in exclude_event_types
-
-
-# ---------------------------------------------------------------------------
-# Input types — shapes of the JSON config files
-# ---------------------------------------------------------------------------
-
-
-@dataclasses.dataclass
-class LinuxConfig:
-    """One entry in linux.json's 'configs' or 'package_configs' arrays."""
-
-    compiler: list[str]
+@dataclass
+class Config:
+    architecture: list[dict]
+    os: list[dict]
     build_type: list[str]
-    arch: list[str]
-    sanitizers: list[str] = dataclasses.field(default_factory=list)
-    suffix: str = ""
-    extra_cmake_args: str = ""
-    image: str = ""  # only used by package_configs entries
-    # List of GitHub event names (e.g. "pull_request") on which this config
-    # should NOT run. Empty means it runs on every event.
-    exclude_event_types: list[str] = dataclasses.field(default_factory=list)
+    cmake_args: list[str]
 
 
-@dataclasses.dataclass
-class LinuxFile:
-    """Shape of linux.json."""
+"""
+Generate a strategy matrix for GitHub Actions CI.
 
-    image_tag: str
-    configs: dict[str, list[LinuxConfig]]  # distro → configs
-    package_configs: dict[str, list[LinuxConfig]]  # distro → packaging configs
+On each PR commit we will build a selection of Debian, RHEL, Ubuntu, MacOS, and
+Windows configurations, while upon merge into the develop or release branches,
+we will build all configurations, and test most of them.
 
-    @classmethod
-    def load(cls, path: Path) -> "LinuxFile":
-        data = json.loads(path.read_text())
-
-        def parse(section: dict) -> dict[str, list[LinuxConfig]]:
-            return {
-                distro: [LinuxConfig(**c) for c in cfgs]
-                for distro, cfgs in section.items()
-            }
-
-        return cls(
-            image_tag=data["image_tag"],
-            configs=parse(data["configs"]),
-            package_configs=parse(data.get("package_configs", {})),
-        )
+We will further set additional CMake arguments as follows:
+- All builds will have the `tests`, `werr`, and `xrpld` options.
+- All builds will have the `wextra` option except for GCC 12 and Clang 16.
+- All release builds will have the `assert` option.
+- Certain Debian Bookworm configurations will change the reference fee, enable
+  codecov, and enable voidstar in PRs.
+"""
 
 
-@dataclasses.dataclass
-class PlatformConfig:
-    """One entry in macos.json's or windows.json's 'configs' array."""
-
-    build_type: list[str]
-    build_only: bool = False  # if true, skip tests (e.g. macos/Windows Debug)
-    extra_cmake_args: str = ""
-    # List of GitHub event names (e.g. "pull_request") on which this config
-    # should NOT run. Empty means it runs on every event.
-    exclude_event_types: list[str] = dataclasses.field(default_factory=list)
-
-    def __post_init__(self) -> None:
-        if isinstance(self.build_type, str):
-            self.build_type = [self.build_type]
+def build_config_name(os_entry: dict[str, str], platform: str, build_type: str) -> str:
+    parts = [os_entry["distro_name"]]
+    for key in ("distro_version", "compiler_name", "compiler_version"):
+        if value := os_entry[key]:
+            parts.append(value)
+    parts.append("arm64" if "arm64" in platform else "amd64")
+    parts.append(build_type.lower())
+    return "-".join(parts)
 
 
-@dataclasses.dataclass
-class PlatformFile:
-    """Shape of macos.json and windows.json."""
-
-    platform: str  # e.g. "macos/arm64" or "windows/amd64"
-    runner: list[str]  # GitHub Actions runner labels
-    configs: list[PlatformConfig]
-
-    @classmethod
-    def load(cls, path: Path) -> "PlatformFile":
-        data = json.loads(path.read_text())
-        return cls(
-            platform=data["platform"],
-            runner=data["runner"],
-            configs=[PlatformConfig(**c) for c in data["configs"]],
-        )
-
-
-# ---------------------------------------------------------------------------
-# Output types — shapes of the generated GitHub Actions matrix entries
-# ---------------------------------------------------------------------------
-
-
-@dataclasses.dataclass
-class Architecture:
-    platform: str
-    runner: list[str]
-
-
-@dataclasses.dataclass
-class MatrixEntry:
-    """One entry in the generated build/test strategy matrix."""
-
-    config_name: str
-    cmake_args: str
-    cmake_target: str
-    build_only: bool
-    build_type: str
-    architecture: Architecture
-    sanitizers: str
-    image: str = ""  # container image; empty for macOS/Windows (runs natively)
-    compiler: str = ""  # compiler name ("gcc" or "clang"); empty for macOS/Windows
-
-
-@dataclasses.dataclass
-class PackagingEntry:
-    """One entry in the generated packaging strategy matrix."""
-
-    artifact_name: str
-    image: str
-    distro: str  # e.g. "debian" or "rhel"; drives package-format-specific steps
-
-
-# ---------------------------------------------------------------------------
-# Matrix expansion
-# ---------------------------------------------------------------------------
-
-_ARCHS: dict[str, Architecture] = {
-    "amd64": Architecture(
-        platform="linux/amd64", runner=["self-hosted", "Linux", "X64", "heavy"]
-    ),
-    "arm64": Architecture(
-        platform="linux/arm64",
-        runner=["self-hosted", "Linux", "ARM64", "heavy-arm64"],
-    ),
-}
-
-
-def expand_linux_matrix(
-    linux: LinuxFile, event: str | None = None
-) -> list[MatrixEntry]:
-    """Expand a LinuxFile into a flat list of matrix entries.
-
-    Each config entry is expanded over the cross-product of its
-    compiler, build_type, sanitizers, and architecture lists. Configs that
-    exclude the current event are skipped.
+def generate_packaging_matrix(config: Config) -> list[dict]:
+    """Emit one entry per os entry with `package: true`. Architecture is
+    hardcoded to linux/amd64 here (and the runner is hardcoded at the
+    workflow level) until arm64 packaging is ready.
     """
-    entries: list[MatrixEntry] = []
+    return [
+        {
+            "artifact_name": f"xrpld-{build_config_name(os, 'linux/amd64', 'Release')}",
+            "os": os,
+        }
+        for os in config.os
+        if os.get("package", False)
+    ]
 
-    for distro, configs in linux.configs.items():
-        for cfg in configs:
-            if not runs_on_event(cfg.exclude_event_types, event):
-                continue
-            # An empty sanitizers list means "one entry with no sanitizer".
-            effective_sanitizers = cfg.sanitizers or [""]
-            effective_archs = {arch: _ARCHS[arch] for arch in cfg.arch}
 
-            for compiler, build_type, sanitizer, (arch, arch_info) in itertools.product(
-                cfg.compiler,
-                cfg.build_type,
-                effective_sanitizers,
-                effective_archs.items(),
+def generate_strategy_matrix(all: bool, config: Config) -> list[dict]:
+    configurations = []
+    for architecture, os, build_type, cmake_args in itertools.product(
+        config.architecture, config.os, config.build_type, config.cmake_args
+    ):
+        # The default CMake target is 'all' for Linux and MacOS and 'install'
+        # for Windows, but it can get overridden for certain configurations.
+        cmake_target = "install" if os["distro_name"] == "windows" else "all"
+
+        # We build and test all configurations by default, except for Windows in
+        # Debug, because it is too slow, as well as when code coverage is
+        # enabled as that mode already runs the tests.
+        build_only = False
+        if os["distro_name"] == "windows" and build_type == "Debug":
+            build_only = True
+
+        # Only generate a subset of configurations in PRs.
+        if not all:
+            # Debian:
+            # - Bookworm using GCC 13: Debug on linux/amd64, set the reference
+            #   fee to 500 and enable code coverage (which will be done below).
+            # - Bookworm using GCC 15: Debug on linux/amd64, enable Address and
+            #   UB sanitizers (which will be done below).
+            # - Bookworm using Clang 16: Debug on linux/amd64, enable voidstar.
+            # - Bookworm using Clang 17: Release on linux/amd64, set the
+            #   reference fee to 1000.
+            # - Bookworm using Clang 20: Debug on linux/amd64, enable Address
+            #   and UB sanitizers (which will be done below).
+            if os["distro_name"] == "debian":
+                skip = True
+                if os["distro_version"] == "bookworm":
+                    if (
+                        f"{os['compiler_name']}-{os['compiler_version']}" == "gcc-13"
+                        and build_type == "Debug"
+                        and architecture["platform"] == "linux/amd64"
+                    ):
+                        cmake_args = f"-DUNIT_TEST_REFERENCE_FEE=500 {cmake_args}"
+                        skip = False
+                    if (
+                        f"{os['compiler_name']}-{os['compiler_version']}" == "gcc-15"
+                        and build_type == "Release"
+                        and architecture["platform"] == "linux/amd64"
+                    ):
+                        skip = False
+                    if (
+                        f"{os['compiler_name']}-{os['compiler_version']}" == "clang-16"
+                        and build_type == "Debug"
+                        and architecture["platform"] == "linux/amd64"
+                    ):
+                        cmake_args = f"-Dvoidstar=ON {cmake_args}"
+                        skip = False
+                    if (
+                        f"{os['compiler_name']}-{os['compiler_version']}" == "clang-17"
+                        and build_type == "Release"
+                        and architecture["platform"] == "linux/amd64"
+                    ):
+                        cmake_args = f"-DUNIT_TEST_REFERENCE_FEE=1000 {cmake_args}"
+                        skip = False
+                elif os["distro_version"] == "trixie":
+                    if (
+                        f"{os['compiler_name']}-{os['compiler_version']}" == "clang-22"
+                        and build_type == "Debug"
+                        and architecture["platform"] == "linux/amd64"
+                    ):
+                        skip = False
+                if skip:
+                    continue
+
+            # RHEL:
+            # - 9 using GCC 12: Debug and Release on linux/amd64
+            #   (Release is required for RPM packaging).
+            # - 10 using Clang: Release on linux/amd64.
+            if os["distro_name"] == "rhel":
+                skip = True
+                if os["distro_version"] == "9":
+                    if (
+                        f"{os['compiler_name']}-{os['compiler_version']}" == "gcc-12"
+                        and build_type in ["Debug", "Release"]
+                        and architecture["platform"] == "linux/amd64"
+                    ):
+                        skip = False
+                elif os["distro_version"] == "10":
+                    if (
+                        f"{os['compiler_name']}-{os['compiler_version']}" == "clang-any"
+                        and build_type == "Release"
+                        and architecture["platform"] == "linux/amd64"
+                    ):
+                        skip = False
+                if skip:
+                    continue
+
+            # Ubuntu:
+            # - Jammy using GCC 12: Debug on linux/arm64, Release on
+            #   linux/amd64 (Release is required for DEB packaging).
+            # - Noble using GCC 14: Release on linux/amd64.
+            # - Noble using Clang 18: Debug on linux/amd64.
+            # - Noble using Clang 19: Release on linux/arm64.
+            if os["distro_name"] == "ubuntu":
+                skip = True
+                if os["distro_version"] == "jammy":
+                    if (
+                        f"{os['compiler_name']}-{os['compiler_version']}" == "gcc-12"
+                        and build_type == "Debug"
+                        and architecture["platform"] == "linux/arm64"
+                    ):
+                        skip = False
+                    if (
+                        f"{os['compiler_name']}-{os['compiler_version']}" == "gcc-12"
+                        and build_type == "Release"
+                        and architecture["platform"] == "linux/amd64"
+                    ):
+                        skip = False
+                elif os["distro_version"] == "noble":
+                    if (
+                        f"{os['compiler_name']}-{os['compiler_version']}" == "gcc-14"
+                        and build_type == "Release"
+                        and architecture["platform"] == "linux/amd64"
+                    ):
+                        skip = False
+                    if (
+                        f"{os['compiler_name']}-{os['compiler_version']}" == "clang-18"
+                        and build_type == "Debug"
+                        and architecture["platform"] == "linux/amd64"
+                    ):
+                        skip = False
+                    if (
+                        f"{os['compiler_name']}-{os['compiler_version']}" == "clang-19"
+                        and build_type == "Release"
+                        and architecture["platform"] == "linux/arm64"
+                    ):
+                        skip = False
+                if skip:
+                    continue
+
+            # MacOS:
+            # - Debug on macos/arm64.
+            if os["distro_name"] == "macos" and not (
+                build_type == "Debug" and architecture["platform"] == "macos/arm64"
             ):
-                name = f"{distro}-{compiler}-{build_type.lower()}-{arch}"
-                suffix_parts = [
-                    s for s in [cfg.suffix, _SANITIZER_SUFFIX.get(sanitizer, "")] if s
-                ]
-                if suffix_parts:
-                    name += "-" + "-".join(suffix_parts)
+                continue
 
-                entries.append(
-                    MatrixEntry(
-                        config_name=name,
-                        image=f"ghcr.io/xrplf/xrpld/nix-{distro}:{linux.image_tag}",
-                        cmake_args=get_cmake_args(build_type, cfg.extra_cmake_args),
-                        cmake_target="all",
-                        build_only=False,
-                        build_type=build_type,
-                        architecture=arch_info,
-                        sanitizers=sanitizer,
-                        compiler=compiler,
-                    )
-                )
+            # Windows:
+            # - Release on windows/amd64.
+            if os["distro_name"] == "windows" and not (
+                build_type == "Release" and architecture["platform"] == "windows/amd64"
+            ):
+                continue
 
-    return entries
+        # Additional CMake arguments.
+        cmake_args = f"{cmake_args} -Dtests=ON -Dwerr=ON -Dxrpld=ON"
+        if not f"{os['compiler_name']}-{os['compiler_version']}" in [
+            "gcc-12",
+            "clang-16",
+        ]:
+            cmake_args = f"{cmake_args} -Dwextra=ON"
+        if build_type == "Release":
+            cmake_args = f"{cmake_args} -Dassert=ON"
 
-
-def expand_linux_packaging(linux: LinuxFile) -> list[PackagingEntry]:
-    """Generate the packaging matrix from a LinuxFile's package_configs section.
-
-    Packaging uses vanilla distro images (debian:bookworm, ubi9, …) instead of
-    the nix-based build images, because deb/rpm tooling (debhelper, rpm-build)
-    is taken from the distro's archive rather than from nixpkgs. Each config
-    entry carries its own 'image'.
-    """
-    entries = []
-    for distro, configs in linux.package_configs.items():
-        for cfg in configs:
-            for compiler, build_type in itertools.product(cfg.compiler, cfg.build_type):
-                entries.append(
-                    PackagingEntry(
-                        artifact_name=f"xrpld-{distro}-{compiler}-{build_type.lower()}-amd64",
-                        image=cfg.image,
-                        distro=distro,
-                    )
-                )
-
-    return entries
-
-
-def expand_platform_matrix(
-    pf: PlatformFile, event: str | None = None
-) -> list[MatrixEntry]:
-    """Expand a PlatformFile (macOS or Windows) into matrix entries.
-
-    Configs that exclude the current event are skipped.
-    """
-    platform_name, arch = pf.platform.split("/")
-    is_windows = platform_name == "windows"
-
-    entries: list[MatrixEntry] = []
-    for cfg in pf.configs:
-        if not runs_on_event(cfg.exclude_event_types, event):
+        # We skip all RHEL on arm64 due to a build failure that needs further
+        # investigation.
+        if os["distro_name"] == "rhel" and architecture["platform"] == "linux/arm64":
             continue
-        for build_type in cfg.build_type:
-            entries.append(
-                MatrixEntry(
-                    config_name=f"{platform_name}-{arch}-{build_type.lower()}",
-                    cmake_args=get_cmake_args(build_type, cfg.extra_cmake_args),
-                    cmake_target="install" if is_windows else "all",
-                    build_only=cfg.build_only,
-                    build_type=build_type,
-                    architecture=Architecture(platform=pf.platform, runner=pf.runner),
-                    sanitizers="",
-                )
+
+        # We skip all clang 20+ on arm64 due to Boost build error.
+        if (
+            os["compiler_name"] == "clang"
+            and os["compiler_version"].isdigit()
+            and int(os["compiler_version"]) >= 20
+            and architecture["platform"] == "linux/arm64"
+        ):
+            continue
+
+        # Enable code coverage for Debian Bookworm using GCC 13 in Debug on
+        # linux/amd64.
+        if (
+            f"{os['distro_name']}-{os['distro_version']}" == "debian-bookworm"
+            and f"{os['compiler_name']}-{os['compiler_version']}" == "gcc-13"
+            and build_type == "Debug"
+            and architecture["platform"] == "linux/amd64"
+        ):
+            cmake_args = f"{cmake_args} -Dcoverage=ON -Dcoverage_format=xml -DCODE_COVERAGE_VERBOSE=ON -DCMAKE_C_FLAGS=-O0 -DCMAKE_CXX_FLAGS=-O0"
+
+        # Enable unity build for Ubuntu Jammy using GCC 12 in Debug on
+        # linux/amd64.
+        if (
+            f"{os['distro_name']}-{os['distro_version']}" == "ubuntu-jammy"
+            and f"{os['compiler_name']}-{os['compiler_version']}" == "gcc-12"
+            and build_type == "Debug"
+            and architecture["platform"] == "linux/amd64"
+        ):
+            cmake_args = f"{cmake_args} -Dunity=ON"
+
+        # Generate a unique name for the configuration, e.g. macos-arm64-debug
+        # or debian-bookworm-gcc-12-amd64-release.
+        config_name = build_config_name(os, architecture["platform"], build_type)
+        if "-Dcoverage=ON" in cmake_args:
+            config_name += "-coverage"
+        if "-Dunity=ON" in cmake_args:
+            config_name += "-unity"
+
+        # Add the configuration to the list, with the most unique fields first,
+        # so that they are easier to identify in the GitHub Actions UI, as long
+        # names get truncated.
+        # Add Address and UB sanitizers as separate configurations for specific
+        # bookworm distros. Thread sanitizer is currently disabled (see below).
+        # GCC-Asan xrpld-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']}" == "gcc-15"
+        ) or (
+            os["distro_version"] == "trixie"
+            and f"{os['compiler_name']}-{os['compiler_version']}" == "clang-22"
+        ):
+            # Add ASAN and UBSAN configurations for both gcc-15 and clang-22
+            configurations.append(
+                {
+                    "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",
+                }
             )
-    return entries
+            configurations.append(
+                {
+                    "config_name": config_name + "-ubsan",
+                    "cmake_args": cmake_args,
+                    "cmake_target": cmake_target,
+                    "build_only": build_only,
+                    "build_type": build_type,
+                    "os": os,
+                    "architecture": architecture,
+                    "sanitizers": "undefinedbehavior",
+                }
+            )
+            # TSAN is deactivated due to seg faults with latest compilers.
+            activate_tsan = False
+            if activate_tsan:
+                configurations.append(
+                    {
+                        "config_name": config_name + "-tsan-ubsan",
+                        "cmake_args": cmake_args,
+                        "cmake_target": cmake_target,
+                        "build_only": build_only,
+                        "build_type": build_type,
+                        "os": os,
+                        "architecture": architecture,
+                        "sanitizers": "thread,undefinedbehavior",
+                    }
+                )
+        else:
+            configurations.append(
+                {
+                    "config_name": config_name,
+                    "cmake_args": cmake_args,
+                    "cmake_target": cmake_target,
+                    "build_only": build_only,
+                    "build_type": build_type,
+                    "os": os,
+                    "architecture": architecture,
+                    "sanitizers": "",
+                }
+            )
+
+    return configurations
 
 
-# ---------------------------------------------------------------------------
-# Entry point
-# ---------------------------------------------------------------------------
+def read_config(file: Path) -> Config:
+    config = json.loads(file.read_text())
+    if (
+        config["architecture"] is None
+        or config["os"] is None
+        or config["build_type"] is None
+        or config["cmake_args"] is None
+    ):
+        raise Exception("Invalid configuration file.")
+
+    return Config(**config)
 
 
 if __name__ == "__main__":
-    parser = argparse.ArgumentParser(
-        description="Generate a CI strategy matrix for all platforms or a specific one."
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "-a",
+        "--all",
+        help="Set to generate all configurations (generally used when merging a PR) or leave unset to generate a subset of configurations (generally used when committing to a PR).",
+        action="store_true",
     )
     parser.add_argument(
         "-c",
         "--config",
-        help="Platform to generate for ('linux', 'macos', or 'windows'). Defaults to all platforms.",
-        choices=["linux", "macos", "windows"],
-        default=None,
+        help="Path to the JSON file containing the strategy matrix configurations.",
+        required=False,
+        type=Path,
     )
     parser.add_argument(
         "-p",
         "--packaging",
-        help="Emit the Linux packaging matrix instead of the build/test matrix.",
+        help="Emit the packaging matrix (derived from the 'package' field on os entries) instead of the build/test matrix.",
         action="store_true",
     )
-    parser.add_argument(
-        "-e",
-        "--event",
-        help="The GitHub event name that triggered the workflow (e.g. 'push', "
-        "'pull_request'). Configs are filtered by their 'event_type'. If "
-        "omitted, no filtering is applied.",
-        default=None,
-    )
     args = parser.parse_args()
 
-    matrix: list[MatrixEntry] | list[PackagingEntry] = []
-
+    matrix = []
     if args.packaging:
-        matrix = expand_linux_packaging(LinuxFile.load(THIS_DIR / "linux.json"))
+        config_path = args.config if args.config else THIS_DIR / "linux.json"
+        matrix += generate_packaging_matrix(read_config(config_path))
+    elif args.config is None or args.config == "":
+        matrix += generate_strategy_matrix(
+            args.all, read_config(THIS_DIR / "linux.json")
+        )
+        matrix += generate_strategy_matrix(
+            args.all, read_config(THIS_DIR / "macos.json")
+        )
+        matrix += generate_strategy_matrix(
+            args.all, read_config(THIS_DIR / "windows.json")
+        )
     else:
-        if args.config in ("linux", None):
-            matrix += expand_linux_matrix(
-                LinuxFile.load(THIS_DIR / "linux.json"), args.event
-            )
-        if args.config in ("macos", None):
-            matrix += expand_platform_matrix(
-                PlatformFile.load(THIS_DIR / "macos.json"), args.event
-            )
-        if args.config in ("windows", None):
-            matrix += expand_platform_matrix(
-                PlatformFile.load(THIS_DIR / "windows.json"), args.event
-            )
+        matrix += generate_strategy_matrix(args.all, read_config(args.config))
 
-    print(f"matrix={json.dumps({'include': [dataclasses.asdict(e) for e in matrix]})}")
+    # Generate the strategy matrix.
+    print(f"matrix={json.dumps({'include': matrix})}")

.github/scripts/strategy-matrix/linux.json

@@ -1,84 +1,221 @@
 {
-  "image_tag": "sha-e29b523",
-  "configs": {
-    "ubuntu": [
-      {
-        "compiler": ["gcc", "clang"],
-        "build_type": ["Debug", "Release"],
-        "arch": ["amd64", "arm64"]
-      },
-
-      {
-        "compiler": ["gcc", "clang"],
-        "build_type": ["Debug", "Release"],
-        "arch": ["amd64"],
-        "sanitizers": ["address", "undefinedbehavior"]
-      },
-
-      {
-        "compiler": ["gcc"],
-        "build_type": ["Debug"],
-        "arch": ["amd64"],
-        "suffix": "coverage",
-        "extra_cmake_args": "-DUNIT_TEST_REFERENCE_FEE=500 -Dcoverage=ON -Dcoverage_format=xml -DCODE_COVERAGE_VERBOSE=ON -DCMAKE_C_FLAGS=-O0 -DCMAKE_CXX_FLAGS=-O0"
-      },
-      {
-        "compiler": ["clang"],
-        "build_type": ["Debug"],
-        "arch": ["amd64"],
-        "suffix": "voidstar",
-        "extra_cmake_args": "-Dvoidstar=ON"
-      },
-      {
-        "compiler": ["clang"],
-        "build_type": ["Release"],
-        "arch": ["amd64"],
-        "suffix": "reffee",
-        "extra_cmake_args": "-DUNIT_TEST_REFERENCE_FEE=1000"
-      },
-      {
-        "compiler": ["gcc"],
-        "build_type": ["Debug"],
-        "arch": ["amd64"],
-        "suffix": "unity",
-        "extra_cmake_args": "-Dunity=ON",
-        "exclude_event_types": ["pull_request"]
-      }
-    ],
-
-    "debian": [
-      {
-        "compiler": ["gcc"],
-        "build_type": ["Release"],
-        "arch": ["amd64"]
-      }
-    ],
-
-    "rhel": [
-      {
-        "compiler": ["gcc"],
-        "build_type": ["Release"],
-        "arch": ["amd64"]
-      }
-    ]
-  },
-  "package_configs": {
-    "debian": [
-      {
-        "compiler": ["gcc"],
-        "build_type": ["Release"],
-        "arch": ["amd64"],
-        "image": "ghcr.io/xrplf/xrpld/packaging-debian:sha-577d745"
-      }
-    ],
-
-    "rhel": [
-      {
-        "compiler": ["gcc"],
-        "build_type": ["Release"],
-        "arch": ["amd64"],
-        "image": "ghcr.io/xrplf/xrpld/packaging-rhel:sha-577d745"
-      }
-    ]
-  }
+  "architecture": [
+    {
+      "platform": "linux/amd64",
+      "runner": ["self-hosted", "Linux", "X64", "heavy"]
+    },
+    {
+      "platform": "linux/arm64",
+      "runner": ["self-hosted", "Linux", "ARM64", "heavy-arm64"]
+    }
+  ],
+  "os": [
+    {
+      "distro_name": "debian",
+      "distro_version": "bookworm",
+      "compiler_name": "gcc",
+      "compiler_version": "12",
+      "image_sha": "4c086b9"
+    },
+    {
+      "distro_name": "debian",
+      "distro_version": "bookworm",
+      "compiler_name": "gcc",
+      "compiler_version": "13",
+      "image_sha": "4c086b9"
+    },
+    {
+      "distro_name": "debian",
+      "distro_version": "bookworm",
+      "compiler_name": "gcc",
+      "compiler_version": "14",
+      "image_sha": "4c086b9"
+    },
+    {
+      "distro_name": "debian",
+      "distro_version": "bookworm",
+      "compiler_name": "gcc",
+      "compiler_version": "15",
+      "image_sha": "4c086b9"
+    },
+    {
+      "distro_name": "debian",
+      "distro_version": "bookworm",
+      "compiler_name": "clang",
+      "compiler_version": "16",
+      "image_sha": "4c086b9"
+    },
+    {
+      "distro_name": "debian",
+      "distro_version": "bookworm",
+      "compiler_name": "clang",
+      "compiler_version": "17",
+      "image_sha": "4c086b9"
+    },
+    {
+      "distro_name": "debian",
+      "distro_version": "bookworm",
+      "compiler_name": "clang",
+      "compiler_version": "18",
+      "image_sha": "4c086b9"
+    },
+    {
+      "distro_name": "debian",
+      "distro_version": "bookworm",
+      "compiler_name": "clang",
+      "compiler_version": "19",
+      "image_sha": "4c086b9"
+    },
+    {
+      "distro_name": "debian",
+      "distro_version": "bookworm",
+      "compiler_name": "clang",
+      "compiler_version": "20",
+      "image_sha": "4c086b9"
+    },
+    {
+      "distro_name": "debian",
+      "distro_version": "trixie",
+      "compiler_name": "gcc",
+      "compiler_version": "14",
+      "image_sha": "4c086b9"
+    },
+    {
+      "distro_name": "debian",
+      "distro_version": "trixie",
+      "compiler_name": "gcc",
+      "compiler_version": "15",
+      "image_sha": "4c086b9"
+    },
+    {
+      "distro_name": "debian",
+      "distro_version": "trixie",
+      "compiler_name": "clang",
+      "compiler_version": "20",
+      "image_sha": "4c086b9"
+    },
+    {
+      "distro_name": "debian",
+      "distro_version": "trixie",
+      "compiler_name": "clang",
+      "compiler_version": "21",
+      "image_sha": "4c086b9"
+    },
+    {
+      "distro_name": "debian",
+      "distro_version": "trixie",
+      "compiler_name": "clang",
+      "compiler_version": "22",
+      "image_sha": "4c086b9"
+    },
+    {
+      "distro_name": "rhel",
+      "distro_version": "8",
+      "compiler_name": "gcc",
+      "compiler_version": "14",
+      "image_sha": "4c086b9"
+    },
+    {
+      "distro_name": "rhel",
+      "distro_version": "8",
+      "compiler_name": "clang",
+      "compiler_version": "any",
+      "image_sha": "4c086b9"
+    },
+    {
+      "distro_name": "rhel",
+      "distro_version": "9",
+      "compiler_name": "gcc",
+      "compiler_version": "12",
+      "image_sha": "4c086b9",
+      "package": true
+    },
+    {
+      "distro_name": "rhel",
+      "distro_version": "9",
+      "compiler_name": "gcc",
+      "compiler_version": "13",
+      "image_sha": "4c086b9"
+    },
+    {
+      "distro_name": "rhel",
+      "distro_version": "9",
+      "compiler_name": "gcc",
+      "compiler_version": "14",
+      "image_sha": "4c086b9"
+    },
+    {
+      "distro_name": "rhel",
+      "distro_version": "9",
+      "compiler_name": "clang",
+      "compiler_version": "any",
+      "image_sha": "4c086b9"
+    },
+    {
+      "distro_name": "rhel",
+      "distro_version": "10",
+      "compiler_name": "gcc",
+      "compiler_version": "14",
+      "image_sha": "4c086b9"
+    },
+    {
+      "distro_name": "rhel",
+      "distro_version": "10",
+      "compiler_name": "clang",
+      "compiler_version": "any",
+      "image_sha": "4c086b9"
+    },
+    {
+      "distro_name": "ubuntu",
+      "distro_version": "jammy",
+      "compiler_name": "gcc",
+      "compiler_version": "12",
+      "image_sha": "4c086b9",
+      "package": true
+    },
+    {
+      "distro_name": "ubuntu",
+      "distro_version": "noble",
+      "compiler_name": "gcc",
+      "compiler_version": "13",
+      "image_sha": "4c086b9"
+    },
+    {
+      "distro_name": "ubuntu",
+      "distro_version": "noble",
+      "compiler_name": "gcc",
+      "compiler_version": "14",
+      "image_sha": "4c086b9"
+    },
+    {
+      "distro_name": "ubuntu",
+      "distro_version": "noble",
+      "compiler_name": "clang",
+      "compiler_version": "16",
+      "image_sha": "4c086b9"
+    },
+    {
+      "distro_name": "ubuntu",
+      "distro_version": "noble",
+      "compiler_name": "clang",
+      "compiler_version": "17",
+      "image_sha": "4c086b9"
+    },
+    {
+      "distro_name": "ubuntu",
+      "distro_version": "noble",
+      "compiler_name": "clang",
+      "compiler_version": "18",
+      "image_sha": "4c086b9"
+    },
+    {
+      "distro_name": "ubuntu",
+      "distro_version": "noble",
+      "compiler_name": "clang",
+      "compiler_version": "19",
+      "image_sha": "4c086b9"
+    }
+  ],
+  "build_type": ["Debug", "Release"],
+  "cmake_args": [""]
 }

.github/scripts/strategy-matrix/macos.json

@@ -1,16 +1,19 @@
 {
-  "platform": "macos/arm64",
-  "runner": ["self-hosted", "macOS", "ARM64", "macos-26-apple-clang-21"],
-  "configs": [
+  "architecture": [
     {
-      "build_type": "Release",
-      "extra_cmake_args": "-DCMAKE_POLICY_VERSION_MINIMUM=3.5"
-    },
-    {
-      "build_type": "Debug",
-      "extra_cmake_args": "-DCMAKE_POLICY_VERSION_MINIMUM=3.5",
-      "build_only": true,
-      "exclude_event_types": ["pull_request"]
+      "platform": "macos/arm64",
+      "runner": ["self-hosted", "macOS", "ARM64", "mac-runner-m1"]
     }
-  ]
+  ],
+  "os": [
+    {
+      "distro_name": "macos",
+      "distro_version": "",
+      "compiler_name": "",
+      "compiler_version": "",
+      "image_sha": ""
+    }
+  ],
+  "build_type": ["Debug", "Release"],
+  "cmake_args": ["-DCMAKE_POLICY_VERSION_MINIMUM=3.5"]
 }

.github/scripts/strategy-matrix/windows.json

@@ -1,12 +1,19 @@
 {
-  "platform": "windows/amd64",
-  "runner": ["self-hosted", "Windows", "dev-box-windows-2026"],
-  "configs": [
-    { "build_type": "Release" },
+  "architecture": [
     {
-      "build_type": "Debug",
-      "build_only": true,
-      "exclude_event_types": ["pull_request"]
+      "platform": "windows/amd64",
+      "runner": ["self-hosted", "Windows", "devbox"]
     }
-  ]
+  ],
+  "os": [
+    {
+      "distro_name": "windows",
+      "distro_version": "",
+      "compiler_name": "",
+      "compiler_version": "",
+      "image_sha": ""
+    }
+  ],
+  "build_type": ["Debug", "Release"],
+  "cmake_args": [""]
 }

.github/workflows/build-nix-image.yml

@@ -0,0 +1,109 @@
+name: Build Nix Docker image
+
+on:
+  push:
+    branches:
+      - develop
+    paths:
+      - ".github/workflows/build-nix-image.yml"
+      - ".github/workflows/reusable-build-docker-image.yml"
+      - "docker/**"
+      - "flake.nix"
+      - "flake.lock"
+      - "nix/**"
+  pull_request:
+    paths:
+      - ".github/workflows/build-nix-image.yml"
+      - ".github/workflows/reusable-build-docker-image.yml"
+      - "docker/**"
+      - "flake.nix"
+      - "flake.lock"
+      - "nix/**"
+  workflow_dispatch:
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+defaults:
+  run:
+    shell: bash
+
+jobs:
+  build:
+    name: Build ${{ matrix.distro.name }} (${{ matrix.target.platform }})
+    permissions:
+      contents: read
+      packages: write
+    strategy:
+      fail-fast: false
+      matrix:
+        # The base images are the oldest supported version of each distro
+        # that we want to build images for.
+        distro:
+          - name: nixos
+            base_image: nixos/nix:latest
+          - name: ubuntu
+            base_image: ubuntu:20.04
+          - name: rhel
+            base_image: registry.access.redhat.com/ubi9/ubi:latest
+          - name: debian
+            base_image: debian:bookworm
+        target:
+          - platform: linux/amd64
+            runner: ubuntu-latest
+          - platform: linux/arm64
+            runner: ubuntu-24.04-arm
+    uses: ./.github/workflows/reusable-build-docker-image.yml
+    with:
+      image_name: ghcr.io/xrplf/xrpld/nix-${{ matrix.distro.name }}
+      dockerfile: docker/nix.Dockerfile
+      base_image: ${{ matrix.distro.base_image }}
+      platform: ${{ matrix.target.platform }}
+      runner: ${{ matrix.target.runner }}
+      push: ${{ github.repository == 'XRPLF/rippled' && github.event_name == 'push' }}
+
+  merge:
+    name: Merge ${{ matrix.distro }} manifest
+    needs: build
+    if: ${{ github.repository == 'XRPLF/rippled' && github.event_name == 'push' }}
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+    strategy:
+      fail-fast: false
+      matrix:
+        distro: [nixos, ubuntu, rhel, debian]
+    env:
+      IMAGE_NAME: ghcr.io/xrplf/xrpld/nix-${{ matrix.distro }}
+
+    steps:
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@d7f5e7f509e45cec5c76c4d5afdd7de93d0b3df5 # v4.1.0
+
+      - name: Docker metadata
+        id: meta
+        uses: docker/metadata-action@80c7e94dd9b9319bd5eb7a0e0fe9291e23a2a2e9 # v6.1.0
+        with:
+          images: ${{ env.IMAGE_NAME }}
+          tags: |
+            type=sha,prefix=sha-,format=short
+            type=raw,value=latest
+
+      - name: Login to GitHub Container Registry
+        uses: docker/login-action@650006c6eb7dba73a995cc03b0b2d7f5ca915bee # v4.2.0
+        with:
+          registry: ghcr.io
+          username: ${{ github.repository_owner }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Create multi-arch manifests
+        run: |
+          for tag in $(jq -cr '.tags[]' <<<"$DOCKER_METADATA_OUTPUT_JSON"); do
+              docker buildx imagetools create -t "$tag" "${tag}-amd64" "${tag}-arm64"
+          done
+
+      - name: Inspect image
+        run: |
+          docker buildx imagetools inspect "${IMAGE_NAME}:${{ steps.meta.outputs.version }}"

.github/workflows/build-nix-images.yml

@@ -1,62 +0,0 @@
-name: Build Nix Docker images
-
-on:
-  push:
-    branches:
-      - develop
-    paths:
-      - ".github/workflows/build-nix-images.yml"
-      - "flake.nix"
-      - "flake.lock"
-      - "nix/**"
-      - "!nix/docker/README.md"
-      - "!nix/devshell.nix"
-      - "bin/check-tools.sh"
-      - "bin/install-sanitizer-libs.sh"
-  pull_request:
-    paths:
-      - ".github/workflows/build-nix-images.yml"
-      - "flake.nix"
-      - "flake.lock"
-      - "nix/**"
-      - "!nix/docker/README.md"
-      - "!nix/devshell.nix"
-      - "bin/check-tools.sh"
-      - "bin/install-sanitizer-libs.sh"
-  workflow_dispatch:
-
-concurrency:
-  # Read `on-trigger.yml` for the rationale behind this concurrency group name.
-  group: ${{ github.workflow }}-${{ github.event_name == 'push' && github.ref == 'refs/heads/develop' && github.sha || github.ref }}
-  cancel-in-progress: true
-
-defaults:
-  run:
-    shell: bash
-
-jobs:
-  build-merge:
-    name: Build and push nix-${{ matrix.distro.name }}
-    permissions:
-      contents: read
-      packages: write
-    strategy:
-      fail-fast: false
-      matrix:
-        # The base images are the oldest supported version of each distro
-        # that we want to build images for.
-        distro:
-          - name: nixos
-            base_image: nixos/nix:latest
-          - name: ubuntu
-            base_image: ubuntu:20.04
-          - name: debian
-            base_image: debian:bookworm
-          - name: rhel
-            base_image: registry.access.redhat.com/ubi9/ubi:latest
-    uses: XRPLF/actions/.github/workflows/build-multiarch-image.yml@ee03d31bcc4501d7599dc1b1ecd7a34af582ad1c
-    with:
-      image_name: xrpld/nix-${{ matrix.distro.name }}
-      dockerfile: nix/docker/Dockerfile
-      base_image: ${{ matrix.distro.base_image }}
-      push: ${{ github.event_name == 'push' }}

.github/workflows/build-packaging-images.yml

@@ -1,46 +0,0 @@
-name: Build packaging Docker images
-
-on:
-  push:
-    branches:
-      - develop
-    paths:
-      - ".github/workflows/build-packaging-images.yml"
-      - "package/Dockerfile"
-      - "package/install-packaging-tools.sh"
-  pull_request:
-    paths:
-      - ".github/workflows/build-packaging-images.yml"
-      - "package/Dockerfile"
-      - "package/install-packaging-tools.sh"
-  workflow_dispatch:
-
-concurrency:
-  # Read `on-trigger.yml` for the rationale behind this concurrency group name.
-  group: ${{ github.workflow }}-${{ github.event_name == 'push' && github.ref == 'refs/heads/develop' && github.sha || github.ref }}
-  cancel-in-progress: true
-
-defaults:
-  run:
-    shell: bash
-
-jobs:
-  build-merge:
-    name: Build and push packaging-${{ matrix.distro.name }}
-    permissions:
-      contents: read
-      packages: write
-    strategy:
-      fail-fast: false
-      matrix:
-        distro:
-          - name: debian
-            base_image: debian:bookworm
-          - name: rhel
-            base_image: registry.access.redhat.com/ubi9/ubi:latest
-    uses: XRPLF/actions/.github/workflows/build-multiarch-image.yml@ee03d31bcc4501d7599dc1b1ecd7a34af582ad1c
-    with:
-      image_name: xrpld/packaging-${{ matrix.distro.name }}
-      dockerfile: package/Dockerfile
-      base_image: ${{ matrix.distro.base_image }}
-      push: ${{ github.event_name == 'push' }}

.github/workflows/check-pr-description.yml

@@ -23,7 +23,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout repository
-        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
 
       - name: Write PR body to file
         env:

.github/workflows/conflicting-pr.yml

@@ -17,7 +17,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Check if PRs are dirty
-        uses: eps1lon/actions-label-merge-conflict@0273be72a0bbd58fcd71d0d6c02c209b50d1e5e1 # v3.1.0
+        uses: eps1lon/actions-label-merge-conflict@1df065ebe6e3310545d4f4c4e862e43bdca146f0 # v3.0.3
         with:
           dirtyLabel: "PR: has conflicts"
           repoToken: "${{ secrets.GITHUB_TOKEN }}"

.github/workflows/on-pr.yml

@@ -33,7 +33,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout repository
-        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
       - name: Determine changed files
         # This step checks whether any files have changed that should
         # cause the next jobs to run. We do it this way rather than
@@ -70,7 +70,6 @@ jobs:
             .github/workflows/reusable-upload-recipe.yml
             .clang-tidy
             .codecov.yml
-            bin/check-tools.sh
             cfg/**
             cmake/**
             conan/**
@@ -122,6 +121,7 @@ jobs:
       issues: write
       contents: read
     with:
+      check_only_changed: true
       create_issue_on_failure: false
 
   build-test:
@@ -153,8 +153,8 @@ jobs:
     if: ${{ github.repository == 'XRPLF/rippled' && needs.should-run.outputs.go == 'true' && github.event_name == 'pull_request' && startsWith(github.event.pull_request.base.ref, 'release') }}
     uses: ./.github/workflows/reusable-upload-recipe.yml
     secrets:
-      remote_username: ${{ secrets.NEXUS_REMOTE_USERNAME }}
-      remote_password: ${{ secrets.NEXUS_REMOTE_PASSWORD }}
+      remote_username: ${{ secrets.CONAN_REMOTE_USERNAME }}
+      remote_password: ${{ secrets.CONAN_REMOTE_PASSWORD }}
 
   notify-clio:
     needs: upload-recipe

.github/workflows/on-tag.yml

@@ -20,8 +20,8 @@ jobs:
     if: ${{ github.repository == 'XRPLF/rippled' }}
     uses: ./.github/workflows/reusable-upload-recipe.yml
     secrets:
-      remote_username: ${{ secrets.NEXUS_REMOTE_USERNAME }}
-      remote_password: ${{ secrets.NEXUS_REMOTE_PASSWORD }}
+      remote_username: ${{ secrets.CONAN_REMOTE_USERNAME }}
+      remote_password: ${{ secrets.CONAN_REMOTE_PASSWORD }}
 
   build-test:
     if: ${{ github.repository == 'XRPLF/rippled' }}
@@ -33,6 +33,7 @@ jobs:
     with:
       ccache_enabled: false
       os: ${{ matrix.os }}
+      strategy_matrix: minimal
     secrets:
       CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
 

.github/workflows/on-trigger.yml

@@ -27,7 +27,6 @@ on:
       - ".github/workflows/reusable-upload-recipe.yml"
       - ".clang-tidy"
       - ".codecov.yml"
-      - "bin/check-tools.sh"
       - "cfg/**"
       - "cmake/**"
       - "conan/**"
@@ -72,6 +71,7 @@ jobs:
       issues: write
       contents: read
     with:
+      check_only_changed: false
       create_issue_on_failure: ${{ github.event_name == 'schedule' }}
 
   build-test:
@@ -88,6 +88,7 @@ jobs:
       # not identical to a regular compilation.
       ccache_enabled: ${{ github.repository_owner == 'XRPLF' && !startsWith(github.ref, 'refs/heads/release') }}
       os: ${{ matrix.os }}
+      strategy_matrix: ${{ github.event_name == 'schedule' && 'all' || 'minimal' }}
     secrets:
       CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
 
@@ -97,8 +98,8 @@ jobs:
     if: ${{ github.repository == 'XRPLF/rippled' && github.event_name == 'push' && github.ref == 'refs/heads/develop' }}
     uses: ./.github/workflows/reusable-upload-recipe.yml
     secrets:
-      remote_username: ${{ secrets.NEXUS_REMOTE_USERNAME }}
-      remote_password: ${{ secrets.NEXUS_REMOTE_PASSWORD }}
+      remote_username: ${{ secrets.CONAN_REMOTE_USERNAME }}
+      remote_password: ${{ secrets.CONAN_REMOTE_PASSWORD }}
 
   package:
     needs: build-test

.github/workflows/pre-commit.yml

@@ -14,7 +14,7 @@ on:
 jobs:
   # Call the workflow in the XRPLF/actions repo that runs the pre-commit hooks.
   run-hooks:
-    uses: XRPLF/actions/.github/workflows/pre-commit.yml@1bde119a1ab71305ba5d3716e7a82cea1c7bdede
+    uses: XRPLF/actions/.github/workflows/pre-commit.yml@cba1f0891650baf1a9c88624dc2d72573be2eb81
     with:
       runs_on: ubuntu-latest
       container: '{ "image": "ghcr.io/xrplf/ci/tools-rippled-pre-commit:sha-41ec7c1" }'

.github/workflows/publish-docs.yml

@@ -41,13 +41,13 @@ env:
 jobs:
   build:
     runs-on: ubuntu-latest
-    container: ghcr.io/xrplf/xrpld/nix-ubuntu:sha-e29b523
+    container: ghcr.io/xrplf/ci/tools-rippled-documentation:sha-a8c7be1
     steps:
       - name: Checkout repository
-        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
 
       - name: Prepare runner
-        uses: XRPLF/actions/prepare-runner@64ec3cf3b152b4444638f470bbd6df7a7a30c81c
+        uses: XRPLF/actions/prepare-runner@90f11ee655d1687824fb8793db770477d52afbab
         with:
           enable_ccache: false
 
@@ -57,11 +57,19 @@ jobs:
         with:
           subtract: ${{ env.NPROC_SUBTRACT }}
 
-      - name: Print build environment
-        uses: XRPLF/actions/print-build-env@59dec886e4afb05a1724443af08baccbc045b574
+      - name: Check configuration
+        run: |
+          echo 'Checking path.'
+          echo ${PATH} | tr ':' '\n'
 
-      - name: Check Doxygen version
-        run: doxygen --version
+          echo 'Checking environment variables.'
+          env | sort
+
+          echo 'Checking CMake version.'
+          cmake --version
+
+          echo 'Checking Doxygen version.'
+          doxygen --version
 
       - name: Build documentation
         env:

.github/workflows/reusable-build-docker-image.yml

@@ -0,0 +1,89 @@
+# Build a single-platform Docker image. On push, the image is pushed to
+# GHCR with arch-suffixed tags (e.g. `:latest-amd64`, `:sha-abc-amd64`)
+# so the calling workflow can stitch per-arch builds into a multi-arch
+# manifest without needing to pass digests around.
+name: Reusable build Docker image (single platform)
+
+on:
+  workflow_call:
+    inputs:
+      image_name:
+        description: "Full image name without tag (e.g. 'ghcr.io/xrplf/xrpld/nix-ubuntu')"
+        required: true
+        type: string
+      dockerfile:
+        description: "Path to the Dockerfile, relative to the repository root"
+        required: true
+        type: string
+      base_image:
+        description: "Value passed to the Dockerfile as the BASE_IMAGE build arg"
+        required: true
+        type: string
+      platform:
+        description: "Docker platform string, e.g. linux/amd64"
+        required: true
+        type: string
+      runner:
+        description: "GitHub Actions runner label to build on"
+        required: true
+        type: string
+      push:
+        description: "Whether to push the image to GHCR"
+        required: true
+        type: boolean
+
+defaults:
+  run:
+    shell: bash
+
+jobs:
+  build:
+    name: Build (${{ inputs.platform }})
+    runs-on: ${{ inputs.runner }}
+    permissions:
+      contents: read
+      packages: write
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+
+      - name: Determine arch
+        id: vars
+        env:
+          PLATFORM: ${{ inputs.platform }}
+        run: |
+          echo "arch=${PLATFORM##*/}" >>$GITHUB_OUTPUT
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@d7f5e7f509e45cec5c76c4d5afdd7de93d0b3df5 # v4.1.0
+
+      - name: Login to GitHub Container Registry
+        if: inputs.push
+        uses: docker/login-action@650006c6eb7dba73a995cc03b0b2d7f5ca915bee # v4.2.0
+        with:
+          registry: ghcr.io
+          username: ${{ github.repository_owner }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Docker metadata
+        id: meta
+        uses: docker/metadata-action@80c7e94dd9b9319bd5eb7a0e0fe9291e23a2a2e9 # v6.1.0
+        with:
+          images: ${{ inputs.image_name }}
+          tags: |
+            type=sha,prefix=sha-,format=short
+            type=raw,value=latest
+          flavor: |
+            suffix=-${{ steps.vars.outputs.arch }},onlatest=true
+
+      - name: Build and push
+        uses: docker/build-push-action@f9f3042f7e2789586610d6e8b85c8f03e5195baf # v7.2.0
+        with:
+          context: .
+          file: ${{ inputs.dockerfile }}
+          platforms: ${{ inputs.platform }}
+          push: ${{ inputs.push }}
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}
+          build-args: BASE_IMAGE=${{ inputs.base_image }}

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

@@ -57,12 +57,6 @@ on:
         type: string
         default: ""
 
-      compiler:
-        description: 'The compiler to use ("gcc" or "clang"). Leave empty for macOS/Windows (uses system default).'
-        required: false
-        type: string
-        default: ""
-
     secrets:
       CODECOV_TOKEN:
         description: "The Codecov token to use for uploading coverage reports."
@@ -82,7 +76,7 @@ jobs:
     name: ${{ inputs.config_name }}
     runs-on: ${{ fromJSON(inputs.runs_on) }}
     container: ${{ inputs.image != '' && inputs.image || null }}
-    timeout-minutes: ${{ inputs.sanitizers != '' && 360 || 180 }}
+    timeout-minutes: ${{ inputs.sanitizers != '' && 360 || 60 }}
     env:
       # Use a namespace to keep the objects separate for each configuration.
       CCACHE_NAMESPACE: ${{ inputs.config_name }}
@@ -110,10 +104,10 @@ jobs:
         uses: XRPLF/actions/cleanup-workspace@c7d9ce5ebb03c752a354889ecd870cadfc2b1cd4
 
       - name: Checkout repository
-        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
 
       - name: Prepare runner
-        uses: XRPLF/actions/prepare-runner@64ec3cf3b152b4444638f470bbd6df7a7a30c81c
+        uses: XRPLF/actions/prepare-runner@90f11ee655d1687824fb8793db770477d52afbab
         with:
           enable_ccache: ${{ inputs.ccache_enabled }}
 
@@ -121,11 +115,6 @@ jobs:
         if: ${{ inputs.ccache_enabled && runner.debug == '1' }}
         run: echo "CCACHE_LOGFILE=${{ runner.temp }}/ccache.log" >>"${GITHUB_ENV}"
 
-      - name: Check tools
-        env:
-          CHECK_TOOLS_SKIP_CLONE: "1"
-        run: ./bin/check-tools.sh
-
       - name: Print build environment
         uses: XRPLF/actions/print-build-env@59dec886e4afb05a1724443af08baccbc045b574
 
@@ -135,12 +124,6 @@ jobs:
         with:
           subtract: ${{ inputs.nproc_subtract }}
 
-      - name: Set compiler environment (Linux)
-        if: ${{ runner.os == 'Linux' }}
-        uses: ./.github/actions/set-compiler-env
-        with:
-          compiler: ${{ inputs.compiler }}
-
       - name: Setup Conan
         env:
           SANITIZERS: ${{ inputs.sanitizers }}
@@ -163,33 +146,12 @@ jobs:
           CMAKE_ARGS: ${{ inputs.cmake_args }}
         run: |
           cmake \
-              -G '${{ runner.os == 'Windows' && 'Visual Studio 18 2026' || 'Ninja' }}' \
+              -G '${{ runner.os == 'Windows' && 'Visual Studio 17 2022' || 'Ninja' }}' \
               -DCMAKE_TOOLCHAIN_FILE:FILEPATH=build/generators/conan_toolchain.cmake \
               -DCMAKE_BUILD_TYPE="${BUILD_TYPE}" \
               ${CMAKE_ARGS} \
               ..
 
-      # Export the sanitizer options before any instrumented binary runs. The
-      # protocol code-gen and build steps below invoke instrumented dependency
-      # tools (protoc, grpc), so setting UBSAN_OPTIONS here lets the UBSan
-      # suppression list silence their diagnostics too, not just at test time.
-      # GITHUB_WORKSPACE (not the github.workspace context) is used so the path
-      # resolves correctly inside the container job.
-      - name: Set sanitizer options
-        if: ${{ !inputs.build_only && env.SANITIZERS_ENABLED == 'true' }}
-        env:
-          CONFIG_NAME: ${{ inputs.config_name }}
-        run: |
-          SUPP="${GITHUB_WORKSPACE}/sanitizers/suppressions"
-          ASAN_OPTS="include=${SUPP}/runtime-asan-options.txt:suppressions=${SUPP}/asan.supp"
-          if [[ "${CONFIG_NAME}" == *gcc* ]]; then
-              ASAN_OPTS="${ASAN_OPTS}:alloc_dealloc_mismatch=0"
-          fi
-          echo "ASAN_OPTIONS=${ASAN_OPTS}" >>${GITHUB_ENV}
-          echo "TSAN_OPTIONS=include=${SUPP}/runtime-tsan-options.txt:suppressions=${SUPP}/tsan.supp" >>${GITHUB_ENV}
-          echo "UBSAN_OPTIONS=include=${SUPP}/runtime-ubsan-options.txt:suppressions=${SUPP}/ubsan.supp" >>${GITHUB_ENV}
-          echo "LSAN_OPTIONS=include=${SUPP}/runtime-lsan-options.txt:suppressions=${SUPP}/lsan.supp" >>${GITHUB_ENV}
-
       - name: Check protocol autogen files are up-to-date
         working-directory: ${{ env.BUILD_DIR }}
         env:
@@ -247,15 +209,6 @@ jobs:
           retention-days: 3
           if-no-files-found: error
 
-      - name: Upload the test binary (Linux)
-        if: ${{ github.event.repository.visibility == 'public' && runner.os == 'Linux' }}
-        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
-        with:
-          name: xrpl_tests-${{ inputs.config_name }}
-          path: ${{ env.BUILD_DIR }}/xrpl_tests
-          retention-days: 3
-          if-no-files-found: error
-
       - name: Export server definitions
         if: ${{ runner.os != 'Windows' && !inputs.build_only && env.VOIDSTAR_ENABLED != 'true' }}
         working-directory: ${{ env.BUILD_DIR }}
@@ -264,7 +217,7 @@ jobs:
           ./xrpld --definitions | python3 -m json.tool >server_definitions.json
 
       - name: Upload server definitions
-        if: ${{ github.event.repository.visibility == 'public' && inputs.config_name == 'debian-gcc-release-amd64' }}
+        if: ${{ github.event.repository.visibility == 'public' && inputs.config_name == 'debian-bookworm-gcc-13-amd64-release' }}
         uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
         with:
           name: server-definitions
@@ -290,10 +243,32 @@ jobs:
         run: |
           ./xrpld --version | grep libvoidstar
 
+      - name: Set sanitizer options
+        if: ${{ !inputs.build_only && env.SANITIZERS_ENABLED == 'true' }}
+        env:
+          CONFIG_NAME: ${{ inputs.config_name }}
+        run: |
+          ASAN_OPTS="include=${GITHUB_WORKSPACE}/sanitizers/suppressions/runtime-asan-options.txt:suppressions=${GITHUB_WORKSPACE}/sanitizers/suppressions/asan.supp"
+          if [[ "${CONFIG_NAME}" == *gcc* ]]; then
+              ASAN_OPTS="${ASAN_OPTS}:alloc_dealloc_mismatch=0"
+          fi
+          echo "ASAN_OPTIONS=${ASAN_OPTS}" >>${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
         if: ${{ !inputs.build_only }}
-        working-directory: ${{ runner.os == 'Windows' && format('{0}/{1}', env.BUILD_DIR, inputs.build_type) || env.BUILD_DIR }}
-        run: ./xrpl_tests
+        working-directory: ${{ env.BUILD_DIR }}
+        # Windows locks some of the build files while running tests, and parallel jobs can collide
+        env:
+          BUILD_TYPE: ${{ inputs.build_type }}
+          PARALLELISM: ${{ runner.os == 'Windows' && '1' || steps.nproc.outputs.nproc }}
+        run: |
+          ctest \
+              --output-on-failure \
+              -C "${BUILD_TYPE}" \
+              -j "${PARALLELISM}"
 
       - name: Run the embedded tests
         if: ${{ !inputs.build_only }}
@@ -304,25 +279,7 @@ jobs:
           set -o pipefail
           # Coverage builds are slower due to instrumentation; use fewer parallel jobs to avoid flakiness
           [ "$COVERAGE_ENABLED" = "true" ] && BUILD_NPROC=$((BUILD_NPROC - 2))
-
-          # The resolver/preload workaround is only correct for the ASan build:
-          # a regular build doesn't hit the __dn_expand interceptor bug, and must
-          # NOT have libasan injected. So only preload when xrpld is ASan-built.
-          #
-          # libresolv hosts getaddrinfo's resolver helpers (dn_expand, res_*). Under ASan
-          # these are intercepted via dlsym(RTLD_NEXT, ...), which yields a NULL pointer
-          # and crashes DNS resolution if libresolv isn't loaded. Linking it guarantees
-          # the symbols are present; it's a harmless no-op on glibc >= 2.34 (merged into
-          # libc) and is what the compiler driver already does for sanitizer builds.
-          #   https://github.com/llvm/llvm-project/issues/59007
-          #   https://github.com/google/sanitizers/issues/1592
-          if ldd ./xrpld | grep -q libasan; then
-              PRELOAD="$(gcc -print-file-name=libasan.so):/usr/lib/x86_64-linux-gnu/libresolv.so.2"
-          else
-              PRELOAD=""
-          fi
-
-          LD_PRELOAD="$PRELOAD" ./xrpld --unittest --unittest-jobs "${BUILD_NPROC}" 2>&1 | tee unittest.log
+          ./xrpld --unittest --unittest-jobs "${BUILD_NPROC}" 2>&1 | tee unittest.log
 
       - name: Show test failure summary
         if: ${{ failure() && !inputs.build_only }}

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

@@ -19,6 +19,13 @@ on:
         required: true
         type: string
 
+      strategy_matrix:
+        # TODO: Support additional strategies, e.g. "ubuntu" for generating all Ubuntu configurations.
+        description: 'The strategy matrix to use for generating the configurations ("minimal", "all").'
+        required: false
+        type: string
+        default: "minimal"
+
     secrets:
       CODECOV_TOKEN:
         description: "The Codecov token to use for uploading coverage reports."
@@ -30,6 +37,7 @@ jobs:
     uses: ./.github/workflows/reusable-strategy-matrix.yml
     with:
       os: ${{ inputs.os }}
+      strategy_matrix: ${{ inputs.strategy_matrix }}
 
   # Build and test the binary for each configuration.
   build-test-config:
@@ -39,6 +47,7 @@ jobs:
     strategy:
       fail-fast: ${{ github.event_name == 'merge_group' }}
       matrix: ${{ fromJson(needs.generate-matrix.outputs.matrix) }}
+      max-parallel: 10
     with:
       build_only: ${{ matrix.build_only }}
       build_type: ${{ matrix.build_type }}
@@ -46,9 +55,8 @@ jobs:
       cmake_args: ${{ matrix.cmake_args }}
       cmake_target: ${{ matrix.cmake_target }}
       runs_on: ${{ toJSON(matrix.architecture.runner) }}
-      image: ${{ matrix.image || '' }}
+      image: ${{ contains(matrix.architecture.platform, 'linux') && format('ghcr.io/xrplf/ci/{0}-{1}:{2}-{3}-sha-{4}', matrix.os.distro_name, matrix.os.distro_version, matrix.os.compiler_name, matrix.os.compiler_version, matrix.os.image_sha) || '' }}
       config_name: ${{ matrix.config_name }}
       sanitizers: ${{ matrix.sanitizers }}
-      compiler: ${{ matrix.compiler || '' }}
     secrets:
       CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}

.github/workflows/reusable-check-levelization.yml

@@ -18,7 +18,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout repository
-        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
       - name: Check levelization
         run: python .github/scripts/levelization/generate.py
       - name: Check for differences

.github/workflows/reusable-check-rename.yml

@@ -18,7 +18,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout repository
-        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
       - name: Check definitions
         run: .github/scripts/rename/definitions.sh .
       - name: Check copyright notices

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

@@ -3,6 +3,10 @@ name: Run clang-tidy on files
 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
@@ -16,34 +20,32 @@ env:
   BUILD_DIR: build
   BUILD_TYPE: Debug # Debug so that ASSERTS and such participate in clang-tidy check
 
-  OUTPUT_FILE: /tmp/clang-tidy-output.txt
-  FILTERED_OUTPUT_FILE: /tmp/clang-tidy-filtered-output.txt
-  DIFF_FILE: /tmp/clang-tidy-git-diff.txt
-  ISSUE_FILE: /tmp/clang-tidy-issue.md
-
-  COMPILER: clang
+  OUTPUT_FILE: clang-tidy-output.txt
+  DIFF_FILE: clang-tidy-git-diff.txt
+  ISSUE_FILE: clang-tidy-issue.md
 
 jobs:
   determine-files:
+    if: ${{ inputs.check_only_changed }}
     permissions:
       contents: read
-    uses: XRPLF/actions/.github/workflows/determine-tidy-files.yml@d041ac9f1fa9f07a4ba335eb4c1c82233fb3fef6
+    uses: XRPLF/actions/.github/workflows/determine-tidy-files.yml@224f3c48d3014d082a1129237b8291ff0b0a331f
 
   run-clang-tidy:
     name: Run clang tidy
     needs: [determine-files]
-    if: ${{ needs.determine-files.outputs.cpp_changed_files != '' || needs.determine-files.outputs.need_full_run == 'true' }}
+    if: ${{ always() && !cancelled() && (!inputs.check_only_changed || needs.determine-files.outputs.cpp_changed_files != '' || needs.determine-files.outputs.clang_tidy_config_changed == 'true') }}
     runs-on: ["self-hosted", "Linux", "X64", "heavy"]
-    container: "ghcr.io/xrplf/xrpld/nix-debian:sha-e29b523"
+    container: "ghcr.io/xrplf/ci/debian-trixie:clang-21-sha-53033a2"
     permissions:
       contents: read
       issues: write
     steps:
       - name: Checkout repository
-        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
 
       - name: Prepare runner
-        uses: XRPLF/actions/prepare-runner@64ec3cf3b152b4444638f470bbd6df7a7a30c81c
+        uses: XRPLF/actions/prepare-runner@90f11ee655d1687824fb8793db770477d52afbab
         with:
           enable_ccache: false
 
@@ -54,11 +56,6 @@ jobs:
         uses: XRPLF/actions/get-nproc@cf0433aa74563aead044a1e395610c96d65a37cf
         id: nproc
 
-      - name: Set compiler environment
-        uses: ./.github/actions/set-compiler-env
-        with:
-          compiler: ${{ env.COMPILER }}
-
       - name: Setup Conan
         uses: ./.github/actions/setup-conan
 
@@ -79,7 +76,6 @@ jobs:
               -Dtests=ON \
               -Dwerr=ON \
               -Dxrpld=ON \
-              -Dverify_headers=ON \
               ..
 
       # clang-tidy needs headers generated from proto files
@@ -92,15 +88,15 @@ jobs:
         id: run_clang_tidy
         continue-on-error: true
         env:
-          TARGETS: ${{ needs.determine-files.outputs.need_full_run != 'true' && needs.determine-files.outputs.cpp_changed_files || 'include src tests' }}
+          TARGETS: ${{ (needs.determine-files.outputs.clang_tidy_config_changed != 'true' && inputs.check_only_changed) && needs.determine-files.outputs.cpp_changed_files || 'src tests' }}
         run: |
           set -o pipefail
           run-clang-tidy -j ${{ steps.nproc.outputs.nproc }} -p "${BUILD_DIR}" -quiet -fix -allow-no-checks ${TARGETS} 2>&1 | tee "${OUTPUT_FILE}"
 
-      - name: Print filtered clang-tidy errors
+      - name: Print errors
         if: ${{ steps.run_clang_tidy.outcome != 'success' }}
         run: |
-          bin/filter-clang-tidy.py "${OUTPUT_FILE}"
+          sed '/error\||/!d' "${OUTPUT_FILE}"
 
       - name: Upload clang-tidy output
         if: ${{ github.event.repository.visibility == 'public' && steps.run_clang_tidy.outcome != 'success' }}
@@ -144,26 +140,26 @@ jobs:
           \`\`\`
           EOF
 
-      - name: Append filtered clang-tidy output to issue body
+      - name: Append clang-tidy output to issue body (filter for errors and warnings)
         if: ${{ steps.run_clang_tidy.outcome != 'success' }}
         run: |
           if [ -f "${OUTPUT_FILE}" ]; then
-              # Filter to the unique errors with their source context.
-              bin/filter-clang-tidy.py "${OUTPUT_FILE}" >"${FILTERED_OUTPUT_FILE}" || true
+              # Extract lines containing 'error:', 'warning:', or 'note:'
+              grep -E '(error:|warning:|note:)' "${OUTPUT_FILE}" >filtered-output.txt || true
 
               # If filtered output is empty, use original (might be a different error format)
-              if [ ! -s "${FILTERED_OUTPUT_FILE}" ]; then
-                  cp "${OUTPUT_FILE}" "${FILTERED_OUTPUT_FILE}"
+              if [ ! -s filtered-output.txt ]; then
+                  cp "${OUTPUT_FILE}" filtered-output.txt
               fi
 
               # Truncate if too large
-              head -c 60000 "${FILTERED_OUTPUT_FILE}" >>"${ISSUE_FILE}"
-              if [ "$(wc -c <"${FILTERED_OUTPUT_FILE}")" -gt 60000 ]; then
+              head -c 60000 filtered-output.txt >>"${ISSUE_FILE}"
+              if [ "$(wc -c <filtered-output.txt)" -gt 60000 ]; then
                   echo "" >>"${ISSUE_FILE}"
                   echo "... (output truncated, see artifacts for full output)" >>"${ISSUE_FILE}"
               fi
 
-              rm "${FILTERED_OUTPUT_FILE}"
+              rm filtered-output.txt
           else
               echo "No output file found" >>"${ISSUE_FILE}"
           fi

.github/workflows/reusable-package.yml

@@ -1,7 +1,8 @@
 # Build Linux packages (DEB and RPM) from pre-built binary artifacts.
-# Discovers which configurations to package from linux.json (configs in
-# "package_configs") and fans out one job per distro. Only linux/amd64 is
-# supported; the runner is hardcoded in the job below.
+# Discovers which configurations to package from linux.json (os entries
+# with "package": true) and fans out one job per entry. Today only
+# linux/amd64 is emitted; the architecture is hardcoded both here
+# (runner) and in generate.py.
 name: Package
 
 on:
@@ -27,20 +28,36 @@ jobs:
       matrix: ${{ steps.generate.outputs.matrix }}
     steps:
       - name: Checkout repository
-        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
 
       - name: Set up Python
-        uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1 # v6.3.0
+        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
         with:
-          python-version: "3.13"
+          python-version: 3.13
 
       - name: Generate packaging matrix
         id: generate
         working-directory: .github/scripts/strategy-matrix
-        run: ./generate.py --packaging >>"${GITHUB_OUTPUT}"
+        run: |
+          ./generate.py --packaging --config=linux.json >>"${GITHUB_OUTPUT}"
+
+  generate-version:
+    runs-on: ubuntu-latest
+    outputs:
+      version: ${{ steps.version.outputs.version }}
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          sparse-checkout: |
+            .github/actions/generate-version
+            src/libxrpl/protocol/BuildInfo.cpp
+      - name: Generate version
+        id: version
+        uses: ./.github/actions/generate-version
 
   package:
-    needs: [generate-matrix]
+    needs: [generate-matrix, generate-version]
     if: ${{ github.event.repository.visibility == 'public' }}
     strategy:
       fail-fast: false
@@ -49,12 +66,12 @@ jobs:
     permissions:
       contents: read
     runs-on: ["self-hosted", "Linux", "X64", "heavy"]
-    container: ${{ matrix.image }}
+    container: ${{ format('ghcr.io/xrplf/ci/{0}-{1}:{2}-{3}-sha-{4}', matrix.os.distro_name, matrix.os.distro_version, matrix.os.compiler_name, matrix.os.compiler_version, matrix.os.image_sha) }}
     timeout-minutes: 30
 
     steps:
       - name: Checkout repository
-        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
 
       - name: Download pre-built binary
         uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
@@ -67,13 +84,14 @@ jobs:
 
       - name: Build package
         env:
+          PKG_VERSION: ${{ needs.generate-version.outputs.version }}
           PKG_RELEASE: ${{ inputs.pkg_release }}
         run: ./package/build_pkg.sh
 
       - name: Upload package artifact
         uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
         with:
-          name: ${{ matrix.artifact_name }}-pkg
+          name: ${{ matrix.artifact_name }}-pkg-${{ needs.generate-version.outputs.version }}
           path: |
             ${{ env.BUILD_DIR }}/debbuild/*.deb
             ${{ env.BUILD_DIR }}/debbuild/*.ddeb

.github/workflows/reusable-strategy-matrix.yml

@@ -4,9 +4,15 @@ on:
   workflow_call:
     inputs:
       os:
-        description: 'The operating system to use for the build ("linux", "macos", "windows", or empty for all).'
+        description: 'The operating system to use for the build ("linux", "macos", "windows").'
         required: false
         type: string
+      strategy_matrix:
+        # TODO: Support additional strategies, e.g. "ubuntu" for generating all Ubuntu configurations.
+        description: 'The strategy matrix to use for generating the configurations ("minimal", "all").'
+        required: false
+        type: string
+        default: "minimal"
     outputs:
       matrix:
         description: "The generated strategy matrix."
@@ -23,17 +29,17 @@ jobs:
       matrix: ${{ steps.generate.outputs.matrix }}
     steps:
       - name: Checkout repository
-        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
 
       - name: Set up Python
-        uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1 # v6.3.0
+        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
         with:
-          python-version: "3.13"
+          python-version: 3.13
 
       - name: Generate strategy matrix
         working-directory: .github/scripts/strategy-matrix
         id: generate
         env:
-          GENERATE_CONFIG: ${{ inputs.os != '' && format('--config={0}', inputs.os) || '' }}
-          GENERATE_EVENT: ${{ github.event_name }}
-        run: ./generate.py ${GENERATE_CONFIG} --event="${GENERATE_EVENT}" >>"${GITHUB_OUTPUT}"
+          GENERATE_CONFIG: ${{ inputs.os != '' && format('--config={0}.json', inputs.os) || '' }}
+          GENERATE_OPTION: ${{ inputs.strategy_matrix == 'all' && '--all' || '' }}
+        run: ./generate.py ${GENERATE_OPTION} ${GENERATE_CONFIG} >>"${GITHUB_OUTPUT}"

.github/workflows/reusable-upload-recipe.yml

@@ -14,7 +14,7 @@ on:
         description: "The URL of the Conan endpoint to use."
         required: false
         type: string
-        default: https://conan.xrplf.org/repository/conan/
+        default: https://conan.ripplex.io
 
     secrets:
       remote_username:
@@ -40,14 +40,10 @@ defaults:
 jobs:
   upload:
     runs-on: ubuntu-latest
-    container: ghcr.io/xrplf/xrpld/nix-ubuntu:sha-e29b523
-    env:
-      REMOTE_NAME: ${{ inputs.remote_name }}
-      CONAN_LOGIN_USERNAME_XRPLF: ${{ secrets.remote_username }}
-      CONAN_PASSWORD_XRPLF: ${{ secrets.remote_password }}
+    container: ghcr.io/xrplf/ci/ubuntu-noble:gcc-13-sha-5dd7158
     steps:
       - name: Checkout repository
-        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
 
       - name: Generate build version number
         id: version
@@ -60,9 +56,15 @@ jobs:
           remote_url: ${{ inputs.remote_url }}
 
       - name: Log into Conan remote
-        run: conan remote login "${REMOTE_NAME}" "${CONAN_LOGIN_USERNAME_XRPLF}" --password "${CONAN_PASSWORD_XRPLF}"
+        env:
+          REMOTE_NAME: ${{ inputs.remote_name }}
+          REMOTE_USERNAME: ${{ secrets.remote_username }}
+          REMOTE_PASSWORD: ${{ secrets.remote_password }}
+        run: conan remote login "${REMOTE_NAME}" "${REMOTE_USERNAME}" --password "${REMOTE_PASSWORD}"
 
       - name: Upload Conan recipe (version)
+        env:
+          REMOTE_NAME: ${{ inputs.remote_name }}
         run: |
           conan export . --version=${{ steps.version.outputs.version }}
           conan upload --confirm --check --remote="${REMOTE_NAME}" xrpl/${{ steps.version.outputs.version }}
@@ -71,6 +73,8 @@ jobs:
       # 'develop' branch, see on-trigger.yml.
       - name: Upload Conan recipe (develop)
         if: ${{ github.event_name == 'push' }}
+        env:
+          REMOTE_NAME: ${{ inputs.remote_name }}
         run: |
           conan export . --version=develop
           conan upload --confirm --check --remote="${REMOTE_NAME}" xrpl/develop
@@ -79,6 +83,8 @@ jobs:
       # one of the 'release' branches, see on-pr.yml.
       - name: Upload Conan recipe (rc)
         if: ${{ github.event_name == 'pull_request' }}
+        env:
+          REMOTE_NAME: ${{ inputs.remote_name }}
         run: |
           conan export . --version=rc
           conan upload --confirm --check --remote="${REMOTE_NAME}" xrpl/rc
@@ -87,6 +93,8 @@ jobs:
       # release, see on-tag.yml.
       - name: Upload Conan recipe (release)
         if: ${{ startsWith(github.ref, 'refs/tags/') }}
+        env:
+          REMOTE_NAME: ${{ inputs.remote_name }}
         run: |
           conan export . --version=release
           conan upload --confirm --check --remote="${REMOTE_NAME}" xrpl/release

.github/workflows/upload-conan-deps.yml

@@ -30,11 +30,10 @@ on:
       - ".github/scripts/strategy-matrix/**"
       - conanfile.py
       - conan.lock
-      - conan/profiles/**
 
 env:
   CONAN_REMOTE_NAME: xrplf
-  CONAN_REMOTE_URL: https://conan.xrplf.org/repository/conan/
+  CONAN_REMOTE_URL: https://conan.ripplex.io
   NPROC_SUBTRACT: 2
 
 concurrency:
@@ -49,6 +48,8 @@ jobs:
   # Generate the strategy matrix to be used by the following job.
   generate-matrix:
     uses: ./.github/workflows/reusable-strategy-matrix.yml
+    with:
+      strategy_matrix: ${{ github.event_name == 'pull_request' && 'minimal' || 'all' }}
 
   # Build and upload the dependencies for each configuration.
   run-upload-conan-deps:
@@ -57,18 +58,19 @@ jobs:
     strategy:
       fail-fast: false
       matrix: ${{ fromJson(needs.generate-matrix.outputs.matrix) }}
+      max-parallel: 10
     runs-on: ${{ matrix.architecture.runner }}
-    container: ${{ matrix.image || null }}
+    container: ${{ contains(matrix.architecture.platform, 'linux') && format('ghcr.io/xrplf/ci/{0}-{1}:{2}-{3}-sha-{4}', matrix.os.distro_name, matrix.os.distro_version, matrix.os.compiler_name, matrix.os.compiler_version, matrix.os.image_sha) || null }}
     steps:
       - name: Cleanup workspace (macOS and Windows)
         if: ${{ runner.os == 'macOS' || runner.os == 'Windows' }}
         uses: XRPLF/actions/cleanup-workspace@c7d9ce5ebb03c752a354889ecd870cadfc2b1cd4
 
       - name: Checkout repository
-        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
 
       - name: Prepare runner
-        uses: XRPLF/actions/prepare-runner@64ec3cf3b152b4444638f470bbd6df7a7a30c81c
+        uses: XRPLF/actions/prepare-runner@90f11ee655d1687824fb8793db770477d52afbab
         with:
           enable_ccache: false
 
@@ -81,12 +83,6 @@ jobs:
         with:
           subtract: ${{ env.NPROC_SUBTRACT }}
 
-      - name: Set compiler environment (Linux)
-        if: ${{ runner.os == 'Linux' }}
-        uses: ./.github/actions/set-compiler-env
-        with:
-          compiler: ${{ matrix.compiler }}
-
       - name: Setup Conan
         env:
           SANITIZERS: ${{ matrix.sanitizers }}
@@ -108,12 +104,10 @@ jobs:
 
       - name: Log into Conan remote
         if: ${{ github.repository == 'XRPLF/rippled' && (github.event_name == 'push' || github.event_name == 'workflow_dispatch') }}
-        run: conan remote login "${CONAN_REMOTE_NAME}" "${{ secrets.NEXUS_REMOTE_USERNAME }}" --password "${{ secrets.NEXUS_REMOTE_PASSWORD }}"
+        run: conan remote login "${CONAN_REMOTE_NAME}" "${{ secrets.CONAN_REMOTE_USERNAME }}" --password "${{ secrets.CONAN_REMOTE_PASSWORD }}"
 
       - name: Upload Conan packages
         if: ${{ github.repository == 'XRPLF/rippled' && (github.event_name == 'push' || github.event_name == 'workflow_dispatch') }}
         env:
           FORCE_OPTION: ${{ github.event.inputs.force_upload == 'true' && '--force' || '' }}
-          CONAN_LOGIN_USERNAME_XRPLF: ${{ secrets.NEXUS_REMOTE_USERNAME }}
-          CONAN_PASSWORD_XRPLF: ${{ secrets.NEXUS_REMOTE_PASSWORD }}
         run: conan upload "*" --remote="${CONAN_REMOTE_NAME}" --confirm ${FORCE_OPTION}

.pre-commit-config.yaml

@@ -15,7 +15,6 @@ repos:
     hooks:
       - id: check-added-large-files
         args: [--maxkb=400, --enforce-all]
-      - id: check-executables-have-shebangs
       - id: trailing-whitespace
       - id: end-of-file-fixer
       - id: check-merge-conflict
@@ -28,42 +27,30 @@ repos:
         entry: ./bin/pre-commit/clang_tidy_check.py
         language: python
         types_or: [c++, c]
-        # .ipp fragments are included by their owning header rather than compiled
-        # as standalone translation units, so they have no compile_commands.json
-        # entry to lint (verify_headers checks them transitively).
-        exclude: '^include/xrpl/protocol_autogen|\.ipp$'
+        exclude: ^include/xrpl/protocol_autogen
+        pass_filenames: false # script determines the staged files itself
       - id: fix-include-style
         name: fix include style
         entry: ./bin/pre-commit/fix_include_style.py
         language: python
         types_or: [c++, c]
         exclude: ^include/xrpl/protocol_autogen/(transactions|ledger_entries)/
-      - id: fix-pragma-once
-        name: fix missing '#pragma once' declarations in header files
-        language: python
-        entry: ./bin/pre-commit/fix_pragma_once.py
-        files: \.(h|hpp)$
-      - id: check-doxygen-style
-        name: check Doxygen comment style
-        entry: ./bin/pre-commit/check_doxygen_style.py
-        language: python
-        types_or: [c++, c]
 
   - repo: https://github.com/pre-commit/mirrors-clang-format
     rev: dd18dad857d6133e90bbe478f4f2f22ec0030269 # frozen: v22.1.5
     hooks:
       - id: clang-format
         args: [--style=file]
-        types_or: [c++, c, proto]
+        "types_or": [c++, c, proto]
         exclude: ^include/xrpl/protocol_autogen/(transactions|ledger_entries)/
 
   - repo: https://github.com/BlankSpruce/gersemi-pre-commit
-    rev: e98930bdc210d3387007f9252d8c1694ea7e410f # frozen: 0.27.7
+    rev: faadd6a9d852369ca94f4d15b2404c967ba8cb01 # frozen: 0.27.6
     hooks:
       - id: gersemi
 
   - repo: https://github.com/rbubley/mirrors-prettier
-    rev: 39e2973981e6d2f9b6c543b0086a2d2393abdc89 # frozen: v3.9.4
+    rev: 515f543f5718ebfd6ce22e16708bb32c68ff96e1 # frozen: v3.8.3
     hooks:
       - id: prettier
         args: [--end-of-line=auto]
@@ -93,21 +80,22 @@ repos:
         files: \.md$
 
   - repo: https://github.com/streetsidesoftware/cspell-cli
-    rev: ea11f9efc0bec520073405bc30552da887ba71bc # frozen: v10.0.1
+    rev: 4643f154907327ee0a2c7038f0296e0dd77d9776 # frozen: v10.0.0
     hooks:
-      - id: cspell
-        name: check changed files spelling
+      - id: cspell # Spell check changed files
         exclude: |
           (?x)^(
-              \.cspell\.config\.yaml|
+              .config/cspell.config.yaml|
               include/xrpl/protocol_autogen/(transactions|ledger_entries)/.*
           )$
-      - id: cspell
+      - id: cspell # Spell check the commit message
         name: check commit message spelling
         args:
           - --no-must-find-files
           - --no-progress
           - --no-summary
+          - --files
+          - .git/COMMIT_EDITMSG
         stages: [commit-msg]
 
   - repo: local

BUILD.md

@@ -1,57 +1,26 @@
-| :warning: **WARNING** :warning:                                                                                                                                                                                                                                                                                                                                                                                                                                               |
-| ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| These instructions assume you have a C++ development environment ready with Git, Python, Conan, CMake, and a C++ compiler. For help setting one up on Linux, macOS, or Windows, [see this guide](./docs/build/environment.md).<br><br>These instructions also assume a basic familiarity with Conan and CMake. If you are unfamiliar with Conan, you can read our [crash course](./docs/build/conan.md) or the official [Getting Started][conan-getting-started] walkthrough. |
+| :warning: **WARNING** :warning:                                                                                                                                                                                                |
+| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| These instructions assume you have a C++ development environment ready with Git, Python, Conan, CMake, and a C++ compiler. For help setting one up on Linux, macOS, or Windows, [see this guide](./docs/build/environment.md). |
 
-## Minimum Requirements
+> These instructions also assume a basic familiarity with Conan and CMake.
+> If you are unfamiliar with Conan, you can read our
+> [crash course](./docs/build/conan.md) or the official [Getting Started][3]
+> walkthrough.
 
-See [System Requirements](https://xrpl.org/system-requirements.html).
+## Branches
 
-Building xrpld generally requires Git, Python, Conan, CMake, and a C++
-compiler.
-
-- [Python](https://www.python.org/downloads/)
-- [Conan](https://conan.io/downloads.html)
-- [CMake](https://cmake.org/download/)
-
-You can verify that the required tools are installed and runnable with:
+For a stable release, choose the `master` branch or one of the [tagged
+releases](https://github.com/XRPLF/rippled/releases).
 
 ```bash
-./bin/check-tools.sh
+git checkout master
 ```
 
-`xrpld` is written in the C++23 dialect. The [tested compiler versions][cpp23-support] are:
+For the latest release candidate, choose the `release` branch.
 
-| Compiler    | Version         |
-| ----------- | --------------- |
-| GCC         | 15.2            |
-| Clang       | 22              |
-| Apple Clang | 21              |
-| MSVC        | 19.44[^windows] |
-
-## Operating Systems
-
-Please see the [environment setup guide](./docs/build/environment.md) for detailed instructions for all platforms.
-
-### Linux
-
-The Ubuntu Linux distribution has received the highest level of quality
-assurance, testing, and support. We also support Red Hat and use Debian
-internally.
-Our Linux CI tooling is distro-independent and uses a Nix-based environment, so it should be possible to build on other Linux distributions as well, although we have not tested them.
-
-### macOS
-
-Many `xrpld` engineers use macOS for development.
-
-### Windows
-
-Windows is used by some engineers for development only.
-
-[^windows]: Windows is not recommended for production use.
-
-## Steps
-
-### Branches
+```bash
+git checkout release
+```
 
 For the latest set of untested features, or to contribute, choose the `develop`
 branch.
@@ -60,15 +29,55 @@ branch.
 git checkout develop
 ```
 
-For a release candidate, choose the relevant release branch, e.g.
-`release/3.2.x`.
+## Minimum Requirements
 
-```bash
-git checkout release/3.2.x
-```
+See [System Requirements](https://xrpl.org/system-requirements.html).
 
-For a stable release, choose one of the [tagged
-releases](https://github.com/XRPLF/rippled/releases).
+Building xrpld generally requires git, Python, Conan, CMake, and a C++
+compiler. Some guidance on setting up such a [C++ development environment can be
+found here](./docs/build/environment.md).
+
+- [Python 3.11](https://www.python.org/downloads/), or higher
+- [Conan 2.17](https://conan.io/downloads.html)[^1], or higher
+- [CMake 3.22](https://cmake.org/download/), or higher
+
+[^1]:
+    It is possible to build with Conan 1.60+, but the instructions are
+    significantly different, which is why we are not recommending it.
+
+`xrpld` is written in the C++20 dialect and includes the `<concepts>` header.
+The [minimum compiler versions][2] required are:
+
+| Compiler    | Version   |
+| ----------- | --------- |
+| GCC         | 12        |
+| Clang       | 16        |
+| Apple Clang | 16        |
+| MSVC        | 19.44[^3] |
+
+### Linux
+
+The Ubuntu Linux distribution has received the highest level of quality
+assurance, testing, and support. We also support Red Hat and use Debian
+internally.
+
+Here are [sample instructions for setting up a C++ development environment on
+Linux](./docs/build/environment.md#linux).
+
+### Mac
+
+Many xrpld engineers use macOS for development.
+
+Here are [sample instructions for setting up a C++ development environment on
+macOS](./docs/build/environment.md#macos).
+
+### Windows
+
+Windows is used by some engineers for development only.
+
+[^3]: Windows is not recommended for production use.
+
+## Steps
 
 ### Set Up Conan
 
@@ -77,11 +86,18 @@ Conan, CMake, and a C++ compiler, you may need to set up your Conan profile.
 
 These instructions assume a basic familiarity with Conan and CMake. If you are
 unfamiliar with Conan, then please read [this crash course](./docs/build/conan.md) or the official
-[Getting Started][conan-getting-started] walkthrough.
+[Getting Started][3] walkthrough.
 
-#### Profiles
+#### Conan lockfile
 
-We recommend that you install our Conan profiles:
+To achieve reproducible dependencies, we use a [Conan lockfile](https://docs.conan.io/2/tutorial/versioning/lockfiles.html),
+which has to be updated every time dependencies change.
+
+Please see the [instructions on how to regenerate the lockfile](conan/lockfile/README.md).
+
+#### Default profile
+
+We recommend that you import the provided `conan/profiles/default` profile:
 
 ```bash
 conan config install conan/profiles/ -tf $(conan config home)/profiles/
@@ -93,15 +109,222 @@ You can check your Conan profile by running:
 conan profile show
 ```
 
-If the default profile is not suitable for your environment, you can create a custom profile and pass it to Conan.
-More information on customizing Conan can be found in the [Advanced Conan configuration](./docs/build/advanced_conan.md).
+#### Custom profile
 
-#### Add xrplf remote
-
-Run the following command to add the `xrplf` remote, which hosts some of our dependencies:
+If the default profile does not work for you and you do not yet have a Conan
+profile, you can create one by running:
 
 ```bash
-conan remote add --index 0 --force xrplf https://conan.xrplf.org/repository/conan/
+conan profile detect
+```
+
+You may need to make changes to the profile to suit your environment. You can
+refer to the provided `conan/profiles/default` profile for inspiration, and you
+may also need to apply the required [tweaks](#conan-profile-tweaks) to this
+default profile.
+
+### Patched recipes
+
+Occasionally, we need patched recipes or recipes not present in Conan Center.
+We maintain a fork of the Conan Center Index
+[here](https://github.com/XRPLF/conan-center-index/) containing the modified and newly added recipes.
+
+To ensure our patched recipes are used, you must add our Conan remote at a
+higher index than the default Conan Center remote, so it is consulted first. You
+can do this by running:
+
+```bash
+conan remote add --index 0 xrplf https://conan.ripplex.io
+```
+
+Alternatively, you can pull our recipes from the repository and export them locally:
+
+```bash
+# Define which recipes to export.
+recipes=('abseil' 'ed25519' 'mpt-crypto' 'openssl' 'secp256k1' 'snappy' 'soci' 'wasm-xrplf' 'wasmi')
+
+# Selectively check out the recipes from our CCI fork.
+cd external
+mkdir -p conan-center-index
+cd conan-center-index
+git init
+git remote add origin git@github.com:XRPLF/conan-center-index.git
+git sparse-checkout init
+for recipe in "${recipes[@]}"; do
+    echo "Checking out recipe '${recipe}'..."
+    git sparse-checkout add recipes/${recipe}
+done
+git fetch origin master
+git checkout master
+
+./export_all.sh
+cd ../../
+```
+
+In the case we switch to a newer version of a dependency that still requires a
+patch or add a new dependency, it will be necessary for you to pull in the changes and re-export the
+updated dependencies with the newer version. However, if we switch to a newer
+version that no longer requires a patch, no action is required on your part, as
+the new recipe will be automatically pulled from the official Conan Center.
+
+> [!NOTE]
+> You might need to add `--lockfile=""` to your `conan install` command
+> to avoid automatic use of the existing `conan.lock` file when you run
+> `conan export` manually on your machine
+>
+> This is not recommended though, as you might end up using different revisions of recipes.
+
+### Conan profile tweaks
+
+#### Missing compiler version
+
+If you see an error similar to the following after running `conan profile show`:
+
+```text
+ERROR: Invalid setting '17' is not a valid 'settings.compiler.version' value.
+Possible values are ['5.0', '5.1', '6.0', '6.1', '7.0', '7.3', '8.0', '8.1',
+'9.0', '9.1', '10.0', '11.0', '12.0', '13', '13.0', '13.1', '14', '14.0', '15',
+'15.0', '16', '16.0']
+Read "http://docs.conan.io/2/knowledge/faq.html#error-invalid-setting"
+```
+
+you need to add your compiler to the list of compiler versions in
+`$(conan config home)/settings_user.yml`, by adding the required version number(s)
+to the `version` array specific for your compiler. For example:
+
+```yaml
+compiler:
+  apple-clang:
+    version: ["17.0"]
+```
+
+#### Multiple compilers
+
+If you have multiple compilers installed, make sure to select the one to use in
+your default Conan configuration **before** running `conan profile detect`, by
+setting the `CC` and `CXX` environment variables.
+
+For example, if you are running MacOS and have [homebrew
+LLVM@18](https://formulae.brew.sh/formula/llvm@18), and want to use it as a
+compiler in the new Conan profile:
+
+```bash
+export CC=$(brew --prefix llvm@18)/bin/clang
+export CXX=$(brew --prefix llvm@18)/bin/clang++
+conan profile detect
+```
+
+You should also explicitly set the path to the compiler in the profile file,
+which helps to avoid errors when `CC` and/or `CXX` are set and disagree with the
+selected Conan profile. For example:
+
+```text
+[conf]
+tools.build:compiler_executables={'c':'/usr/bin/gcc','cpp':'/usr/bin/g++'}
+```
+
+#### Multiple profiles
+
+You can manage multiple Conan profiles in the directory
+`$(conan config home)/profiles`, for example renaming `default` to a different
+name and then creating a new `default` profile for a different compiler.
+
+#### Select language
+
+The default profile created by Conan will typically select different C++ dialect
+than C++20 used by this project. You should set `20` in the profile line
+starting with `compiler.cppstd=`. For example:
+
+```bash
+sed -i.bak -e 's|^compiler\.cppstd=.*$|compiler.cppstd=20|' $(conan config home)/profiles/default
+```
+
+#### Select standard library in Linux
+
+**Linux** developers will commonly have a default Conan [profile][] that
+compiles with GCC and links with libstdc++. If you are linking with libstdc++
+(see profile setting `compiler.libcxx`), then you will need to choose the
+`libstdc++11` ABI:
+
+```bash
+sed -i.bak -e 's|^compiler\.libcxx=.*$|compiler.libcxx=libstdc++11|' $(conan config home)/profiles/default
+```
+
+#### Select architecture and runtime in Windows
+
+**Windows** developers may need to use the x64 native build tools. An easy way
+to do that is to run the shortcut "x64 Native Tools Command Prompt" for the
+version of Visual Studio that you have installed.
+
+Windows developers must also build `xrpld` and its dependencies for the x64
+architecture:
+
+```bash
+sed -i.bak -e 's|^arch=.*$|arch=x86_64|' $(conan config home)/profiles/default
+```
+
+**Windows** developers also must select static runtime:
+
+```bash
+sed -i.bak -e 's|^compiler\.runtime=.*$|compiler.runtime=static|' $(conan config home)/profiles/default
+```
+
+#### Clang workaround for grpc
+
+If your compiler is clang, version 19 or later, or apple-clang, version 17 or
+later, you may encounter a compilation error while building the `grpc`
+dependency:
+
+```text
+In file included from .../lib/promise/try_seq.h:26:
+.../lib/promise/detail/basic_seq.h:499:38: error: a template argument list is expected after a name prefixed by the template keyword [-Wmissing-template-arg-list-after-template-kw]
+  499 |                     Traits::template CallSeqFactory(f_, *cur_, std::move(arg)));
+      |                                      ^
+```
+
+The workaround for this error is to add two lines to profile:
+
+```text
+[conf]
+tools.build:cxxflags=['-Wno-missing-template-arg-list-after-template-kw']
+```
+
+#### Workaround for gcc 12
+
+If your compiler is gcc, version 12, and you have enabled `werr` option, you may
+encounter a compilation error such as:
+
+```text
+/usr/include/c++/12/bits/char_traits.h:435:56: error: 'void* __builtin_memcpy(void*, const void*, long unsigned int)' accessing 9223372036854775810 or more bytes at offsets [2, 9223372036854775807] and 1 may overlap up to 9223372036854775813 bytes at offset -3 [-Werror=restrict]
+  435 |         return static_cast<char_type*>(__builtin_memcpy(__s1, __s2, __n));
+      |                                        ~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~
+cc1plus: all warnings being treated as errors
+```
+
+The workaround for this error is to add two lines to your profile:
+
+```text
+[conf]
+tools.build:cxxflags=['-Wno-restrict']
+```
+
+#### Workaround for clang 16
+
+If your compiler is clang, version 16, you may encounter compilation error such
+as:
+
+```text
+In file included from .../boost/beast/websocket/stream.hpp:2857:
+.../boost/beast/websocket/impl/read.hpp:695:17: error: call to 'async_teardown' is ambiguous
+                async_teardown(impl.role, impl.stream(),
+                ^~~~~~~~~~~~~~
+```
+
+The workaround for this error is to add two lines to your profile:
+
+```text
+[conf]
+tools.build:cxxflags=['-DBOOST_ASIO_DISABLE_CONCEPTS']
 ```
 
 ### Set Up Ccache
@@ -110,7 +333,14 @@ To speed up repeated compilations, we recommend that you install
 [ccache](https://ccache.dev), a tool that wraps your compiler so that it can
 cache build objects locally.
 
-On Linux and macOS, `ccache` is included in the [Nix development shell](./docs/build/nix.md).
+#### Linux
+
+You can install it using the package manager, e.g. `sudo apt install ccache`
+(Ubuntu) or `sudo dnf install ccache` (RHEL).
+
+#### macOS
+
+You can install it using Homebrew, i.e. `brew install ccache`.
 
 #### Windows
 
@@ -317,41 +547,21 @@ See [Sanitizers docs](./docs/build/sanitizers.md) for more details.
 
 ## Options
 
-| Option           | Default Value | Description                                                                   |
-| ---------------- | ------------- | ----------------------------------------------------------------------------- |
-| `assert`         | OFF           | Force enabling assertions.                                                    |
-| `coverage`       | OFF           | Prepare the coverage report.                                                  |
-| `tests`          | OFF           | Build tests.                                                                  |
-| `unity`          | OFF           | Configure a unity build.                                                      |
-| `verify_headers` | ON            | Make the `verify-headers` target available to compile each header on its own. |
-| `xrpld`          | OFF           | Build the xrpld application, and not just the libxrpl library.                |
-| `werr`           | OFF           | Treat compilation warnings as errors                                          |
-| `wextra`         | OFF           | Enable additional compilation warnings                                        |
+| Option     | Default Value | Description                                                    |
+| ---------- | ------------- | -------------------------------------------------------------- |
+| `assert`   | OFF           | Enable assertions.                                             |
+| `coverage` | OFF           | Prepare the coverage report.                                   |
+| `tests`    | OFF           | Build tests.                                                   |
+| `unity`    | OFF           | Configure a unity build.                                       |
+| `xrpld`    | OFF           | Build the xrpld application, and not just the libxrpl library. |
+| `werr`     | OFF           | Treat compilation warnings as errors                           |
+| `wextra`   | OFF           | Enable additional compilation warnings                         |
 
-[Unity builds][unity-build] may be faster for the first build (at the cost of much more
+[Unity builds][5] may be faster for the first build (at the cost of much more
 memory) since they concatenate sources into fewer translation units. Non-unity
 builds may be faster for incremental builds, and can be helpful for detecting
 `#include` omissions.
 
-### Verifying headers
-
-The regular build only compiles `.cpp` files, so a header is only ever checked
-through whatever translation unit happens to include it. A header that forgets
-an `#include` is not caught as long as every `.cpp` that uses it includes its
-missing dependency first. The `verify_headers` option (ON by default) adds a
-`verify-headers` target that compiles every header on its own, which fails if a
-header is not self-contained:
-
-```bash
-cmake --build . --target verify-headers
-```
-
-The per-header objects are excluded from the `all` target, so a normal build
-never compiles them; they are built only through `verify-headers`. The generated
-translation units do appear in `compile_commands.json`, so clang-tidy (and
-clangd and IDEs) can lint each header on its own. Pass `-Dverify_headers=OFF` to
-omit them entirely.
-
 ## Troubleshooting
 
 ### Conan
@@ -373,14 +583,14 @@ After any updates or changes to dependencies, you may need to do the following:
    conan remove '*'
    ```
 
-3. Re-run [conan export](./docs/build/advanced_conan.md#patched-recipes) if needed.
-4. [Regenerate lockfile](./docs/build/advanced_conan.md#conan-lockfile).
+3. Re-run [conan export](#patched-recipes) if needed.
+4. [Regenerate lockfile](#conan-lockfile).
 5. Re-run [conan install](#build-and-test).
 
 #### ERROR: Package not resolved
 
 If you're seeing an error like `ERROR: Package 'snappy/1.1.10' not resolved: Unable to find 'snappy/1.1.10#968fef506ff261592ec30c574d4a7809%1756234314.246' in remotes.`,
-please [add `xrplf` remote](#add-xrplf-remote) or re-run `conan export` for [patched recipes](./docs/build/advanced_conan.md#patched-recipes).
+please add `xrplf` remote or re-run `conan export` for [patched recipes](#patched-recipes).
 
 ### `protobuf/port_def.inc` file not found
 
@@ -400,9 +610,28 @@ For example, if you want to build Debug:
 1. For conan install, pass `--settings build_type=Debug`
 2. For cmake, pass `-DCMAKE_BUILD_TYPE=Debug`
 
-[cpp23-support]: https://en.cppreference.com/w/cpp/compiler_support/23
-[conan-getting-started]: https://docs.conan.io/en/latest/getting_started.html
-[unity-build]: https://en.wikipedia.org/wiki/Unity_build
+## Add a Dependency
+
+If you want to experiment with a new package, follow these steps:
+
+1. Search for the package on [Conan Center](https://conan.io/center/).
+2. Modify [`conanfile.py`](./conanfile.py):
+   - Add a version of the package to the `requires` property.
+   - Change any default options for the package by adding them to the
+     `default_options` property (with syntax `'$package:$option': $value`).
+3. Modify [`CMakeLists.txt`](./CMakeLists.txt):
+   - Add a call to `find_package($package REQUIRED)`.
+   - Link a library from the package to the target `xrpl_libs`
+     (search for the existing call to `target_link_libraries(xrpl_libs INTERFACE ...)`).
+4. Start coding! Don't forget to include whatever headers you need from the package.
+
+[1]: https://github.com/conan-io/conan-center-index/issues/13168
+[2]: https://en.cppreference.com/w/cpp/compiler_support/20
+[3]: https://docs.conan.io/en/latest/getting_started.html
+[5]: https://en.wikipedia.org/wiki/Unity_build
+[6]: https://github.com/boostorg/beast/issues/2648
+[7]: https://github.com/boostorg/beast/issues/2661
 [gcovr]: https://gcovr.com/en/stable/getting-started.html
 [python-pip]: https://packaging.python.org/en/latest/guides/installing-using-pip-and-virtual-environments/
 [build_type]: https://cmake.org/cmake/help/latest/variable/CMAKE_BUILD_TYPE.html
+[profile]: https://docs.conan.io/en/latest/reference/profiles.html

CMakeLists.txt

@@ -15,7 +15,7 @@ list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
 
 project(xrpl)
 set(CMAKE_CXX_EXTENSIONS OFF)
-set(CMAKE_CXX_STANDARD 23)
+set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 
@@ -57,8 +57,6 @@ if(target)
     )
 endif()
 
-include(PatchNixBinary)
-
 include(XrplSanity)
 include(XrplVersion)
 include(XrplSettings)
@@ -90,7 +88,6 @@ find_package(ed25519 REQUIRED)
 find_package(gRPC REQUIRED)
 find_package(LibArchive REQUIRED)
 find_package(lz4 REQUIRED)
-find_package(mpt-crypto REQUIRED)
 find_package(nudb REQUIRED)
 find_package(OpenSSL REQUIRED)
 find_package(secp256k1 REQUIRED)
@@ -103,7 +100,6 @@ target_link_libraries(
     INTERFACE
         ed25519::ed25519
         lz4::lz4
-        mpt-crypto::mpt-crypto
         OpenSSL::Crypto
         OpenSSL::SSL
         secp256k1::secp256k1

CONTRIBUTING.md

@@ -14,9 +14,9 @@ The following branches exist in the main project repository:
 
 - `develop`: The latest set of unreleased features, and the most common
   starting point for contributions.
-- `release/*` (e.g. `release/3.2.x`): Release branches, one per release line,
-  holding the latest release candidate, or stable release for that line.
-  Stable releases are published as [tagged releases](https://github.com/XRPLF/rippled/releases).
+- `release`: The latest beta release or release candidate.
+- `master`: The latest stable release.
+- `gh-pages`: The documentation for this project, built by Doxygen.
 
 The tip of each branch must be signed. In order for GitHub to sign a
 squashed commit that it builds from your pull request, GitHub must know
@@ -130,9 +130,11 @@ tl;dr
 ## Pull requests
 
 In general, pull requests use `develop` as the base branch.
+The exceptions are
 
-The exceptions are fixes, improvements, and hotfixes for an existing release,
-which use that release's branch (e.g. `release/3.2.x`) as the base.
+- Fixes and improvements to a release candidate use `release` as the
+  base.
+- Hotfixes use `master` as the base.
 
 If your changes are not quite ready, but you want to make it easily available
 for preliminary examination or review, you can create a "Draft" pull request.
@@ -214,7 +216,7 @@ coherent rather than a set of _thou shalt not_ commandments.
 
 ## Formatting
 
-All code must conform to `clang-format` version 22,
+All code must conform to `clang-format` version 21,
 according to the settings in [`.clang-format`](./.clang-format),
 unless the result would be unreasonably difficult to read or maintain.
 To demarcate lines that should be left as-is, surround them with comments like
@@ -259,7 +261,7 @@ This ensures that configuration changes don't introduce new warnings across the
 
 ### Installing clang-tidy
 
-See the [environment setup guide](./docs/build/environment.md#clang-tidy) for how to get clang-tidy.
+See the [environment setup guide](./docs/build/environment.md#clang-tidy) for platform-specific installation instructions.
 
 ### Running clang-tidy locally
 

bin/check-tools.sh

@@ -1,161 +0,0 @@
-#!/usr/bin/env bash
-#
-# check-tools.sh — verify the xrpld development tooling is present and runnable.
-#
-# Works on Linux, macOS, and Windows (Git Bash / MSYS). For every expected tool
-# it runs a version probe, collecting anything that is missing or fails to run,
-# and prints a summary at the end (exiting non-zero if anything is missing).
-#
-# The tool set is platform-aware:
-#   - Linux:   the full Nix CI environment (see nix/packages.nix, nix/ci-env.nix),
-#              with GCC, Clang and the sanitizer/coverage tooling. This script is
-#              run during the Nix Docker image build (nix/docker/Dockerfile), so
-#              the Linux list is kept in sync with that environment.
-#   - macOS:   the same tooling, minus GCC/g++/gcov/mold
-#   - Windows: the core build tools only (CMake, Conan, Git, Python).
-#              MSVC is expected to be provided separately and is not checked here.
-#
-# Some tools (clang-format, doxygen, gcovr, gh, git-cliff, gpg, pre-commit,
-# run-clang-tidy) are present in our Linux CI images and in local development
-# setups, but not in the macOS CI environment. They are checked everywhere
-# except when running in CI on macOS.
-#
-# Environment variables:
-#   CI                      if set, skip the tools above when on macOS.
-#   CHECK_TOOLS_SKIP_CLONE  if set, skip the git-over-HTTPS connectivity check.
-
-set -uo pipefail
-
-missing=()
-checked=0
-
-# check <name> [probe-command...]
-# Runs the probe (default: "<name> --version") quietly. Records <name> as
-# missing if the command is not found or exits non-zero.
-check() {
-    local name="$1"
-    shift
-    local -a probe=("$@")
-    if [ "${#probe[@]}" -eq 0 ]; then
-        probe=("${name}" --version)
-    fi
-
-    echo "Checking ${name}..."
-    checked=$((checked + 1))
-    if "${probe[@]}" | head -n 1; then
-        printf '  [ ok ] %s\n' "${name}"
-    else
-        printf '  [MISS] %s\n' "${name}"
-        missing+=("${name}")
-    fi
-}
-
-case "$(uname -s)" in
-    Linux*) os=linux ;;
-    Darwin*) os=macos ;;
-    MINGW* | MSYS* | CYGWIN*) os=windows ;;
-    *)
-        echo "Unknown OS: $(uname -s)" >&2
-        exit 1
-        ;;
-esac
-
-echo "Detected OS: ${os} ($(uname -s) $(uname -m))"
-echo
-echo "Core build tools:"
-check cmake
-check conan
-check git
-if [ "${os}" = "windows" ]; then
-    check python python --version
-else
-    check python3
-fi
-
-# The full development toolchain. Available from Nix on Linux and macOS; on
-# Windows these are typically not installed, so they are skipped.
-if [ "${os}" = "linux" ] || [ "${os}" = "macos" ]; then
-    echo
-    echo "Development tooling:"
-    check ccache
-    check clang
-    check clang++
-    check ClangBuildAnalyzer
-    check curl
-    check file
-    check less
-    check make
-    check netstat which netstat
-    check ninja
-    check perl
-    check pkg-config
-    check vim
-    check zip
-
-    # These tools are present in our Linux CI images and in local development
-    # setups, but not in the macOS CI environment. So check them everywhere
-    # except when running in CI on macOS.
-    if [ "${os}" = "linux" ] || [ -z "${CI:-}" ]; then
-        check clang-format
-        check dot
-        check doxygen
-        check gcovr
-        check gh
-        check git-cliff
-        check git-lfs
-        check gpg
-        # pre-commit, or its alternative implementation prek
-        check pre-commit sh -c 'pre-commit --version || prek --version'
-        check run-clang-tidy run-clang-tidy --help
-    fi
-fi
-
-# GCC is the default compiler on Linux. macOS uses the system Apple Clang
-# instead, so GCC/g++/gcov are not expected there.
-if [ "${os}" = "linux" ]; then
-    echo
-    echo "GCC toolchain:"
-    check gcc
-    check g++
-    check gcov
-
-    echo
-    echo "Mold:"
-    check mold
-fi
-
-if [ "${os}" = "windows" ]; then
-    echo
-    echo "Note: on Windows the C++ compiler is MSVC, which is provided"
-    echo "      separately (e.g. via Visual Studio) and is not checked here."
-fi
-
-# A simple test to verify that git can clone a repository over HTTPS
-# (i.e. the CA bundle is wired up). Clone to a temp dir and clean up.
-if [ -n "${CHECK_TOOLS_SKIP_CLONE:-}" ]; then
-    echo
-    echo "Skipping git-over-HTTPS check (CHECK_TOOLS_SKIP_CLONE is set)."
-else
-    echo
-    echo "Connectivity check:"
-    checked=$((checked + 1))
-    tmp_clone="$(mktemp -d)"
-    if git clone --depth 1 https://github.com/XRPLF/actions.git "${tmp_clone}/actions" >/dev/null 2>&1; then
-        printf '  [ ok ] git clone over HTTPS\n'
-    else
-        printf '  [MISS] git clone over HTTPS\n'
-        missing+=("git-https-clone")
-    fi
-    rm -rf "${tmp_clone}"
-fi
-
-echo
-if [ "${#missing[@]}" -eq 0 ]; then
-    echo "All ${checked} checked tools are present and runnable."
-else
-    echo "Missing or non-functional tools (${#missing[@]} of ${checked}):" >&2
-    for tool in "${missing[@]}"; do
-        echo "  - ${tool}" >&2
-    done
-    exit 1
-fi

bin/filter-clang-tidy.py

@@ -1,102 +0,0 @@
-#!/usr/bin/env python3
-
-"""
-Reduce run-clang-tidy output to its unique errors.
-
-It does two things:
-
-  1. Filters the raw output down to diagnostics and their source-context lines
-     (the indented "  103 | ..." / "      | ^" lines clang-tidy prints),
-     matching the "path:line:col: error:" diagnostic shape.
-
-  2. Deduplicates. The same diagnostic in a header is reported once per
-     translation unit that includes it, so identical error blocks are collapsed
-     to their first occurrence.
-
-An "error block" is an "error:" line together with the indented context lines
-and any "note:" lines that follow it (up to the next "error:" line). Blocks are
-compared as a whole, so an error stays attached to its own context, and
-first-occurrence order is preserved.
-
-The deduplicated output goes to stdout; a summary of unique error counts per
-check is printed to stderr.
-
-Usage:
-  bin/filter-clang-tidy.py [INPUT_FILE]            # read from file, or
-  run-clang-tidy ... | bin/filter-clang-tidy.py    # read from stdin
-"""
-
-import re
-import sys
-from collections import Counter
-
-# A clang-tidy diagnostic line looks like "path:line:col: error: msg [check]".
-# Matching on that shape (rather than a loose "error" substring) avoids treating
-# progress lines whose paths contain "error" as diagnostics, e.g.
-#   [284/850][0.7s] /nix/.../clang-tidy ... src/.../error.cpp
-DIAG_RE = re.compile(r":\d+:\d+: (?:error|warning|note):")
-ERROR_RE = re.compile(r":\d+:\d+: error:")
-CHECK_RE = re.compile(r" error: .*\[([^\],]+)")
-
-
-def filter_and_dedup(lines: list[str]) -> list[str]:
-    """Keep diagnostics with their context, then drop duplicate error blocks."""
-    blocks: list[str] = []
-    seen: set[str] = set()
-    current: list[str] = []
-
-    def flush() -> None:
-        if not current:
-            return
-        block = "".join(current)
-        if block not in seen:
-            seen.add(block)
-            blocks.append(block)
-
-    for line in lines:
-        # Keep only diagnostics and their indented source-context lines; drop
-        # progress/status output and blank lines.
-        if not (DIAG_RE.search(line) or line[:1] in (" ", "\t")):
-            continue
-        # An "error:" line starts a new block; its context and any following
-        # "note:" lines (and their context) belong to it.
-        if ERROR_RE.search(line):
-            flush()
-            current = []
-        current.append(line)
-    flush()
-
-    return blocks
-
-
-def summarize(blocks: list[str]) -> Counter[str]:
-    """Count unique errors per check name (e.g. "bugprone-branch-clone")."""
-    counts: Counter[str] = Counter()
-    for block in blocks:
-        # The error line is the first line of the block.
-        match = CHECK_RE.search(block.splitlines()[0])
-        if match:
-            counts[match.group(1)] += 1
-    return counts
-
-
-def main() -> int:
-    if len(sys.argv) > 1 and sys.argv[1] != "-":
-        with open(sys.argv[1], encoding="utf-8") as f:
-            lines = f.readlines()
-    else:
-        lines = sys.stdin.readlines()
-
-    blocks = filter_and_dedup(lines)
-    # Blank line between blocks so distinct errors are easy to tell apart.
-    sys.stdout.write("\n".join(blocks))
-
-    print("\nUnique errors per check:", file=sys.stderr)
-    for check, count in summarize(blocks).most_common():
-        print(f"{count:>4} {check}", file=sys.stderr)
-
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())

bin/install-sanitizer-libs.sh

@@ -1,113 +0,0 @@
-#!/bin/bash
-# Install sanitizer runtime libraries required to run binaries compiled with:
-#   -fsanitize=address   → libasan.so.8
-#   -fsanitize=thread    → libtsan.so.2
-#   -fsanitize=undefined → libubsan.so.1
-#
-# The exact SONAMEs required depend on the compiler toolchain used to build the
-# test binaries (see nix/ci-env.nix). If the toolchain is bumped and SONAMEs
-# change, update the list below (or detect them from the binaries).
-#
-# Supported base images:
-#   debian:bookworm
-#   ubuntu:20.04
-#   rhel:9
-#   nixos/nix        — tests are skipped; this script is not called
-
-set -euo pipefail
-
-if [ ! -f /etc/os-release ]; then
-    echo "ERROR: /etc/os-release not found; cannot detect OS" >&2
-    exit 1
-fi
-
-# shellcheck source=/dev/null
-. /etc/os-release
-
-echo "Detected OS: ${ID} ${VERSION_ID:-}"
-
-case "${ID}" in
-    ubuntu | debian | rhel | centos | rocky | almalinux)
-        echo "Supported OS detected: ${ID}"
-        ;;
-    *)
-        echo "ERROR: unsupported OS '${ID}'. Supported: debian, ubuntu, rhel-family" >&2
-        exit 1
-        ;;
-esac
-
-function preinstall() {
-    case "${ID}" in
-        ubuntu)
-            apt-get update -y
-            apt-get install -y --no-install-recommends \
-                gnupg \
-                software-properties-common
-            add-apt-repository -y ppa:ubuntu-toolchain-r/test
-            ;;
-    esac
-}
-
-function install() {
-    case "${ID}" in
-        debian | ubuntu)
-            apt-get update -y
-            apt-get install -y --no-install-recommends \
-                libasan8 \
-                libtsan2 \
-                libubsan1
-            ;;
-
-        rhel | centos | rocky | almalinux)
-            dnf install -y \
-                libasan8 \
-                libtsan2 \
-                libubsan
-            ;;
-    esac
-}
-
-function postinstall() {
-    # Don't clear cache in non-CI environments
-    if [ -z "${CI:-}" ]; then
-        echo "Not running in CI environment; skipping cache cleanup"
-        return
-    fi
-
-    case "${ID}" in
-        debian | ubuntu)
-            apt-get clean
-            rm -rf /var/lib/apt/lists/*
-            ;;
-
-        rhel | centos | rocky | almalinux)
-            dnf clean -y all
-            rm -rf /var/cache/dnf/*
-            ;;
-    esac
-}
-
-function verify() {
-    # Verify that every expected library is now resolvable by the dynamic linker.
-    missing=0
-    for lib in libasan.so.8 libtsan.so.2 libubsan.so.1; do
-        if ldconfig -p | grep -q "${lib}"; then
-            echo "OK: ${lib} found"
-        else
-            echo "ERROR: ${lib} not found after installation" >&2
-            missing=$((missing + 1))
-        fi
-    done
-
-    if [ "${missing}" -ne 0 ]; then
-        echo "ERROR: ${missing} library/libraries missing" >&2
-        exit 1
-    fi
-}
-
-preinstall
-install
-postinstall
-verify
-
-echo "All sanitizer runtime libraries installed successfully."

bin/pre-commit/check_doxygen_style.py

@@ -1,440 +0,0 @@
-#!/usr/bin/env python3
-"""
-Check C++ Doxygen comment style.
-
-Enforces the house convention for documentation comments:
-
-  * Use ``/** ... */`` blocks, not ``///``, ``//!`` or ``/*! ... */``; a plain
-    ``/* ... */`` that contains Doxygen commands is a doc comment missing its
-    second star. Trailing member-after comments use ``///<`` (not ``//!<``,
-    ``/*!< ... */`` or ``/**< ... */`` -- the block forms get reflowed and
-    mis-attached by clang-format on packed enum values, the line form does not).
-  * ``/**`` sits alone on its line; the closing ``*/`` sits alone on its line.
-  * Every content line is prefixed with `` * `` (no bare-indented continuation).
-  * The first content line is flush (not over-indented).
-  * Doxygen commands use the ``@cmd`` form, not ``\\cmd``.
-  * Use ``@return`` / ``@throws`` rather than prose ``Returns:`` / ``Throws:``.
-  * A plain ``//`` comment carrying a block-level ``@command`` (``@param``,
-    ``@return``, ``@see``, ...) is documentation and must be a ``/** ... */``
-    block (Doxygen ignores ``//``).
-  * Use canonical command spellings: ``@return`` (not ``@returns``),
-    ``@throws`` (not ``@throw``), ``@see`` (not ``@sa``).
-  * Order block tags ``@tparam`` -> ``@param`` -> ``@return``. (Whether
-    ``@param`` order matches the signature is not checked here -- too fragile to
-    parse; Doxygen's WARN_IF_DOC_ERROR covers name mismatches.)
-  * One-liners are expanded to three lines, EXCEPT bare markers ``@{`` / ``@}``
-    / ``@cond [label]`` / ``@endcond`` / ``@file [name]`` which stay on one line.
-
-Left intentionally alone (recognized, valid Doxygen that is not this style's
-concern):
-
-  * ``///<`` trailing "member-after" comments (the house form).
-  * Divider lines made only of slashes (``//////////``).
-  * Plain ``/* ... */`` (non-Doxygen) comments.
-
-Usage:
-    check_doxygen_style.py [FILE ...]      # explicit files
-    check_doxygen_style.py                 # default: src/ and include/ trees
-
-Exit status is non-zero if any violation is found.
-"""
-
-import argparse
-import re
-import sys
-from collections.abc import Iterable, Iterator
-from dataclasses import dataclass
-from enum import Enum
-from pathlib import Path
-
-
-class Category(Enum):
-    """A kind of style violation: a printed ``label`` and its ``description``.
-
-    The description is the default message; a few categories whose wording
-    depends on the offending text (see ``Finding.detail``) override it.
-    """
-
-    def __init__(self, label: str, description: str) -> None:
-        self.label = label
-        self.description = description
-
-    BACKSLASH_COMMAND = ("backslash-command", "use the @cmd form, not \\cmd")
-    WRONG_COMMAND = ("wrong-command", "use the canonical command spelling")
-    TRIPLE_SLASH = ("triple-slash", "use a /** ... */ block instead of ///")
-    QT_MEMBER = ("qt-member", "use ///< instead of //!<")
-    QT_LINE = ("qt-line", "use a /** ... */ block instead of //!")
-    BLOCK_MEMBER = ("block-member", "use ///< instead of /**<")
-    QT_BLOCK_MEMBER = ("qt-block-member", "use ///< instead of /*!<")
-    DOC_IN_LINE_COMMENT = (
-        "doc-in-line-comment",
-        "use a /** ... */ block for documentation, not //",
-    )
-    QT_COMMENT = ("qt-comment", "use /** instead of /*!")
-    SINGLE_LINE_BLOCK = (
-        "single-line-block",
-        "expand one-line /** ... */ to a multi-line block "
-        "(markers @{ @} @cond @endcond @file may stay)",
-    )
-    TEXT_ON_OPENER = ("text-on-opener", "move text off the /** opener line")
-    BARE_CONTINUATION = ("bare-continuation", 'prefix continuation lines with " * "')
-    OVER_INDENTED = ("over-indented", "first content line is over-indented")
-    OVER_INDENTED_TAG = (
-        "over-indented-tag",
-        'Doxygen tag over-indented; use a single space after "*"',
-    )
-    COMBINED_MARKER = (
-        "combined-marker",
-        "scope marker @{ / @} should be its own single-line /** @{ */ block",
-    )
-    PROSE_LABEL = ("prose-label", "use a Doxygen tag instead of a prose label")
-    CONTENT_ON_CLOSER = ("content-on-closer", "move content off the closing */ line")
-    PLAIN_BLOCK_DOC = (
-        "plain-block-doc",
-        "documentation comment must open with /** not /*",
-    )
-    TAG_ORDER = (
-        "tag-order",
-        "block tags out of order; expected @tparam, then @param, then @return",
-    )
-
-
-@dataclass(frozen=True)
-class Finding:
-    """A single style violation at a 1-based line number.
-
-    ``detail`` overrides the category's default description when the message
-    depends on the offending text (e.g. which command was misspelled).
-    """
-
-    line: int
-    category: Category
-    detail: str | None = None
-
-    @property
-    def message(self) -> str:
-        return self.detail if self.detail is not None else self.category.description
-
-
-DEFAULT_ROOTS = ("src", "include")
-EXTS = {".h", ".hpp", ".cpp", ".ipp", ".cxx", ".cc"}
-
-# Every Doxygen command we recognize when written with a backslash (\cmd).
-_ALL_COMMANDS = (
-    "brief|param|tparam|return|returns|retval|note|warning|pre|post|see|sa|ref|"
-    "throw|throws|exception|deprecated|details|code|endcode|verbatim|endverbatim|"
-    "li|arg|c|internal|since|todo|attention|remark|remarks|ingroup|defgroup"
-)
-# Block-level tags whose over-indentation we flag inside a block body.
-_BLOCK_TAGS = (
-    "param|tparam|returns?|retval|brief|throws?|note|warning|"
-    "pre|post|see|sa|details|deprecated"
-)
-# Tags that, appearing anywhere in a comment, mark it as documentation.
-_ANY_DOC_TAGS = (
-    "param|tparam|returns?|retval|brief|throws?|note|warning|pre|post|see|sa"
-)
-# Tags that make a plain // comment a mis-styled doc comment.
-_LINE_DOC_TAGS = "brief|param|tparam|returns?|retval|throws?|note|see|pre|post"
-
-# \cmd that should be @cmd.
-RE_BACKSLASH_CMD = re.compile(r"\\(" + _ALL_COMMANDS + r")\b")
-# Bare markers that may legitimately stay on a single line.
-RE_MARKER = re.compile(r"^@(\{|\}|cond(\s.*)?|endcond|file(\s.*)?)$")
-# Prose section labels that should be Doxygen tags.
-RE_PROSE_LABEL = re.compile(r"^\*\s(Returns|Throws|Exceptions):\s*$")
-# An over-indented block tag: "*" followed by 2+ spaces then the tag.
-RE_OVERINDENTED_TAG = re.compile(r"^\*\s{2,}@(" + _BLOCK_TAGS + r")\b")
-# Any documentation tag (used to spot a doc comment hiding in a plain /* */).
-RE_ANY_DOC_TAG = re.compile(r"@(" + _ANY_DOC_TAGS + r")\b")
-# A documentation tag inside a // comment.
-RE_LINE_DOC_TAG = re.compile(r"@(" + _LINE_DOC_TAGS + r")\b")
-# Order-relevant tags, for the @tparam -> @param -> @return ordering check.
-RE_ORDER_TAG = re.compile(r"^\*\s*@(param|tparam|returns?|retval)\b")
-# First content line indented by 2+ spaces after the "*".
-RE_FIRST_OVERINDENT = re.compile(r"^\s*\*\s{2,}\S")
-# A scope marker @{ / @} sharing a comment with other text.
-RE_COMBINED_MARKER = re.compile(r"^\*\s*@[{}]\s*$")
-
-# Non-canonical command spellings -> the house spelling (bare command names).
-# Used both to flag a wrong @form and to suggest the right @form for a \wrong.
-CANONICAL_COMMAND = {"returns": "return", "throw": "throws", "sa": "see"}
-WRONG_SPELLINGS = [
-    (re.compile(rf"@{wrong}\b"), f"@{right}")
-    for wrong, right in CANONICAL_COMMAND.items()
-]
-
-# Order block tags should appear in; a body out of this order is a violation.
-EXPECTED_TAG_ORDER = ("tparam", "param", "return")
-
-
-def is_doxy_open(stripped: str) -> bool:
-    """True for a line-start Doxygen block opener we should normalize."""
-    if stripped.startswith("/*!"):  # Qt-style Doxygen
-        return not stripped.startswith("/*!<")  # member-after, leave inline
-    return (
-        stripped.startswith("/**")
-        and not stripped.startswith("/***")
-        and not stripped.startswith("/**/")
-        and not stripped.startswith("/**<")
-    )
-
-
-def _flag_commands(raw_line: str, stripped: str, index: int) -> list[Finding]:
-    """Flag \\cmd and misspelled @cmd on a comment line (opener, body, or closer)."""
-    if not stripped.startswith(("*", "//", "/*")):
-        return []
-    findings: list[Finding] = []
-    backslash = RE_BACKSLASH_CMD.search(raw_line)
-    if backslash:
-        command = backslash.group(1)
-        canonical = CANONICAL_COMMAND.get(command, command)
-        findings.append(
-            Finding(
-                index + 1,
-                Category.BACKSLASH_COMMAND,
-                f"use @{canonical} instead of \\{command}",
-            )
-        )
-    for pattern, replacement in WRONG_SPELLINGS:
-        wrong = pattern.search(raw_line)
-        if wrong:
-            findings.append(
-                Finding(
-                    index + 1,
-                    Category.WRONG_COMMAND,
-                    f"use {replacement} instead of {wrong.group(0)}",
-                )
-            )
-    return findings
-
-
-def _flag_line_comment(raw_line: str, stripped: str, index: int) -> Finding | None:
-    """Return the finding for a single-line comment form (///, //!, /**<, ...), else None."""
-    if stripped.startswith("///") and not stripped.startswith(("////", "///<")):
-        return Finding(index + 1, Category.TRIPLE_SLASH)
-    if "//!<" in raw_line:
-        return Finding(index + 1, Category.QT_MEMBER)
-    if stripped.startswith("//!"):
-        return Finding(index + 1, Category.QT_LINE)
-    if "/**<" in raw_line:
-        return Finding(index + 1, Category.BLOCK_MEMBER)
-    if "/*!<" in raw_line:
-        return Finding(index + 1, Category.QT_BLOCK_MEMBER)
-    if stripped.startswith("//") and RE_LINE_DOC_TAG.search(stripped):
-        return Finding(index + 1, Category.DOC_IN_LINE_COMMENT)
-    return None
-
-
-def _flag_single_line_block(stripped: str, line_no: int, is_qt: bool) -> list[Finding]:
-    """Findings for a whole /** ... */ or /*! ... */ block on one line."""
-    inner = re.sub(r"^/\*[*!]", "", stripped)
-    inner = re.sub(r"\*/\s*$", "", inner).strip()
-    findings: list[Finding] = []
-    if is_qt:
-        findings.append(Finding(line_no, Category.QT_COMMENT))
-    if inner and not RE_MARKER.match(inner):
-        findings.append(Finding(line_no, Category.SINGLE_LINE_BLOCK))
-    return findings
-
-
-def _canonical_order_tag(body: str) -> str | None:
-    """The order-relevant tag (tparam/param/return) a body line opens with, if any."""
-    match = RE_ORDER_TAG.match(body)
-    if match is None:
-        return None
-    command = match.group(1)
-    return "return" if command in ("return", "returns", "retval") else command
-
-
-def _flag_body_line(
-    body_line: str, line_no: int, is_first_content: bool
-) -> list[Finding]:
-    """Findings for one interior line of a multi-line block."""
-    body = body_line.strip()
-    findings: list[Finding] = []
-    if body and not body.startswith("*"):
-        findings.append(Finding(line_no, Category.BARE_CONTINUATION))
-    if body.startswith("*"):
-        if is_first_content and RE_FIRST_OVERINDENT.match(body_line):
-            findings.append(Finding(line_no, Category.OVER_INDENTED))
-        if RE_OVERINDENTED_TAG.match(body):
-            findings.append(Finding(line_no, Category.OVER_INDENTED_TAG))
-        if RE_COMBINED_MARKER.match(body):
-            findings.append(Finding(line_no, Category.COMBINED_MARKER))
-        label = RE_PROSE_LABEL.match(body)
-        if label:
-            suggested_tag = "@return" if label.group(1) == "Returns" else "@throws"
-            findings.append(
-                Finding(
-                    line_no,
-                    Category.PROSE_LABEL,
-                    f'use {suggested_tag} instead of prose "{label.group(1)}:"',
-                )
-            )
-    return findings
-
-
-def _flag_closer(closer_line: str, line_no: int) -> list[Finding]:
-    """Findings for content sharing the closing */ line."""
-    before = closer_line[: closer_line.index("*/")].strip()
-    if before and before != "*":
-        return [Finding(line_no, Category.CONTENT_ON_CLOSER)]
-    return []
-
-
-def _flag_tag_order(first_tag_line: dict[str, int]) -> list[Finding]:
-    """One finding if the present block tags are not in EXPECTED_TAG_ORDER."""
-    tag_lines = [
-        first_tag_line[tag] for tag in EXPECTED_TAG_ORDER if tag in first_tag_line
-    ]
-    if tag_lines != sorted(tag_lines):
-        return [Finding(min(tag_lines), Category.TAG_ORDER)]
-    return []
-
-
-def _flag_doxy_block(lines: list[str], start: int) -> tuple[int, list[Finding]]:
-    """Handle a /** or /*! block opening at ``start``; return (next index, findings)."""
-    raw_line = lines[start]
-    stripped = raw_line.lstrip()
-    open_pos = raw_line.index("/*")
-    is_qt = stripped.startswith("/*!")
-
-    # A whole block on one line: /** ... */.
-    if "*/" in raw_line[open_pos + 2 :]:
-        return start + 1, _flag_single_line_block(stripped, start + 1, is_qt)
-
-    # Multi-line block: opener, then scan the body to the closer.
-    findings: list[Finding] = []
-    if is_qt:
-        findings.append(Finding(start + 1, Category.QT_COMMENT))
-    if raw_line[open_pos + 3 :].strip():
-        findings.append(Finding(start + 1, Category.TEXT_ON_OPENER))
-
-    line_count = len(lines)
-    cursor = start + 1
-    is_first_content = True
-    first_tag_line: dict[str, int] = {}  # canonical tag -> 1-based first line
-    while cursor < line_count and "*/" not in lines[cursor]:
-        body_line = lines[cursor]
-        body = body_line.strip()
-        findings.extend(_flag_commands(body_line, body, cursor))
-        tag = _canonical_order_tag(body)
-        if tag is not None:
-            first_tag_line.setdefault(tag, cursor + 1)
-        findings.extend(_flag_body_line(body_line, cursor + 1, is_first_content))
-        if body.startswith("*"):
-            is_first_content = False
-        cursor += 1
-
-    if cursor < line_count:
-        closer_line = lines[cursor]
-        findings.extend(_flag_commands(closer_line, closer_line.strip(), cursor))
-        findings.extend(_flag_closer(closer_line, cursor + 1))
-    findings.extend(_flag_tag_order(first_tag_line))
-
-    return cursor + 1, findings
-
-
-def _flag_plain_block(lines: list[str], start: int) -> tuple[int, list[Finding]]:
-    """Handle a line-start plain /* ... */ block; return (next index, findings).
-
-    Only flagged when it hides a documentation command (a missing second star).
-    """
-    line_count = len(lines)
-    cursor = start
-    while cursor < line_count and "*/" not in lines[cursor]:
-        cursor += 1
-    findings: list[Finding] = []
-    # The opener (start) is command-checked by check_file; check the rest here.
-    for i in range(start + 1, min(cursor + 1, line_count)):
-        findings.extend(_flag_commands(lines[i], lines[i].strip(), i))
-    block_text = "\n".join(
-        lines[start : cursor + 1] if cursor < line_count else lines[start:]
-    )
-    if RE_ANY_DOC_TAG.search(block_text):
-        findings.append(Finding(start + 1, Category.PLAIN_BLOCK_DOC))
-    next_index = cursor + 1 if cursor < line_count else line_count
-    return next_index, findings
-
-
-def check_source(text: str) -> list[Finding]:
-    """Return all style violations found in the given source text."""
-    lines = text.split("\n")
-    findings: list[Finding] = []
-    line_count = len(lines)
-    index = 0
-    in_plain_block = False  # inside a mid-line, non-Doxygen /* ... */
-    while index < line_count:
-        raw_line = lines[index]
-        stripped = raw_line.lstrip()
-
-        # Skip the interior of a plain block opened on an earlier line.
-        if in_plain_block:
-            in_plain_block = "*/" not in raw_line
-            index += 1
-            continue
-
-        findings.extend(_flag_commands(raw_line, stripped, index))
-
-        line_finding = _flag_line_comment(raw_line, stripped, index)
-        if line_finding is not None:
-            findings.append(line_finding)
-            index += 1
-        elif is_doxy_open(stripped):
-            index, block_findings = _flag_doxy_block(lines, index)
-            findings.extend(block_findings)
-        elif stripped.startswith("/*"):
-            index, block_findings = _flag_plain_block(lines, index)
-            findings.extend(block_findings)
-        else:
-            # A /* that opens mid-line without closing starts a plain block.
-            if "/*" in raw_line and not stripped.startswith("//"):
-                if "*/" not in raw_line[raw_line.index("/*") + 2 :]:
-                    in_plain_block = True
-            index += 1
-    return findings
-
-
-def check_file(path: Path) -> list[Finding]:
-    """Return all style violations found in one file."""
-    return check_source(path.read_text(encoding="utf-8"))
-
-
-def iter_files(paths: Iterable[str]) -> Iterator[Path]:
-    """Yield every C++ source file among the given files and directories."""
-    for raw_path in paths:
-        path = Path(raw_path)
-        if path.is_dir():
-            for candidate in path.rglob("*"):
-                if candidate.is_file() and candidate.suffix in EXTS:
-                    yield candidate
-        elif path.suffix in EXTS:
-            yield path
-
-
-def main() -> int:
-    parser = argparse.ArgumentParser(description="Check Doxygen comment style.")
-    parser.add_argument(
-        "files", nargs="*", help="files or directories (default: src/ include/)"
-    )
-    parser.add_argument(
-        "-q", "--quiet", action="store_true", help="only print the summary count"
-    )
-    args = parser.parse_args()
-    roots = args.files or [root for root in DEFAULT_ROOTS if Path(root).is_dir()]
-
-    total = 0
-    for path in sorted(set(iter_files(roots)), key=str):
-        for finding in check_file(path):
-            total += 1
-            if not args.quiet:
-                print(
-                    f"{path}:{finding.line}: {finding.category.label}: {finding.message}"
-                )
-    print(f"\n{total} doxygen-style violation(s)", file=sys.stderr)
-    return 1 if total else 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())

bin/pre-commit/clang_tidy_check.py

@@ -1,27 +1,24 @@
 #!/usr/bin/env python3
-"""Pre-commit hook that runs clang-tidy on changed files using run-clang-tidy.
-
-The set of files is chosen by pre-commit (see .pre-commit-config.yaml), which
-filters to C/C++ sources and excludes `.ipp` fragments. Headers are linted
-directly: the `verify_headers` build option (ON by default) compiles every
-`.h`/`.hpp` on its own, so each header is the main file of its own
-compile_commands.json entry and run-clang-tidy can analyse it just like a
-`.cpp`.
-"""
+"""Pre-commit hook that runs clang-tidy on changed files using run-clang-tidy."""
 
 from __future__ import annotations
 
+import json
 import os
+import re
 import shutil
 import subprocess
 import sys
+from collections import defaultdict
 from pathlib import Path
 
-CLANG_TIDY_VERSION = 22
+HEADER_EXTENSIONS = {".h", ".hpp", ".ipp"}
+SOURCE_EXTENSIONS = {".cpp"}
+INCLUDE_RE = re.compile(r"^\s*#\s*include\s*[<\"]([^>\"]+)[>\"]")
 
 
 def find_run_clang_tidy() -> str | None:
-    for candidate in (f"run-clang-tidy-{CLANG_TIDY_VERSION}", "run-clang-tidy"):
+    for candidate in ("run-clang-tidy-21", "run-clang-tidy"):
         if path := shutil.which(candidate):
             return path
     return None
@@ -35,23 +32,142 @@ def find_build_dir(repo_root: Path) -> Path | None:
     return None
 
 
+def build_include_graph(build_dir: Path, repo_root: Path) -> tuple[dict, set]:
+    """
+    Scan all files reachable from compile_commands.json and build an inverted include graph.
+
+    Returns:
+        inverted: header_path -> set of files that include it
+        source_files: set of all TU paths from compile_commands.json
+    """
+    with open(build_dir / "compile_commands.json") as f:
+        db = json.load(f)
+
+    source_files = {Path(e["file"]).resolve() for e in db}
+    include_roots = [repo_root / "include", repo_root / "src"]
+    inverted: dict[Path, set[Path]] = defaultdict(set)
+
+    to_scan: set[Path] = set(source_files)
+    scanned: set[Path] = set()
+
+    while to_scan:
+        file = to_scan.pop()
+        if file in scanned or not file.exists():
+            continue
+        scanned.add(file)
+
+        content = file.read_text()
+
+        for line in content.splitlines():
+            m = INCLUDE_RE.match(line)
+            if not m:
+                continue
+            for root in include_roots:
+                candidate = (root / m.group(1)).resolve()
+                if candidate.exists():
+                    inverted[candidate].add(file)
+                    if candidate not in scanned:
+                        to_scan.add(candidate)
+                    break
+
+    return inverted, source_files
+
+
+def find_tus_for_headers(
+    headers: list[Path],
+    inverted: dict[Path, set[Path]],
+    source_files: set[Path],
+) -> set[Path]:
+    """
+    For each header, pick one TU that transitively includes it.
+    Prefers a TU whose stem matches the header's stem, otherwise picks the first found.
+    """
+    result: set[Path] = set()
+
+    for header in headers:
+        preferred: Path | None = None
+        visited: set[Path] = {header}
+        stack: list[Path] = [header]
+
+        while stack:
+            h = stack.pop()
+            for inc in inverted.get(h, ()):
+                if inc in source_files:
+                    if inc.stem == header.stem:
+                        preferred = inc
+                        break
+                    if preferred is None:
+                        preferred = inc
+                if inc not in visited:
+                    visited.add(inc)
+                    stack.append(inc)
+            if preferred is not None and preferred.stem == header.stem:
+                break
+
+        if preferred is not None:
+            result.add(preferred)
+
+    return result
+
+
+def resolve_files(
+    input_files: list[str], build_dir: Path, repo_root: Path
+) -> list[str]:
+    """
+    Split input into source files and headers. Source files are passed through;
+    headers are resolved to the TUs that transitively include them.
+    """
+    sources: list[Path] = []
+    headers: list[Path] = []
+
+    for f in input_files:
+        p = Path(f).resolve()
+        if p.suffix in SOURCE_EXTENSIONS:
+            sources.append(p)
+        elif p.suffix in HEADER_EXTENSIONS:
+            headers.append(p)
+
+    if not headers:
+        return [str(p) for p in sources]
+
+    print(
+        f"Resolving {len(headers)} header(s) to compilation units...", file=sys.stderr
+    )
+    inverted, source_files = build_include_graph(build_dir, repo_root)
+    tus = find_tus_for_headers(headers, inverted, source_files)
+
+    if not tus:
+        print(
+            "Warning: no compilation units found that include the modified headers; "
+            "skipping clang-tidy for headers.",
+            file=sys.stderr,
+        )
+
+    return sorted({str(p) for p in (*sources, *tus)})
+
+
+def staged_files(repo_root: Path) -> list[str]:
+    result = subprocess.run(
+        ["git", "diff", "--staged", "--name-only", "--diff-filter=d"],
+        capture_output=True,
+        text=True,
+        cwd=repo_root,
+    )
+    if result.returncode != 0:
+        print(
+            "clang-tidy check failed: 'git diff --staged' command failed.",
+            file=sys.stderr,
+        )
+        if result.stderr:
+            print(result.stderr, file=sys.stderr)
+        sys.exit(result.returncode or 1)
+    return [str(repo_root / p) for p in result.stdout.splitlines() if p]
+
+
 def main():
     if not os.environ.get("TIDY"):
         return 0
 
-    files = sys.argv[1:]
-    if not files:
-        return 0
-
-    run_clang_tidy = find_run_clang_tidy()
-    if not run_clang_tidy:
-        print(
-            f"clang-tidy check failed: TIDY is enabled but neither "
-            f"'run-clang-tidy-{CLANG_TIDY_VERSION}' nor 'run-clang-tidy' was found in PATH.",
-            file=sys.stderr,
-        )
-        return 1
-
     repo_root = Path(
         subprocess.check_output(
             ["git", "rev-parse", "--show-toplevel"],
@@ -59,6 +175,19 @@ def main():
             text=True,
         ).strip()
     )
+    files = staged_files(repo_root)
+    if not files:
+        return 0
+
+    run_clang_tidy = find_run_clang_tidy()
+    if not run_clang_tidy:
+        print(
+            "clang-tidy check failed: TIDY is enabled but neither "
+            "'run-clang-tidy-21' nor 'run-clang-tidy' was found in PATH.",
+            file=sys.stderr,
+        )
+        return 1
+
     build_dir = find_build_dir(repo_root)
     if not build_dir:
         print(
@@ -68,9 +197,13 @@ def main():
         )
         return 1
 
+    tidy_files = resolve_files(files, build_dir, repo_root)
+    if not tidy_files:
+        return 0
+
     result = subprocess.run(
         [run_clang_tidy, "-quiet", "-p", str(build_dir), "-fix", "-allow-no-checks"]
-        + files
+        + tidy_files
     )
     return result.returncode
 

bin/pre-commit/fix_pragma_once.py

@@ -1,34 +0,0 @@
-#!/usr/bin/env python3
-
-"""
-Adds "#pragma once" to the top of header files that don't already have it.
-
-Usage: ./bin/pre-commit/fix_pragma_once.py <file1> <file2> ...
-"""
-
-import sys
-from pathlib import Path
-
-PRAGMA_ONCE = "#pragma once\n\n"
-
-
-def fix_pragma_once(path: Path) -> bool:
-    original = path.read_text(encoding="utf-8")
-    if PRAGMA_ONCE not in original:
-        path.write_text(PRAGMA_ONCE + original, encoding="utf-8")
-        return False
-    return True
-
-
-def main() -> int:
-    files = [Path(f) for f in sys.argv[1:]]
-    success = True
-
-    for path in files:
-        success &= fix_pragma_once(path)
-
-    return 0 if success else 1
-
-
-if __name__ == "__main__":
-    sys.exit(main())

bin/pre-commit/test_check_doxygen_style.py

@@ -1,406 +0,0 @@
-#!/usr/bin/env python3
-"""
-Tests for check_doxygen_style.py.
-
-Run directly (no test framework needed):
-    ./bin/pre-commit/test_check_doxygen_style.py
-or under pytest:
-    pytest bin/pre-commit/test_check_doxygen_style.py
-"""
-
-import sys
-import textwrap
-
-from check_doxygen_style import Finding, check_source
-
-
-def findings_for(text: str) -> list[Finding]:
-    """Return the style violations for the given source text.
-
-    The text is dedented and its leading newline stripped, so fixtures can be
-    written as indented triple-quoted here-docs while keeping honest 1-based
-    line numbers.
-    """
-    text = textwrap.dedent(text).lstrip("\n")
-    return check_source(text)
-
-
-def labels_for(text: str) -> list[str]:
-    return [f.category.label for f in findings_for(text)]
-
-
-def messages_for(text: str) -> list[str]:
-    return [f.message for f in findings_for(text)]
-
-
-# --- well-formed input produces nothing -------------------------------------
-
-
-def test_clean_block_ok() -> None:
-    code = """
-    /**
-     * Brief.
-     *
-     * @tparam T a type
-     * @param x the x
-     * @return the result
-     */
-    """
-    assert findings_for(code) == []
-
-
-def test_blank_lines_inside_block_ok() -> None:
-    code = """
-    /**
-     * a
-     *
-     * b
-     */
-    """
-    assert findings_for(code) == []
-
-
-def test_member_and_divider_allowed() -> None:
-    assert findings_for("int x;  ///< ok member\n") == []
-    assert findings_for("//////////\n") == []
-    assert findings_for("//// text\n") == []
-
-
-# --- line-comment forms ------------------------------------------------------
-
-
-def test_triple_slash() -> None:
-    code = "/// doc\n"
-    assert labels_for(code) == ["triple-slash"]
-
-
-def test_qt_line() -> None:
-    code = "//! doc\n"
-    assert labels_for(code) == ["qt-line"]
-
-
-def test_qt_member() -> None:
-    code = "int x;  //!< doc\n"
-    assert labels_for(code) == ["qt-member"]
-
-
-def test_block_member() -> None:
-    code = "int x;  /**< doc */\n"
-    assert labels_for(code) == ["block-member"]
-
-
-def test_qt_block_member() -> None:
-    code = "int x;  /*!< doc */\n"
-    assert labels_for(code) == ["qt-block-member"]
-
-
-def test_doc_in_line_comment() -> None:
-    code = "// @param x\n"
-    assert labels_for(code) == ["doc-in-line-comment"]
-
-
-# --- block forms -------------------------------------------------------------
-
-
-def test_qt_comment() -> None:
-    code = """
-    /*!
-     * brief
-     */
-    """
-    assert labels_for(code) == ["qt-comment"]
-
-
-def test_qt_comment_single_line() -> None:
-    # /*! ... */ on one line -> qt-comment (plus single-line-block)
-    code = "/*! brief */\n"
-    assert labels_for(code) == ["qt-comment", "single-line-block"]
-
-
-def test_single_line_block() -> None:
-    code = "/** brief */\n"
-    assert labels_for(code) == ["single-line-block"]
-
-
-def test_single_line_markers_allowed() -> None:
-    for marker in ("@{", "@}", "@cond LABEL", "@endcond", "@file foo.h"):
-        code = f"/** {marker} */\n"
-        assert findings_for(code) == [], marker
-
-
-def test_text_on_opener() -> None:
-    code = """
-    /** text here
-     * more
-     */
-    """
-    assert labels_for(code) == ["text-on-opener"]
-
-
-def test_bare_continuation() -> None:
-    code = """
-    /**
-     * a
-       bare line
-     */
-    """
-    assert labels_for(code) == ["bare-continuation"]
-
-
-def test_over_indented_first_line() -> None:
-    code = """
-    /**
-     *   over
-     */
-    """
-    assert labels_for(code) == ["over-indented"]
-
-
-def test_over_indented_tag() -> None:
-    # a flush first line consumes "first content", isolating the tag check
-    code = """
-    /**
-     * brief
-     *   @param x
-     */
-    """
-    assert labels_for(code) == ["over-indented-tag"]
-
-
-def test_combined_marker() -> None:
-    code = """
-    /**
-     * @{
-     */
-    """
-    assert labels_for(code) == ["combined-marker"]
-
-
-def test_prose_label() -> None:
-    for word in ("Returns", "Throws", "Exceptions"):
-        code = f"""
-        /**
-         * {word}:
-         */
-        """
-        assert labels_for(code) == ["prose-label"], word
-
-
-def test_content_on_closer() -> None:
-    code = """
-    /**
-     * a
-     * b */
-    """
-    assert labels_for(code) == ["content-on-closer"]
-
-
-def test_plain_block_doc() -> None:
-    assert labels_for("/* @param x */\n") == ["plain-block-doc"]
-    assert findings_for("/* just an ordinary note */\n") == []
-
-
-def test_tag_order() -> None:
-    out_of_order = """
-    /**
-     * @param x
-     * @tparam T
-     */
-    """
-    assert labels_for(out_of_order) == ["tag-order"]
-
-    correct = """
-    /**
-     * @tparam T
-     * @param x
-     * @return r
-     */
-    """
-    assert findings_for(correct) == []
-
-    single = """
-    /**
-     * @param x
-     */
-    """
-    assert findings_for(single) == []  # single tag: never out of order
-
-
-# --- command spelling (must work on body/closer lines, not just the opener) --
-
-
-def test_backslash_command_on_body_line() -> None:
-    code = r"""
-    /**
-     * \brief x
-     */
-    """
-    assert labels_for(code) == ["backslash-command"]
-
-
-def test_backslash_command_suggests_canonical_spelling() -> None:
-    # a backslash + non-canonical spelling is fixed in one pass, not two:
-    # \sa -> @see (not @sa), \returns -> @return (not @returns)
-    sa = r"""
-    /**
-     * \sa other
-     */
-    """
-    assert messages_for(sa) == [r"use @see instead of \sa"]
-
-    returns = r"""
-    /**
-     * \returns x
-     */
-    """
-    assert messages_for(returns) == [r"use @return instead of \returns"]
-
-
-def test_wrong_command_on_body_line() -> None:
-    code = """
-    /**
-     * @returns x
-     */
-    """
-    assert labels_for(code) == ["wrong-command"]
-
-
-def test_body_line_commands_regression() -> None:
-    # regression: these live on body lines of a multi-line block
-    code = r"""
-    /**
-     * @returns bad
-     * @throw ex
-     * @sa other
-     * \param y
-     */
-    """
-    assert labels_for(code) == [
-        "wrong-command",
-        "wrong-command",
-        "wrong-command",
-        "backslash-command",
-    ]
-
-
-def test_command_on_closer_line() -> None:
-    code = """
-    /**
-     * a
-     * @sa b */
-    """
-    assert labels_for(code) == ["wrong-command", "content-on-closer"]
-
-
-def test_no_double_count_across_opener_body_closer() -> None:
-    code = """
-    /** @returns opener
-     * @throw body
-     * @sa closer */
-    """
-    assert labels_for(code).count("wrong-command") == 3
-
-
-def test_code_with_word_allowed() -> None:
-    # @code{.cpp} is valid Doxygen and must not be flagged
-    code = """
-    /**
-     * @code{.cpp}
-     * int x;
-     * @endcode
-     */
-    """
-    assert findings_for(code) == []
-
-
-# --- rendered message text ---------------------------------------------------
-
-
-def test_message_uses_category_description() -> None:
-    # a static category renders its default description
-    code = "/// doc\n"
-    assert messages_for(code) == ["use a /** ... */ block instead of ///"]
-
-
-def test_message_detail_overrides() -> None:
-    # dynamic categories render the offending text via Finding.detail
-    backslash = r"""
-    /**
-     * \param y
-     */
-    """
-    assert messages_for(backslash) == [r"use @param instead of \param"]
-
-    wrong = """
-    /**
-     * @returns x
-     */
-    """
-    assert messages_for(wrong) == ["use @return instead of @returns"]
-
-    prose = """
-    /**
-     * Throws:
-     */
-    """
-    assert messages_for(prose) == ['use @throws instead of prose "Throws:"']
-
-
-# --- robustness --------------------------------------------------------------
-
-
-def test_empty_file_no_crash() -> None:
-    assert findings_for("") == []
-
-
-def test_mid_line_plain_block_skipped() -> None:
-    # a /* opened mid-line (after code) and spanning lines is skipped, so its
-    # comment-like contents are not analyzed
-    code = """
-    int x = 0;  /* note: @returns is not a real tag here
-     * @param also not real
-     */
-    int y = 0;
-    """
-    assert findings_for(code) == []
-
-
-def test_unclosed_block_scanned_to_eof() -> None:
-    # an unterminated /** block is still scanned to EOF (no crash, body checked)
-    code = """
-    /**
-     * @returns x
-    """
-    assert labels_for(code) == ["wrong-command"]
-
-
-def test_banner_and_empty_comment_not_flagged() -> None:
-    code = """
-    /***
-     * banner
-     ***/
-    """
-    assert findings_for(code) == []
-    assert findings_for("/**/\n") == []
-
-
-def main() -> int:
-    tests = sorted(
-        (name, fn)
-        for name, fn in globals().items()
-        if name.startswith("test_") and callable(fn)
-    )
-    failed = 0
-    for name, fn in tests:
-        try:
-            fn()
-            print(f"PASS {name}")
-        except AssertionError as exc:
-            failed += 1
-            print(f"FAIL {name}: {exc!r}")
-    print(f"\n{len(tests) - failed}/{len(tests)} passed")
-    return 1 if failed else 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())

cmake/CompilationEnv.cmake

@@ -56,16 +56,3 @@ elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64|arm64|ARM64")
 else()
     message(FATAL_ERROR "Unknown architecture: ${CMAKE_SYSTEM_PROCESSOR}")
 endif()
-
-# --------------------------------------------------------------------
-# Sanitizers
-# --------------------------------------------------------------------
-# SANITIZERS is injected by the Conan toolchain when a sanitizer build is
-# requested (see conan/profiles/sanitizers). The flags are applied to the
-# 'common' target in XrplSanitizers; this flag lets other modules know a
-# sanitizer build is active without depending on that module.
-if(DEFINED SANITIZERS)
-    set(SANITIZERS_ENABLED TRUE)
-else()
-    set(SANITIZERS_ENABLED FALSE)
-endif()

cmake/PatchNixBinary.cmake

@@ -1,53 +0,0 @@
-#[===================================================================[
-   Patch executables to run in non-Nix environments.
-
-   The Nix-based CI image links binaries against an ELF interpreter (loader)
-   that lives in the Nix store, so the resulting binaries don't run elsewhere
-   (including once installed from the .deb package). `patch_nix_binary` adds a
-   POST_BUILD step that resets the interpreter to the system default loader and
-   drops the rpath.
-
-   This is only active inside the Nix-based image, detected by the presence of
-   /tmp/loader-path.sh (shipped by that image, resolves the default loader). It
-   is skipped for sanitizer builds, whose runtime libraries are resolved through
-   the rpath. Everywhere else `patch_nix_binary` is a no-op.
-#]===================================================================]
-
-include_guard(GLOBAL)
-
-include(CompilationEnv)
-
-# Provided by the Nix-based CI image; prints the system default ELF loader path.
-set(_loader_path_script "/tmp/loader-path.sh")
-
-if(is_linux AND NOT SANITIZERS_ENABLED AND EXISTS "${_loader_path_script}")
-    execute_process(
-        COMMAND "${_loader_path_script}"
-        OUTPUT_VARIABLE DEFAULT_LOADER_PATH
-        OUTPUT_STRIP_TRAILING_WHITESPACE
-        COMMAND_ERROR_IS_FATAL ANY
-    )
-    find_program(PATCHELF_COMMAND patchelf REQUIRED)
-    set(PATCH_NIX_BINARIES TRUE)
-    message(
-        STATUS
-        "Binaries will be patched to use loader '${DEFAULT_LOADER_PATH}'"
-    )
-else()
-    set(PATCH_NIX_BINARIES FALSE)
-endif()
-
-function(patch_nix_binary target)
-    if(NOT PATCH_NIX_BINARIES)
-        return()
-    endif()
-    add_custom_command(
-        TARGET ${target}
-        POST_BUILD
-        COMMAND
-            "${PATCHELF_COMMAND}" --set-interpreter "${DEFAULT_LOADER_PATH}"
-            --remove-rpath "$<TARGET_FILE:${target}>"
-        COMMENT "Patching ${target}: set default loader, remove rpath"
-        VERBATIM
-    )
-endfunction()

cmake/XrplAddTest.cmake

@@ -0,0 +1,22 @@
+include(isolate_headers)
+
+function(xrpl_add_test name)
+    set(target ${PROJECT_NAME}.test.${name})
+
+    file(
+        GLOB_RECURSE sources
+        CONFIGURE_DEPENDS
+        "${CMAKE_CURRENT_SOURCE_DIR}/${name}/*.cpp"
+        "${CMAKE_CURRENT_SOURCE_DIR}/${name}.cpp"
+    )
+    add_executable(${target} ${ARGN} ${sources})
+
+    isolate_headers(
+        ${target}
+        "${CMAKE_SOURCE_DIR}"
+        "${CMAKE_SOURCE_DIR}/tests/${name}"
+        PRIVATE
+    )
+
+    add_test(NAME ${target} COMMAND ${target})
+endfunction()

cmake/XrplCompiler.cmake

@@ -145,48 +145,13 @@ else()
         INTERFACE
             -rdynamic
             $<$<BOOL:${is_linux}>:-Wl,-z,relro,-z,now,--build-id>
-            # link to static libc/c++ if:
-            # * static option set and
-            # * NOT APPLE (AppleClang does not support static libc/c++)
-            $<$<AND:$<BOOL:${static}>,$<NOT:$<BOOL:${APPLE}>>>:
+            # link to static libc/c++ iff: * static option set and * NOT APPLE (AppleClang does not support static
+            # libc/c++) and * NOT SANITIZERS (sanitizers typically don't work with static libc/c++)
+            $<$<AND:$<BOOL:${static}>,$<NOT:$<BOOL:${APPLE}>>,$<NOT:$<BOOL:${SANITIZERS_ENABLED}>>>:
             -static-libstdc++
             -static-libgcc
             >
     )
-
-    # On aarch64, libatomic is required for atomic operations. It is not needed on x86_64.
-    # Linking it statically on Linux
-    if(is_arm64 AND is_linux)
-        target_link_options(
-            common
-            INTERFACE -Wl,--push-state -Wl,-Bstatic -latomic -Wl,--pop-state
-        )
-    endif()
-
-    # Keep -stdlib=libstdc++ off the compile commands, but preserve it for linking.
-    #
-    # Conan turns `compiler.libcxx=libstdc++` into `-stdlib=libstdc++` and puts it in
-    # CMAKE_CXX_FLAGS, which CMake passes to BOTH compile and link steps. On a normal Clang
-    # the compile step consumes it while choosing the C++ stdlib include paths. The Nixpkgs
-    # Clang wrapper supplies those paths itself (via -nostdinc++), so at compile time the
-    # flag is unused -> Clang errors under our -Werror. At link time the flag IS consumed
-    # (it selects the C++ runtime), so we move it there instead of dropping it entirely.
-    get_filename_component(_cxx_real "${CMAKE_CXX_COMPILER}" REALPATH)
-    if(
-        _cxx_real MATCHES "^/nix/store/"
-        AND is_linux
-        AND is_clang
-        AND CMAKE_CXX_FLAGS MATCHES "stdlib=libstdc"
-    )
-        string(
-            REPLACE "-stdlib=libstdc++"
-            ""
-            CMAKE_CXX_FLAGS
-            "${CMAKE_CXX_FLAGS}"
-        )
-        string(STRIP "${CMAKE_CXX_FLAGS}" CMAKE_CXX_FLAGS)
-        add_link_options($<$<LINK_LANGUAGE:CXX>:-stdlib=libstdc++>)
-    endif()
 endif()
 
 # Antithesis instrumentation will only be built and deployed using machines running Linux.

cmake/XrplCore.cmake

@@ -94,9 +94,6 @@ add_module(xrpl basics)
 target_link_libraries(xrpl.libxrpl.basics PUBLIC xrpl.libxrpl.beast)
 
 # Level 03
-add_module(xrpl config)
-target_link_libraries(xrpl.libxrpl.config PUBLIC xrpl.libxrpl.basics)
-
 add_module(xrpl json)
 target_link_libraries(xrpl.libxrpl.json PUBLIC xrpl.libxrpl.basics)
 
@@ -123,7 +120,6 @@ target_link_libraries(
     xrpl.libxrpl.core
     PUBLIC
         xrpl.libxrpl.basics
-        xrpl.libxrpl.config
         xrpl.libxrpl.json
         xrpl.libxrpl.protocol
         xrpl.libxrpl.protocol_autogen
@@ -147,11 +143,7 @@ target_link_libraries(
 add_module(xrpl nodestore)
 target_link_libraries(
     xrpl.libxrpl.nodestore
-    PUBLIC
-        xrpl.libxrpl.basics
-        xrpl.libxrpl.config
-        xrpl.libxrpl.json
-        xrpl.libxrpl.protocol
+    PUBLIC xrpl.libxrpl.basics xrpl.libxrpl.json xrpl.libxrpl.protocol
 )
 
 add_module(xrpl shamap)
@@ -167,14 +159,13 @@ target_link_libraries(
 add_module(xrpl rdb)
 target_link_libraries(
     xrpl.libxrpl.rdb
-    PUBLIC xrpl.libxrpl.basics xrpl.libxrpl.config xrpl.libxrpl.core
+    PUBLIC xrpl.libxrpl.basics xrpl.libxrpl.core
 )
 
 add_module(xrpl server)
 target_link_libraries(
     xrpl.libxrpl.server
     PUBLIC
-        xrpl.libxrpl.config
         xrpl.libxrpl.protocol
         xrpl.libxrpl.core
         xrpl.libxrpl.rdb
@@ -219,7 +210,6 @@ target_link_modules(
     basics
     beast
     conditions
-    config
     core
     crypto
     git
@@ -247,7 +237,6 @@ target_link_modules(
 
 if(xrpld)
     add_executable(xrpld)
-    patch_nix_binary(xrpld)
     if(tests)
         target_compile_definitions(xrpld PUBLIC ENABLE_TESTS)
         target_compile_definitions(
@@ -293,13 +282,4 @@ if(xrpld)
             PRIVATE ${CMAKE_SOURCE_DIR}/external/antithesis-sdk
         )
     endif()
-
-    # The xrpld headers are not built with add_module, so verify them against
-    # the executable's own compile environment.
-    if(verify_headers)
-        verify_target_headers(xrpld "${CMAKE_CURRENT_SOURCE_DIR}/src/xrpld")
-        if(tests)
-            verify_target_headers(xrpld "${CMAKE_CURRENT_SOURCE_DIR}/src/test")
-        endif()
-    endif()
 endif()

cmake/XrplCov.cmake

@@ -47,7 +47,7 @@ setup_target_for_coverage_gcovr(
         "include/xrpl/beast/test"
         "include/xrpl/beast/unit_test"
         "${CMAKE_BINARY_DIR}/pb-xrpl.libpb"
-    DEPENDENCIES xrpld xrpl_tests
+    DEPENDENCIES xrpld xrpl.tests
 )
 
 add_code_coverage_to_target(opts INTERFACE)

cmake/XrplPackaging.cmake

@@ -28,6 +28,7 @@ endif()
 set(package_env
     SRC_DIR=${CMAKE_SOURCE_DIR}
     BUILD_DIR=${CMAKE_BINARY_DIR}
+    PKG_VERSION=${xrpld_version}
     PKG_RELEASE=${pkg_release}
 )
 

cmake/XrplSanitizers.cmake

@@ -14,9 +14,11 @@
 include_guard(GLOBAL)
 include(CompilationEnv)
 
-if(NOT SANITIZERS_ENABLED)
+if(NOT DEFINED SANITIZERS)
+    set(SANITIZERS_ENABLED FALSE)
     return()
 endif()
+set(SANITIZERS_ENABLED TRUE)
 
 message(STATUS "=== Configuring Sanitizers ===")
 message(STATUS "  SANITIZERS: ${SANITIZERS}")

cmake/XrplSettings.cmake

@@ -30,23 +30,6 @@ if(tests)
     endif()
 endif()
 
-# Enabled by default so every header is compiled on its own as the main file of
-# its own compile_commands.json entry - this is what lets clang-tidy (and clangd
-# and IDEs) analyse a header's own includes directly. The per-header objects are
-# EXCLUDE_FROM_ALL (see cmake/verify_headers.cmake) and the aggregate target
-# below is not part of `all`, so a normal `cmake --build` never compiles them.
-option(
-    verify_headers
-    "Compile every header on its own to verify it is self-contained."
-    ON
-)
-if(verify_headers)
-    # Aggregate target that builds every per-module header-verification library
-    # created by add_module (see cmake/verify_headers.cmake). Build it with:
-    #   cmake --build . --target verify-headers
-    add_custom_target(verify-headers)
-endif()
-
 option(unity "Creates a build using UNITY support in cmake." OFF)
 if(unity)
     if(NOT is_ci)

cmake/add_module.cmake

@@ -1,5 +1,4 @@
 include(isolate_headers)
-include(verify_headers)
 
 # Create an OBJECT library target named
 #
@@ -38,20 +37,4 @@ function(add_module parent name)
         "${CMAKE_CURRENT_SOURCE_DIR}/src/lib${parent}/${name}"
         PRIVATE
     )
-    # protocol_autogen contains generated headers that are deliberately exempt
-    # from clang-tidy (see ExcludeHeaderFilterRegex in .clang-tidy), so we do not
-    # verify them either.
-    if(
-        verify_headers
-        AND NOT "${parent}/${name}" STREQUAL "xrpl/protocol_autogen"
-    )
-        verify_target_headers(
-            ${target}
-            "${CMAKE_CURRENT_SOURCE_DIR}/include/${parent}/${name}"
-        )
-        verify_target_headers(
-            ${target}
-            "${CMAKE_CURRENT_SOURCE_DIR}/src/lib${parent}/${name}"
-        )
-    endif()
 endfunction()

cmake/scripts/codegen/templates/LedgerEntry.h.mako

@@ -33,7 +33,7 @@ public:
      * @brief Construct a ${name} ledger entry wrapper from an existing SLE object.
      * @throws std::runtime_error if the ledger entry type doesn't match.
      */
-    explicit ${name}(SLE::const_pointer sle)
+    explicit ${name}(std::shared_ptr<SLE const> sle)
         : LedgerEntryBase(std::move(sle))
     {
         // Verify ledger entry type
@@ -168,7 +168,7 @@ ${field['typeData']['setter_type']} ${field['paramName']}${',' if i < len(requir
      * @param sle The existing ledger entry to copy from.
      * @throws std::runtime_error if the ledger entry type doesn't match.
      */
-    ${name}Builder(SLE::const_pointer sle)
+    ${name}Builder(std::shared_ptr<SLE const> sle)
     {
         if (sle->at(sfLedgerEntryType) != ${tag})
         {
@@ -177,9 +177,7 @@ ${field['typeData']['setter_type']} ${field['paramName']}${',' if i < len(requir
         object_ = *sle;
     }
 
-    /**
-     * @brief Ledger entry-specific field setters
-     */
+    /** @brief Ledger entry-specific field setters */
 % for field in fields:
 
     /**

cmake/scripts/codegen/templates/Transaction.h.mako

@@ -185,9 +185,7 @@ public:
         object_ = *tx;
     }
 
-    /**
-     * @brief Transaction-specific field setters
-     */
+    /** @brief Transaction-specific field setters */
 % for field in fields:
 
     /**

cmake/verify_headers.cmake

@@ -1,84 +0,0 @@
-# Our normal build only ever compiles `.cpp` files, so a header is only ever
-# checked through whatever translation unit happens to include it. A header that
-# is missing an `#include` is never caught as long as every `.cpp` that uses it
-# includes its missing dependency first. To check a header on its own we compile
-# it directly as a translation unit.
-#
-# Compiling the header itself - rather than a `.cpp` wrapper that includes it -
-# gives two checks at once:
-#   * the compiler fails if the header is not self-contained, i.e. it uses a
-#     declaration that is not available (directly or transitively); and
-#   * the header is the *main file* of its `compile_commands.json` entry, so
-#     clang-tidy's misc-include-cleaner analyses (and can --fix) the header's own
-#     includes - flagging a dependency that is only available transitively, which
-#     a plain compile cannot catch. A wrapper would be the main file instead, and
-#     include-cleaner never looks inside the headers a main file includes.
-#
-# The objects are never linked anywhere; we build them only for these checks.
-
-# Verify that the headers under headers_dir compile on their own, using the
-# compile environment of an existing target so each header is compiled exactly as
-# that target compiles it. This works for both add_module libraries and the xrpld
-# and test binaries: a library's isolated public and private include directories
-# and a binary's `-I src` both live in its INCLUDE_DIRECTORIES, and the modules or
-# libraries it links live in its LINK_LIBRARIES. We copy those usage requirements
-# through generator expressions (rather than linking ${target}, which is
-# impossible for an executable), evaluated at generation time so they capture
-# requirements the caller adds after this runs. The verify library is created
-# once; call this repeatedly to add more header directories.
-#
-# verify_target_headers(target headers_dir)
-function(verify_target_headers target headers_dir)
-    set(verify ${target}.verify)
-    if(NOT TARGET ${verify})
-        add_library(${verify} OBJECT EXCLUDE_FROM_ALL)
-        # A unity build would concatenate the headers into a single translation
-        # unit, where a header missing an include could be satisfied by one that
-        # precedes it in the blob - exactly the bug we want to catch.
-        set_target_properties(${verify} PROPERTIES UNITY_BUILD OFF)
-        target_include_directories(
-            ${verify}
-            PRIVATE $<TARGET_PROPERTY:${target},INCLUDE_DIRECTORIES>
-        )
-        target_compile_definitions(
-            ${verify}
-            PRIVATE $<TARGET_PROPERTY:${target},COMPILE_DEFINITIONS>
-        )
-        target_compile_options(
-            ${verify}
-            PRIVATE $<TARGET_PROPERTY:${target},COMPILE_OPTIONS>
-        )
-        target_link_libraries(
-            ${verify}
-            PRIVATE $<TARGET_PROPERTY:${target},LINK_LIBRARIES>
-        )
-        add_dependencies(verify-headers ${verify})
-    endif()
-    _verify_add_headers(${verify} "${headers_dir}")
-endfunction()
-
-# Add every .h/.hpp under dir to target as a directly-compiled C++ translation
-# unit. .ipp files are inline-implementation fragments included by their owning
-# header (often after a class declaration), so they are not self-contained on
-# their own and are verified transitively when that header is verified.
-function(_verify_add_headers target dir)
-    file(GLOB_RECURSE headers CONFIGURE_DEPENDS "${dir}/*.h" "${dir}/*.hpp")
-    if(NOT headers)
-        return()
-    endif()
-    # `-xc++` forces the header to be compiled as a C++ translation unit; a lone
-    # `.h` is otherwise treated as a header to precompile. `#pragma once` is
-    # harmless (and warns) when the header is the main file, so silence it.
-    # Compiled on its own, a header legitimately defines constants and static or
-    # template functions that nothing in this single translation unit uses (they
-    # exist for the files that include it), so the resulting unused-entity
-    # warnings are expected and must not fail the build under -Werror.
-    set_source_files_properties(
-        ${headers}
-        PROPERTIES
-            LANGUAGE CXX
-            COMPILE_OPTIONS
-                "-xc++;-Wno-pragma-once-outside-header;-Wno-unused-const-variable;-Wno-unused-function"
-    )
-    target_sources(${target} PRIVATE ${headers})
-endfunction()

conan.lock

@@ -1,44 +1,43 @@
 {
     "version": "0.5",
     "requires": [
-        "zlib/1.3.2#1cb806da49011867778ffb6ac7190fcb%1782392402.122708",
-        "xxhash/0.8.3#681d36a0a6111fc56e5e45ea182c19cc%1782392402.420688",
-        "sqlite3/3.53.0#324ada52333108388a9a6108bfa96734%1782392403.185447",
-        "soci/4.0.3#e726491a03468795453f7c83fc924a96%1782392402.679521",
-        "snappy/1.1.10#968fef506ff261592ec30c574d4a7809%1782307151.633168",
-        "secp256k1/0.7.1#b1f450b7f78a36fff75bb6934a356f3a%1782338841.3729",
-        "rocksdb/10.5.1#4a197eca381a3e5ae8adf8cffa5aacd0%1782392413.075713",
-        "re2/20251105#8579cfd0bda4daf0683f9e3898f964b4%1782392402.431897",
-        "protobuf/6.33.5#ff253ead763bd8d9904a52979cd21e81%1782392410.233933",
-        "openssl/3.6.3#1163d4ddc603907084d08a6a0c6e580f%1782307150.583886",
-        "nudb/2.0.9#11149c73f8f2baff9a0198fe25971fc7%1782392402.297166",
-        "mpt-crypto/0.4.0-rc2#a580f2f9ad0e795de696aa62d54fb9af%1782425834.488828",
-        "lz4/1.10.0#982d9b673900f665a1da109e09c17cab%1782392402.164188",
-        "libiconv/1.17#9923bc6dc6f106646d6967e0039a5ada%1782392792.775744",
-        "libbacktrace/cci.20210118#a7691bfccd8caaf66309df196790a5a1%1782392402.420732",
-        "libarchive/3.8.7#c446109bd1f1d8ba7936c94189bc50e6%1782392403.066892",
+        "zlib/1.3.2#1cb806da49011867778ffb6ac7190fcb%1777558780.503",
+        "xxhash/0.8.3#681d36a0a6111fc56e5e45ea182c19cc%1765850149.987",
+        "sqlite3/3.53.0#324ada52333108388a9a6108bfa96734%1776096494.149",
+        "soci/4.0.3#fe32b9ad5eb47e79ab9e45a68f363945%1774450067.231",
+        "snappy/1.1.10#968fef506ff261592ec30c574d4a7809%1765850147.878",
+        "secp256k1/0.7.1#481881709eb0bdd0185a12b912bbe8ad%1770910500.329",
+        "rocksdb/10.5.1#4a197eca381a3e5ae8adf8cffa5aacd0%1765850186.86",
+        "re2/20251105#8579cfd0bda4daf0683f9e3898f964b4%1774398111.888",
+        "protobuf/6.33.5#d96d52ba5baaaa532f47bda866ad87a5%1774467363.12",
+        "openssl/3.6.2#4789bbf131b77d0515d15e094c8f697f%1778071755.506",
+        "nudb/2.0.9#11149c73f8f2baff9a0198fe25971fc7%1775040983.408",
+        "lz4/1.10.0#59fc63cac7f10fbe8e05c7e62c2f3504%1765850143.914",
+        "libiconv/1.17#1e65319e945f2d31941a9d28cc13c058%1765842973.492",
+        "libbacktrace/cci.20210118#a7691bfccd8caaf66309df196790a5a1%1765842973.03",
+        "libarchive/3.8.7#c446109bd1f1d8ba7936c94189bc50e6%1776147552.838",
         "jemalloc/5.3.1#1fc58d55316041f10fbc1e8a2eae632a%1776700028.228",
-        "gtest/1.17.0#5224b3b3ff3b4ce1133cbdd27d53ee7d%1782392402.791979",
-        "grpc/1.81.1#5217e6ef0544c42b46f4af35d5e7f649%1782307148.845616",
-        "ed25519/2015.03#ae761bdc52730a843f0809bdf6c1b1f6%1782307148.15562",
-        "date/3.0.4#862e11e80030356b53c2c38599ceb32b%1782392402.538492",
-        "c-ares/1.34.6#545240bb1c40e2cacd4362d6b8967650%1782392402.681654",
-        "bzip2/1.0.8#c470882369c2d95c5c77e970c0c7e321%1782392402.296732",
-        "boost/1.91.0#ea540ca2133d831b560036aa24dece3c%1782392419.475605",
-        "abseil/20250127.0#bb0baf1f362bc4a725a24eddd419b8f7%1782307147.395833"
+        "gtest/1.17.0#5224b3b3ff3b4ce1133cbdd27d53ee7d%1768312129.152",
+        "grpc/1.78.1#b1a9e74b145cc471bed4dc64dc6eb2c1%1774467387.342",
+        "ed25519/2015.03#ae761bdc52730a843f0809bdf6c1b1f6%1765850143.772",
+        "date/3.0.4#862e11e80030356b53c2c38599ceb32b%1765850143.772",
+        "c-ares/1.34.6#545240bb1c40e2cacd4362d6b8967650%1774439234.681",
+        "bzip2/1.0.8#c470882369c2d95c5c77e970c0c7e321%1765850143.837",
+        "boost/1.91.0#ea540ca2133d831b560036aa24dece3c%1778050991.9",
+        "abseil/20250127.0#bb0baf1f362bc4a725a24eddd419b8f7%1774365460.196"
     ],
     "build_requires": [
-        "zlib/1.3.2#1cb806da49011867778ffb6ac7190fcb%1782392402.122708",
-        "strawberryperl/5.32.1.1#8d114504d172cfea8ea1662d09b6333e%1782395692.540639",
-        "protobuf/6.33.5#ff253ead763bd8d9904a52979cd21e81%1782392410.233933",
-        "nasm/2.16.01#31e26f2ee3c4346ecd347911bd126904%1782395690.33162",
+        "zlib/1.3.2#1cb806da49011867778ffb6ac7190fcb%1777558780.503",
+        "strawberryperl/5.32.1.1#8d114504d172cfea8ea1662d09b6333e%1774447376.964",
+        "protobuf/6.33.5#d96d52ba5baaaa532f47bda866ad87a5%1774467363.12",
+        "nasm/2.16.01#31e26f2ee3c4346ecd347911bd126904%1765850144.707",
         "msys2/cci.latest#d22fe7b2808f5fd34d0a7923ace9c54f%1770657326.649",
-        "m4/1.4.19#34c4bbc3eeebe98ca6edf2f52d602e7d%1777282960.259",
-        "cmake/4.3.3#840cf00ea09777e05c2050a50a82c722%1782392418.696091",
-        "b2/5.4.2#ffd6084a119587e70f11cd45d1a386e2%1782392402.624226",
+        "m4/1.4.19#4523e4347b55cd26ae918bd5770cab9a%1778062762.471",
+        "cmake/4.3.0#b939a42e98f593fb34d3a8c5cc860359%1774439249.183",
+        "b2/5.4.2#ffd6084a119587e70f11cd45d1a386e2%1774439233.447",
         "automake/1.16.5#b91b7c384c3deaa9d535be02da14d04f%1755524470.56",
         "autoconf/2.71#51077f068e61700d65bb05541ea1e4b0%1731054366.86",
-        "abseil/20250127.0#bb0baf1f362bc4a725a24eddd419b8f7%1782307147.395833"
+        "abseil/20250127.0#bb0baf1f362bc4a725a24eddd419b8f7%1774365460.196"
     ],
     "python_requires": [],
     "overrides": {
@@ -58,7 +57,7 @@
             "boost/1.91.0"
         ],
         "lz4/[>=1.9.4 <2]": [
-            "lz4/1.10.0#982d9b673900f665a1da109e09c17cab"
+            "lz4/1.10.0#59fc63cac7f10fbe8e05c7e62c2f3504"
         ]
     },
     "config_requires": []

conan/lockfile/linux.profile

@@ -2,7 +2,7 @@
 arch=x86_64
 build_type=Release
 compiler=gcc
-compiler.cppstd=23
+compiler.cppstd=20
 compiler.libcxx=libstdc++11
 compiler.version=13
 os=Linux

conan/lockfile/macos.profile

@@ -2,7 +2,7 @@
 arch=armv8
 build_type=Release
 compiler=apple-clang
-compiler.cppstd=23
+compiler.cppstd=20
 compiler.libcxx=libc++
 compiler.version=17.0
 os=Macos

conan/lockfile/regenerate.sh

@@ -14,7 +14,7 @@ export CONAN_HOME="$TEMP_DIR"
 # Ensure that the xrplf remote is the first to be consulted, so any recipes we
 # patched are used. We also add it there to not created huge diff when the
 # official Conan Center Index is updated.
-conan remote add --force --index 0 xrplf https://conan.xrplf.org/repository/conan/
+conan remote add --force --index 0 xrplf https://conan.ripplex.io
 
 # Delete any existing lockfile.
 rm -f conan.lock

conan/lockfile/windows.profile

@@ -2,7 +2,7 @@
 arch=x86_64
 build_type=Release
 compiler=msvc
-compiler.cppstd=23
+compiler.cppstd=20
 compiler.runtime=dynamic
 compiler.runtime_type=Release
 compiler.version=194

conan/profiles/ci

@@ -1,8 +1 @@
-{% set os = detect_api.detect_os() %}
 include(sanitizers)
-
-[conf]
-{% if os == "Linux" %}
-user.package:libc_version=2.31
-tools.info.package_id:confs+=["user.package:libc_version"]
-{% endif %}

conan/profiles/default

@@ -10,18 +10,16 @@
 os={{ os }}
 arch={{ arch }}
 build_type=Debug
-compiler={{ compiler }}
+compiler={{compiler}}
 compiler.version={{ compiler_version }}
-compiler.cppstd=23
+compiler.cppstd=20
 {% if os == "Windows" %}
 compiler.runtime=static
 {% else %}
-compiler.libcxx={{ detect_api.detect_libcxx(compiler, version, compiler_exe) }}
+compiler.libcxx={{detect_api.detect_libcxx(compiler, version, compiler_exe)}}
 {% endif %}
 
 [conf]
-{# By default, Conan tries to reuse binaries built with different cppstd versions. #}
-{# We want to avoid that to improve reproduceability, so we add the cppstd version to the package ID. #}
-{# More info: https://docs.conan.io/2/reference/extensions/binary_compatibility.html #}
-user.package:cppstd_version=23
-tools.info.package_id:confs+=["user.package:cppstd_version"]
+{% if compiler == "gcc" and compiler_version < 13 %}
+tools.build:cxxflags+=['-Wno-restrict']
+{% endif %}

conan/profiles/sanitizers

@@ -52,50 +52,52 @@ include(default)
 {% endif %}
 
 {# Frame pointer required for meaningful stack traces; -O1 for reasonable performance #}
-{% set sanitizer_compiler_flags = ["-fno-omit-frame-pointer", "-O1"] %}
+{% set compile_flags = ["-fno-omit-frame-pointer", "-O1"] %}
 
 {% if compiler == "gcc" %}
     {# Suppress false positive warnings with GCC #}
-    {% set _ = sanitizer_compiler_flags.append("-Wno-stringop-overflow") %}
+    {% set _ = compile_flags.append("-Wno-stringop-overflow") %}
 
     {% set relocation_flags = [] %}
 
     {% if arch == "x86_64" and enable_asan %}
         {# Large code model prevents relocation errors in instrumented ASAN binaries #}
-        {% set _ = sanitizer_compiler_flags.append("-mcmodel=large") %}
+        {% set _ = compile_flags.append("-mcmodel=large") %}
         {% set _ = relocation_flags.append("-mcmodel=large") %}
     {% elif enable_tsan %}
         {# GCC doesn't support atomic_thread_fence with TSAN; suppress warnings #}
-        {% set _ = sanitizer_compiler_flags.append("-Wno-tsan") %}
+        {% set _ = compile_flags.append("-Wno-tsan") %}
         {% if arch == "x86_64" %}
             {# Medium code model for TSAN; large is incompatible #}
-            {% set _ = sanitizer_compiler_flags.append("-mcmodel=medium") %}
+            {% set _ = compile_flags.append("-mcmodel=medium") %}
             {% set _ = relocation_flags.append("-mcmodel=medium") %}
         {% endif %}
     {% endif %}
 
     {% set fsanitize = "-fsanitize=" ~ ",".join(sanitizer_types) %}
-    {% set _ = sanitizer_compiler_flags.append(fsanitize) %}
+    {% set _ = compile_flags.append(fsanitize) %}
     {% set _ = relocation_flags.append(fsanitize) %}
 
-    {% set sanitizer_linker_flags = relocation_flags %}
+    {% set sanitizer_compiler_flags = " ".join(compile_flags) %}
+    {% set sanitizer_linker_flags = " ".join(relocation_flags) %}
 {% elif compiler == "clang" or compiler == "apple-clang" %}
     {% set fsanitize = "-fsanitize=" ~ ",".join(sanitizer_types) %}
-    {% set _ = sanitizer_compiler_flags.append(fsanitize) %}
+    {% set _ = compile_flags.append(fsanitize) %}
 
-    {% set sanitizer_linker_flags = [fsanitize] %}
+    {% set sanitizer_compiler_flags = " ".join(compile_flags) %}
+    {% set sanitizer_linker_flags = fsanitize %}
 {% endif %}
 
 [conf]
-tools.build:defines+={{ defines }}
-tools.build:cxxflags+={{ sanitizer_compiler_flags }}
-tools.build:sharedlinkflags+={{ sanitizer_linker_flags }}
-tools.build:exelinkflags+={{ sanitizer_linker_flags }}
+tools.build:defines+={{defines}}
+tools.build:cxxflags+=['{{sanitizer_compiler_flags}}']
+tools.build:sharedlinkflags+=['{{sanitizer_linker_flags}}']
+tools.build:exelinkflags+=['{{sanitizer_linker_flags}}']
 
 tools.info.package_id:confs+=["tools.build:cxxflags", "tools.build:exelinkflags", "tools.build:sharedlinkflags", "tools.build:defines"]
 
 # &: means "apply only to the consumer/root package"
-&:tools.cmake.cmaketoolchain:extra_variables={"SANITIZERS": "{{ sanitizers }}", "SANITIZERS_COMPILER_FLAGS": "{{ sanitizer_compiler_flags | join(' ') }}", "SANITIZERS_LINKER_FLAGS": "{{ sanitizer_linker_flags | join(' ') }}"}
+&:tools.cmake.cmaketoolchain:extra_variables={"SANITIZERS": "{{sanitizers}}", "SANITIZERS_COMPILER_FLAGS": "{{sanitizer_compiler_flags}}", "SANITIZERS_LINKER_FLAGS": "{{sanitizer_linker_flags}}"}
 
 [options]
 {% if enable_asan %}

conanfile.py

@@ -28,10 +28,11 @@ class Xrpl(ConanFile):
 
     requires = [
         "ed25519/2015.03",
-        "grpc/1.81.1",
+        "grpc/1.78.1",
         "libarchive/3.8.7",
         "nudb/2.0.9",
-        "openssl/3.6.3",
+        "openssl/3.6.2",
+        "secp256k1/0.7.1",
         "soci/4.0.3",
         "zlib/1.3.2",
     ]
@@ -131,15 +132,13 @@ class Xrpl(ConanFile):
     def requirements(self):
         self.requires("boost/1.91.0", force=True, transitive_headers=True)
         self.requires("date/3.0.4", transitive_headers=True)
+        self.requires("lz4/1.10.0", force=True)
+        self.requires("protobuf/6.33.5", force=True)
+        self.requires("sqlite3/3.53.0", force=True)
         if self.options.jemalloc:
             self.requires("jemalloc/5.3.1")
-        self.requires("lz4/1.10.0", force=True)
-        self.requires("mpt-crypto/0.4.0-rc2", transitive_headers=True)
-        self.requires("protobuf/6.33.5", force=True)
         if self.options.rocksdb:
             self.requires("rocksdb/10.5.1")
-        self.requires("secp256k1/0.7.1", transitive_headers=True)
-        self.requires("sqlite3/3.53.0", force=True)
         self.requires("xxhash/0.8.3", transitive_headers=True)
 
     exports_sources = (
@@ -209,7 +208,6 @@ class Xrpl(ConanFile):
             "grpc::grpc++",
             "libarchive::libarchive",
             "lz4::lz4",
-            "mpt-crypto::mpt-crypto",
             "nudb::nudb",
             "openssl::crypto",
             "protobuf::libprotobuf",

cspell.config.yaml

@@ -36,7 +36,9 @@ overrides:
       - /'[^']*'/g # single-quoted strings
       - /`[^`]*`/g # backtick strings
 suggestWords:
-  - unsynched->unsynced
+  - xprl->xrpl
+  - xprld->xrpld # cspell: disable-line not sure what this problem is....
+  - unsynched->unsynced # cspell: disable-line not sure what this problem is....
   - synched->synced
   - synch->sync
 words:
@@ -48,7 +50,6 @@ words:
   - AMMXRP
   - amt
   - amts
-  - archs
   - asnode
   - asynchrony
   - attestation
@@ -58,7 +59,6 @@ words:
   - autobridging
   - bimap
   - bindir
-  - blindings
   - bookdir
   - Bougalis
   - Britto
@@ -83,7 +83,6 @@ words:
   - coro
   - coros
   - cowid
-  - cpack
   - cryptocondition
   - cryptoconditional
   - cryptoconditions
@@ -94,7 +93,6 @@ words:
   - daria
   - dcmake
   - dearmor
-  - decryptor
   - dedented
   - deleteme
   - demultiplexer
@@ -106,11 +104,9 @@ words:
   - distro
   - doxyfile
   - dxrpl
-  - elgamal
   - enabled
   - enablerepo
   - endmacro
-  - envrc
   - exceptioned
   - EXPECT_STREQ
   - Falco
@@ -120,7 +116,6 @@ words:
   - fmtdur
   - fsanitize
   - funclets
-  - Gamal
   - gcov
   - gcovr
   - ghead
@@ -139,7 +134,6 @@ words:
   - iou
   - ious
   - isrdc
-  - isystem
   - itype
   - jemalloc
   - jlog
@@ -218,7 +212,6 @@ words:
   - partitioner
   - paychan
   - paychans
-  - Pedersen
   - permdex
   - perminute
   - permissioned
@@ -237,15 +230,9 @@ words:
   - pyenv
   - pyparsing
   - qalloc
-  - qbsprofile
   - queuable
   - Raphson
-  - rcflags
   - replayer
-  - rerandomize
-  - rerandomization
-  - rerandomized
-  - rerandomizes
   - rerere
   - retriable
   - RIPD
@@ -262,7 +249,6 @@ words:
   - sahyadri
   - Satoshi
   - scons
-  - Schnorr
   - secp
   - sendq
   - seqit
@@ -279,8 +265,6 @@ words:
   - sles
   - soci
   - socidb
-  - sponsee
-  - sponsees
   - SRPMS
   - sslws
   - statsd
@@ -295,14 +279,12 @@ words:
   - stvar
   - stvector
   - stxchainattestations
-  - summands
   - superpeer
   - superpeers
   - takergets
   - takerpays
   - ters
   - TMEndpointv2
-  - tparam
   - trixie
   - tx
   - txid
@@ -313,7 +295,6 @@ words:
   - txs
   - ubsan
   - UBSAN
-  - ufdio
   - umant
   - unacquired
   - unambiguity
@@ -330,7 +311,6 @@ words:
   - unserviced
   - unshareable
   - unshares
-  - unsponsored
   - unsquelch
   - unsquelched
   - unsquelching

docker/check-sanitizers.sh

@@ -0,0 +1,48 @@
+#!/bin/bash
+
+# Sanity-check that the sanitizer runtimes shipped with g++/clang++ work
+# end-to-end against the system loader: compile each example with both
+# compilers, run it, and confirm the expected diagnostic is emitted.
+
+set -eo pipefail
+
+cpp_files_dir="${1:?usage: $0 <cpp_files_dir>}"
+
+case "$(uname -m)" in
+    x86_64) loader=/lib64/ld-linux-x86-64.so.2 ;;
+    aarch64) loader=/lib/ld-linux-aarch64.so.1 ;;
+    *)
+        echo "Unsupported arch: $(uname -m)" >&2
+        exit 1
+        ;;
+esac
+
+declare -A sanitize=(
+    [asan]="-fsanitize=address"
+    [tsan]="-fsanitize=thread"
+    [ubsan]="-fsanitize=undefined"
+)
+declare -A expect=(
+    [asan]="heap-use-after-free"
+    [tsan]="data race"
+    [ubsan]="signed integer overflow"
+)
+
+for compiler in g++ clang++; do
+    for name in asan tsan ubsan; do
+        bin="/tmp/${name}-${compiler}"
+        echo "=== Build ${name} with ${compiler} ==="
+        "$compiler" -std=c++20 -O1 -g ${sanitize[$name]} \
+            -Wl,--dynamic-linker=$loader \
+            "${cpp_files_dir}/${name}.cpp" -o "$bin"
+        echo "=== Run ${name}-${compiler} ==="
+        output=$("$bin" 2>&1) || true
+        echo "$output"
+        echo "$output" | grep -q "${expect[$name]}" ||
+            {
+                echo "expected '${expect[$name]}' from $bin"
+                exit 1
+            }
+        rm -f "$bin"
+    done
+done

docker/cpp_files/asan.cpp

@@ -2,13 +2,6 @@
 #include <cstddef>
 #include <iostream>
 
-// Regression test: the compiler-rt sanitizer interface headers must be on the
-// include path. A bare on-PATH clang in the Nix CI env doesn't get them
-// propagated automatically, so this include would fail to compile with clang++
-// if the env isn't wired up correctly. abseil hits the same include during
-// sanitizer builds. LeakSanitizer ships with AddressSanitizer.
-#include <sanitizer/lsan_interface.h>
-
 #if defined(__clang__) || defined(__GNUC__)
 __attribute__((noinline))
 #elif defined(_MSC_VER)

docker/nix.Dockerfile

@@ -0,0 +1,95 @@
+ARG BASE_IMAGE=nixos/nix:latest
+
+# Nix builder
+FROM nixos/nix:latest AS builder-source
+
+RUN mkdir -p ~/.config/nix && \
+    echo "experimental-features = nix-command flakes" >> ~/.config/nix/nix.conf
+
+# Copy our source and setup our working dir.
+COPY nix/ci-env.nix /tmp/build/nix/ci-env.nix
+COPY nix/packages.nix /tmp/build/nix/packages.nix
+COPY nix/utils.nix /tmp/build/nix/utils.nix
+COPY flake.nix /tmp/build/
+COPY flake.lock /tmp/build/
+WORKDIR /tmp/build
+
+FROM builder-source AS builder
+
+# Build our Nix CI environment (all build tools in a single store path)
+RUN nix \
+    --option filter-syscalls false \
+    build
+
+# Copy the Nix store closure into a directory. The Nix store closure is the
+# entire set of Nix store values that we need for our build.
+RUN mkdir /tmp/nix-store-closure && \
+    cp -R $(nix-store -qR result/) /tmp/nix-store-closure
+
+# Final image
+FROM ${BASE_IMAGE}
+
+# bash is not located at /bin/bash in nixos/nix, so we need to create a symlink to it.
+RUN if [ -d /nix ]; then \
+        ln -s /root/.nix-profile/bin/bash /bin/bash; \
+    fi
+
+# Use Bash as the default shell for RUN commands, using the options
+# `set -o errexit -o pipefail`, and as the entrypoint.
+SHELL ["/bin/bash", "-e", "-o", "pipefail", "-c"]
+ENTRYPOINT ["/bin/bash"]
+
+# Copy /nix/store and the env symlink tree
+COPY --from=builder /tmp/nix-store-closure /nix/store
+COPY --from=builder /tmp/build/result /nix/ci-env
+
+ENV PATH="/nix/ci-env/bin:$PATH"
+
+# Externally-built dynamically-linked ELF binaries hard-code the loader path
+# (e.g. /lib64/ld-linux-x86-64.so.2) in their PT_INTERP header. Copy the
+# loader from the Nix store to that path when the base image doesn't already
+# provide one (i.e. on nixos/nix).
+RUN <<EOF
+case "$(uname -m)" in
+    x86_64)  target=/lib64/ld-linux-x86-64.so.2 ;;
+    aarch64) target=/lib/ld-linux-aarch64.so.1 ;;
+    *) echo "Unsupported arch: $(uname -m)" >&2; exit 1 ;;
+esac
+if [ ! -e "$target" ]; then
+    # Use the loader from the same glibc that gcc links libc against, so
+    # ld-linux and libc/libpthread share GLIBC_PRIVATE symbols at runtime.
+    src="$(dirname "$(gcc -print-file-name=libc.so.6)")/$(basename "$target")"
+    [ -e "$src" ] || { echo "ld-linux not found at $src" >&2; exit 1; }
+    mkdir -p "$(dirname "$target")"
+    cp "$src" "$target"
+fi
+EOF
+
+RUN <<EOF
+ccache --version
+clang --version
+clang++ --version
+clang-format --version
+cmake --version
+conan --version
+g++ --version
+gcc --version
+gcovr --version
+git --version
+make --version
+mold --version
+ninja --version
+perl --version
+pkg-config --version
+pre-commit --version
+python3 --version
+run-clang-tidy --help
+vim --version
+EOF
+
+# Sanity-check that the sanitizer runtimes shipped with g++/clang++ work
+# end-to-end against the system loader.
+COPY docker/cpp_files/ /tmp/cpp_files/
+COPY docker/check-sanitizers.sh /tmp/check-sanitizers.sh
+
+RUN grep -qi ubuntu /etc/os-release 2>/dev/null && /tmp/check-sanitizers.sh /tmp/cpp_files || true

docs/0001-negative-unl/README.md

@@ -288,7 +288,7 @@ components with non-trivial changes are colored green.
     validated.
 
 ![Sequence diagram](./negativeUNL_highLevel_sequence.png?raw=true "Negative UNL
-Changes")
+ Changes")
 
 ## Roads Not Taken
 

docs/build/advanced_conan.md

@@ -1,193 +0,0 @@
-# Advanced Conan configuration
-
-This document provides advanced instructions for setting up and configuring Conan for `xrpld` development: custom profiles, the lockfile, patched recipes, and profile tweaks.
-
-## Custom profile
-
-If the default profile does not work for you and you do not yet have a Conan
-profile, you can create one by running:
-
-```bash
-conan profile detect
-```
-
-You may need to make changes to the profile to suit your environment. You can
-refer to the provided `conan/profiles/default` profile for inspiration, and you
-may also need to apply the required [tweaks](#conan-profile-tweaks) to this
-default profile.
-
-## Conan lockfile
-
-To achieve reproducible dependencies, we use a [Conan lockfile](https://docs.conan.io/2/tutorial/versioning/lockfiles.html),
-which has to be updated every time dependencies change.
-
-Please see the [instructions on how to regenerate the lockfile](../../conan/lockfile/README.md).
-
-## Patched recipes
-
-Occasionally, we need patched recipes or recipes not present in Conan Center.
-We maintain a fork of the Conan Center Index
-[here](https://github.com/XRPLF/conan-center-index/) containing the modified and newly added recipes.
-
-To ensure our patched recipes are used, you must add our Conan remote at a
-higher index than the default Conan Center remote, so it is consulted first. You
-can do this by running:
-
-```bash
-conan remote add --index 0 --force xrplf https://conan.xrplf.org/repository/conan/
-```
-
-Alternatively, you can pull our recipes from the repository and export them locally:
-
-```bash
-# Define which recipes to export.
-recipes=('abseil' 'ed25519' 'mpt-crypto' 'openssl' 'secp256k1' 'snappy' 'soci' 'wasm-xrplf' 'wasmi')
-
-# Selectively check out the recipes from our CCI fork.
-cd external
-mkdir -p conan-center-index
-cd conan-center-index
-git init
-git remote add origin git@github.com:XRPLF/conan-center-index.git
-git sparse-checkout init
-for recipe in "${recipes[@]}"; do
-    echo "Checking out recipe '${recipe}'..."
-    git sparse-checkout add recipes/${recipe}
-done
-git fetch origin master
-git checkout master
-
-./export_all.sh
-cd ../../
-```
-
-In the case we switch to a newer version of a dependency that still requires a
-patch or add a new dependency, it will be necessary for you to pull in the changes and re-export the
-updated dependencies with the newer version. However, if we switch to a newer
-version that no longer requires a patch, no action is required on your part, as
-the new recipe will be automatically pulled from the official Conan Center.
-
-> [!NOTE]
-> You might need to add `--lockfile=""` to your `conan install` command
-> to avoid automatic use of the existing `conan.lock` file when you run
-> `conan export` manually on your machine
->
-> This is not recommended though, as you might end up using different revisions of recipes.
-
-## Conan profile tweaks
-
-### Missing compiler version
-
-If you see an error similar to the following after running `conan profile show`:
-
-```text
-ERROR: Invalid setting '17' is not a valid 'settings.compiler.version' value.
-Possible values are ['5.0', '5.1', '6.0', '6.1', '7.0', '7.3', '8.0', '8.1',
-'9.0', '9.1', '10.0', '11.0', '12.0', '13', '13.0', '13.1', '14', '14.0', '15',
-'15.0', '16', '16.0']
-Read "http://docs.conan.io/2/knowledge/faq.html#error-invalid-setting"
-```
-
-you need to create `$(conan config home)/settings_user.yml` file if it doesn't exist and add the required version number(s)
-to the `version` array specific for your compiler. For example:
-
-```yaml
-compiler:
-  apple-clang:
-    version: ["17.0"]
-```
-
-### Multiple compilers
-
-If you have multiple compilers installed, make sure to select the one to use in
-your default Conan configuration **before** running `conan profile detect`, by
-setting the `CC` and `CXX` environment variables.
-
-For example, if you are running MacOS and have [homebrew
-LLVM@18](https://formulae.brew.sh/formula/llvm@18), and want to use it as a
-compiler in the new Conan profile:
-
-```bash
-export CC=$(brew --prefix llvm@18)/bin/clang
-export CXX=$(brew --prefix llvm@18)/bin/clang++
-conan profile detect
-```
-
-You should also explicitly set the path to the compiler in the profile file,
-which helps to avoid errors when `CC` and/or `CXX` are set and disagree with the
-selected Conan profile. For example:
-
-```text
-[conf]
-tools.build:compiler_executables={'c':'/usr/bin/gcc','cpp':'/usr/bin/g++'}
-```
-
-### Multiple profiles
-
-You can manage multiple Conan profiles in the directory
-`$(conan config home)/profiles`, for example renaming `default` to a different
-name and then creating a new `default` profile for a different compiler.
-
-### Select language
-
-The default profile created by Conan will typically select different C++ dialect
-than C++23 used by this project. You should set `23` in the profile line
-starting with `compiler.cppstd=`. For example:
-
-```bash
-sed -i.bak -e 's|^compiler\.cppstd=.*$|compiler.cppstd=23|' $(conan config home)/profiles/default
-```
-
-### Select standard library in Linux
-
-**Linux** developers will commonly have a default Conan [profile][] that
-compiles with GCC and links with libstdc++. If you are linking with libstdc++
-(see profile setting `compiler.libcxx`), then you will need to choose the
-`libstdc++11` ABI:
-
-```bash
-sed -i.bak -e 's|^compiler\.libcxx=.*$|compiler.libcxx=libstdc++11|' $(conan config home)/profiles/default
-```
-
-### Select architecture and runtime in Windows
-
-**Windows** developers may need to use the x64 native build tools. An easy way
-to do that is to run the shortcut "x64 Native Tools Command Prompt" for the
-version of Visual Studio that you have installed.
-
-Windows developers must also build `xrpld` and its dependencies for the x64
-architecture:
-
-```bash
-sed -i.bak -e 's|^arch=.*$|arch=x86_64|' $(conan config home)/profiles/default
-```
-
-**Windows** developers also must select static runtime:
-
-```bash
-sed -i.bak -e 's|^compiler\.runtime=.*$|compiler.runtime=static|' $(conan config home)/profiles/default
-```
-
-## Add a Dependency
-
-If you want to experiment with a new package, follow these steps:
-
-1. Search for the package on [Conan Center](https://conan.io/center/).
-2. Modify [`conanfile.py`](../../conanfile.py):
-   - Add a version of the package to the `requires` property.
-   - Change any default options for the package by adding them to the
-     `default_options` property (with syntax `'$package:$option': $value`).
-3. Regenerate the [Conan lockfile](../../conan/lockfile/README.md) so the new
-   dependency is captured:
-
-   ```bash
-   ./conan/lockfile/regenerate.sh
-   ```
-
-4. Modify [`CMakeLists.txt`](../../CMakeLists.txt):
-   - Add a call to `find_package($package REQUIRED)`.
-   - Link a library from the package to the target `xrpl_libs`
-     (search for the existing call to `target_link_libraries(xrpl_libs INTERFACE ...)`).
-5. Start coding! Don't forget to include whatever headers you need from the package.
-
-[profile]: https://docs.conan.io/2/reference/config_files/profiles.html

docs/build/conan.md

@@ -115,7 +115,7 @@ By default, Conan will use the profile named "default".
 [find_package]: https://cmake.org/cmake/help/latest/command/find_package.html
 [pcf]: https://cmake.org/cmake/help/latest/manual/cmake-packages.7.html#package-configuration-file
 [prefix_path]: https://cmake.org/cmake/help/latest/variable/CMAKE_PREFIX_PATH.html
-[profile]: https://docs.conan.io/2/reference/config_files/profiles.html
+[profile]: https://docs.conan.io/en/latest/reference/profiles.html
 [pvf]: https://cmake.org/cmake/help/latest/manual/cmake-packages.7.html#package-version-file
 [runtime]: https://cmake.org/cmake/help/latest/variable/CMAKE_MSVC_RUNTIME_LIBRARY.html
 [search]: https://cmake.org/cmake/help/latest/command/find_package.html#search-procedure

docs/build/environment.md

@@ -1,74 +1,69 @@
 Our [build instructions][BUILD.md] assume you have a C++ development
 environment complete with Git, Python, Conan, CMake, and a C++ compiler.
-This document explains how to set one up.
+This document exists to help readers set one up on any of the Big Three
+platforms: Linux, macOS, or Windows.
+
+As an alternative to system packages, the Nix development shell can be used to provide a development environment. See [using nix development shell](./nix.md) for more details.
 
 [BUILD.md]: ../../BUILD.md
 
-## Tested compiler versions
+## Linux
 
-`xrpld` is built in the **C++23** dialect by default.
-Make sure your toolchain is recent enough — the compiler versions currently tested in CI are:
+Package ecosystems vary across Linux distributions,
+so there is no one set of instructions that will work for every Linux user.
+The instructions below are written for Debian 12 (Bookworm).
 
-| Compiler    | Version |
-| ----------- | ------- |
-| GCC         | 15.2    |
-| Clang       | 22      |
-| Apple Clang | 17      |
-| MSVC        | 19.44   |
+```
+export GCC_RELEASE=12
+sudo apt update
+sudo apt install --yes gcc-${GCC_RELEASE} g++-${GCC_RELEASE} python3-pip \
+  python-is-python3 python3-venv python3-dev curl wget ca-certificates \
+  git build-essential cmake ninja-build libc6-dev
+sudo pip install --break-system-packages conan
 
-LLVM tools (`clang-tidy` and `clang-format`) are also pinned to version 22.
-
-Older compilers may fail to build the latest `develop` code: the codebase now
-relies on C++23 features and has been adjusted for `clang-tidy`.
-If the latest code doesn't build for you, update your build toolchain first.
-
-## Linux and macOS
-
-The **recommended way** to get a development environment on Linux and macOS is
-the Nix development shell. It provides the exact tooling used in CI — `git`,
-`python`, `conan`, `cmake`, `clang-tidy`, `clang-format`, and everything else —
-with a single command and without installing anything system-wide:
-
-```bash
-nix --experimental-features 'nix-command flakes' develop
+sudo update-alternatives --install /usr/bin/cc cc /usr/bin/gcc-${GCC_RELEASE} 999
+sudo update-alternatives --install \
+  /usr/bin/gcc gcc /usr/bin/gcc-${GCC_RELEASE} 100 \
+  --slave /usr/bin/g++ g++ /usr/bin/g++-${GCC_RELEASE} \
+  --slave /usr/bin/gcc-ar gcc-ar /usr/bin/gcc-ar-${GCC_RELEASE} \
+  --slave /usr/bin/gcc-nm gcc-nm /usr/bin/gcc-nm-${GCC_RELEASE} \
+  --slave /usr/bin/gcc-ranlib gcc-ranlib /usr/bin/gcc-ranlib-${GCC_RELEASE} \
+  --slave /usr/bin/gcov gcov /usr/bin/gcov-${GCC_RELEASE} \
+  --slave /usr/bin/gcov-tool gcov-tool /usr/bin/gcov-tool-${GCC_RELEASE} \
+  --slave /usr/bin/gcov-dump gcov-dump /usr/bin/gcov-dump-${GCC_RELEASE} \
+  --slave /usr/bin/lto-dump lto-dump /usr/bin/lto-dump-${GCC_RELEASE}
+sudo update-alternatives --auto cc
+sudo update-alternatives --auto gcc
 ```
 
-On **Linux**, Nix also provides the compiler (GCC); on **macOS**, it provides
-Clang. If you instead opt to use your system-wide Apple Clang (via
-`nix develop .#apple-clang`), you need to manage its version yourself (see
-below).
+If you use different Linux distribution, hope the instruction above can guide
+you in the right direction. We try to maintain compatibility with all recent
+compiler releases, so if you use a rolling distribution like e.g. Arch or CentOS
+then there is a chance that everything will "just work".
 
-See [Using the Nix development shell](./nix.md) for installation and usage
-details, including how to select a different compiler.
+## macOS
 
-> [!NOTE]
-> Using Nix is not mandatory. Any custom environment (Homebrew packages or
-> anything else) will continue to work, but then it is up to you to keep it in
-> sync with the environment used in CI. Nix unifies the development environment
-> for everyone and synchronizes updates, which is why we recommend it.
+Open a Terminal and enter the below command to bring up a dialog to install
+the command line developer tools.
+Once it is finished, this command should return a version greater than the
+minimum required (see [BUILD.md][]).
 
-### macOS: managing the Apple Clang version
-
-If you use your system-wide Apple Clang on macOS (via `nix develop .#apple-clang`),
-the compiler version is whatever your installed Xcode (or Command Line Tools)
-provides. The following command should return a version greater than or equal to
-the [minimum required](#tested-compiler-versions):
-
-```bash
+```
 clang --version
 ```
 
-If you develop other applications using Xcode, you might be consistently
-updating to the newest version of Apple Clang, which will likely cause issues
-building xrpld. You may want to install and pin a specific version of Xcode:
+### Install Xcode Specific Version (Optional)
+
+If you develop other applications using XCode you might be consistently updating to the newest version of Apple Clang.
+This will likely cause issues building xrpld. You may want to install a specific version of Xcode:
 
 1. **Download Xcode**
    - Visit [Apple Developer Downloads](https://developer.apple.com/download/more/)
    - Sign in with your Apple Developer account
-   - Search for an Xcode version that includes the expected Apple Clang version
+   - Search for an Xcode version that includes **Apple Clang (Expected Version)**
    - Download the `.xip` file
 
-2. **Install and configure Xcode**
+2. **Install and Configure Xcode**
 
    ```bash
    # Extract the .xip file and rename for version management
@@ -84,28 +79,62 @@ building xrpld. You may want to install and pin a specific version of Xcode:
    export DEVELOPER_DIR=/Applications/Xcode_16.2.app/Contents/Developer
    ```
 
-## Windows
+The command line developer tools should include Git too:
 
-Nix is not available on Windows, so the required tools have to be installed
-manually:
+```
+git --version
+```
 
-- [Visual Studio 2022](https://visualstudio.microsoft.com/) with the
-  **"Desktop development with C++"** workload — this provides MSVC and the
-  "x64 Native Tools Command Prompt".
-- [Git for Windows](https://git-scm.com/download/win)
-- [Python 3.11](https://www.python.org/downloads/), or higher
-- [Conan 2.17](https://conan.io/downloads.html), or higher
-- [CMake 3.22](https://cmake.org/download/), or higher
+Install [Homebrew][],
+use it to install [pyenv][],
+use it to install Python,
+and use it to install Conan:
 
-> [!NOTE]
-> Windows is used for development only and is not recommended for production.
+[Homebrew]: https://brew.sh/
+[pyenv]: https://github.com/pyenv/pyenv
+
+```
+/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
+brew update
+brew install xz
+brew install pyenv
+pyenv install 3.11
+pyenv global 3.11
+eval "$(pyenv init -)"
+pip install 'conan'
+```
+
+Install CMake with Homebrew too:
+
+```
+brew install cmake
+```
 
 ## Clang-tidy
 
-`clang-tidy` is required to run static analysis checks locally (see
-[CONTRIBUTING.md](../../CONTRIBUTING.md)). It is not required to build the
-project. This project currently uses `clang-tidy` version 22.
+Clang-tidy is required to run static analysis checks locally (see [CONTRIBUTING.md](../../CONTRIBUTING.md)).
+It is not required to build the project. Currently this project uses clang-tidy version 21.
 
-On Linux and macOS, the [Nix development shell](./nix.md) provides `clang-tidy`
-22 out of the box — run it via `run-clang-tidy`. No separate installation is
-needed.
+### Linux
+
+LLVM 21 is not available in the default Debian 12 (Bookworm) repositories.
+Install it using the official LLVM apt installer:
+
+```
+wget https://apt.llvm.org/llvm.sh
+chmod +x llvm.sh
+sudo ./llvm.sh 21
+sudo apt install --yes clang-tidy-21
+```
+
+Then use `run-clang-tidy-21` when running clang-tidy locally.
+
+### macOS
+
+Install LLVM 21 via Homebrew:
+
+```
+brew install llvm@21
+```
+
+Then use `run-clang-tidy` from the LLVM 21 Homebrew prefix when running clang-tidy locally.

docs/build/nix.md

@@ -2,14 +2,11 @@
 
 This guide explains how to use Nix to set up a reproducible development environment for xrpld. Using Nix eliminates the need to manually install utilities and ensures consistent tooling across different machines.
 
-**The Nix development shell is the recommended way to develop xrpld.** It unifies the development environment for everyone and synchronizes updates: the same tooling and compiler versions are used both here and in CI. Any custom environment (Homebrew packages or anything else) will continue to work, but then it is up to you to keep it in sync with the environment used in CI.
-
 ## Benefits of Using Nix
 
 - **Reproducible environment**: Everyone gets the same versions of tools and compilers
-- **Matches CI**: The Linux CI runs in Docker images built from this exact Nix environment
 - **No system pollution**: Dependencies are isolated and don't affect your system packages
-- **Consistent compilers**: The GCC and Clang shells use the same versions as CI
+- **Multiple compiler versions**: Easily switch between different GCC and Clang versions
 - **Quick setup**: Get started with a single command
 - **Works on Linux and macOS**: Consistent experience across platforms
 
@@ -31,22 +28,11 @@ This will:
 
 - Download and set up all required development tools (CMake, Ninja, Conan, etc.)
 - Configure the appropriate compiler for your platform:
-  - **Linux**: GCC (provided by Nix)
-  - **macOS**: Clang (provided by Nix)
+  - **macOS**: Apple Clang (default system compiler)
+  - **Linux**: GCC 15
 
 The first time you run this command, it will take a few minutes to download and build the environment. Subsequent runs will be much faster.
 
-### Platform notes
-
-- **Linux**: `nix develop` gives you a shell with all the tooling necessary to
-  develop xrpld and with GCC 15.2 (also provided by Nix). There are no caveats.
-- **macOS**: `nix develop` gives you a full environment too, with Clang (and
-  every other tool, including Conan) provided by Nix. To use your system-wide
-  Apple Clang instead, enter `nix develop .#apple-clang`. Conan has no binary in
-  the Nix cache for macOS, so it is built from source the first time you enter
-  the shell, which makes the initial setup slower (this is handled
-  automatically; see [`nix/devshell.nix`](../../nix/devshell.nix)).
-
 > [!TIP]
 > To avoid typing `--experimental-features 'nix-command flakes'` every time, you can permanently enable flakes by creating `~/.config/nix/nix.conf`:
 >
@@ -62,21 +48,19 @@ The first time you run this command, it will take a few minutes to download and
 
 ### Choosing a different compiler
 
-A compiler can be chosen by providing its name with the `.#` prefix, e.g. `nix develop .#clang`.
-The `.#gcc` and `.#clang` shells provide the same GCC and Clang versions used in CI
-(pinned in [`nix/packages.nix`](../../nix/packages.nix)).
+A compiler can be chosen by providing its name with the `.#` prefix, e.g. `nix develop .#gcc15`.
 Use `nix flake show` to see all the available development shells.
 
-Use `nix develop .#no-compiler` to use the compiler from your system.
+Use `nix develop .#no_compiler` to use the compiler from your system.
 
 ### Example Usage
 
 ```bash
-# Use GCC (same version as CI)
-nix develop .#gcc
+# Use GCC 14
+nix develop .#gcc14
 
-# Use Clang (same version as CI)
-nix develop .#clang
+# Use Clang 19
+nix develop .#clang19
 
 # Use default for your platform
 nix develop
@@ -84,28 +68,12 @@ nix develop
 
 ### Using a different shell
 
-`nix develop` opens bash by default. To use another shell, pass it with the `-c` flag — this works with any shell, e.g. `zsh` or `fish`:
+`nix develop` opens bash by default. If you want to use another shell this could be done by adding `-c` flag. For example:
 
 ```bash
-# Use zsh
 nix develop -c zsh
-
-# Use fish
-nix develop -c fish
-
-# Use your login shell
-nix develop -c "$SHELL"
 ```
 
-> [!WARNING]
-> Your shell's interactive startup files (e.g. `config.fish`, `.zshrc`) may prepend other directories — most commonly Homebrew — to `$PATH`, which can shadow the tools provided by the Nix shell. After entering, verify that tools resolve into the Nix store:
->
-> ```bash
-> command -v cmake   # should print a /nix/store/... path
-> ```
->
-> If it doesn't, either adjust your shell configuration so it doesn't override `$PATH`, or use [direnv](#automatic-activation-with-direnv) (below), which loads the environment _after_ your shell config and so takes precedence regardless of the shell you use.
-
 ## Building xrpld with Nix
 
 Once inside the Nix development shell, follow the standard [build instructions](../../BUILD.md#steps). The Nix shell provides all necessary tools (CMake, Ninja, Conan, etc.).
@@ -114,16 +82,6 @@ Once inside the Nix development shell, follow the standard [build instructions](
 
 [direnv](https://direnv.net/) or [nix-direnv](https://github.com/nix-community/nix-direnv) can automatically activate the Nix development shell when you enter the repository directory.
 
-This is also the most robust way to use the environment from **any shell** (bash, zsh, fish, …): direnv stays in your current shell and loads the environment _after_ your shell's startup files have run, so the Nix-provided tools take precedence over anything your shell configuration adds to `$PATH`.
-
-The repository already ships an `.envrc` at its root that activates the Nix flake development shell, so you don't need to create one. To use it:
-
-1. [Install direnv](https://direnv.net/docs/installation.html) and [hook it into your shell](https://direnv.net/docs/hook.html) (bash, zsh, fish, …). Installing [nix-direnv](https://github.com/nix-community/nix-direnv) as well is recommended: it caches the shell so that activation is near-instant after the first run.
-2. Run `direnv allow` once in the repository root. direnv will then load (and reload) the Nix development shell automatically whenever you enter the directory.
-
-> [!NOTE]
-> direnv only caches the `.direnv` directory (already listed in `.gitignore`); no other repository files are affected.
-
 ## Conan and Prebuilt Packages
 
 Please note that there is no guarantee that binaries from conan cache will work when using nix. If you encounter any errors, please use `--build '*'` to force conan to compile everything from source:
@@ -135,8 +93,3 @@ conan install .. --output-folder . --build '*' --settings build_type=Release
 ## Updating `flake.lock` file
 
 To update `flake.lock` to the latest revision use `nix flake update` command.
-
-## Troubleshooting
-
-See [Troubleshooting Nix problems](./nix_troubleshooting.md) for common issues,
-such as `nix develop` failing inside Git worktrees.

docs/build/nix_troubleshooting.md

@@ -1,61 +0,0 @@
-# Troubleshooting Nix problems
-
-Common issues encountered when using the [Nix development shell](./nix.md), and
-how to resolve them.
-
-## Git worktrees
-
-If `nix develop` fails with an error like:
-
-```
-error:
-       … while fetching the input 'git+file:///path/to/rippled'
-
-       error: opening Git repository "/path/to/rippled": unsupported extension name extensions.relativeworktrees (libgit2 error code = 6)
-```
-
-then your Nix is linked against a libgit2 older than **1.9.4**. Git 2.48+ writes
-the `extensions.relativeWorktrees` config entry when a worktree is created with
-relative paths (`git worktree add --relative-paths`, or with
-`worktree.useRelativePaths=true`), and older libgit2 versions refuse to open a
-repository that uses it. Nix uses libgit2 to read the flake, so evaluation
-fails.
-
-> [!IMPORTANT]
-> This entry is written to the **shared** repository config, so once any
-> relative worktree exists, `nix develop` fails in the main checkout too — not
-> just inside the worktree.
-
-### Workarounds
-
-These work today, with any Nix version:
-
-- bypass libgit2 with a `path:` flakeref: `nix develop "path:$PWD"`
-  (note: this copies the working tree to the store and ignores `.gitignore`); or
-- create worktrees with absolute paths (omit `--relative-paths`); or
-- clear the extension if you don't need relative worktrees:
-  `git config --unset extensions.relativeWorktrees`.
-
-### Permanent fix
-
-The fix is in [libgit2 1.9.4](https://github.com/libgit2/libgit2/releases/tag/v1.9.4),
-so the real solution is a Nix that links against libgit2 `1.9.4` or newer. Check
-which version yours links against:
-
-```bash
-nix-store -qR "$(readlink -f "$(command -v nix)")" | grep libgit2
-```
-
-> [!WARNING]
-> `nix upgrade-nix` does **not** help yet. It installs the build from the
-> official [`nix-fallback-paths`](https://github.com/NixOS/nixpkgs/blob/master/nixos/modules/installer/tools/nix-fallback-paths.nix),
-> which is still linked against libgit2 `1.9.2` — there is no new upstream Nix
-> release with the fix. (On some systems that build is even the exact store path
-> you already have, making the upgrade a no-op.)
-
-nixpkgs has already rebuilt Nix against the fixed libgit2 (e.g. `nix-2.34.7+1`),
-so the cleanest path is to reinstall Nix using your usual installation method
-once it picks up that rebuild, then re-run the `grep libgit2` check above to
-confirm it reports `1.9.4` or newer.
-
-Until then, prefer the workarounds above.

flake.lock

@@ -2,18 +2,17 @@
   "nodes": {
     "nixpkgs": {
       "locked": {
-        "lastModified": 1781173989,
-        "narHash": "sha256-fnzKKPvS+oieI/pTzotA5tkoM47EB1NpaBcgk4R97hE=",
+        "lastModified": 1777954456,
+        "narHash": "sha256-hGdgeU2Nk87RAuZyYjyDjFL6LK7dAZN5RE9+hrDTkDU=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "8c91a71d13451abc40eb9dae8910f972f979852f",
+        "rev": "549bd84d6279f9852cae6225e372cc67fb91a4c1",
         "type": "github"
       },
       "original": {
-        "owner": "NixOS",
-        "ref": "nixpkgs-unstable",
-        "repo": "nixpkgs",
-        "type": "github"
+        "id": "nixpkgs",
+        "ref": "nixos-unstable",
+        "type": "indirect"
       }
     },
     "nixpkgs-custom-glibc": {

flake.nix

@@ -1,7 +1,7 @@
 {
   description = "Nix related things for xrpld";
   inputs = {
-    nixpkgs.url = "github:NixOS/nixpkgs/nixpkgs-unstable";
+    nixpkgs.url = "nixpkgs/nixos-unstable";
     # nixpkgs snapshot (2020-06-30) that shipped glibc 2.31 as the primary
     # version — matches the system libc on Ubuntu 20.04 LTS. Imported
     # manually (flake = false) because this revision predates nixpkgs'

include/xrpl/basics/Archive.h

@@ -4,14 +4,13 @@
 
 namespace xrpl {
 
-/**
- * Extract a tar archive compressed with lz4
- *
- * @param src the path of the archive to be extracted
- * @param dst the directory to extract to
- *
- * @throws runtime_error
- */
+/** Extract a tar archive compressed with lz4
+
+    @param src the path of the archive to be extracted
+    @param dst the directory to extract to
+
+    @throws runtime_error
+*/
 void
 extractTarLz4(boost::filesystem::path const& src, boost::filesystem::path const& dst);
 

include/xrpl/basics/BasicConfig.h

@@ -6,13 +6,9 @@
 #include <boost/lexical_cast.hpp>
 
 #include <algorithm>
-#include <cstddef>
 #include <optional>
-#include <ostream>
-#include <stdexcept>
 #include <string>
 #include <unordered_map>
-#include <utility>
 #include <vector>
 
 namespace xrpl {
@@ -21,10 +17,9 @@ using IniFileSections = std::unordered_map<std::string, std::vector<std::string>
 
 //------------------------------------------------------------------------------
 
-/**
- * Holds a collection of configuration values.
- * A configuration file contains zero or more sections.
- */
+/** Holds a collection of configuration values.
+    A configuration file contains zero or more sections.
+*/
 class Section
 {
 private:
@@ -37,34 +32,28 @@ private:
     using const_iterator = decltype(lookup_)::const_iterator;
 
 public:
-    /**
-     * Create an empty section.
-     */
+    /** Create an empty section. */
     explicit Section(std::string name = "");
 
-    /**
-     * Returns the name of this section.
-     */
+    /** Returns the name of this section. */
     [[nodiscard]] std::string const&
     name() const
     {
         return name_;
     }
 
-    /**
-     * Returns all the lines in the section.
-     * This includes everything.
-     */
+    /** Returns all the lines in the section.
+        This includes everything.
+    */
     [[nodiscard]] std::vector<std::string> const&
     lines() const
     {
         return lines_;
     }
 
-    /**
-     * Returns all the values in the section.
-     * Values are non-empty lines which are not key/value pairs.
-     */
+    /** Returns all the values in the section.
+        Values are non-empty lines which are not key/value pairs.
+    */
     [[nodiscard]] std::vector<std::string> const&
     values() const
     {
@@ -91,7 +80,7 @@ public:
      * Get the legacy value for this section.
      *
      * @return The retrieved value. A section with an empty legacy value returns
-     *         an empty string.
+               an empty string.
      */
     [[nodiscard]] std::string
     legacy() const
@@ -106,34 +95,28 @@ public:
         return lines_[0];
     }
 
-    /**
-     * Set a key/value pair.
-     * The previous value is discarded.
-     */
+    /** Set a key/value pair.
+        The previous value is discarded.
+    */
     void
     set(std::string const& key, std::string const& value);
 
-    /**
-     * Append a set of lines to this section.
-     * Lines containing key/value pairs are added to the map,
-     * else they are added to the values list. Everything is
-     * added to the lines list.
-     */
+    /** Append a set of lines to this section.
+        Lines containing key/value pairs are added to the map,
+        else they are added to the values list. Everything is
+        added to the lines list.
+    */
     void
     append(std::vector<std::string> const& lines);
 
-    /**
-     * Append a line to this section.
-     */
+    /** Append a line to this section. */
     void
     append(std::string const& line)
     {
         append(std::vector<std::string>{line});
     }
 
-    /**
-     * Returns `true` if a key with the given name exists.
-     */
+    /** Returns `true` if a key with the given name exists. */
     [[nodiscard]] bool
     exists(std::string const& name) const;
 
@@ -147,9 +130,7 @@ public:
         return boost::lexical_cast<T>(iter->second);
     }
 
-    /**
-     * Returns a value if present, else another value.
-     */
+    /// Returns a value if present, else another value.
     template <class T>
     [[nodiscard]] T
     valueOr(std::string const& name, T const& other) const
@@ -214,27 +195,23 @@ public:
 
 //------------------------------------------------------------------------------
 
-/**
- * Holds unparsed configuration information.
- * The raw data sections are processed with intermediate parsers specific
- * to each module instead of being all parsed in a central location.
- */
+/** Holds unparsed configuration information.
+    The raw data sections are processed with intermediate parsers specific
+    to each module instead of being all parsed in a central location.
+*/
 class BasicConfig
 {
 private:
     std::unordered_map<std::string, Section> map_;
 
 public:
-    /**
-     * Returns `true` if a section with the given name exists.
-     */
+    /** Returns `true` if a section with the given name exists. */
     [[nodiscard]] bool
     exists(std::string const& name) const;
 
-    /**
-     * Returns the section with the given name.
-     * If the section does not exist, an empty section is returned.
-     */
+    /** Returns the section with the given name.
+        If the section does not exist, an empty section is returned.
+    */
     /** @{ */
     Section&
     section(std::string const& name);
@@ -255,39 +232,37 @@ public:
     }
     /** @} */
 
-    /**
-     * Overwrite a key/value pair with a command line argument
-     * If the section does not exist it is created.
-     * The previous value, if any, is overwritten.
-     */
+    /** Overwrite a key/value pair with a command line argument
+        If the section does not exist it is created.
+        The previous value, if any, is overwritten.
+    */
     void
     overwrite(std::string const& section, std::string const& key, std::string const& value);
 
-    /**
-     * Remove all the key/value pairs from the section.
+    /** Remove all the key/value pairs from the section.
      */
     void
     deprecatedClearSection(std::string const& section);
 
     /**
-     * Set a value that is not a key/value pair.
+     *  Set a value that is not a key/value pair.
      *
-     * The value is stored as the section's first value and may be retrieved
-     * through section::legacy.
+     *  The value is stored as the section's first value and may be retrieved
+     *  through section::legacy.
      *
-     * @param section Name of the section to modify.
-     * @param value Contents of the legacy value.
+     *  @param section Name of the section to modify.
+     *  @param value Contents of the legacy value.
      */
     void
     legacy(std::string const& section, std::string value);
 
     /**
-     * Get the legacy value of a section. A section with a
-     * single-line value may be retrieved as a legacy value.
+     *  Get the legacy value of a section. A section with a
+     *  single-line value may be retrieved as a legacy value.
      *
-     * @param sectionName Retrieve the contents of this section's
-     *        legacy value.
-     * @return Contents of the legacy value.
+     *  @param sectionName Retrieve the contents of this section's
+     *         legacy value.
+     *  @return Contents of the legacy value.
      */
     [[nodiscard]] std::string
     legacy(std::string const& sectionName) const;
@@ -310,12 +285,11 @@ protected:
 
 //------------------------------------------------------------------------------
 
-/**
- * Set a value from a configuration Section
- * If the named value is not found or doesn't parse as a T,
- * the variable is unchanged.
- * @return `true` if value was set.
- */
+/** Set a value from a configuration Section
+    If the named value is not found or doesn't parse as a T,
+    the variable is unchanged.
+    @return `true` if value was set.
+*/
 template <class T>
 bool
 set(T& target, std::string const& name, Section const& section)
@@ -324,8 +298,7 @@ set(T& target, std::string const& name, Section const& section)
     try
     {
         auto const val = section.get<T>(name);
-        foundAndValid = val.has_value();
-        if (foundAndValid)
+        if ((foundAndValid = val.has_value()))
             target = *val;
     }
     catch (boost::bad_lexical_cast const&)  // NOLINT(bugprone-empty-catch)
@@ -334,12 +307,11 @@ set(T& target, std::string const& name, Section const& section)
     return foundAndValid;
 }
 
-/**
- * Set a value from a configuration Section
- * If the named value is not found or doesn't cast to T,
- * the variable is assigned the default.
- * @return `true` if the named value was found and is valid.
- */
+/** Set a value from a configuration Section
+    If the named value is not found or doesn't cast to T,
+    the variable is assigned the default.
+    @return `true` if the named value was found and is valid.
+*/
 template <class T>
 bool
 set(T& target, T const& defaultValue, std::string const& name, Section const& section)
@@ -350,11 +322,10 @@ set(T& target, T const& defaultValue, std::string const& name, Section const& se
     return foundAndValid;
 }
 
-/**
- * Retrieve a key/value pair from a section.
- * @return The value string converted to T if it exists
- *         and can be parsed, or else defaultValue.
- */
+/** Retrieve a key/value pair from a section.
+    @return The value string converted to T if it exists
+            and can be parsed, or else defaultValue.
+*/
 // NOTE This routine might be more clumsy than the previous two
 template <class T = std::string>
 T

include/xrpl/basics/Blob.h

@@ -4,10 +4,9 @@
 
 namespace xrpl {
 
-/**
- * Storage for linear binary data.
- * Blocks of binary data appear often in various idioms and structures.
- */
+/** Storage for linear binary data.
+    Blocks of binary data appear often in various idioms and structures.
+*/
 using Blob = std::vector<unsigned char>;
 
 }  // namespace xrpl

include/xrpl/basics/Buffer.h

@@ -6,14 +6,12 @@
 #include <cstdint>
 #include <cstring>
 #include <memory>
-#include <utility>
 
 namespace xrpl {
 
-/**
- * Like std::vector<char> but better.
- * Meets the requirements of BufferFactory.
- */
+/** Like std::vector<char> but better.
+    Meets the requirements of BufferFactory.
+*/
 class Buffer
 {
 private:
@@ -25,37 +23,30 @@ public:
 
     Buffer() = default;
 
-    /**
-     * Create an uninitialized buffer with the given size.
-     */
+    /** Create an uninitialized buffer with the given size. */
     explicit Buffer(std::size_t size)
         : p_((size != 0u) ? new std::uint8_t[size] : nullptr), size_(size)
     {
     }
 
-    /**
-     * Create a buffer as a copy of existing memory.
-     *
-     * @param data a pointer to the existing memory. If
-     *             size is non-zero, it must not be null.
-     * @param size size of the existing memory block.
-     */
+    /** Create a buffer as a copy of existing memory.
+
+        @param data a pointer to the existing memory. If
+                    size is non-zero, it must not be null.
+        @param size size of the existing memory block.
+    */
     Buffer(void const* data, std::size_t size) : Buffer(size)
     {
         if (size != 0u)
             std::memcpy(p_.get(), data, size);
     }
 
-    /**
-     * Copy-construct
-     */
+    /** Copy-construct */
     Buffer(Buffer const& other) : Buffer(other.p_.get(), other.size_)
     {
     }
 
-    /**
-     * Copy assign
-     */
+    /** Copy assign */
     Buffer&
     operator=(Buffer const& other)
     {
@@ -67,19 +58,17 @@ public:
         return *this;
     }
 
-    /**
-     * Move-construct.
-     * The other buffer is reset.
-     */
+    /** Move-construct.
+        The other buffer is reset.
+    */
     Buffer(Buffer&& other) noexcept : p_(std::move(other.p_)), size_(other.size_)
     {
         other.size_ = 0;
     }
 
-    /**
-     * Move-assign.
-     * The other buffer is reset.
-     */
+    /** Move-assign.
+        The other buffer is reset.
+    */
     Buffer&
     operator=(Buffer&& other) noexcept
     {
@@ -92,16 +81,12 @@ public:
         return *this;
     }
 
-    /**
-     * Construct from a slice
-     */
+    /** Construct from a slice */
     explicit Buffer(Slice s) : Buffer(s.data(), s.size())
     {
     }
 
-    /**
-     * Assign from slice
-     */
+    /** Assign from slice */
     Buffer&
     operator=(Slice s)
     {
@@ -115,9 +100,7 @@ public:
         return *this;
     }
 
-    /**
-     * Returns the number of bytes in the buffer.
-     */
+    /** Returns the number of bytes in the buffer. */
     [[nodiscard]] std::size_t
     size() const noexcept
     {
@@ -137,11 +120,10 @@ public:
         return Slice{p_.get(), size_};
     }
 
-    /**
-     * Return a pointer to beginning of the storage.
-     * @note The return type is guaranteed to be a pointer
-     *       to a single byte, to facilitate pointer arithmetic.
-     */
+    /** Return a pointer to beginning of the storage.
+        @note The return type is guaranteed to be a pointer
+              to a single byte, to facilitate pointer arithmetic.
+    */
     /** @{ */
     [[nodiscard]] std::uint8_t const*
     data() const noexcept
@@ -156,10 +138,9 @@ public:
     }
     /** @} */
 
-    /**
-     * Reset the buffer.
-     * All memory is deallocated. The resulting size is 0.
-     */
+    /** Reset the buffer.
+        All memory is deallocated. The resulting size is 0.
+    */
     void
     clear() noexcept
     {
@@ -167,10 +148,9 @@ public:
         size_ = 0;
     }
 
-    /**
-     * Reallocate the storage.
-     * Existing data, if any, is discarded.
-     */
+    /** Reallocate the storage.
+        Existing data, if any, is discarded.
+    */
     std::uint8_t*
     alloc(std::size_t n)
     {

include/xrpl/basics/CompressionAlgorithms.h

@@ -5,15 +5,13 @@
 #include <lz4.h>
 
 #include <algorithm>
-#include <cstddef>
 #include <cstdint>
 #include <stdexcept>
 #include <vector>
 
 namespace xrpl::compression_algorithms {
 
-/**
- * LZ4 block compression.
+/** LZ4 block compression.
  * @tparam BufferFactory Callable object or lambda.
  *     Takes the requested buffer size and returns allocated buffer pointer.
  * @param in Data to compress
@@ -81,8 +79,7 @@ lz4Decompress(
     return decompressedSize;
 }
 
-/**
- * LZ4 block decompression.
+/** LZ4 block decompression.
  * @tparam InputStream ZeroCopyInputStream
  * @param in Input source stream
  * @param inSize Size of compressed data

include/xrpl/basics/CountedObject.h

@@ -9,9 +9,7 @@
 
 namespace xrpl {
 
-/**
- * Manages all counted object types.
- */
+/** Manages all counted object types. */
 class CountedObjects
 {
 public:
@@ -25,11 +23,10 @@ public:
     getCounts(int minimumThreshold) const;
 
 public:
-    /**
-     * Implementation for @ref CountedObject.
-     *
-     * @internal
-     */
+    /** Implementation for @ref CountedObject.
+
+        @internal
+    */
     class Counter
     {
     public:
@@ -97,14 +94,13 @@ private:
 
 //------------------------------------------------------------------------------
 
-/**
- * Tracks the number of instances of an object.
- *
- * Derived classes have their instances counted automatically. This is used
- * for reporting purposes.
- *
- * @ingroup basics
- */
+/** Tracks the number of instances of an object.
+
+    Derived classes have their instances counted automatically. This is used
+    for reporting purposes.
+
+    @ingroup basics
+*/
 template <class Object>
 class CountedObject
 {

include/xrpl/basics/DecayingSample.h

@@ -2,34 +2,31 @@
 
 #include <chrono>
 #include <cmath>
-#include <cstddef>
 
 namespace xrpl {
 
-/**
- * Sampling function using exponential decay to provide a continuous value.
- * @tparam The number of seconds in the decay window.
- */
+/** Sampling function using exponential decay to provide a continuous value.
+    @tparam The number of seconds in the decay window.
+*/
 template <int Window, typename Clock>
 class DecayingSample
 {
 public:
-    using value_type = Clock::duration::rep;
-    using time_point = Clock::time_point;
+    using value_type = typename Clock::duration::rep;
+    using time_point = typename Clock::time_point;
 
     DecayingSample() = delete;
 
     /**
-     * @param now Start time of DecayingSample.
-     */
+        @param now Start time of DecayingSample.
+    */
     explicit DecayingSample(time_point now) : value_(value_type()), when_(now)
     {
     }
 
-    /**
-     * Add a new sample.
-     * The value is first aged according to the specified time.
-     */
+    /** Add a new sample.
+        The value is first aged according to the specified time.
+    */
     value_type
     add(value_type value, time_point now)
     {
@@ -38,10 +35,9 @@ public:
         return value_ / Window;
     }
 
-    /**
-     * Retrieve the current value in normalized units.
-     * The samples are first aged according to the specified time.
-     */
+    /** Retrieve the current value in normalized units.
+        The samples are first aged according to the specified time.
+    */
     value_type
     value(time_point now)
     {
@@ -90,15 +86,14 @@ private:
 
 //------------------------------------------------------------------------------
 
-/**
- * Sampling function using exponential decay to provide a continuous value.
- * @tparam HalfLife The half life of a sample, in seconds.
- */
+/** Sampling function using exponential decay to provide a continuous value.
+    @tparam HalfLife The half life of a sample, in seconds.
+*/
 template <int HalfLife, class Clock>
 class DecayWindow
 {
 public:
-    using time_point = Clock::time_point;
+    using time_point = typename Clock::time_point;
 
     explicit DecayWindow(time_point now) : when_(now)
     {

include/xrpl/basics/Expected.h

@@ -0,0 +1,248 @@
+#pragma once
+
+#include <xrpl/basics/contract.h>
+
+#include <boost/outcome.hpp>
+
+#include <stdexcept>
+
+namespace xrpl {
+
+/** Expected is an approximation of std::expected (hoped for in C++23)
+
+    See: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2021/p0323r10.html
+
+    The implementation is entirely based on boost::outcome_v2::result.
+*/
+
+// Exception thrown by an invalid access to Expected.
+struct BadExpectedAccess : public std::runtime_error
+{
+    BadExpectedAccess() : runtime_error("bad expected access")
+    {
+    }
+};
+
+namespace detail {
+
+// Custom policy for Expected.  Always throw on an invalid access.
+struct ThrowPolicy : public boost::outcome_v2::policy::base
+{
+    template <class Impl>
+    static constexpr void
+    // NOLINTNEXTLINE(readability-identifier-naming)
+    wide_value_check(Impl&& self)
+    {
+        if (!base::_has_value(std::forward<Impl>(self)))
+            Throw<BadExpectedAccess>();
+    }
+
+    template <class Impl>
+    static constexpr void
+    // NOLINTNEXTLINE(readability-identifier-naming)
+    wide_error_check(Impl&& self)
+    {
+        if (!base::_has_error(std::forward<Impl>(self)))
+            Throw<BadExpectedAccess>();
+    }
+
+    template <class Impl>
+    static constexpr void
+    // NOLINTNEXTLINE(readability-identifier-naming)
+    wide_exception_check(Impl&& self)
+    {
+        if (!base::_has_exception(std::forward<Impl>(self)))
+            Throw<BadExpectedAccess>();
+    }
+};
+
+}  // namespace detail
+
+// Definition of Unexpected, which is used to construct the unexpected
+// return type of an Expected.
+template <class E>
+class Unexpected
+{
+public:
+    static_assert(!std::is_same_v<E, void>, "E must not be void");
+
+    Unexpected() = delete;
+
+    constexpr explicit Unexpected(E const& e) : val_(e)
+    {
+    }
+
+    constexpr explicit Unexpected(E&& e) : val_(std::move(e))
+    {
+    }
+
+    [[nodiscard]] constexpr E const&
+    value() const&
+    {
+        return val_;
+    }
+
+    constexpr E&
+    value() &
+    {
+        return val_;
+    }
+
+    constexpr E&&
+    value() &&
+    {
+        return std::move(val_);
+    }
+
+    [[nodiscard]] constexpr E const&&
+    value() const&&
+    {
+        return std::move(val_);
+    }
+
+private:
+    E val_;
+};
+
+// Unexpected deduction guide that converts array to const*.
+template <typename E, std::size_t N>
+Unexpected(E (&)[N]) -> Unexpected<E const*>;
+
+// Definition of Expected.  All of the machinery comes from boost::result.
+template <class T, class E>
+class [[nodiscard]] Expected : private boost::outcome_v2::result<T, E, detail::ThrowPolicy>
+{
+    using Base = boost::outcome_v2::result<T, E, detail::ThrowPolicy>;
+
+public:
+    template <typename U>
+        requires std::convertible_to<U, T>
+    constexpr Expected(U&& r) : Base(boost::outcome_v2::in_place_type_t<T>{}, std::forward<U>(r))
+    {
+    }
+
+    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()))
+    {
+    }
+
+    [[nodiscard]] constexpr bool
+    // NOLINTNEXTLINE(readability-identifier-naming)
+    has_value() const
+    {
+        return Base::has_value();
+    }
+
+    [[nodiscard]] constexpr T const&
+    value() const
+    {
+        return Base::value();
+    }
+
+    constexpr T&
+    value()
+    {
+        return Base::value();
+    }
+
+    [[nodiscard]] constexpr E const&
+    error() const&
+    {
+        return Base::error();
+    }
+
+    [[nodiscard]] constexpr E&
+    error() &
+    {
+        return Base::error();
+    }
+
+    [[nodiscard]] constexpr E&&
+    error() &&
+    {
+        return std::move(Base::error());
+    }
+
+    constexpr explicit
+    operator bool() const
+    {
+        return has_value();
+    }
+
+    // Add operator* and operator-> so the Expected API looks a bit more like
+    // what std::expected is likely to look like.  See:
+    // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2021/p0323r10.html
+    [[nodiscard]] constexpr T&
+    operator*()
+    {
+        return this->value();
+    }
+
+    [[nodiscard]] constexpr T const&
+    operator*() const
+    {
+        return this->value();
+    }
+
+    [[nodiscard]] constexpr T*
+    operator->()
+    {
+        return &this->value();
+    }
+
+    [[nodiscard]] constexpr T const*
+    operator->() const
+    {
+        return &this->value();
+    }
+};
+
+// 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::ThrowPolicy>
+{
+    using Base = boost::outcome_v2::result<void, E, detail::ThrowPolicy>;
+
+public:
+    // The default constructor makes a successful Expected<void, E>.
+    // This aligns with std::expected behavior proposed in P0323R10.
+    constexpr Expected() : Base(boost::outcome_v2::success())
+    {
+    }
+
+    template <typename U>
+        requires std::convertible_to<U, E> && (!std::is_reference_v<U>)
+    constexpr Expected(Unexpected<U> e) : Base(E(std::move(e.value())))
+    {
+    }
+
+    [[nodiscard]] constexpr E const&
+    error() const&
+    {
+        return Base::error();
+    }
+
+    [[nodiscard]] constexpr E&
+    error() &
+    {
+        return Base::error();
+    }
+
+    [[nodiscard]] constexpr E&&
+    error() &&
+    {
+        return std::move(Base::error());
+    }
+
+    constexpr explicit
+    operator bool() const
+    {
+        return Base::has_value();
+    }
+};
+
+}  // namespace xrpl

include/xrpl/basics/FileUtilities.h

@@ -3,9 +3,7 @@
 #include <boost/filesystem.hpp>
 #include <boost/system/error_code.hpp>
 
-#include <cstddef>
 #include <optional>
-#include <string>
 
 namespace xrpl {
 

include/xrpl/basics/IntrusivePointer.h

@@ -1,7 +1,6 @@
 #pragma once
 
 #include <concepts>
-#include <cstddef>
 #include <cstdint>
 #include <type_traits>
 #include <utility>
@@ -10,37 +9,33 @@ namespace xrpl {
 
 //------------------------------------------------------------------------------
 
-/**
- * Tag to create an intrusive pointer from another intrusive pointer by using a
- * static cast. This is useful to create an intrusive pointer to a derived
- * class from an intrusive pointer to a base class.
- */
+/** Tag to create an intrusive pointer from another intrusive pointer by using a
+    static cast. This is useful to create an intrusive pointer to a derived
+    class from an intrusive pointer to a base class.
+*/
 struct StaticCastTagSharedIntrusive
 {
 };
 
-/**
- * Tag to create an intrusive pointer from another intrusive pointer by using a
- * dynamic cast. This is useful to create an intrusive pointer to a derived
- * class from an intrusive pointer to a base class. If the cast fails an empty
- * (null) intrusive pointer is created.
- */
+/** Tag to create an intrusive pointer from another intrusive pointer by using a
+    dynamic cast. This is useful to create an intrusive pointer to a derived
+    class from an intrusive pointer to a base class. If the cast fails an empty
+    (null) intrusive pointer is created.
+*/
 struct DynamicCastTagSharedIntrusive
 {
 };
 
-/**
- * When creating or adopting a raw pointer, controls whether the strong count
- * is incremented or not. Use this tag to increment the strong count.
- */
+/** When creating or adopting a raw pointer, controls whether the strong count
+    is incremented or not. Use this tag to increment the strong count.
+*/
 struct SharedIntrusiveAdoptIncrementStrongTag
 {
 };
 
-/**
- * When creating or adopting a raw pointer, controls whether the strong count
- * is incremented or not. Use this tag to leave the strong count unchanged.
- */
+/** When creating or adopting a raw pointer, controls whether the strong count
+    is incremented or not. Use this tag to leave the strong count unchanged.
+*/
 struct SharedIntrusiveAdoptNoIncrementTag
 {
 };
@@ -54,21 +49,20 @@ concept CAdoptTag = std::is_same_v<T, SharedIntrusiveAdoptIncrementStrongTag> ||
 
 //------------------------------------------------------------------------------
 
-/**
- * A shared intrusive pointer class that supports weak pointers.
- *
- * This is meant to be used for SHAMapInnerNodes, but may be useful for other
- * cases. Since the reference counts are stored on the pointee, the pointee is
- * not destroyed until both the strong _and_ weak pointer counts go to zero.
- * When the strong pointer count goes to zero, the "partialDestructor" is
- * called. This can be used to destroy as much of the object as possible while
- * still retaining the reference counts. For example, for SHAMapInnerNodes the
- * children may be reset in that function. Note that std::shared_pointer WILL
- * run the destructor when the strong count reaches zero, but may not free the
- * memory used by the object until the weak count reaches zero. In xrpld, we
- * typically allocate shared pointers with the `make_shared` function. When
- * that is used, the memory is not reclaimed until the weak count reaches zero.
- */
+/** A shared intrusive pointer class that supports weak pointers.
+
+    This is meant to be used for SHAMapInnerNodes, but may be useful for other
+    cases. Since the reference counts are stored on the pointee, the pointee is
+    not destroyed until both the strong _and_ weak pointer counts go to zero.
+    When the strong pointer count goes to zero, the "partialDestructor" is
+    called. This can be used to destroy as much of the object as possible while
+    still retaining the reference counts. For example, for SHAMapInnerNodes the
+    children may be reset in that function. Note that std::shared_pointer WILL
+    run the destructor when the strong count reaches zero, but may not free the
+    memory used by the object until the weak count reaches zero. In xrpld, we
+    typically allocate shared pointers with the `make_shared` function. When
+    that is used, the memory is not reclaimed until the weak count reaches zero.
+*/
 template <class T>
 class SharedIntrusive
 {
@@ -116,9 +110,8 @@ public:
     operator=(
         SharedIntrusive<TT>&& rhs);  // NOLINT(cppcoreguidelines-rvalue-reference-param-not-moved)
 
-    /**
-     * Adopt the raw pointer. The strong reference may or may not be
-     * incremented, depending on the TAdoptTag
+    /** Adopt the raw pointer. The strong reference may or may not be
+        incremented, depending on the TAdoptTag
      */
     template <CAdoptTag TAdoptTag = SharedIntrusiveAdoptIncrementStrongTag>
     void
@@ -126,31 +119,27 @@ public:
 
     ~SharedIntrusive();
 
-    /**
-     * Create a new SharedIntrusive by statically casting the pointer
-     * controlled by the rhs param.
-     */
+    /** Create a new SharedIntrusive by statically casting the pointer
+        controlled by the rhs param.
+    */
     template <class TT>
     SharedIntrusive(StaticCastTagSharedIntrusive, SharedIntrusive<TT> const& rhs);
 
-    /**
-     * Create a new SharedIntrusive by statically casting the pointer
-     * controlled by the rhs param.
-     */
+    /** Create a new SharedIntrusive by statically casting the pointer
+       controlled by the rhs param.
+    */
     template <class TT>
     SharedIntrusive(StaticCastTagSharedIntrusive, SharedIntrusive<TT>&& rhs);
 
-    /**
-     * Create a new SharedIntrusive by dynamically casting the pointer
-     * controlled by the rhs param.
-     */
+    /** Create a new SharedIntrusive by dynamically casting the pointer
+       controlled by the rhs param.
+    */
     template <class TT>
     SharedIntrusive(DynamicCastTagSharedIntrusive, SharedIntrusive<TT> const& rhs);
 
-    /**
-     * Create a new SharedIntrusive by dynamically casting the pointer
-     * controlled by the rhs param.
-     */
+    /** Create a new SharedIntrusive by dynamically casting the pointer
+       controlled by the rhs param.
+    */
     template <class TT>
     SharedIntrusive(DynamicCastTagSharedIntrusive, SharedIntrusive<TT>&& rhs);
 
@@ -163,22 +152,17 @@ public:
     explicit
     operator bool() const noexcept;
 
-    /**
-     * Set the pointer to null, decrement the strong count, and run the
-     * appropriate release action.
-     */
+    /** Set the pointer to null, decrement the strong count, and run the
+        appropriate release action.
+      */
     void
     reset();
 
-    /**
-     * Get the raw pointer
-     */
+    /** Get the raw pointer */
     [[nodiscard]] T*
     get() const;
 
-    /**
-     * Return the strong count
-     */
+    /** Return the strong count */
     [[nodiscard]] std::size_t
     useCount() const;
 
@@ -196,51 +180,43 @@ public:
     friend class WeakIntrusive;
 
 private:
-    /**
-     * Return the raw pointer held by this object.
-     */
+    /** Return the raw pointer held by this object. */
     [[nodiscard]] T*
     unsafeGetRawPtr() const;
 
-    /**
-     * Exchange the current raw pointer held by this object with the given
-     * pointer. Decrement the strong count of the raw pointer previously held
-     * by this object and run the appropriate release action.
+    /** Exchange the current raw pointer held by this object with the given
+        pointer. Decrement the strong count of the raw pointer previously held
+        by this object and run the appropriate release action.
      */
     void
     unsafeReleaseAndStore(T* next);
 
-    /**
-     * Set the raw pointer directly. This is wrapped in a function so the class
-     * can support both atomic and non-atomic pointers in a future patch.
+    /** Set the raw pointer directly. This is wrapped in a function so the class
+        can support both atomic and non-atomic pointers in a future patch.
      */
     void
     unsafeSetRawPtr(T* p);
 
-    /**
-     * Exchange the raw pointer directly.
-     * This sets the raw pointer to the given value and returns the previous
-     * value. This is wrapped in a function so the class can support both
-     * atomic and non-atomic pointers in a future patch.
+    /** Exchange the raw pointer directly.
+        This sets the raw pointer to the given value and returns the previous
+        value. This is wrapped in a function so the class can support both
+        atomic and non-atomic pointers in a future patch.
      */
     T*
     unsafeExchange(T* p);
 
-    /**
-     * pointer to the type with an intrusive count
-     */
+    /** pointer to the type with an intrusive count */
     T* ptr_{nullptr};
 };
 
 //------------------------------------------------------------------------------
 
-/**
- * A weak intrusive pointer class for the SharedIntrusive pointer class.
- *
- * Note that this weak pointer class asks differently from normal weak pointer
- * classes. When the strong pointer count goes to zero, the "partialDestructor"
- * is called. See the comment on SharedIntrusive for a fuller explanation.
- */
+/** A weak intrusive pointer class for the SharedIntrusive pointer class.
+
+Note that this weak pointer class asks differently from normal weak pointer
+classes. When the strong pointer count goes to zero, the "partialDestructor"
+is called. See the comment on SharedIntrusive for a fuller explanation.
+*/
 template <class T>
 class WeakIntrusive
 {
@@ -270,62 +246,54 @@ public:
     WeakIntrusive&
     operator=(SharedIntrusive<TT> const& rhs);
 
-    /**
-     * Adopt the raw pointer and increment the weak count.
-     */
+    /** Adopt the raw pointer and increment the weak count. */
     void
     adopt(T* ptr);
 
     ~WeakIntrusive();
 
-    /**
-     * Get a strong pointer from the weak pointer, if possible. This will
-     * only return a seated pointer if the strong count on the raw pointer
-     * is non-zero before locking.
+    /** Get a strong pointer from the weak pointer, if possible. This will
+       only return a seated pointer if the strong count on the raw pointer
+       is non-zero before locking.
      */
     SharedIntrusive<T>
     lock() const;
 
-    /**
-     * Return true if the strong count is zero.
-     */
+    /** Return true if the strong count is zero. */
     [[nodiscard]] bool
     expired() const;
 
-    /**
-     * Set the pointer to null and decrement the weak count.
-     *
-     * Note: This may run the destructor if the strong count is zero.
-     */
+    /** Set the pointer to null and decrement the weak count.
+
+    Note: This may run the destructor if the strong count is zero.
+    */
     void
     reset();
 
 private:
     T* ptr_ = nullptr;
 
-    /**
-     * Decrement the weak count. This does _not_ set the raw pointer to
-     * null.
-     *
-     * Note: This may run the destructor if the strong count is zero.
-     */
+    /** Decrement the weak count. This does _not_ set the raw pointer to
+    null.
+
+    Note: This may run the destructor if the strong count is zero.
+    */
     void
     unsafeReleaseNoStore();
 };
 
 //------------------------------------------------------------------------------
 
-/**
- * A combination of a strong and a weak intrusive pointer stored in the
- * space of a single pointer.
- *
- * This class is similar to a `std::variant<SharedIntrusive,WeakIntrusive>`
- * with some optimizations. In particular, it uses a low-order bit to
- * determine if the raw pointer represents a strong pointer or a weak
- * pointer. It can also be quickly switched between its strong pointer and
- * weak pointer representations. This class is useful for storing intrusive
- * pointers in tagged caches.
- */
+/** A combination of a strong and a weak intrusive pointer stored in the
+    space of a single pointer.
+
+    This class is similar to a `std::variant<SharedIntrusive,WeakIntrusive>`
+    with some optimizations. In particular, it uses a low-order bit to
+    determine if the raw pointer represents a strong pointer or a weak
+    pointer. It can also be quickly switched between its strong pointer and
+    weak pointer representations. This class is useful for storing intrusive
+    pointers in tagged caches.
+  */
 
 template <class T>
 class SharedWeakUnion
@@ -367,83 +335,69 @@ public:
 
     ~SharedWeakUnion();
 
-    /**
-     * Return a strong pointer if this is already a strong pointer (i.e.
-     * don't lock the weak pointer. Use the `lock` method if that's what's
-     * needed)
+    /** Return a strong pointer if this is already a strong pointer (i.e.
+       don't lock the weak pointer. Use the `lock` method if that's what's
+       needed)
      */
     [[nodiscard]] SharedIntrusive<T>
     getStrong() const;
 
-    /**
-     * Return true if this is a strong pointer and the strong pointer is
-     * seated.
+    /** Return true if this is a strong pointer and the strong pointer is
+        seated.
      */
     explicit
     operator bool() const noexcept;
 
-    /**
-     * Set the pointer to null, decrement the appropriate ref count, and
-     * run the appropriate release action.
+    /** Set the pointer to null, decrement the appropriate ref count, and
+       run the appropriate release action.
      */
     void
     reset();
 
-    /**
-     * If this is a strong pointer, return the raw pointer. Otherwise
-     * return null.
+    /** If this is a strong pointer, return the raw pointer. Otherwise
+       return null.
      */
     [[nodiscard]] T*
     get() const;
 
-    /**
-     * If this is a strong pointer, return the strong count. Otherwise
+    /** If this is a strong pointer, return the strong count. Otherwise
      * return 0
      */
     [[nodiscard]] std::size_t
     useCount() const;
 
-    /**
-     * Return true if there is a non-zero strong count.
-     */
+    /** Return true if there is a non-zero strong count. */
     [[nodiscard]] bool
     expired() const;
 
-    /**
-     * If this is a strong pointer, return the strong pointer. Otherwise
-     * attempt to lock the weak pointer.
+    /** If this is a strong pointer, return the strong pointer. Otherwise
+        attempt to lock the weak pointer.
      */
     [[nodiscard]] SharedIntrusive<T>
     lock() const;
 
-    /**
-     * Return true is this represents a strong pointer.
-     */
+    /** Return true is this represents a strong pointer. */
     [[nodiscard]] bool
     isStrong() const;
 
-    /**
-     * Return true is this represents a weak pointer.
-     */
+    /** Return true is this represents a weak pointer. */
     [[nodiscard]] bool
     isWeak() const;
 
-    /**
-     * If this is a weak pointer, attempt to convert it to a strong
-     * pointer.
-     *
-     * @return true if successfully converted to a strong pointer (or was
-     *         already a strong pointer). Otherwise false.
-     */
+    /** If this is a weak pointer, attempt to convert it to a strong
+       pointer.
+
+        @return true if successfully converted to a strong pointer (or was
+                already a strong pointer). Otherwise false.
+      */
     bool
     convertToStrong();
 
-    /**
-     * If this is a strong pointer, attempt to convert it to a weak
-     * pointer.
-     *
-     * @return false if the pointer is null. Otherwise return true.
-     */
+    /** If this is a strong pointer, attempt to convert it to a weak
+       pointer.
+
+        @return false if the pointer is null. Otherwise return true.
+      */
     bool
     convertToWeak();
 
@@ -456,27 +410,23 @@ private:
     static constexpr std::uintptr_t kPtrMask = ~kTagMask;
 
 private:
-    /**
-     * Return the raw pointer held by this object.
+    /** Return the raw pointer held by this object.
      */
     [[nodiscard]] T*
     unsafeGetRawPtr() const;
 
     enum class RefStrength { Strong, Weak };
-    /**
-     * Set the raw pointer and tag bit directly.
+    /** Set the raw pointer and tag bit directly.
      */
     void
     unsafeSetRawPtr(T* p, RefStrength rs);
 
-    /**
-     * Set the raw pointer and tag bit to all zeros (strong null pointer).
+    /** Set the raw pointer and tag bit to all zeros (strong null pointer).
      */
     void unsafeSetRawPtr(std::nullptr_t);
 
-    /**
-     * Decrement the appropriate ref count, and run the appropriate release
-     * action. Note: this does _not_ set the raw pointer to null.
+    /** Decrement the appropriate ref count, and run the appropriate release
+        action. Note: this does _not_ set the raw pointer to null.
      */
     void
     unsafeReleaseNoStore();
@@ -484,13 +434,12 @@ private:
 
 //------------------------------------------------------------------------------
 
-/**
- * Create a shared intrusive pointer.
- *
- * Note: unlike std::shared_ptr, where there is an advantage of allocating
- * the pointer and control block together, there is no benefit for intrusive
- * pointers.
- */
+/** Create a shared intrusive pointer.
+
+    Note: unlike std::shared_ptr, where there is an advantage of allocating
+    the pointer and control block together, there is no benefit for intrusive
+    pointers.
+*/
 template <class TT, class... Args>
 SharedIntrusive<TT>
 makeSharedIntrusive(Args&&... args)

include/xrpl/basics/IntrusivePointer.ipp

@@ -641,9 +641,6 @@ template <class T>
 T*
 SharedWeakUnion<T>::unsafeGetRawPtr() const
 {
-    // tp_ packs a raw pointer together with a strength bit; recovering the
-    // pointer inherently requires an integer-to-pointer cast.
-    // NOLINTNEXTLINE(performance-no-int-to-ptr)
     return reinterpret_cast<T*>(tp_ & kPtrMask);
 }
 

include/xrpl/basics/IntrusiveRefCounts.h

@@ -3,43 +3,39 @@
 #include <xrpl/beast/utility/instrumentation.h>
 
 #include <atomic>
-#include <cstddef>
 #include <cstdint>
 
 namespace xrpl {
 
-/**
- * Action to perform when releasing a strong pointer.
- *
- * noop: Do nothing. For example, a `noop` action will occur when a count is
- * decremented to a non-zero value.
- *
- * partialDestroy: Run the `partialDestructor`. This action will happen when a
- * strong count is decremented to zero and the weak count is non-zero.
- *
- * destroy: Run the destructor. This action will occur when either the strong
- * count or weak count is decremented and the other count is also zero.
+/** Action to perform when releasing a strong pointer.
+
+    noop: Do nothing. For example, a `noop` action will occur when a count is
+    decremented to a non-zero value.
+
+    partialDestroy: Run the `partialDestructor`. This action will happen when a
+    strong count is decremented to zero and the weak count is non-zero.
+
+    destroy: Run the destructor. This action will occur when either the strong
+    count or weak count is decremented and the other count is also zero.
  */
 enum class ReleaseStrongRefAction { NoOp, PartialDestroy, Destroy };
 
-/**
- * Action to perform when releasing a weak pointer.
- *
- * noop: Do nothing. For example, a `noop` action will occur when a count is
- * decremented to a non-zero value.
- *
- * destroy: Run the destructor. This action will occur when either the strong
- * count or weak count is decremented and the other count is also zero.
+/** Action to perform when releasing a weak pointer.
+
+    noop: Do nothing. For example, a `noop` action will occur when a count is
+    decremented to a non-zero value.
+
+    destroy: Run the destructor. This action will occur when either the strong
+    count or weak count is decremented and the other count is also zero.
  */
 enum class ReleaseWeakRefAction { NoOp, Destroy };
 
-/**
- * Implement the strong count, weak count, and bit flags for an intrusive
- * pointer.
- *
- * A class can satisfy the requirements of an xrpl::IntrusivePointer by
- * inheriting from this class.
- */
+/** Implement the strong count, weak count, and bit flags for an intrusive
+    pointer.
+
+    A class can satisfy the requirements of an xrpl::IntrusivePointer by
+    inheriting from this class.
+  */
 struct IntrusiveRefCounts
 {
     virtual ~IntrusiveRefCounts() noexcept;
@@ -108,123 +104,109 @@ private:
     static constexpr size_t kFieldTypeBits = sizeof(FieldType) * 8;
     static constexpr FieldType kOne = 1;
 
-    /**
-     * `refCounts` consists of four fields that are treated atomically:
-     *
-     * 1. Strong count. This is a count of the number of shared pointers that
-     * hold a reference to this object. When the strong counts goes to zero,
-     * if the weak count is zero, the destructor is run. If the weak count is
-     * non-zero when the strong count goes to zero then the partialDestructor
-     * is run.
-     *
-     * 2. Weak count. This is a count of the number of weak pointer that hold
-     * a reference to this object. When the weak count goes to zero and the
-     * strong count is also zero, then the destructor is run.
-     *
-     * 3. Partial destroy started bit. This bit is set if the
-     * `partialDestructor` function has been started (or is about to be
-     * started). This is used to prevent the destructor from running
-     * concurrently with the partial destructor. This can easily happen when
-     * the last strong pointer release its reference in one thread and starts
-     * the partialDestructor, while in another thread the last weak pointer
-     * goes out of scope and starts the destructor while the partialDestructor
-     * is still running. Both a start and finished bit is needed to handle a
-     * corner-case where the last strong pointer goes out of scope, then then
-     * last `weakPointer` goes out of scope, but this happens before the
-     * `partialDestructor` bit is set. It would be possible to use a single
-     * bit if it could also be set atomically when the strong count goes to
-     * zero and the weak count is non-zero, but that would add complexity (and
-     * likely slow down common cases as well).
-     *
-     * 4. Partial destroy finished bit. This bit is set when the
-     * `partialDestructor` has finished running. See (3) above for more
-     * information.
-     */
+    /** `refCounts` consists of four fields that are treated atomically:
+
+         1. Strong count. This is a count of the number of shared pointers that
+         hold a reference to this object. When the strong counts goes to zero,
+         if the weak count is zero, the destructor is run. If the weak count is
+         non-zero when the strong count goes to zero then the partialDestructor
+         is run.
+
+         2. Weak count. This is a count of the number of weak pointer that hold
+         a reference to this object. When the weak count goes to zero and the
+         strong count is also zero, then the destructor is run.
+
+         3. Partial destroy started bit. This bit is set if the
+         `partialDestructor` function has been started (or is about to be
+         started). This is used to prevent the destructor from running
+         concurrently with the partial destructor. This can easily happen when
+         the last strong pointer release its reference in one thread and starts
+         the partialDestructor, while in another thread the last weak pointer
+         goes out of scope and starts the destructor while the partialDestructor
+         is still running. Both a start and finished bit is needed to handle a
+         corner-case where the last strong pointer goes out of scope, then then
+         last `weakPointer` goes out of scope, but this happens before the
+         `partialDestructor` bit is set. It would be possible to use a single
+         bit if it could also be set atomically when the strong count goes to
+         zero and the weak count is non-zero, but that would add complexity (and
+         likely slow down common cases as well).
+
+         4. Partial destroy finished bit. This bit is set when the
+         `partialDestructor` has finished running. See (3) above for more
+         information.
+
+         */
 
     mutable std::atomic<FieldType> refCounts_{kStrongDelta};
 
-    /**
-     * Amount to change the strong count when adding or releasing a reference
-     *
-     *   Note: The strong count is stored in the low `StrongCountNumBits` bits
-     * of refCounts
-     */
+    /**  Amount to change the strong count when adding or releasing a reference
+
+         Note: The strong count is stored in the low `StrongCountNumBits` bits
+       of refCounts
+      */
     static constexpr FieldType kStrongDelta = 1;
 
-    /**
-     * Amount to change the weak count when adding or releasing a reference
-     *
-     * Note: The weak count is stored in the high `WeakCountNumBits` bits of
-     * refCounts
-     */
+    /**  Amount to change the weak count when adding or releasing a reference
+
+         Note: The weak count is stored in the high `WeakCountNumBits` bits of
+         refCounts
+      */
     static constexpr FieldType kWeakDelta = (kOne << kStrongCountNumBits);
 
-    /**
-     * Flag that is set when the partialDestroy function has started running
-     * (or is about to start running).
-     *
-     * See description of the `refCounts` field for a fuller description of
-     * this field.
-     */
+    /**  Flag that is set when the partialDestroy function has started running
+         (or is about to start running).
+
+         See description of the `refCounts` field for a fuller description of
+         this field.
+      */
     static constexpr FieldType kPartialDestroyStartedMask = (kOne << (kFieldTypeBits - 1));
 
-    /**
-     * Flag that is set when the partialDestroy function has finished running
-     *
-     * See description of the `refCounts` field for a fuller description of
-     * this field.
-     */
+    /**  Flag that is set when the partialDestroy function has finished running
+
+         See description of the `refCounts` field for a fuller description of
+         this field.
+      */
     static constexpr FieldType kPartialDestroyFinishedMask = (kOne << (kFieldTypeBits - 2));
 
-    /**
-     * Mask that will zero out all the `count` bits and leave the tag bits
-     * unchanged.
-     */
+    /** Mask that will zero out all the `count` bits and leave the tag bits
+        unchanged.
+      */
     static constexpr FieldType kTagMask = kPartialDestroyStartedMask | kPartialDestroyFinishedMask;
 
-    /**
-     * Mask that will zero out the `tag` bits and leave the count bits
-     * unchanged.
-     */
+    /** Mask that will zero out the `tag` bits and leave the count bits
+        unchanged.
+      */
     static constexpr FieldType kValueMask = ~kTagMask;
 
-    /**
-     * Mask that will zero out everything except the strong count.
+    /** Mask that will zero out everything except the strong count.
      */
     static constexpr FieldType kStrongMask = ((kOne << kStrongCountNumBits) - 1) & kValueMask;
 
-    /**
-     * Mask that will zero out everything except the weak count.
+    /** Mask that will zero out everything except the weak count.
      */
     static constexpr FieldType kWeakMask =
         (((kOne << kWeakCountNumBits) - 1) << kStrongCountNumBits) & kValueMask;
 
-    /**
-     * Unpack the count and tag fields from the packed atomic integer form.
-     */
+    /** Unpack the count and tag fields from the packed atomic integer form. */
     struct RefCountPair
     {
         CountType strong;
         CountType weak;
-        /**
-         * The `partialDestroyStartedBit` is set to on when the partial
-         * destroy function is started. It is not a boolean; it is a uint32
-         * with all bits zero with the possible exception of the
-         * `partialDestroyStartedMask` bit. This is done so it can be directly
-         * masked into the `combinedValue`.
+        /**  The `partialDestroyStartedBit` is set to on when the partial
+             destroy function is started. It is not a boolean; it is a uint32
+             with all bits zero with the possible exception of the
+             `partialDestroyStartedMask` bit. This is done so it can be directly
+             masked into the `combinedValue`.
          */
         FieldType partialDestroyStartedBit{0};
-        /**
-         * The `partialDestroyFinishedBit` is set to on when the partial
-         * destroy function has finished.
+        /**  The `partialDestroyFinishedBit` is set to on when the partial
+             destroy function has finished.
          */
         FieldType partialDestroyFinishedBit{0};
         RefCountPair(FieldType v) noexcept;
         RefCountPair(CountType s, CountType w) noexcept;
 
-        /**
-         * Convert back to the packed integer form.
-         */
+        /** Convert back to the packed integer form. */
         [[nodiscard]] FieldType
         combinedValue() const noexcept;
 
@@ -232,10 +214,9 @@ private:
             static_cast<CountType>((kOne << kStrongCountNumBits) - 1);
         static constexpr CountType kMaxWeakValue =
             static_cast<CountType>((kOne << kWeakCountNumBits) - 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).
+        /**  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).
          */
         static constexpr CountType kCheckStrongMaxValue = kMaxStrongValue - 32;
         static constexpr CountType kCheckWeakMaxValue = kMaxWeakValue - 32;

include/xrpl/basics/LocalValue.h

@@ -70,15 +70,11 @@ public:
     {
     }
 
-    /**
-     * Stores instance of T specific to the calling coroutine or thread.
-     */
+    /** Stores instance of T specific to the calling coroutine or thread. */
     T&
     operator*();
 
-    /**
-     * Stores instance of T specific to the calling coroutine or thread.
-     */
+    /** Stores instance of T specific to the calling coroutine or thread. */
     T*
     operator->()
     {

include/xrpl/basics/Log.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <xrpl/basics/UnorderedContainers.h>
 #include <xrpl/beast/utility/Journal.h>
 
 #include <boost/beast/core/string.hpp>
@@ -10,15 +11,11 @@
 #include <memory>
 #include <mutex>
 #include <optional>
-#include <string>
 #include <utility>
-#include <vector>
 
 namespace xrpl {
 
-/**
- * Manages partitions for logging.
- */
+/** Manages partitions for logging. */
 class Logs
 {
 private:
@@ -42,81 +39,69 @@ private:
         writeAlways(beast::Severity level, std::string const& text) override;
     };
 
-    /**
-     * Manages a system file containing logged output.
-     * The system file remains open during program execution. Interfaces
-     * are provided for interoperating with standard log management
-     * tools like logrotate(8):
-     *     http://linuxcommand.org/man_pages/logrotate8.html
-     * @note None of the listed interfaces are thread-safe.
-     */
+    /** Manages a system file containing logged output.
+        The system file remains open during program execution. Interfaces
+        are provided for interoperating with standard log management
+        tools like logrotate(8):
+            http://linuxcommand.org/man_pages/logrotate8.html
+        @note None of the listed interfaces are thread-safe.
+    */
     class File
     {
     public:
-        /**
-         * Construct with no associated system file.
-         * A system file may be associated later with @ref open.
-         * @see open
-         */
+        /** Construct with no associated system file.
+            A system file may be associated later with @ref open.
+            @see open
+        */
         File();
 
-        /**
-         * Destroy the object.
-         * If a system file is associated, it will be flushed and closed.
-         */
+        /** Destroy the object.
+            If a system file is associated, it will be flushed and closed.
+        */
         ~File() = default;
 
-        /**
-         * Determine if a system file is associated with the log.
-         * @return `true` if a system file is associated and opened for
-         * writing.
-         */
+        /** Determine if a system file is associated with the log.
+            @return `true` if a system file is associated and opened for
+            writing.
+        */
         [[nodiscard]] bool
         isOpen() const noexcept;
 
-        /**
-         * Associate a system file with the log.
-         * If the file does not exist an attempt is made to create it
-         * and open it for writing. If the file already exists an attempt is
-         * made to open it for appending.
-         * If a system file is already associated with the log, it is closed
-         * first.
-         * @return `true` if the file was opened.
-         */
+        /** Associate a system file with the log.
+            If the file does not exist an attempt is made to create it
+            and open it for writing. If the file already exists an attempt is
+            made to open it for appending.
+            If a system file is already associated with the log, it is closed
+            first.
+            @return `true` if the file was opened.
+        */
         bool
         open(boost::filesystem::path const& path);
 
-        /**
-         * Close and re-open the system file associated with the log
-         * This assists in interoperating with external log management tools.
-         * @return `true` if the file was opened.
-         */
+        /** Close and re-open the system file associated with the log
+            This assists in interoperating with external log management tools.
+            @return `true` if the file was opened.
+        */
         bool
         closeAndReopen();
 
-        /**
-         * Close the system file if it is open.
-         */
+        /** Close the system file if it is open. */
         void
         close();
 
-        /**
-         * write to the log file.
-         * Does nothing if there is no associated system file.
-         */
+        /** write to the log file.
+            Does nothing if there is no associated system file.
+        */
         void
         write(char const* text);
 
-        /**
-         * write to the log file and append an end of line marker.
-         * Does nothing if there is no associated system file.
-         */
+        /** write to the log file and append an end of line marker.
+            Does nothing if there is no associated system file.
+        */
         void
         writeln(char const* text);
 
-        /**
-         * Write to the log file using std::string.
-         */
+        /** Write to the log file using std::string. */
         /** @{ */
         void
         write(std::string const& str)
@@ -221,7 +206,8 @@ private:
 #ifndef JLOG
 #define JLOG(x) \
     if (!(x))   \
-        ;       \
+    {           \
+    }           \
     else        \
         x
 #endif
@@ -237,21 +223,19 @@ private:
 //------------------------------------------------------------------------------
 // Debug logging:
 
-/**
- * Set the sink for the debug journal.
- *
- * @param sink unique_ptr to new debug Sink.
- * @return unique_ptr to the previous Sink.  nullptr if there was no Sink.
- */
+/** Set the sink for the debug journal.
+
+    @param sink unique_ptr to new debug Sink.
+    @return unique_ptr to the previous Sink.  nullptr if there was no Sink.
+*/
 std::unique_ptr<beast::Journal::Sink>
 setDebugLogSink(std::unique_ptr<beast::Journal::Sink> sink);
 
-/**
- * Returns a debug journal.
- * The journal may drain to a null sink, so its output
- * may never be seen. Never use it for critical
- * information.
- */
+/** Returns a debug journal.
+    The journal may drain to a null sink, so its output
+    may never be seen. Never use it for critical
+    information.
+*/
 beast::Journal
 debugLog();
 

include/xrpl/basics/MathUtilities.h

@@ -6,8 +6,7 @@
 
 namespace xrpl {
 
-/**
- * Calculate one number divided by another number in percentage.
+/** Calculate one number divided by another number in percentage.
  * The result is rounded up to the next integer, and capped in the range [0,100]
  * E.g. calculatePercent(1, 100) = 1 because 1/100 = 0.010000
  *      calculatePercent(1, 99) = 2 because 1/99 = 0.010101
@@ -20,7 +19,7 @@ namespace xrpl {
  * @return the percentage, in [0, 100]
  *
  * @note total cannot be zero.
- */
+ * */
 constexpr std::size_t
 calculatePercent(std::size_t count, std::size_t total)
 {

include/xrpl/basics/Number.h

@@ -2,9 +2,7 @@
 
 #include <xrpl/beast/utility/instrumentation.h>
 
-#include <algorithm>
 #include <array>
-#include <cstddef>
 #include <cstdint>
 #include <functional>
 #include <limits>
@@ -13,8 +11,7 @@
 #include <set>
 #include <stdexcept>
 #include <string>
-#include <type_traits>
-#include <utility>
+#include <unordered_map>
 
 namespace xrpl {
 
@@ -47,54 +44,46 @@ isPowerOfTen(T value)
 
 namespace detail {
 
-/**
- * Builds a table of the powers of 10
+/** Builds a table of the powers of 10
  *
  * This function is marked consteval, so it can only be run in
  * a constexpr context. This assures that it is and can only be run at
  * compile time. Doing it at runtime would be pretty wasteful and
  * inefficient.
  */
-constexpr std::size_t kUint64Digits = 20;
-[[maybe_unused]] constexpr std::size_t kUint128Digits = 39;
-
-template <typename T, std::size_t Digits>
-consteval std::array<T, Digits>
+constexpr std::size_t kInt64Digits = 20;
+consteval std::array<std::uint64_t, kInt64Digits>
 buildPowersOfTen()
 {
-    std::array<T, Digits> result{};
+    std::array<std::uint64_t, kInt64Digits> result{};
 
-    T power = 1;
+    std::uint64_t power = 1;
     std::size_t exponent = 0;
     // end the loop early so it doesn't overflow;
     for (; exponent < result.size() - 1; ++exponent, power *= 10)
     {
         result[exponent] = power;
-        if (power > std::numeric_limits<T>::max() / 10)
+        if (power > std::numeric_limits<std::uint64_t>::max() / 10)
             throw std::logic_error("Power of 10 table is too big");
     }
     result[exponent] = power;
-    if (power < std::numeric_limits<T>::max() / 10)
-        throw std::logic_error("Power of 10 table is not big enough for the given type");
+    if (power < std::numeric_limits<std::uint64_t>::max() / 10)
+        throw std::logic_error("Power of 10 table is not big enough for the uint64_t type");
 
     return result;
 }
 
 }  // namespace detail
 
-template <typename T = std::uint64_t, std::size_t Digits = detail::kUint64Digits>
-constexpr std::array<T, Digits> kPowerOfTenImpl = detail::buildPowersOfTen<T, Digits>();
-
-constexpr auto kPowerOfTen = kPowerOfTenImpl<std::uint64_t, detail::kUint64Digits>;
+constexpr std::array<std::uint64_t, detail::kInt64Digits> kPowerOfTen = detail::buildPowersOfTen();
 
 static_assert(kPowerOfTen[0] == 1);
 static_assert(kPowerOfTen[1] == 10);
 static_assert(kPowerOfTen[10] == 10'000'000'000);
 static_assert(
-    isPowerOfTen(kPowerOfTen.back()) && *logTen(kPowerOfTen.back()) == detail::kUint64Digits - 1);
+    isPowerOfTen(kPowerOfTen.back()) && *logTen(kPowerOfTen.back()) == detail::kInt64Digits - 1);
 
-/**
- * MantissaRange defines a range for the mantissa of a normalized Number.
+/** 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
@@ -131,37 +120,17 @@ struct MantissaRange final
 {
     using rep = std::uint64_t;
 
-    // NOLINTBEGIN(readability-enum-initial-value)
-    // The values don't matter, except for Large
     enum class MantissaScale {
-        // Small can be removed when either featureSingleAssetVault or featureLendingProtocol are
-        // retired
         Small,
         // LargeLegacy can be removed when fixCleanup3_2_0 is retired
         LargeLegacy,
-        // Large320 can be removed when fixCleanup3_3_0 is retired
-        Large320,
-        // If Large330 is ever the only remaining "Large*" entry, it can be renamed to just "Large".
-        Large330,
-        // Large is a de-facto alias for "the latest", and is only here for backward compatibility
-        // in the extremely unlikely case that a downstream project made use of it. Note that
-        // because the behavior changed, this may still be a breaking change.
-        Large = Large330,
+        Large,
     };
-    // NOLINTEND(readability-enum-initial-value)
 
-    // This entire enum can be removed when the last relevant amendment is retired
-    enum class CuspRoundingFix : std::uint8_t {
-        // Disabled can be removed when fixCleanup3_2_0 is retired
-        Disabled = 0,
-        // Enabled320 can be removed when fixCleanup3_3_0 is retired
-        Enabled320 = 1,
-        // If we ever get to the point that there's only one entry, remove the entire enum
-        Enabled330 = 2,
-        // Enabled is a de-facto alias for "the latest", and is only here for backward compatibility
-        // in the extremely unlikely case that a downstream project made use of it. Note that
-        // because the behavior changed, this may still be a breaking change.
-        Enabled = Enabled330,
+    // This entire enum can be removed when fixCleanup3_2_0 is retired
+    enum class CuspRoundingFix : bool {
+        Disabled = false,
+        Enabled = true,
     };
 
     explicit constexpr MantissaRange(MantissaScale sc) : scale(sc)
@@ -172,27 +141,13 @@ struct MantissaRange final
     int const log{getExponent(scale)};
     rep const min{getMin(scale, log)};
     rep const max{(min * 10) - 1};
-    CuspRoundingFix const cuspRoundingFix{isCuspFixEnabled(scale)};
+    CuspRoundingFix const cuspRoundingFixEnabled{isCuspFixEnabled(scale)};
+
+    static MantissaRange const&
+    getMantissaRange(MantissaScale scale);
 
     static std::set<MantissaScale> const&
-    getAllScales()
-    {
-        static std::set<MantissaRange::MantissaScale> const kScales = {
-            MantissaRange::MantissaScale::Small,
-            MantissaRange::MantissaScale::LargeLegacy,
-            MantissaRange::MantissaScale::Large320,
-            MantissaRange::MantissaScale::Large330,
-        };
-        return kScales;
-    }
-
-    class Access
-    {
-        static constexpr MantissaRange const&
-        mantissaRange(MantissaScale scale);
-
-        friend Number;
-    };
+    getAllScales();
 
 private:
     static constexpr int
@@ -203,8 +158,7 @@ private:
             case MantissaScale::Small:
                 return 15;
             case MantissaScale::LargeLegacy:
-            case MantissaScale::Large320:
-            case MantissaScale::Large330:
+            case MantissaScale::Large:
                 return 18;
             // LCOV_EXCL_START
             default:
@@ -233,24 +187,24 @@ private:
             case MantissaScale::Small:
             case MantissaScale::LargeLegacy:
                 return CuspRoundingFix::Disabled;
-            case MantissaScale::Large320:
-                return CuspRoundingFix::Enabled320;
-            case MantissaScale::Large330:
-                return CuspRoundingFix::Enabled330;
+            case MantissaScale::Large:
+                return CuspRoundingFix::Enabled;
             default:
                 // If called in a constexpr context, this throw assures that the build fails if an
                 // invalid scale is used.
                 throw std::runtime_error("Unknown mantissa scale");  // LCOV_EXCL_LINE
         }
     }
+
+    static std::unordered_map<MantissaScale, MantissaRange> const&
+    getRanges();
 };
 
 // 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>;
 
-/**
- * Number is a floating point type that can represent a wide range of values.
+/** 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 -
  * regardless of asset type - XRPAmount, MPTAmount, and IOUAmount, with at least
@@ -346,6 +300,7 @@ concept Integral64 = std::is_same_v<T, std::int64_t> || std::is_same_v<T, std::u
  * disable the amendments that control the mantissa range choice
  * (SingleAssetVault and LendingProtocol), and/or check if either of those
  * amendments are enabled to determine which result to expect.
+ *
  */
 class Number final
 {
@@ -431,11 +386,10 @@ public:
     static Number
     lowest() noexcept;
 
-    /**
-     * Conversions to Number are implicit and conversions away from Number
-     * are explicit. This design encourages and facilitates the use of Number
-     * as the preferred type for floating point arithmetic as it makes
-     * "mixed mode" more convenient, e.g. MPTAmount + Number.
+    /** Conversions to Number are implicit and conversions away from Number
+     *  are explicit. This design encourages and facilitates the use of Number
+     *  as the preferred type for floating point arithmetic as it makes
+     *  "mixed mode" more convenient, e.g. MPTAmount + Number.
      */
     explicit
     operator rep() const;  // round to nearest, even on tie
@@ -490,9 +444,7 @@ public:
         return l.mantissa_ < r.mantissa_;
     }
 
-    /**
-     * Return the sign of the amount
-     */
+    /** Return the sign of the amount */
     [[nodiscard]] constexpr int
     signum() const noexcept
     {
@@ -546,16 +498,14 @@ public:
     static RoundingMode
     setround(RoundingMode inMode);
 
-    /**
-     * Returns which mantissa scale is currently in use for normalization.
+    /** Returns which mantissa scale is currently in use for normalization.
      *
      * If you think you need to call this outside of unit tests, no you don't.
      */
     static MantissaRange::MantissaScale
     getMantissaScale();
 
-    /**
-     * Changes which mantissa scale is used for normalization.
+    /** Changes which mantissa scale is used for normalization.
      *
      * If you think you need to call this outside of unit tests, no you don't.
      */
@@ -600,17 +550,10 @@ private:
     // changing the values inside the range.
     static thread_local std::reference_wrapper<MantissaRange const> kRange;
 
-    class Guard;
-
     void
     normalize(MantissaRange const& range);
 
-    // Guard has the fields that we need, as well as MantissaRange, so if we have a guard, use that
-    void
-    normalize(Guard const& guard);
-
-    /**
-     * Normalize Number components to an arbitrary range.
+    /** Normalize Number components to an arbitrary range.
      *
      * min/maxMantissa are parameters because this function is used by both
      * normalize(), which reads from kRange, and by normalizeToRange,
@@ -624,7 +567,7 @@ private:
         int& exponent,
         internalrep const& minMantissa,
         internalrep const& maxMantissa,
-        MantissaRange::CuspRoundingFix cuspRoundingFix);
+        MantissaRange::CuspRoundingFix cuspRoundingFixEnabled);
 
     template <class T>
     friend void
@@ -634,7 +577,7 @@ private:
         int& exponent,
         MantissaRange::rep const& minMantissa,
         MantissaRange::rep const& maxMantissa,
-        MantissaRange::CuspRoundingFix cuspRoundingFix,
+        MantissaRange::CuspRoundingFix cuspRoundingFixEnabled,
         bool dropped);
 
     [[nodiscard]] bool
@@ -652,6 +595,8 @@ private:
     // UB, and can vary across compilers.
     static internalrep
     externalToInternal(rep mantissa);
+
+    class Guard;
 };
 
 constexpr Number::Number(bool negative, internalrep mantissa, int exponent, Unchecked) noexcept
@@ -686,8 +631,7 @@ inline Number::Number(rep mantissa) : Number{mantissa, 0}
 {
 }
 
-/**
- * Returns the mantissa of the external view of the Number.
+/** Returns the mantissa of the external view of the Number.
  *
  * Please see the "---- External Interface ----" section of the class
  * documentation for an explanation of why the internal value may be modified.
@@ -708,8 +652,7 @@ Number::mantissa() const noexcept
     return sign * static_cast<Number::rep>(m);
 }
 
-/**
- * Returns the exponent of the external view of the Number.
+/** Returns the exponent of the external view of the Number.
  *
  * Please see the "---- External Interface ----" section of the class
  * documentation for an explanation of why the internal value may be modified.
@@ -915,11 +858,21 @@ squelch(Number const& x, Number const& limit) noexcept
     return x;
 }
 
-std::string
-to_string(MantissaRange::MantissaScale const& scale);
-
-std::string
-to_string(Number::RoundingMode const& round);
+inline std::string
+to_string(MantissaRange::MantissaScale const& scale)
+{
+    switch (scale)
+    {
+        case MantissaRange::MantissaScale::Small:
+            return "small";
+        case MantissaRange::MantissaScale::LargeLegacy:
+            return "largeLegacy";
+        case MantissaRange::MantissaScale::Large:
+            return "large";
+        default:
+            throw std::runtime_error("Bad scale");
+    }
+}
 
 class SaveNumberRoundMode
 {
@@ -958,10 +911,10 @@ public:
     operator=(NumberRoundModeGuard const&) = delete;
 };
 
-/**
- * Sets the new scale and restores the old scale when it leaves scope.
+/** Sets the new scale and restores the old scale when it leaves scope.
  *
  * If you think you need to use this class outside of unit tests, no you don't.
+ *
  */
 class NumberMantissaScaleGuard
 {

include/xrpl/basics/RangeSet.h

@@ -6,32 +6,29 @@
 #include <boost/icl/closed_interval.hpp>
 #include <boost/icl/interval_set.hpp>
 
-#include <functional>
 #include <optional>
 #include <string>
 #include <vector>
 
 namespace xrpl {
 
-/**
- * A closed interval over the domain T.
- *
- * For an instance ClosedInterval c, this represents the closed interval
- * (c.first(), c.last()).  A single element interval has c.first() == c.last().
- *
- * This is simply a type-alias for boost interval container library interval
- * set, so users should consult that documentation for available supporting
- * member and free functions.
- */
+/** A closed interval over the domain T.
+
+    For an instance ClosedInterval c, this represents the closed interval
+    (c.first(), c.last()).  A single element interval has c.first() == c.last().
+
+    This is simply a type-alias for boost interval container library interval
+    set, so users should consult that documentation for available supporting
+    member and free functions.
+*/
 template <class T>
 using ClosedInterval = boost::icl::closed_interval<T>;
 
-/**
- * Create a closed range interval
- *
- * Helper function to create a closed range interval without having to qualify
- * the template argument.
- */
+/** Create a closed range interval
+
+    Helper function to create a closed range interval without having to qualify
+    the template argument.
+*/
 template <class T>
 ClosedInterval<T>
 range(T low, T high)
@@ -39,30 +36,28 @@ range(T low, T high)
     return ClosedInterval<T>(low, high);
 }
 
-/**
- * A set of closed intervals over the domain T.
- *
- * Represents a set of values of the domain T using the minimum number
- * of disjoint ClosedInterval<T>.  This is useful to represent ranges of
- * T where a few instances are missing, e.g. the set 1-5,8-9,11-14.
- *
- * This is simply a type-alias for boost interval container library interval
- * set, so users should consult that documentation for available supporting
- * member and free functions.
- */
+/** A set of closed intervals over the domain T.
+
+    Represents a set of values of the domain T using the minimum number
+    of disjoint ClosedInterval<T>.  This is useful to represent ranges of
+    T where a few instances are missing, e.g. the set 1-5,8-9,11-14.
+
+    This is simply a type-alias for boost interval container library interval
+    set, so users should consult that documentation for available supporting
+    member and free functions.
+*/
 template <class T>
 using RangeSet = boost::icl::interval_set<T, std::less, ClosedInterval<T>>;
 
-/**
- * Convert a ClosedInterval to a styled string
- *
- * The styled string is
- *     "c.first()-c.last()"  if c.first() != c.last()
- *     "c.first()" if c.first() == c.last()
- *
- * @param ci The closed interval to convert
- * @return The style string
- */
+/** Convert a ClosedInterval to a styled string
+
+    The styled string is
+        "c.first()-c.last()"  if c.first() != c.last()
+        "c.first()" if c.first() == c.last()
+
+    @param ci The closed interval to convert
+    @return The style string
+*/
 template <class T>
 std::string
 to_string(ClosedInterval<T> const& ci)
@@ -72,15 +67,14 @@ to_string(ClosedInterval<T> const& ci)
     return std::to_string(ci.first()) + "-" + std::to_string(ci.last());
 }
 
-/**
- * Convert the given RangeSet to a styled string.
- *
- * The styled string representation is the set of disjoint intervals joined
- * by commas.  The string "empty" is returned if the set is empty.
- *
- * @param rs The rangeset to convert
- * @return The styled string
- */
+/** Convert the given RangeSet to a styled string.
+
+    The styled string representation is the set of disjoint intervals joined
+    by commas.  The string "empty" is returned if the set is empty.
+
+    @param rs The rangeset to convert
+    @return The styled string
+*/
 template <class T>
 std::string
 to_string(RangeSet<T> const& rs)
@@ -96,16 +90,15 @@ to_string(RangeSet<T> const& rs)
     return s;
 }
 
-/**
- * Convert the given styled string to a RangeSet.
- *
- * The styled string representation is the set
- * of disjoint intervals joined by commas.
- *
- * @param rs The set to be populated
- * @param s The styled string to convert
- * @return True on successfully converting styled string
- */
+/** Convert the given styled string to a RangeSet.
+
+    The styled string representation is the set
+    of disjoint intervals joined by commas.
+
+    @param rs The set to be populated
+    @param s The styled string to convert
+    @return True on successfully converting styled string
+*/
 template <class T>
 [[nodiscard]] bool
 fromString(RangeSet<T>& rs, std::string const& s)
@@ -167,15 +160,14 @@ fromString(RangeSet<T>& rs, std::string const& s)
     return result;
 }
 
-/**
- * Find the largest value not in the set that is less than a given value.
- *
- * @param rs The set of interest
- * @param t The value that must be larger than the result
- * @param minVal (Default is 0) The smallest allowed value
- * @return The largest v such that minV <= v < t and !contains(rs, v) or
- *         std::nullopt if no such v exists.
- */
+/** Find the largest value not in the set that is less than a given value.
+
+    @param rs The set of interest
+    @param t The value that must be larger than the result
+    @param minVal (Default is 0) The smallest allowed value
+    @return The largest v such that minV <= v < t and !contains(rs, v) or
+            std::nullopt if no such v exists.
+*/
 template <class T>
 std::optional<T>
 prevMissing(RangeSet<T> const& rs, T t, T minVal = 0)

include/xrpl/basics/Resolver.h

@@ -3,7 +3,6 @@
 #include <xrpl/beast/net/IPEndpoint.h>
 
 #include <functional>
-#include <string>
 #include <vector>
 
 namespace xrpl {
@@ -15,29 +14,22 @@ public:
 
     virtual ~Resolver() = 0;
 
-    /**
-     * Issue an asynchronous stop request.
-     */
+    /** Issue an asynchronous stop request. */
     virtual void
     stopAsync() = 0;
 
-    /**
-     * Issue a synchronous stop request.
-     */
+    /** Issue a synchronous stop request. */
     virtual void
     stop() = 0;
 
-    /**
-     * Issue a synchronous start request.
-     */
+    /** Issue a synchronous start request. */
     virtual void
     start() = 0;
 
-    /**
-     * resolve all hostnames on the list
-     * @param names the names to be resolved
-     * @param handler the handler to call
-     */
+    /** resolve all hostnames on the list
+        @param names the names to be resolved
+        @param handler the handler to call
+    */
     /** @{ */
     template <class Handler>
     void

include/xrpl/basics/ResolverAsio.h

@@ -5,8 +5,6 @@
 
 #include <boost/asio/io_context.hpp>
 
-#include <memory>
-
 namespace xrpl {
 
 class ResolverAsio : public Resolver