Merge branch 'dev' into refactor/transactions-macro-includes

Partial cherry-pick of XRPLF/rippled#5590. Each TRANSACTION entry now
carries its transactor header behind `#if TRANSACTION_INCLUDE`, and
applySteps.cpp pulls them in by expanding the macro with
TRANSACTION_INCLUDE defined. Adding a transaction type no longer
requires touching the include list in applySteps.cpp.

ApplyContext.h (reached via Transactor.h) and XahauGenesis.h (unused
there) are dropped from applySteps.cpp.

.clang-format

@@ -44,7 +44,6 @@ DerivePointerAlignment: false
 DisableFormat:   false
 ExperimentalAutoDetectBinPacking: false
 ForEachMacros:   [ Q_FOREACH,  BOOST_FOREACH ]
-IncludeBlocks:   Regroup
 IncludeCategories:
   - Regex:           '^<(test)/'
     Priority:        0
@@ -54,12 +53,8 @@ IncludeCategories:
     Priority:        2
   - Regex:           '^<(boost)/'
     Priority:        3
-  - Regex:           '^.*/'
-    Priority:        4
-  - Regex:           '^.*\.h'
-    Priority:        5
   - Regex:           '.*'
-    Priority:        6
+    Priority:        4
 IncludeIsMainRegex: '$'
 IndentCaseLabels: true
 IndentFunctionDeclarationAfterType: false
@@ -94,4 +89,3 @@ SpacesInSquareBrackets: false
 Standard:        Cpp11
 TabWidth:        8
 UseTab:          Never
-QualifierAlignment: Right

.codecov.yml

@@ -1,6 +1,46 @@
+codecov:
+  require_ci_to_pass: true
+
+comment:
+  behavior: default
+  layout: reach,diff,flags,tree,reach
+  show_carryforward_flags: false
+
 coverage:
+  range: "60..80"
+  precision: 1
+  round: nearest
   status:
     project:
       default:
         target: 60%
         threshold: 2%
+    patch:
+      default:
+        target: auto
+        threshold: 2%
+        paths:
+          # PeerImp is historically hard to exercise in the current unit-test
+          # harness. Keep this list narrow; new testable code should remain
+          # covered by the default patch gate.
+          - "!src/xrpld/overlay/detail/PeerImp.cpp"
+      historically-untested:
+        target: 0%
+        paths:
+          - "src/xrpld/overlay/detail/PeerImp.cpp"
+    changes: false
+
+github_checks:
+  annotations: true
+
+parsers:
+  cobertura:
+    partials_as_hits: true
+    handle_missing_conditions : true
+
+slack_app: false
+
+ignore:
+  - "src/test/"
+  - "include/xrpl/beast/test/"
+  - "include/xrpl/beast/unit_test/"

.git-blame-ignore-revs

@@ -1,8 +1,25 @@
 # This feature requires Git >= 2.24
 # To use it by default in git blame:
 # git config blame.ignoreRevsFile .git-blame-ignore-revs
+# Format first-party source according to .clang-format
 50760c693510894ca368e90369b0cc2dabfd07f3
-e2384885f5f630c8f0ffe4bf21a169b433a16858
-241b9ddde9e11beb7480600fd5ed90e1ef109b21
-760f16f56835663d9286bd29294d074de26a7ba6
-0eebe6a5f4246fced516d52b83ec4e7f47373edd
+# Reintroduce Clang-Format & Levelization
+da1d20d6d5d862716125d60899b80fab5302954a
+# Consolidate external libraries
+da1d20d6d5d862716125d60899b80fab5302954a
+# Rename .hpp to .h
+0345a2645d0f5ad900f4fbbcaff96040d3a887fc
+# Format formerly .hpp files
+5a227dc719016e10045e17c9396ad401118044f1
+# Rewrite includes
+e61880699997398f5a746e6c4034edc7632661f5
+# Move CMake directory (#4997)
+e47b1c1b3b97c3f6d11858ee02f463596e29e7f0
+# Rearrange sources (#4997)
+bfafa2bb39e562901736d656806bd700c3699a2f
+# Rewrite includes (#4997)
+e61880699997398f5a746e6c4034edc7632661f5
+# Recompute loops (#4997)
+d25b5dcd568bb96c18e347d55fac10fe901a1bfb
+# Reformat code with clang-format-18
+02749feea88ce61c1f7eeb2d61a57d8ecf07ab11

.github/actions/xahau-ga-dependencies/action.yml

@@ -50,6 +50,10 @@ inputs:
     options:
       - libstdcxx
       - libcxx
+  conan_deps_cxxflags:
+    description: 'Extra cxxflags applied to Conan dependency package builds only (NOT the rippled build). JSON object keyed by Conan package pattern, e.g. {"grpc/*":["-Wno-foo"]}. Maps to <pattern>:tools.build:cxxflags.'
+    required: false
+    default: '{}'
 
 outputs:
   cache-hit:
@@ -81,6 +85,8 @@ runs:
 
     - name: Configure Conan
       shell: bash
+      env:
+        CONAN_DEPS_CXXFLAGS: ${{ inputs.conan_deps_cxxflags }}
       run: |
         # Create the default profile directory if it doesn't exist
         mkdir -p ~/.conan2/profiles
@@ -105,7 +111,14 @@ runs:
         os=${{ inputs.os }}
         EOF
 
-        # Add buildenv and conf sections for Linux (not needed for macOS)
+        # [buildenv] + [conf] sections.
+        # Linux pins compiler executables; macOS uses the system toolchain.
+        # conan_deps_cxxflags (matrix-driven) optionally adds package-pattern
+        # scoped tools.build:cxxflags for Conan dependency builds only - typically
+        # grpc workarounds for newer clang's stricter diagnostics. Because these
+        # are profile-pattern scoped (e.g. grpc/*:...), they do NOT affect the
+        # consumer/rippled toolchain generated for the main build.
+        NEED_CONF=0
         if [ "${{ inputs.os }}" = "Linux" ] && [ -n "${{ inputs.cc }}" ]; then
           cat >> ~/.conan2/profiles/default <<EOF
 
@@ -116,16 +129,38 @@ runs:
         [conf]
         tools.build:compiler_executables={"c": "/usr/bin/${{ inputs.cc }}", "cpp": "/usr/bin/${{ inputs.cxx }}"}
         EOF
+          NEED_CONF=1
         fi
 
-        # Add macOS-specific conf if needed
-        if [ "${{ inputs.os }}" = "Macos" ]; then
-          cat >> ~/.conan2/profiles/default <<EOF
+        if [ -n "${CONAN_DEPS_CXXFLAGS}" ] && [ "${CONAN_DEPS_CXXFLAGS}" != "{}" ]; then
+          CONAN_DEPS_CXXFLAGS_LINES="$(python3 - <<'PY'
+        import json
+        import os
+        import sys
 
-        [conf]
-        # Workaround for gRPC with newer Apple Clang
-        tools.build:cxxflags=["-Wno-missing-template-arg-list-after-template-kw"]
-        EOF
+        raw = os.environ["CONAN_DEPS_CXXFLAGS"]
+        data = json.loads(raw)
+        if not isinstance(data, dict):
+            sys.exit("conan_deps_cxxflags must be a JSON object like {\"grpc/*\": [\"-Wno-...\"]}")
+
+        for pattern, flags in data.items():
+            if not isinstance(pattern, str) or not pattern:
+                sys.exit("conan_deps_cxxflags keys must be non-empty Conan package patterns")
+            if pattern == "&":
+                sys.exit("conan_deps_cxxflags must target dependency package patterns, not the consumer (&)")
+            if not isinstance(flags, list) or not all(isinstance(flag, str) for flag in flags):
+                sys.exit(f"{pattern}: cxxflags must be a JSON string list")
+            if flags:
+                print(f"{pattern}:tools.build:cxxflags={json.dumps(flags, separators=(',', ':'))}")
+        PY
+          )"
+          if [ -n "${CONAN_DEPS_CXXFLAGS_LINES}" ] && [ "$NEED_CONF" = "0" ]; then
+            echo "" >> ~/.conan2/profiles/default
+            echo "[conf]" >> ~/.conan2/profiles/default
+          fi
+          if [ -n "${CONAN_DEPS_CXXFLAGS_LINES}" ]; then
+            printf '%s\n' "${CONAN_DEPS_CXXFLAGS_LINES}" >> ~/.conan2/profiles/default
+          fi
         fi
 
         # Display profile for verification

.github/workflows/build-in-docker.yml

@@ -15,6 +15,9 @@ env:
 
 jobs:
   checkout:
+    # build publishes to build.xahau.tech, so this workflow only runs from
+    # Xahau/xahaud. build and tests are skipped along with this job.
+    if: github.repository == 'Xahau/xahaud'
     runs-on: [self-hosted, vanity]
     outputs:
       checkout_path: ${{ steps.vars.outputs.checkout_path }}
@@ -86,10 +89,16 @@ jobs:
   cleanup:
     runs-on: [self-hosted, xahaud-build]
     needs: [tests, checkout]
-    if: always()
+    if: always() && github.repository == 'Xahau/xahaud'
     steps:
       - name: Cleanup workspace
         run: |
           CHECKOUT_PATH="${{ needs.checkout.outputs.checkout_path }}"
+          # A run cancelled before checkout has no path; an empty one would
+          # make the rm below delete every run's checkout on the runner.
+          if [[ -z "${CHECKOUT_PATH}" ]]; then
+            echo "No checkout path (cancelled before checkout); nothing to clean"
+            exit 0
+          fi
           echo "Cleaning workspace for ${CHECKOUT_PATH}"
           rm -rf "${{ github.workspace }}/${CHECKOUT_PATH}"

.github/workflows/clang-format.yml

@@ -20,7 +20,7 @@ jobs:
         sudo apt-get update
         sudo apt-get install clang-format-${CLANG_VERSION}
     - name: Format first-party sources
-      run: find include src tests -type f \( -name '*.cpp' -o -name '*.hpp' -o -name '*.h' -o -name '*.ipp' \) -exec clang-format-${CLANG_VERSION} -i {} +
+      run: find include src -type f \( -name '*.cpp' -o -name '*.hpp' -o -name '*.h' -o -name '*.ipp' \) -exec clang-format-${CLANG_VERSION} -i {} +
     - name: Check for differences
       id: assert
       run: |

.github/workflows/xahau-ga-macos.yml

@@ -107,6 +107,9 @@ jobs:
           compiler: apple-clang
           compiler_version: ${{ steps.detect-compiler.outputs.compiler_version }}
           stdlib: libcxx
+          # grpc 1.50.1 trips clang-19+ -Werror=missing-template-arg-list-after-template-kw
+          # on Apple Clang. Drop when grpc is bumped past the fix.
+          conan_deps_cxxflags: '{"grpc/*":["-Wno-missing-template-arg-list-after-template-kw"]}'
 
       - name: Build
         uses: ./.github/actions/xahau-ga-build

.github/workflows/xahau-ga-nix.yml

@@ -8,12 +8,6 @@ on:
     types: [opened, synchronize, reopened, labeled, unlabeled]
   schedule:
     - cron: '0 0 * * *'
-  workflow_dispatch:
-    inputs:
-      full_matrix:
-        description: "Force full matrix (6 configs)"
-        required: false
-        default: "false"
 
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
@@ -30,37 +24,14 @@ jobs:
     outputs:
       matrix: ${{ steps.set-matrix.outputs.matrix }}
     steps:
-      - name: escape double quotes
-        id: escape
-        shell: bash
-        env:
-          PR_TITLE: ${{ github.event.pull_request.title }}
-        run: |
-          ESCAPED_PR_TITLE="${PR_TITLE//\"/\\\"}"
-          echo "title=${ESCAPED_PR_TITLE}" >> "$GITHUB_OUTPUT"
       - name: Generate build matrix
         id: set-matrix
         shell: python
-        env:
-          GH_TOKEN: ${{ github.token }}
         run: |
           import json
           import os
-          import urllib.request
 
-          # Full matrix with all 6 compiler configurations
-          # Each configuration includes all parameters needed by the build job
-          full_matrix = [
-              {
-                  "compiler_id": "gcc-11-libstdcxx",
-                  "compiler": "gcc",
-                  "cc": "gcc-11",
-                  "cxx": "g++-11",
-                  "compiler_version": 11,
-                  "stdlib": "default",
-                  "configuration": "Debug",
-                  "job_type": "build"
-              },
+          matrix = [
               {
                   "compiler_id": "gcc-13-libstdcxx",
                   "compiler": "gcc",
@@ -72,26 +43,26 @@ jobs:
                   "job_type": "build"
               },
               {
-                  "compiler_id": "gcc-13-libstdcxx",
-                  "compiler": "gcc",
-                  "cc": "gcc-13",
-                  "cxx": "g++-13",
-                  "gcov": "gcov-13",
-                  "compiler_version": 13,
-                  "stdlib": "default",
-                  "configuration": "Debug",
-                  "job_type": "coverage"
-              },
-              {
-                  "compiler_id": "clang-14-libstdcxx-gcc11",
+                  # Latest stable Clang for the most accurate source-based
+                  # coverage mapping (newer language features, fewer bugs in
+                  # llvm-cov region inference). Pulled from apt.llvm.org since
+                  # Ubuntu 24.04 default repos cap at clang-18.
+                  "compiler_id": "clang-20-libcxx",
                   "compiler": "clang",
-                  "cc": "clang-14",
-                  "cxx": "clang++-14",
-                  "compiler_version": 14,
-                  "stdlib": "libstdcxx",
-                  "clang_gcc_toolchain": 11,
+                  "cc": "clang-20",
+                  "cxx": "clang++-20",
+                  "compiler_version": 20,
+                  "stdlib": "libcxx",
                   "configuration": "Debug",
-                  "job_type": "build"
+                  "job_type": "coverage",
+                  "coverage_tool": "llvm",
+                  "coverage_format": "lcov",
+                  # grpc 1.50.1 uses `Foo::template Bar(...)` without an
+                  # angle-bracket arg list; clang-19+ promoted that to
+                  # -Werror. Drop when grpc is bumped past the fix.
+                  "conan_deps_cxxflags": {
+                      "grpc/*": ["-Wno-missing-template-arg-list-after-template-kw"]
+                  }
               },
               {
                   "compiler_id": "clang-16-libstdcxx-gcc13",
@@ -103,117 +74,8 @@ jobs:
                   "clang_gcc_toolchain": 13,
                   "configuration": "Debug",
                   "job_type": "build"
-              },
-              {
-                  "compiler_id": "clang-17-libcxx",
-                  "compiler": "clang",
-                  "cc": "clang-17",
-                  "cxx": "clang++-17",
-                  "compiler_version": 17,
-                  "stdlib": "libcxx",
-                  "configuration": "Debug",
-                  "job_type": "build"
-              },
-              {
-                  # Clang 18 - testing if it's faster than Clang 17 with libc++
-                  # Requires patching Conan v1 settings.yml to add version 18
-                  "compiler_id": "clang-18-libcxx",
-                  "compiler": "clang",
-                  "cc": "clang-18",
-                  "cxx": "clang++-18",
-                  "compiler_version": 18,
-                  "stdlib": "libcxx",
-                  "configuration": "Debug",
-                  "job_type": "build"
               }
           ]
-          
-          # Minimal matrix for PRs and feature branches
-          minimal_matrix = [
-              full_matrix[1],  # gcc-13 (middle-ground gcc)
-              full_matrix[2],  # gcc-13 coverage
-              full_matrix[3]   # clang-14 (mature, stable clang)
-          ]
-          
-          # Determine which matrix to use based on the target branch
-          ref = "${{ github.ref }}"
-          base_ref = "${{ github.base_ref }}"  # For PRs, this is the target branch
-          event_name = "${{ github.event_name }}"
-          pr_title = """${{ steps.escape.outputs.title }}"""
-          pr_labels = """${{ join(github.event.pull_request.labels.*.name, ',') }}"""
-          pr_head_sha = "${{ github.event.pull_request.head.sha }}"
-
-          # Get commit message - for PRs, fetch via API since head_commit.message is empty
-          if event_name == "pull_request" and pr_head_sha:
-              try:
-                  url = f"https://api.github.com/repos/${{ github.repository }}/commits/{pr_head_sha}"
-                  req = urllib.request.Request(url, headers={
-                      "Accept": "application/vnd.github.v3+json",
-                      "Authorization": f"Bearer {os.environ.get('GH_TOKEN', '')}"
-                  })
-                  with urllib.request.urlopen(req) as response:
-                      data = json.load(response)
-                      commit_message = data["commit"]["message"]
-              except Exception as e:
-                  print(f"Failed to fetch commit message: {e}")
-                  commit_message = ""
-          else:
-              commit_message = """${{ github.event.head_commit.message }}"""
-
-          # Debug logging
-          print(f"Event: {event_name}")
-          print(f"Ref: {ref}")
-          print(f"Base ref: {base_ref}")
-          print(f"PR head SHA: {pr_head_sha}")
-          print(f"PR title: {pr_title}")
-          print(f"PR labels: {pr_labels}")
-          print(f"Commit message: {commit_message}")
-          
-          # Manual trigger input to force full matrix.
-          manual_full = "${{ github.event.inputs.full_matrix || 'false' }}" == "true"
-
-          # Label/manual overrides, while preserving existing title/commit behavior.
-          force_full = (
-              manual_full
-              or "[ci-nix-full-matrix]" in commit_message
-              or "[ci-nix-full-matrix]" in pr_title
-              or ("ci-full-build" in pr_labels and "ci-nix-full-matrix" in pr_labels)
-          )
-          force_min = (
-              "ci-full-build" in pr_labels
-          )
-          print(f"Force full matrix: {force_full}")
-          print(f"Force min matrix: {force_min}")
-          
-          # Check if this is targeting a main branch
-          # For PRs: check base_ref (target branch)
-          # For pushes: check ref (current branch)
-          main_branches = ["refs/heads/dev", "refs/heads/release", "refs/heads/candidate"]
-          
-          if force_full:
-              # Override: always use full matrix if forced by manual input or label.
-              use_full = True
-          elif force_min:
-              # Override: always use minimal matrix if ci-full-build label is present.
-              use_full = False
-          elif event_name == "pull_request":
-              # For PRs, base_ref is just the branch name (e.g., "dev", not "refs/heads/dev")
-              # Check if the PR targets release or candidate (more critical branches)
-              use_full = base_ref in ["release", "candidate"]
-          else:
-              # For pushes, ref is the full reference (e.g., "refs/heads/dev")
-              use_full = ref in main_branches
-          
-          # Select the appropriate matrix
-          if use_full:
-              if force_full:
-                  print(f"Using FULL matrix (7 configs) - forced by [ci-nix-full-matrix] tag")
-              else:
-                  print(f"Using FULL matrix (7 configs) - targeting main branch")
-              matrix = full_matrix
-          else:
-              print(f"Using MINIMAL matrix (3 configs) - feature branch/PR")
-              matrix = minimal_matrix
 
           # Add runs_on based on job_type
           for entry in matrix:
@@ -257,9 +119,25 @@ jobs:
 
       - name: Install build dependencies
         run: |
+          # Bump apt's default 3 retries; papers over short upstream blips
+          # like the recurring ppa.launchpadcontent.net outages.
+          echo 'Acquire::Retries "5";' > /etc/apt/apt.conf.d/80-retries
           apt-get update
           apt-get install -y software-properties-common
           add-apt-repository ppa:ubuntu-toolchain-r/test -y
+
+          # apt.llvm.org for Clang versions newer than what Ubuntu 24.04 ships
+          # (24.04 default repos cap at clang-18). The bootstrap script adds
+          # the LLVM apt source for the requested version and runs apt-get update.
+          if [ "${{ matrix.compiler }}" = "clang" ] && [ "${{ matrix.compiler_version }}" -ge 19 ]; then
+            apt-get install -y wget gnupg lsb-release
+            wget -qO /tmp/llvm.sh https://apt.llvm.org/llvm.sh
+            chmod +x /tmp/llvm.sh
+            # `all` installs clang + libllvm + lldb + lld + the llvm-N package
+            # (which provides llvm-profdata-N / llvm-cov-N for coverage runs).
+            /tmp/llvm.sh ${{ matrix.compiler_version }} all
+          fi
+
           apt-get update
           apt-get install -y git python3 python-is-python3 pipx
           pipx ensurepath
@@ -332,10 +210,16 @@ jobs:
           pipx install "conan>=2.0,<3"
           echo "$HOME/.local/bin" >> $GITHUB_PATH
 
-          # Install gcovr for coverage jobs
+          # Install coverage tooling
           if [ "${{ matrix.job_type }}" = "coverage" ]; then
-            pipx install "gcovr>=7,<9"
             apt-get install -y curl lcov
+            if [ "${{ matrix.coverage_tool }}" = "llvm" ]; then
+              # Native LLVM source-based coverage: llvm-profdata + llvm-cov.
+              # The clang-N package doesn't pull these in; the llvm-N package does.
+              apt-get install -y "llvm-${{ matrix.compiler_version }}"
+            else
+              pipx install "gcovr>=7,<9"
+            fi
           fi
 
       - name: Check environment
@@ -348,10 +232,15 @@ jobs:
           which ${{ matrix.cxx }} && ${{ matrix.cxx }} --version || echo "${{ matrix.cxx }} not found"
           which ccache && ccache --version || echo "ccache not found"
 
-          # Check gcovr for coverage jobs
+          # Check coverage tooling
           if [ "${{ matrix.job_type }}" = "coverage" ]; then
-            which gcov && gcov --version || echo "gcov not found"
-            which gcovr && gcovr --version || echo "gcovr not found"
+            if [ "${{ matrix.coverage_tool }}" = "llvm" ]; then
+              which "llvm-profdata-${{ matrix.compiler_version }}" && "llvm-profdata-${{ matrix.compiler_version }}" --version || echo "llvm-profdata not found"
+              which "llvm-cov-${{ matrix.compiler_version }}" && "llvm-cov-${{ matrix.compiler_version }}" --version || echo "llvm-cov not found"
+            else
+              which gcov && gcov --version || echo "gcov not found"
+              which gcovr && gcovr --version || echo "gcovr not found"
+            fi
           fi
 
           echo "---- Full Environment ----"
@@ -378,6 +267,7 @@ jobs:
           cc: ${{ matrix.cc }}
           cxx: ${{ matrix.cxx }}
           stdlib: ${{ matrix.stdlib }}
+          conan_deps_cxxflags: ${{ matrix.conan_deps_cxxflags && toJson(matrix.conan_deps_cxxflags) || '{}' }}
           gha_cache_enabled: 'false' # Disable caching for self hosted runner
 
       - name: Build
@@ -410,8 +300,9 @@ jobs:
           cache_version: ${{ env.CACHE_VERSION }}
           main_branch: ${{ env.MAIN_BRANCH_NAME }}
           stdlib: ${{ matrix.stdlib }}
-          # Coverage builds are slower due to instrumentation; use fewer parallel jobs to avoid flakiness
-          cmake-args: '-Dcoverage=ON -Dcoverage_format=xml -Dcoverage_test_parallelism=$(($(nproc)/2)) -DCODE_COVERAGE_VERBOSE=ON -DCMAKE_CXX_FLAGS="-O0" -DCMAKE_C_FLAGS="-O0"'
+          # Coverage builds are slower due to instrumentation; use fewer parallel jobs to avoid flakiness.
+          # Use *_FLAGS_DEBUG so the build action's stdlib flag (e.g. -stdlib=libc++) in CMAKE_CXX_FLAGS isn't clobbered.
+          cmake-args: '-Dcoverage=ON -Dcoverage_tool=${{ matrix.coverage_tool }} -Dcoverage_format=${{ matrix.coverage_format }} -Dcoverage_test_parallelism=$(($(nproc)/2)) -DCODE_COVERAGE_VERBOSE=ON -DCMAKE_CXX_FLAGS_DEBUG="-g -O0" -DCMAKE_C_FLAGS_DEBUG="-g -O0"'
           cmake-target: 'coverage'
           ccache_max_size: '100G'
 
@@ -443,22 +334,26 @@ jobs:
       - name: Move coverage report
         if: matrix.job_type == 'coverage'
         shell: bash
+        env:
+          COVERAGE_FILE: ${{ matrix.coverage_tool == 'llvm' && 'coverage.lcov' || 'coverage.xml' }}
         run: |
-          mv "${{ env.build_dir }}/coverage.xml" ./
+          mv "${{ env.build_dir }}/${COVERAGE_FILE}" ./
+          echo "COVERAGE_FILE=${COVERAGE_FILE}" >> "$GITHUB_ENV"
 
       - name: Archive coverage report
         if: matrix.job_type == 'coverage'
         uses: actions/upload-artifact@v4
         with:
-          name: coverage.xml
-          path: coverage.xml
+          name: ${{ env.COVERAGE_FILE }}-${{ matrix.compiler_id }}
+          path: ${{ env.COVERAGE_FILE }}
           retention-days: 30
 
       - name: Upload coverage report
-        if: matrix.job_type == 'coverage'
+        if: matrix.job_type == 'coverage' && github.repository == 'Xahau/xahaud'
         uses: codecov/codecov-action@v5
         with:
-          files: coverage.xml
+          files: ${{ env.COVERAGE_FILE }}
+          flags: ${{ matrix.coverage_tool }}
           fail_ci_if_error: true
           disable_search: true
           verbose: true

API-CHANGELOG.md

@@ -83,17 +83,9 @@ The [commandline](https://xrpl.org/docs/references/http-websocket-apis/api-conve
 
 The `network_id` field was added in the `server_info` response in version 1.5.0 (2019), but it is not returned in [reporting mode](https://xrpl.org/rippled-server-modes.html#reporting-mode). However, use of reporting mode is now discouraged, in favor of using [Clio](https://github.com/XRPLF/clio) instead.
 
-## XRP Ledger server version 2.5.0
-
-As of 2025-04-04, version 2.5.0 is in development. You can use a pre-release version by building from source or [using the `nightly` package](https://xrpl.org/docs/infrastructure/installation/install-rippled-on-ubuntu).
-
-### Additions and bugfixes in 2.5.0
-
-- `channel_authorize`: If `signing_support` is not enabled in the config, the RPC is disabled.
-
 ## XRP Ledger server version 2.4.0
 
-[Version 2.4.0](https://github.com/XRPLF/rippled/releases/tag/2.4.0) was released on March 4, 2025.
+As of 2025-01-28, version 2.4.0 is in development. You can use a pre-release version by building from source or [using the `nightly` package](https://xrpl.org/docs/infrastructure/installation/install-rippled-on-ubuntu).
 
 ### Additions and bugfixes in 2.4.0
 

BUILD.md

@@ -301,7 +301,7 @@ It fixes some source files to add missing `#include`s.
    Single-config generators:
 
    ```
-   cmake --build . -j $(nproc)
+   cmake --build .
    ```
 
    Multi-config generators:

Builds/levelization/results/loops.txt

@@ -26,10 +26,10 @@ Loop: xrpld.app xrpld.nodestore
   xrpld.app > xrpld.nodestore
 
 Loop: xrpld.app xrpld.overlay
-  xrpld.overlay ~= xrpld.app
+  xrpld.overlay == xrpld.app
 
 Loop: xrpld.app xrpld.peerfinder
-  xrpld.peerfinder ~= xrpld.app
+  xrpld.app > xrpld.peerfinder
 
 Loop: xrpld.app xrpld.rpc
   xrpld.rpc > xrpld.app
@@ -41,10 +41,10 @@ Loop: xrpld.core xrpld.net
   xrpld.net > xrpld.core
 
 Loop: xrpld.core xrpld.perflog
-  xrpld.perflog == xrpld.core
+  xrpld.perflog ~= xrpld.core
 
 Loop: xrpld.net xrpld.rpc
-  xrpld.rpc ~= xrpld.net
+  xrpld.rpc > xrpld.net
 
 Loop: xrpld.overlay xrpld.rpc
   xrpld.rpc ~= xrpld.overlay

Builds/levelization/results/ordering.txt

@@ -7,12 +7,12 @@ libxrpl.protocol > xrpl.hook
 libxrpl.protocol > xrpl.json
 libxrpl.protocol > xrpl.protocol
 libxrpl.resource > xrpl.basics
-libxrpl.resource > xrpl.json
 libxrpl.resource > xrpl.resource
 libxrpl.server > xrpl.basics
 libxrpl.server > xrpl.json
 libxrpl.server > xrpl.protocol
 libxrpl.server > xrpl.server
+test.app > test.shamap
 test.app > test.toplevel
 test.app > test.unit_test
 test.app > xrpl.basics
@@ -22,6 +22,7 @@ test.app > xrpld.ledger
 test.app > xrpld.nodestore
 test.app > xrpld.overlay
 test.app > xrpld.rpc
+test.app > xrpld.shamap
 test.app > xrpl.hook
 test.app > xrpl.json
 test.app > xrpl.protocol
@@ -33,6 +34,7 @@ test.basics > xrpld.perflog
 test.basics > xrpld.rpc
 test.basics > xrpl.json
 test.basics > xrpl.protocol
+test.beast > test.unit_test
 test.beast > xrpl.basics
 test.conditions > xrpl.basics
 test.conditions > xrpld.conditions
@@ -44,15 +46,12 @@ test.consensus > xrpld.app
 test.consensus > xrpld.consensus
 test.consensus > xrpld.core
 test.consensus > xrpld.ledger
-test.consensus > xrpl.json
 test.consensus > xrpl.protocol
 test.core > test.jtx
 test.core > test.toplevel
 test.core > test.unit_test
 test.core > xrpl.basics
 test.core > xrpld.core
-test.core > xrpld.perflog
-test.core > xrpl.json
 test.core > xrpl.server
 test.csf > xrpl.basics
 test.csf > xrpld.consensus
@@ -62,6 +61,7 @@ test.json > test.jtx
 test.json > xrpl.json
 test.jtx > xrpl.basics
 test.jtx > xrpld.app
+test.jtx > xrpld.consensus
 test.jtx > xrpld.core
 test.jtx > xrpld.ledger
 test.jtx > xrpld.net
@@ -78,6 +78,11 @@ test.ledger > xrpld.app
 test.ledger > xrpld.core
 test.ledger > xrpld.ledger
 test.ledger > xrpl.protocol
+test.net > test.toplevel
+test.net > xrpl.basics
+test.net > xrpld.core
+test.net > xrpld.net
+test.net > xrpl.json
 test.nodestore > test.jtx
 test.nodestore > test.toplevel
 test.nodestore > test.unit_test
@@ -91,10 +96,12 @@ test.overlay > test.toplevel
 test.overlay > test.unit_test
 test.overlay > xrpl.basics
 test.overlay > xrpld.app
+test.overlay > xrpld.core
 test.overlay > xrpld.overlay
 test.overlay > xrpld.peerfinder
 test.overlay > xrpld.shamap
 test.overlay > xrpl.protocol
+test.overlay > xrpl.resource
 test.peerfinder > test.beast
 test.peerfinder > test.unit_test
 test.peerfinder > xrpl.basics
@@ -118,6 +125,7 @@ test.rpc > xrpl.basics
 test.rpc > xrpld.app
 test.rpc > xrpld.core
 test.rpc > xrpld.net
+test.rpc > xrpld.nodestore
 test.rpc > xrpld.overlay
 test.rpc > xrpld.rpc
 test.rpc > xrpld.shamap
@@ -170,6 +178,7 @@ xrpld.core > xrpl.basics
 xrpld.core > xrpl.json
 xrpld.core > xrpl.protocol
 xrpld.ledger > xrpl.basics
+xrpld.ledger > xrpld.core
 xrpld.ledger > xrpl.json
 xrpld.ledger > xrpl.protocol
 xrpld.net > xrpl.basics
@@ -185,6 +194,7 @@ xrpld.overlay > xrpl.basics
 xrpld.overlay > xrpld.core
 xrpld.overlay > xrpld.peerfinder
 xrpld.overlay > xrpld.perflog
+xrpld.overlay > xrpld.shamap
 xrpld.overlay > xrpl.json
 xrpld.overlay > xrpl.protocol
 xrpld.overlay > xrpl.resource
@@ -194,11 +204,13 @@ xrpld.peerfinder > xrpld.core
 xrpld.peerfinder > xrpl.protocol
 xrpld.perflog > xrpl.basics
 xrpld.perflog > xrpl.json
+xrpld.perflog > xrpl.protocol
 xrpld.rpc > xrpl.basics
 xrpld.rpc > xrpld.core
 xrpld.rpc > xrpld.ledger
 xrpld.rpc > xrpld.nodestore
 xrpld.rpc > xrpld.shamap
+xrpld.rpc > xrpl.hook
 xrpld.rpc > xrpl.json
 xrpld.rpc > xrpl.protocol
 xrpld.rpc > xrpl.resource

CMakeLists.txt

@@ -21,18 +21,6 @@ endif()
 project (xrpl)
 set(Boost_NO_BOOST_CMAKE ON)
 
-if(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
-    # GCC-specific fixes
-    add_compile_options(-Wno-unknown-pragmas -Wno-subobject-linkage)
-    # -Wno-subobject-linkage can be removed when we upgrade GCC version to at least 13.3
-elseif(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
-    # Clang-specific fixes
-    add_compile_options(-Wno-unknown-warning-option) # Ignore unknown warning options
-elseif(MSVC)
-    # MSVC-specific fixes
-    add_compile_options(/wd4068) # Ignore unknown pragmas
-endif()
-
 # make GIT_COMMIT_HASH define available to all sources
 find_package(Git)
 if(Git_FOUND)

build-core.sh

@@ -88,15 +88,23 @@ git remote -v >> release.info &&
 echo "Git status:" >> release.info &&
 git status -v >> release.info &&
 echo "Git log [last 20]:" >> release.info &&
-git log -n 20 >> release.info;
+git log -n 20 >> release.info || exit 1
 
 if [[ "$4" == "" ]]; then
   # Non GH, local building
   echo "Non GH, local building, no Action runner magic"
 else
   # GH Action, runner
-  cp /io/release-build/xahaud /data/builds/$(date +%Y).$(date +%-m).$(date +%-d)-$(git rev-parse --abbrev-ref HEAD)+$4
-  cp /io/release-build/release.info /data/builds/$(date +%Y).$(date +%-m).$(date +%-d)-$(git rev-parse --abbrev-ref HEAD)+$4.releaseinfo
+    if [[ "$(git rev-parse --abbrev-ref HEAD)" == "release" ]]; then
+        echo "building on the release branch... placing it in builds/candidate"
+        mkdir -p /data/builds/candidate
+        cp /io/release-build/xahaud /data/builds/candidate/$(date +%Y).$(date +%-m).$(date +%-d)-$(git rev-parse --abbrev-ref HEAD)+$4
+        cp /io/release-build/release.info /data/builds/candidate/$(date +%Y).$(date +%-m).$(date +%-d)-$(git rev-parse --abbrev-ref HEAD)+$4.releaseinfo
+    else
+        echo "building non-release branch, placing it in builds root"
+        cp /io/release-build/xahaud /data/builds/$(date +%Y).$(date +%-m).$(date +%-d)-$(git rev-parse --abbrev-ref HEAD)+$4
+        cp /io/release-build/release.info /data/builds/$(date +%Y).$(date +%-m).$(date +%-d)-$(git rev-parse --abbrev-ref HEAD)+$4.releaseinfo
+    fi  
   echo "Published build to: http://build.xahau.tech/"
   echo $(date +%Y).$(date +%-m).$(date +%-d)-$(git rev-parse --abbrev-ref HEAD)+$4
 fi

cfg/xahaud-example.cfg

@@ -166,10 +166,13 @@
 #       ws          Websockets
 #       wss         Secure Websockets
 #       peer        Peer Protocol
+#       pwa         On-ledger AppLoader documents (featurePWALoader), for a
+#                   reverse proxy only. Read "pwa ports" below first.
 #
 #       Restrictions:
 #
 #       Only one port may be configured to support the peer protocol.
+#       The pwa protocol cannot be combined with any other protocol.
 #       A port cannot have websocket and non websocket protocols at the
 #       same time. It is possible have both Websockets and Secure Websockets
 #       together in one port.
@@ -264,6 +267,119 @@
 #       "secure_gateway" connections, then they will be treated as
 #       "admin" addresses.
 #
+#   pwa ports
+#
+#       A port whose protocol is "pwa" serves accounts' on-ledger AppLoader
+#       documents (featurePWALoader) as HTML. This makes the node a web host
+#       for third-party content: anyone can publish a loader to an account
+#       for about a drop per byte, and nothing in protocol takes one down.
+#       Hosting, and a hosting provider's obligations, are yours.
+#
+#       One host per account, on a zone used for nothing else:
+#
+#           https://pwa<account-index>.<domain>/<r-address>
+#           https://<domain>/<r-address>          301 to the above
+#           https://<custom host>/                see custom_domains
+#
+#       The first label of the Host header is "pwa" followed by the decimal
+#       AccountIndex of the account (an account created before AccountIndex
+#       existed has no host); the rest must be one of the port's "domain"
+#       values; the path must be that account's exact r-address. One
+#       trailing slash and a query string are ignored; anything else is
+#       404. The bare zone never serves a document (every page would share
+#       one origin): it redirects, keeping :port and query.
+#       Never set cookies at or above the zone and never serve your own
+#       site from it. Wildcard DNS and a wildcard certificate cover it.
+#
+#       Rules enforced at startup and on every request:
+#
+#       - "pwa" is the port's only protocol; no admin, user/password or
+#         ssl_* keys (terminate TLS at the proxy).
+#       - "domain" is required: the zone(s), comma-separated. The proxy must
+#         forward the Host header unchanged.
+#       - "secure_gateway" is required and may not cover every address.
+#         Every request must come from it carrying X-Forwarded-For, whose
+#         RIGHTMOST entry (the one the proxy wrote) is the client. The
+#         "Forwarded" header is ignored.
+#       - Clients are metered per IPv4 address, per IPv6 /64; a miss costs
+#         what a hit does; over-use is answered 503 until it decays.
+#       - GET and HEAD only; every response closes the connection; only
+#         validated state is served, with an ETag (304 on If-None-Match).
+#         X-NetworkID, X-LedgerSeq, X-LedgerHash and X-PWASeq name the
+#         validated ledger and AppLoaderSequence the document came from, so
+#         a client (a browser extension, say) can vet it against a second
+#         node with the pwa_validate RPC (account, hash of the bytes, host).
+#       - Lookups run on at most two job queue threads, below client RPC;
+#         beyond a bounded backlog they are refused with 503. Put a cache in
+#         front (the ETag makes revalidation cheap).
+#       - The admin RPC "pwa_info" reports requests by outcome and bytes
+#         served; "reset": true zeroes them, "flush_dns": true drops the
+#         custom domain cache (CLI: xahaud pwa_info [reset] [flush_dns]).
+#
+#       Example (also add port_pwa to the [server] list):
+#
+#           [port_pwa]
+#           port = 8088
+#           ip = 127.0.0.1
+#           protocol = pwa
+#           secure_gateway = 127.0.0.1
+#           domain = pwapp.example
+#
+#       with nginx in front, TLS terminated there, Host passed through:
+#
+#           server {
+#               listen 443 ssl;
+#               server_name pwapp.example ~^pwa[0-9]+\.pwapp\.example$;
+#               ssl_certificate     /etc/ssl/wildcard.pwapp.example.pem;
+#               ssl_certificate_key /etc/ssl/wildcard.pwapp.example.key;
+#               location / {
+#                   proxy_pass http://127.0.0.1:8088;
+#                   proxy_set_header Host $host;
+#                   proxy_set_header X-Forwarded-For $remote_addr;
+#               }
+#           }
+#
+#   custom_domains = 0 | 1
+#
+#       Default 0. With 1, a request whose Host is outside every zone is
+#       served as the account named by DNS, so a domain owner can point
+#       their own name at your proxy:
+#
+#           app.example.org.             CNAME  pwa-proxy.your.example.
+#           _xahau-pwa.app.example.org.  TXT    "rAbC..."
+#
+#       The record lives on the _xahau-pwa label beneath the host because
+#       the host is usually a CNAME to your proxy. Exactly one address must
+#       be present there (other TXT strings are ignored; two addresses count
+#       as none). The named account must consent: its Domain field must
+#       equal the host or a parent of it (ignoring case), else 503. Lists
+#       apply as at the account's own host; only the root path is a
+#       document. No usable record is 404 (cached 15 minutes), a resolver
+#       failure 503 (cached 60 s), a record is cached for its TTL (clamped
+#       to 60..3600 s). Lookups run on their own job queue threads, at most
+#       four at a time and one per host; a request that misses the cache is
+#       answered 429 with Retry-After and a refreshing page rather than
+#       waiting, so a flood of Host headers cannot tie up the node. The
+#       admin RPC pwa_info with "flush_dns": true drops the cache. Your
+#       proxy must accept, and hold certificates for, the hosts you will
+#       serve (e.g. Caddy on-demand TLS); xahaud only sees the Host header.
+#
+#   resolver = <IPv4 address>[:port]
+#
+#       The recursive resolver for custom_domains; default is the system
+#       resolver. xahaud does not validate DNSSEC, so prefer a validating
+#       resolver on the same host.
+#
+#       Documents are served with "Content-Security-Policy: sandbox
+#       allow-scripts ...": an opaque origin that cannot read anything from
+#       the node but can still send requests anywhere, including the
+#       visitor's own machine, so keep admin ports behind credentials.
+#
+#       [pwa_allowlist] and [pwa_blocklist], one r-address per line, apply to
+#       every pwa port: if the allowlist is non-empty only those accounts are
+#       served; blocklisted accounts are never served (403), whatever the
+#       allowlist says. An account on both is a startup error.
+#
 #   ssl_key = <filename>
 #   ssl_cert = <filename>
 #   ssl_chain = <filename>
@@ -448,6 +564,30 @@
 #
 #
 #
+# [udp_highway]
+#
+#   0 or 1.
+#
+#   0: Disable the Xahau UDP Superhighway (XUSH). [default]
+#   1: Enable the Xahau UDP Superhighway (XUSH).
+#
+#   The UDP Superhighway is a best-effort transport that runs alongside the
+#   peer protocol. When it is enabled the server also listens for UDP
+#   datagrams on its peer port number, and every transaction it relays to its
+#   peers is also sent, over UDP, to a small random set of other servers that
+#   have the highway enabled. It never replaces the peer protocol: anything
+#   sent over the highway is also relayed normally.
+#
+#   To receive highway traffic, inbound UDP must be allowed to the peer port
+#   (in addition to inbound TCP).
+#
+#   A server that keeps its address private (peer_private = 1, or any server
+#   configured as a validator) only exchanges highway traffic with the peers
+#   listed in [ips_fixed], and never advertises highway endpoints. Fixed peers
+#   are never advertised to other servers.
+#
+#
+#
 # [peers_max]
 #
 #   The largest number of desired peer connections (incoming or outgoing).
@@ -494,7 +634,7 @@
 #
 #   Configure the maximum number of transactions to have in the job queue
 #
-#   Must be a number between 100 and 1000, defaults to 250
+#   Must be a number between 100 and 1000, defaults to 1000
 #
 #
 # [overlay]
@@ -593,7 +733,7 @@
 #       reaches or exceeds this number. After that the limit may still
 #       change, but will stay above the target. If consensus is not
 #       healthy, the limit will be clamped to this value or lower.
-#       Default: 50.
+#       Default: 1000.
 #
 #   maximum_txn_in_ledger = <number>
 #
@@ -674,6 +814,38 @@
 #
 #
 #
+# [early_manifest_sync]
+#
+#   Controls whether, while acquiring its first ledger, the server fetches and
+#   reads the on-ledger validator manifests ahead of the rest of that ledger's
+#   state. Doing so lets it resolve validators' current signing keys, including
+#   rotations and revocations published on-ledger, within seconds of starting
+#   a sync rather than once the whole state has arrived.
+#
+#   The manifests read are those of the master keys on the server's own
+#   validator lists, fetched by key, and as many more from the on-ledger
+#   manifest directory as the manifest cache keeps.
+#
+#   The cost is a dozen or so request/response rounds with peers. With more
+#   than one peer serving the ledger these overlap with fetching the rest of
+#   its state; with only one, they come first.
+#
+#   It also lets a server that starts with nothing but the master keys of its
+#   validators and a few peers find its way. Until it has validated a ledger,
+#   while it holds manifests for too few of its validators to make a quorum,
+#   it reads them from up to three of the ledgers its peers report, the most
+#   widely reported first, every 15 seconds. Every manifest read is checked
+#   against its master key's signature, so a ledger reported by a peer that
+#   is not on the network can leave something out but cannot add anything.
+#
+#   Legal values are:
+#     1 - Fetch the manifests first, and from peers' ledgers if needed
+#     0 - Fetch the ledger's state in the usual order, and read the manifests
+#         from it once it is complete
+#
+#   The default is 1. A ledger without on-ledger manifests costs only the few
+#   nodes on the paths to where their directory and objects would be.
+#
 #
 #
 # [ledger_history]
@@ -1416,6 +1588,19 @@
 #      contains breaking changes that require a new API version number.
 #      They are not ready for public consumption.
 #
+# [hook_validate_rpc]
+#
+#   0 or 1.
+#
+#   0: Disable the hook_validate RPC method
+#   1: Enable the hook_validate RPC method, which runs the Hook guard
+#      checker and WASM VM validation against caller-supplied code using
+#      the current open ledger's rules.
+#
+#   The default is 0 on networked nodes and 1 in standalone mode (-a).
+#   When enabled the method is available to non-admin (user role) clients,
+#   so consider the CPU cost before enabling it on a public-facing node.
+#
 #-------------------------------------------------------------------------------
 #
 # 10. Example Settings

cfg/xahaud-standalone.cfg

@@ -146,11 +146,8 @@ D686F2538F410C9D0D856788E98E3579595DAF7B38D38887F81ECAC934B06040 HooksUpdate1
 3C43D9A973AA4443EF3FC38E42DD306160FBFFDAB901CD8BAA15D09F2597EB87 NonFungibleTokensV1
 0285B7E5E08E1A8E4C15636F0591D87F73CB6A7B6452A932AD72BBC8E5D1CBE3 fixNFTokenDirV1
 36799EA497B1369B170805C078AEFE6188345F9B3E324C21E9CA3FF574E3C3D6 fixNFTokenNegOffer
-4C499D17719BB365B69010A436B64FD1A82AAB199FC1CEB06962EBD01059FB09 fixXahauV1
-215181D23BF5C173314B5FDB9C872C92DE6CC918483727DE037C0C13E7E6EE9D fixXahauV2
 0D8BF22FF7570D58598D1EF19EBB6E142AD46E59A223FD3816262FBB69345BEA Remit
 7CA0426E7F411D39BB014E57CD9E08F61DE1750F0D41FCD428D9FB80BB7596B0 ZeroB2M
 4B8466415FAB32FFA89D9DCBE166A42340115771DF611A7160F8D7439C87ECD8 fixNSDelete
 EDB4EE4C524E16BDD91D9A529332DED08DCAAA51CC6DC897ACFA1A0ED131C5B6 fix240819
 8063140E9260799D6716756B891CEC3E7006C4E4F277AB84670663A88F94B9C4 fixPageCap
-88693F108C3CD8A967F3F4253A32DEF5E35F9406ACD2A11B88B11D90865763A9 fix240911

cmake/CodeCoverage.cmake

@@ -95,6 +95,9 @@
 #     - replace both functions setup_target_for_coverage_gcovr_* with a single setup_target_for_coverage_gcovr
 #     - add support for all gcovr output formats
 #
+# 2024-04-03, Bronek Kozicki
+#     - add support for output formats: jacoco, clover, lcov
+#
 # USAGE:
 #
 # 1. Copy this file into your cmake modules path.
@@ -256,10 +259,10 @@ endif()
 #     BASE_DIRECTORY "../"                   # Base directory for report
 #                                            #  (defaults to PROJECT_SOURCE_DIR)
 #     FORMAT "cobertura"                     # Output format, one of:
-#                                            #  xml cobertura sonarqube json-summary
-#                                            #  json-details coveralls csv txt
-#                                            #  html-single html-nested html-details
-#                                            #  (xml is an alias to cobertura;
+#                                            #  xml cobertura sonarqube jacoco clover
+#                                            #  json-summary json-details coveralls csv
+#                                            #  txt html-single html-nested html-details
+#                                            #  lcov (xml is an alias to cobertura;
 #                                            #  if no format is set, defaults to xml)
 #     EXCLUDE "src/dir1/*" "src/dir2/*"      # Patterns to exclude (can be relative
 #                                            #  to BASE_DIRECTORY, with CMake 3.4+)
@@ -308,6 +311,8 @@ function(setup_target_for_coverage_gcovr)
             set(GCOVR_OUTPUT_FILE ${Coverage_NAME}.txt)
         elseif(Coverage_FORMAT STREQUAL "csv")
             set(GCOVR_OUTPUT_FILE ${Coverage_NAME}.csv)
+        elseif(Coverage_FORMAT STREQUAL "lcov")
+            set(GCOVR_OUTPUT_FILE ${Coverage_NAME}.lcov)
         else()
             set(GCOVR_OUTPUT_FILE ${Coverage_NAME}.xml)
         endif()
@@ -320,6 +325,14 @@ function(setup_target_for_coverage_gcovr)
         set(Coverage_FORMAT cobertura) # overwrite xml
     elseif(Coverage_FORMAT STREQUAL "sonarqube")
         list(APPEND GCOVR_ADDITIONAL_ARGS --sonarqube "${GCOVR_OUTPUT_FILE}" )
+    elseif(Coverage_FORMAT STREQUAL "jacoco")
+        list(APPEND GCOVR_ADDITIONAL_ARGS --jacoco "${GCOVR_OUTPUT_FILE}" )
+        list(APPEND GCOVR_ADDITIONAL_ARGS --jacoco-pretty )
+    elseif(Coverage_FORMAT STREQUAL "clover")
+        list(APPEND GCOVR_ADDITIONAL_ARGS --clover "${GCOVR_OUTPUT_FILE}" )
+        list(APPEND GCOVR_ADDITIONAL_ARGS --clover-pretty )
+    elseif(Coverage_FORMAT STREQUAL "lcov")
+        list(APPEND GCOVR_ADDITIONAL_ARGS --lcov "${GCOVR_OUTPUT_FILE}" )
     elseif(Coverage_FORMAT STREQUAL "json-summary")
         list(APPEND GCOVR_ADDITIONAL_ARGS --json-summary "${GCOVR_OUTPUT_FILE}" )
         list(APPEND GCOVR_ADDITIONAL_ARGS --json-summary-pretty)

cmake/CodeCoverageLLVM.cmake

@@ -0,0 +1,156 @@
+#[===================================================================[
+  Native LLVM source-based code coverage helper.
+
+  Drives the -fprofile-instr-generate / -fcoverage-mapping pipeline:
+    1. Run instrumented binary with LLVM_PROFILE_FILE=...%m-%p.profraw
+    2. llvm-profdata merge -sparse  -> coverage.profdata
+    3. llvm-cov export/show/report  -> final report
+
+  Output filename per coverage_format:
+    lcov              -> coverage.lcov
+    json              -> coverage.json
+    txt | text        -> coverage.txt
+    html | html-details -> <NAME>/index.html
+#]===================================================================]
+
+include(CMakeParseArguments)
+
+# Locate llvm-profdata / llvm-cov, preferring versioned variants matching the
+# Clang we're building with so we don't accidentally pair clang-20 with
+# llvm-cov-14 (profile format mismatch -> hard failure).
+function(_find_llvm_cov_tools)
+  if(LLVM_PROFDATA_PATH AND LLVM_COV_PATH)
+    return()
+  endif()
+
+  string(REGEX MATCH "^[0-9]+" _major "${CMAKE_CXX_COMPILER_VERSION}")
+
+  set(_pd_names llvm-profdata)
+  set(_cov_names llvm-cov)
+  if(_major)
+    list(PREPEND _pd_names "llvm-profdata-${_major}")
+    list(PREPEND _cov_names "llvm-cov-${_major}")
+  endif()
+
+  # Only delegate to xcrun when the *compiler* is AppleClang. On macOS with
+  # Homebrew/system clang-N, xcrun would resolve to Xcode's llvm tools which
+  # could be a different version - exactly the mismatch we want to avoid.
+  if(APPLE AND CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang")
+    execute_process(COMMAND xcrun -f llvm-profdata
+      OUTPUT_VARIABLE _pd_xcrun OUTPUT_STRIP_TRAILING_WHITESPACE
+      ERROR_QUIET RESULT_VARIABLE _pd_rc)
+    if(_pd_rc EQUAL 0 AND _pd_xcrun)
+      set(LLVM_PROFDATA_PATH "${_pd_xcrun}" CACHE FILEPATH "llvm-profdata" FORCE)
+    endif()
+    execute_process(COMMAND xcrun -f llvm-cov
+      OUTPUT_VARIABLE _cov_xcrun OUTPUT_STRIP_TRAILING_WHITESPACE
+      ERROR_QUIET RESULT_VARIABLE _cov_rc)
+    if(_cov_rc EQUAL 0 AND _cov_xcrun)
+      set(LLVM_COV_PATH "${_cov_xcrun}" CACHE FILEPATH "llvm-cov" FORCE)
+    endif()
+  endif()
+
+  if(NOT LLVM_PROFDATA_PATH)
+    find_program(LLVM_PROFDATA_PATH NAMES ${_pd_names})
+  endif()
+  if(NOT LLVM_COV_PATH)
+    find_program(LLVM_COV_PATH NAMES ${_cov_names})
+  endif()
+endfunction()
+
+function(setup_target_for_coverage_llvm)
+  set(oneValueArgs NAME FORMAT)
+  set(multiValueArgs EXCLUDE EXECUTABLE EXECUTABLE_ARGS DEPENDENCIES)
+  cmake_parse_arguments(Cov "" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
+
+  _find_llvm_cov_tools()
+  if(NOT LLVM_PROFDATA_PATH)
+    message(FATAL_ERROR "llvm-profdata not found (needed for coverage_tool=llvm)")
+  endif()
+  if(NOT LLVM_COV_PATH)
+    message(FATAL_ERROR "llvm-cov not found (needed for coverage_tool=llvm)")
+  endif()
+
+  if(NOT Cov_FORMAT)
+    set(Cov_FORMAT lcov)
+  endif()
+
+  set(_profraw_dir "${PROJECT_BINARY_DIR}/${Cov_NAME}-profraw")
+  set(_profdata    "${PROJECT_BINARY_DIR}/${Cov_NAME}.profdata")
+
+  # Resolve binary path: accept either an absolute path or a bare target name
+  # (resolved against PROJECT_BINARY_DIR). Splice the resolved path back into
+  # Cov_EXECUTABLE so the run command invokes it via absolute path - bare
+  # names aren't on PATH and the build dir isn't `.` either.
+  list(GET Cov_EXECUTABLE 0 _exec_name)
+  if(IS_ABSOLUTE "${_exec_name}")
+    set(_binary "${_exec_name}")
+  else()
+    set(_binary "${PROJECT_BINARY_DIR}/${_exec_name}")
+    list(REMOVE_AT Cov_EXECUTABLE 0)
+    list(PREPEND Cov_EXECUTABLE "${_binary}")
+  endif()
+
+  # llvm-cov takes a single -ignore-filename-regex; OR our excludes together.
+  set(_ignore_regex "")
+  foreach(EXC IN LISTS Cov_EXCLUDE)
+    if(_ignore_regex)
+      string(APPEND _ignore_regex "|")
+    endif()
+    string(APPEND _ignore_regex "${EXC}")
+  endforeach()
+  set(_filter "")
+  if(_ignore_regex)
+    set(_filter "-ignore-filename-regex='${_ignore_regex}'")
+  endif()
+
+  # Pick llvm-cov subcommand + output file for the requested format. Each
+  # branch builds a single shell command string that we'll hand to bash -c.
+  if(Cov_FORMAT STREQUAL "lcov")
+    set(_output "${PROJECT_BINARY_DIR}/coverage.lcov")
+    set(_report_sh "${LLVM_COV_PATH} export -instr-profile='${_profdata}' -format=lcov ${_filter} '${_binary}' > '${_output}'")
+  elseif(Cov_FORMAT STREQUAL "json")
+    set(_output "${PROJECT_BINARY_DIR}/coverage.json")
+    set(_report_sh "${LLVM_COV_PATH} export -instr-profile='${_profdata}' -format=text ${_filter} '${_binary}' > '${_output}'")
+  elseif(Cov_FORMAT STREQUAL "txt" OR Cov_FORMAT STREQUAL "text")
+    set(_output "${PROJECT_BINARY_DIR}/coverage.txt")
+    set(_report_sh "${LLVM_COV_PATH} report -instr-profile='${_profdata}' ${_filter} '${_binary}' > '${_output}'")
+  elseif(Cov_FORMAT STREQUAL "html" OR Cov_FORMAT STREQUAL "html-details")
+    set(_output "${PROJECT_BINARY_DIR}/${Cov_NAME}/index.html")
+    set(_report_sh "${LLVM_COV_PATH} show -instr-profile='${_profdata}' -format=html -output-dir='${PROJECT_BINARY_DIR}/${Cov_NAME}' ${_filter} '${_binary}'")
+  else()
+    message(FATAL_ERROR "coverage_tool=llvm: unsupported coverage_format '${Cov_FORMAT}' (use lcov|json|txt|html)")
+  endif()
+
+  set(_merge_sh "${LLVM_PROFDATA_PATH} merge -sparse -o '${_profdata}' '${_profraw_dir}'/*.profraw")
+
+  if(CODE_COVERAGE_VERBOSE)
+    message(STATUS "[coverage:llvm] binary:   ${_binary}")
+    message(STATUS "[coverage:llvm] profraw:  ${_profraw_dir}")
+    message(STATUS "[coverage:llvm] profdata: ${_profdata}")
+    message(STATUS "[coverage:llvm] format:   ${Cov_FORMAT}")
+    message(STATUS "[coverage:llvm] output:   ${_output}")
+    if(_ignore_regex)
+      message(STATUS "[coverage:llvm] ignore:   ${_ignore_regex}")
+    endif()
+    message(STATUS "[coverage:llvm] merge:    ${_merge_sh}")
+    message(STATUS "[coverage:llvm] report:   ${_report_sh}")
+  endif()
+
+  # %m: hash of the binary, %p: pid. Wipe the dir up front so stale profraw
+  # files can't leak into a fresh merge.
+  add_custom_target(${Cov_NAME}
+    COMMAND ${CMAKE_COMMAND} -E rm -rf "${_profraw_dir}"
+    COMMAND ${CMAKE_COMMAND} -E make_directory "${_profraw_dir}"
+    COMMAND ${CMAKE_COMMAND} -E env
+        "LLVM_PROFILE_FILE=${_profraw_dir}/rippled-%m-%p.profraw"
+        ${Cov_EXECUTABLE} ${Cov_EXECUTABLE_ARGS}
+    COMMAND bash -c "${_merge_sh}"
+    COMMAND bash -c "${_report_sh}"
+    BYPRODUCTS ${_output}
+    WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
+    DEPENDS ${Cov_DEPENDENCIES}
+    VERBATIM
+    COMMENT "Running llvm-cov (${Cov_FORMAT}) -> ${_output}"
+  )
+endfunction()

cmake/RippledCore.cmake

@@ -164,9 +164,6 @@ if(xrpld)
   add_executable(rippled)
   if(tests)
     target_compile_definitions(rippled PUBLIC ENABLE_TESTS)
-    target_compile_definitions(rippled PRIVATE
-                                       UNIT_TEST_REFERENCE_FEE=${UNIT_TEST_REFERENCE_FEE}
-    )
   endif()
   target_include_directories(rippled
     PRIVATE

cmake/RippledCov.cmake

@@ -11,6 +11,21 @@ if(CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
   return()
 endif()
 
+if(coverage_tool STREQUAL "llvm")
+  include(CodeCoverageLLVM)
+
+  setup_target_for_coverage_llvm(
+    NAME coverage
+    FORMAT ${coverage_format}
+    EXECUTABLE rippled
+    EXECUTABLE_ARGS --unittest$<$<BOOL:${coverage_test}>:=${coverage_test}> --unittest-jobs ${coverage_test_parallelism} --quiet --unittest-log
+    EXCLUDE "src/test" "include/xrpl/beast/test" "include/xrpl/beast/unit_test" "${CMAKE_BINARY_DIR}/pb-xrpl.libpb"
+    DEPENDENCIES rippled
+  )
+  return()
+endif()
+
+# coverage_tool == "gcov" (default): existing gcovr-driven pipeline.
 include(CodeCoverage)
 
 # The instructions for these commands come from the `CodeCoverage` module,

cmake/RippledInterface.cmake

@@ -28,15 +28,17 @@ target_compile_options (opts
     $<$<AND:$<BOOL:${is_gcc}>,$<COMPILE_LANGUAGE:CXX>>:-Wsuggest-override>
     $<$<BOOL:${is_gcc}>:-Wno-maybe-uninitialized>
     $<$<BOOL:${perf}>:-fno-omit-frame-pointer>
-    $<$<AND:$<BOOL:${is_gcc}>,$<BOOL:${coverage}>>:-g --coverage -fprofile-abs-path>
-    $<$<AND:$<BOOL:${is_clang}>,$<BOOL:${coverage}>>:-g --coverage>
+    $<$<AND:$<BOOL:${is_gcc}>,$<BOOL:${coverage}>,$<STREQUAL:${coverage_tool},gcov>>:-g --coverage -fprofile-abs-path>
+    $<$<AND:$<BOOL:${is_clang}>,$<BOOL:${coverage}>,$<STREQUAL:${coverage_tool},gcov>>:-g --coverage>
+    $<$<AND:$<BOOL:${is_clang}>,$<BOOL:${coverage}>,$<STREQUAL:${coverage_tool},llvm>>:-g -fprofile-instr-generate -fcoverage-mapping>
     $<$<BOOL:${profile}>:-pg>
     $<$<AND:$<BOOL:${is_gcc}>,$<BOOL:${profile}>>:-p>)
 
 target_link_libraries (opts
   INTERFACE
-    $<$<AND:$<BOOL:${is_gcc}>,$<BOOL:${coverage}>>:-g --coverage -fprofile-abs-path>
-    $<$<AND:$<BOOL:${is_clang}>,$<BOOL:${coverage}>>:-g --coverage>
+    $<$<AND:$<BOOL:${is_gcc}>,$<BOOL:${coverage}>,$<STREQUAL:${coverage_tool},gcov>>:-g --coverage -fprofile-abs-path>
+    $<$<AND:$<BOOL:${is_clang}>,$<BOOL:${coverage}>,$<STREQUAL:${coverage_tool},gcov>>:-g --coverage>
+    $<$<AND:$<BOOL:${is_clang}>,$<BOOL:${coverage}>,$<STREQUAL:${coverage_tool},llvm>>:-g -fprofile-instr-generate -fcoverage-mapping>
     $<$<BOOL:${profile}>:-pg>
     $<$<AND:$<BOOL:${is_gcc}>,$<BOOL:${profile}>>:-p>)
 
@@ -95,6 +97,7 @@ target_link_libraries (ripple_syslibs
       crypt32
     >
     $<$<NOT:$<BOOL:${MSVC}>>:dl>
+    $<$<NOT:$<BOOL:${MSVC}>>:resolv>
     $<$<NOT:$<OR:$<BOOL:${MSVC}>,$<BOOL:${APPLE}>>>:rt>)
 
 if (NOT MSVC)

cmake/RippledSanity.cmake

@@ -2,7 +2,22 @@
    convenience variables and sanity checks
 #]===================================================================]
 
-get_property(is_multiconfig GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
+include(ProcessorCount)
+
+if (NOT ep_procs)
+  ProcessorCount(ep_procs)
+  if (ep_procs GREATER 1)
+    # never use more than half of cores for EP builds
+    math (EXPR ep_procs "${ep_procs} / 2")
+    message (STATUS "Using ${ep_procs} cores for ExternalProject builds.")
+  endif ()
+endif ()
+get_property (is_multiconfig GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
+if (is_multiconfig STREQUAL "NOTFOUND")
+  if (${CMAKE_GENERATOR} STREQUAL "Xcode" OR ${CMAKE_GENERATOR} MATCHES "^Visual Studio")
+    set (is_multiconfig TRUE)
+  endif ()
+endif ()
 
 set (CMAKE_CONFIGURATION_TYPES "Debug;Release" CACHE STRING "" FORCE)
 if (NOT is_multiconfig)

cmake/RippledSettings.cmake

@@ -11,12 +11,6 @@ option(assert "Enables asserts, even in release builds" OFF)
 option(xrpld "Build xrpld" ON)
 
 option(tests "Build tests" ON)
-if(tests)
-  # This setting allows making a separate workflow to test fees other than default 10
-  if(NOT UNIT_TEST_REFERENCE_FEE)
-    set(UNIT_TEST_REFERENCE_FEE "10" CACHE STRING "")
-  endif()
-endif()
 
 option(unity "Creates a build using UNITY support in cmake. This is the default" ON)
 if(unity)
@@ -35,13 +29,25 @@ if(is_gcc OR is_clang)
     "Unit tests parallelism for the purpose of coverage report.")
   set(coverage_format "html-details" CACHE STRING
     "Output format of the coverage report.")
+  set(coverage_tool "gcov" CACHE STRING
+    "Coverage instrumentation tool: 'gcov' (default, gcc/clang via --coverage + gcovr) or 'llvm' (clang only, native source-based coverage via -fprofile-instr-generate).")
+  set_property(CACHE coverage_tool PROPERTY STRINGS "gcov" "llvm")
+  if(NOT coverage_tool MATCHES "^(gcov|llvm)$")
+    message(FATAL_ERROR "coverage_tool must be 'gcov' or 'llvm', got '${coverage_tool}'")
+  endif()
   set(coverage_extra_args "" CACHE STRING
-    "Additional arguments to pass to gcovr.")
+    "Additional arguments to pass to gcovr (gcov tool only).")
   set(coverage_test "" CACHE STRING
     "On gcc & clang, the specific unit test(s) to run for coverage. Default is all tests.")
   if(coverage_test AND NOT coverage)
     set(coverage ON CACHE BOOL "gcc/clang only" FORCE)
   endif()
+  # Validate after coverage_test may have flipped coverage on, otherwise
+  # `-Dcoverage_tool=llvm -Dcoverage_test=Foo` on gcc would silently slip
+  # past the Clang guard and produce a broken instrumentation combo.
+  if(coverage AND coverage_tool STREQUAL "llvm" AND NOT is_clang)
+    message(FATAL_ERROR "coverage_tool=llvm requires Clang (got ${CMAKE_CXX_COMPILER_ID})")
+  endif()
   option(wextra "compile with extra gcc/clang warnings enabled" ON)
 else()
   set(profile OFF CACHE BOOL "gcc/clang only" FORCE)
@@ -118,7 +124,7 @@ option(beast_no_unit_test_inline
   "Prevents unit test definitions from being inserted into global table"
   OFF)
 option(single_io_service_thread
-  "Restricts the number of threads calling io_service::run to one. \
+  "Restricts the number of threads calling io_context::run to one. \
   This can be useful when debugging."
   OFF)
 option(boost_show_deprecated

cmake/deps/Boost.cmake

@@ -32,9 +32,9 @@ target_link_libraries(ripple_boost
     Boost::date_time
     Boost::filesystem
     Boost::json
+    Boost::process
     Boost::program_options
     Boost::regex
-    Boost::system
     Boost::iostreams
     Boost::thread)
 if(Boost_COMPILER)

conanfile.py

@@ -1,161 +1,161 @@
-from conan import ConanFile, __version__ as conan_version
+from conan import ConanFile
 from conan.tools.cmake import CMake, CMakeToolchain, cmake_layout
 import re
 
-class Xrpl(ConanFile):
-    name = 'xrpl'
 
-    license = 'ISC'
-    author = 'John Freeman <[email protected]>'
-    url = 'https://github.com/xrplf/rippled'
-    description = 'The XRP Ledger'
-    settings = 'os', 'compiler', 'build_type', 'arch'
+class Xrpl(ConanFile):
+    name = "xrpl"
+
+    license = "ISC"
+    author = "John Freeman <[email protected]>"
+    url = "https://github.com/xrplf/rippled"
+    description = "The XRP Ledger"
+    settings = "os", "compiler", "build_type", "arch"
     options = {
-        'assertions': [True, False],
-        'coverage': [True, False],
-        'fPIC': [True, False],
-        'jemalloc': [True, False],
-        'rocksdb': [True, False],
-        'shared': [True, False],
-        'static': [True, False],
-        'tests': [True, False],
-        'unity': [True, False],
-        'xrpld': [True, False],
-        'with_wasmedge': [True, False],
-        'tool_requires_b2': [True, False],
+        "assertions": [True, False],
+        "coverage": [True, False],
+        "fPIC": [True, False],
+        "jemalloc": [True, False],
+        "rocksdb": [True, False],
+        "shared": [True, False],
+        "static": [True, False],
+        "tests": [True, False],
+        "unity": [True, False],
+        "xrpld": [True, False],
+        "with_wasmedge": [True, False],
+        "tool_requires_b2": [True, False],
     }
 
     requires = [
-        'grpc/1.50.1',
-        'libarchive/3.7.6',
-        'magic_enum/0.9.5',
-        'nudb/2.0.8',
-        'openssl/3.6.0',
-        'soci/4.0.3@xahaud/stable',
-        'zlib/1.3.1',
+        "date/3.0.3",
+        "grpc/1.50.1",
+        "libarchive/3.7.6",
+        "magic_enum/0.9.5",
+        "nudb/2.0.9",
+        "openssl/3.6.0",
+        "soci/4.0.3@xahaud/stable",
+        "xxhash/0.8.2",
+        "zlib/1.3.1",
     ]
 
     tool_requires = [
-        'protobuf/3.21.12',
+        "protobuf/3.21.12",
     ]
 
     default_options = {
-        'assertions': False,
-        'coverage': False,
-        'fPIC': True,
-        'jemalloc': False,
-        'rocksdb': True,
-        'shared': False,
-        'static': True,
-        'tests': False,
-        'unity': False,
-        'xrpld': False,
-        'with_wasmedge': True,
-        'tool_requires_b2': False,
-
-        'date/*:header_only': False,
-        'grpc/*:shared': False,
-        'grpc/*:secure': True,
-        'libarchive/*:shared': False,
-        'libarchive/*:with_acl': False,
-        'libarchive/*:with_bzip2': False,
-        'libarchive/*:with_cng': False,
-        'libarchive/*:with_expat': False,
-        'libarchive/*:with_iconv': False,
-        'libarchive/*:with_libxml2': False,
-        'libarchive/*:with_lz4': True,
-        'libarchive/*:with_lzma': False,
-        'libarchive/*:with_lzo': False,
-        'libarchive/*:with_nettle': False,
-        'libarchive/*:with_openssl': False,
-        'libarchive/*:with_pcreposix': False,
-        'libarchive/*:with_xattr': False,
-        'libarchive/*:with_zlib': False,
-        'lz4/*:shared': False,
-        'openssl/*:shared': False,
-        'protobuf/*:shared': False,
-        'protobuf/*:with_zlib': True,
-        'rocksdb/*:enable_sse': False,
-        'rocksdb/*:lite': False,
-        'rocksdb/*:shared': False,
-        'rocksdb/*:use_rtti': True,
-        'rocksdb/*:with_jemalloc': False,
-        'rocksdb/*:with_lz4': True,
-        'rocksdb/*:with_snappy': True,
-        'snappy/*:shared': False,
-        'soci/*:shared': False,
-        'soci/*:with_sqlite3': True,
-        'soci/*:with_boost': True,
-        'xxhash/*:shared': False,
+        "assertions": False,
+        "coverage": False,
+        "fPIC": True,
+        "jemalloc": False,
+        "rocksdb": True,
+        "shared": False,
+        "static": True,
+        "tests": False,
+        "unity": False,
+        "xrpld": False,
+        "with_wasmedge": True,
+        "tool_requires_b2": False,
+        "boost/*:without_cobalt": True,
+        "date/*:header_only": False,
+        "grpc/*:shared": False,
+        "grpc/*:secure": True,
+        "libarchive/*:shared": False,
+        "libarchive/*:with_acl": False,
+        "libarchive/*:with_bzip2": False,
+        "libarchive/*:with_cng": False,
+        "libarchive/*:with_expat": False,
+        "libarchive/*:with_iconv": False,
+        "libarchive/*:with_libxml2": False,
+        "libarchive/*:with_lz4": True,
+        "libarchive/*:with_lzma": False,
+        "libarchive/*:with_lzo": False,
+        "libarchive/*:with_nettle": False,
+        "libarchive/*:with_openssl": False,
+        "libarchive/*:with_pcreposix": False,
+        "libarchive/*:with_xattr": False,
+        "libarchive/*:with_zlib": False,
+        "lz4/*:shared": False,
+        "openssl/*:shared": False,
+        "protobuf/*:shared": False,
+        "protobuf/*:with_zlib": True,
+        "rocksdb/*:enable_sse": False,
+        "rocksdb/*:lite": False,
+        "rocksdb/*:shared": False,
+        "rocksdb/*:use_rtti": True,
+        "rocksdb/*:with_jemalloc": False,
+        "rocksdb/*:with_lz4": True,
+        "rocksdb/*:with_snappy": True,
+        "snappy/*:shared": False,
+        "soci/*:shared": False,
+        "soci/*:with_sqlite3": True,
+        "soci/*:with_boost": True,
+        "xxhash/*:shared": False,
     }
 
     def set_version(self):
-        path = f'{self.recipe_folder}/src/libxrpl/protocol/BuildInfo.cpp'
-        regex = r'versionString\s?=\s?\"(.*)\"'
-        with open(path, 'r') as file:
+        path = f"{self.recipe_folder}/src/libxrpl/protocol/BuildInfo.cpp"
+        regex = r"versionString\s?=\s?\"(.*)\""
+        with open(path, "r") as file:
             matches = (re.search(regex, line) for line in file)
             match = next(m for m in matches if m)
             self.version = match.group(1)
 
     def build_requirements(self):
         # These provide build tools (protoc, grpc plugins) that run during build
-        self.tool_requires('grpc/1.50.1')
+        self.tool_requires("grpc/1.50.1")
         # Explicitly require b2 (e.g. for building from source for glibc compatibility)
         if self.options.tool_requires_b2:
-            self.tool_requires('b2/5.3.2')
+            self.tool_requires("b2/5.3.2")
 
     def configure(self):
-        if self.settings.compiler == 'apple-clang':
-            self.options['boost/*'].visibility = 'global'
+        if self.settings.compiler == "apple-clang":
+            self.options["boost/*"].visibility = "global"
 
     def requirements(self):
-        # Conan 2 requires transitive headers to be specified
-        transitive_headers_opt = {'transitive_headers': True} if conan_version.split('.')[0] == '2' else {}
         # Force sqlite3 version to avoid conflicts with soci
-        self.requires('sqlite3/3.47.0', override=True)
-        # Force our custom snappy build to avoid Conan CMakeDeps stdc++ heuristic bug
-        self.requires('snappy/1.1.10@xahaud/stable', override=True)
+        self.requires("sqlite3/3.47.0", override=True)
+        # Force our custom snappy build for all dependencies
+        self.requires("snappy/1.1.10@xahaud/stable", override=True)
         # Force boost version for all dependencies to avoid conflicts
-        self.requires('boost/1.86.0', force=True, **transitive_headers_opt)
-        self.requires('date/3.0.3', **transitive_headers_opt)
-        self.requires('lz4/1.10.0', force=True)
+        self.requires("boost/1.91.0", override=True)
+        self.requires("lz4/1.10.0", force=True)
 
         if self.options.with_wasmedge:
-            self.requires('wasmedge/0.11.2@xahaud/stable', **transitive_headers_opt)
+            self.requires("wasmedge/0.11.2@xahaud/stable")
         if self.options.jemalloc:
-            self.requires('jemalloc/5.3.0', **transitive_headers_opt)
+            self.requires("jemalloc/5.3.0")
         if self.options.rocksdb:
-            self.requires('rocksdb/9.7.3', **transitive_headers_opt)
-        self.requires('xxhash/0.8.2', **transitive_headers_opt)
+            self.requires("rocksdb/6.29.5")
 
     exports_sources = (
-        'CMakeLists.txt',
-        'bin/getRippledInfo',
-        'cfg/*',
-        'cmake/*',
-        'external/*',
-        'include/*',
-        'src/*',
+        "CMakeLists.txt",
+        "bin/getRippledInfo",
+        "cfg/*",
+        "cmake/*",
+        "external/*",
+        "include/*",
+        "src/*",
     )
 
     def layout(self):
         cmake_layout(self)
         # Fix this setting to follow the default introduced in Conan 1.48
         # to align with our build instructions.
-        self.folders.generators = 'build/generators'
+        self.folders.generators = "build/generators"
+
+    generators = "CMakeDeps"
 
-    generators = 'CMakeDeps'
     def generate(self):
         tc = CMakeToolchain(self)
-        tc.variables['tests'] = self.options.tests
-        tc.variables['assert'] = self.options.assertions
-        tc.variables['coverage'] = self.options.coverage
-        tc.variables['jemalloc'] = self.options.jemalloc
-        tc.variables['rocksdb'] = self.options.rocksdb
-        tc.variables['BUILD_SHARED_LIBS'] = self.options.shared
-        tc.variables['static'] = self.options.static
-        tc.variables['unity'] = self.options.unity
-        tc.variables['xrpld'] = self.options.xrpld
+        tc.variables["tests"] = self.options.tests
+        tc.variables["assert"] = self.options.assertions
+        tc.variables["coverage"] = self.options.coverage
+        tc.variables["jemalloc"] = self.options.jemalloc
+        tc.variables["rocksdb"] = self.options.rocksdb
+        tc.variables["BUILD_SHARED_LIBS"] = self.options.shared
+        tc.variables["static"] = self.options.static
+        tc.variables["unity"] = self.options.unity
+        tc.variables["xrpld"] = self.options.xrpld
         tc.generate()
 
     def build(self):
@@ -170,29 +170,29 @@ class Xrpl(ConanFile):
         cmake.install()
 
     def package_info(self):
-        libxrpl = self.cpp_info.components['libxrpl']
+        libxrpl = self.cpp_info.components["libxrpl"]
         libxrpl.libs = [
-            'xrpl',
-            'xrpl.libpb',
-            'ed25519',
-            'secp256k1',
+            "xrpl",
+            "xrpl.libpb",
+            "ed25519",
+            "secp256k1",
         ]
         # TODO: Fix the protobufs to include each other relative to
         # `include/`, not `include/ripple/proto/`.
-        libxrpl.includedirs = ['include', 'include/ripple/proto']
+        libxrpl.includedirs = ["include", "include/ripple/proto"]
         libxrpl.requires = [
-            'boost::boost',
-            'date::date',
-            'grpc::grpc++',
-            'libarchive::libarchive',
-            'lz4::lz4',
-            'nudb::nudb',
-            'openssl::crypto',
-            'protobuf::libprotobuf',
-            'soci::soci',
-            'sqlite3::sqlite',
-            'xxhash::xxhash',
-            'zlib::zlib',
+            "boost::boost",
+            "date::date",
+            "grpc::grpc++",
+            "libarchive::libarchive",
+            "lz4::lz4",
+            "nudb::nudb",
+            "openssl::crypto",
+            "protobuf::libprotobuf",
+            "soci::soci",
+            "sqlite3::sqlite",
+            "xxhash::xxhash",
+            "zlib::zlib",
         ]
         if self.options.rocksdb:
-            libxrpl.requires.append('rocksdb::librocksdb')
+            libxrpl.requires.append("rocksdb::librocksdb")

docs/build/environment.md

@@ -23,7 +23,7 @@ direction.
 
 ```
 apt update
-apt install --yes curl git libssl-dev pipx python3.10-dev python3-pip make g++-11 libprotobuf-dev protobuf-compiler
+apt install --yes curl git libssl-dev python3.10-dev python3-pip make g++-11 libprotobuf-dev protobuf-compiler
 
 curl --location --remote-name \
   "https://github.com/Kitware/CMake/releases/download/v3.25.1/cmake-3.25.1.tar.gz"
@@ -35,8 +35,7 @@ make --jobs $(nproc)
 make install
 cd ..
 
-pipx install 'conan<2'
-pipx ensurepath
+pip3 install 'conan<2'
 ```
 
 [1]: https://github.com/thejohnfreeman/rippled-docker/blob/master/ubuntu-22.04/install.sh

examples/example/src/example.cpp

@@ -1,10 +1,8 @@
-#include <xrpl/protocol/BuildInfo.h>
-
 #include <cstdio>
 
-int
-main(int argc, char const** argv)
-{
+#include <xrpl/protocol/BuildInfo.h>
+
+int main(int argc, char const** argv) {
     std::printf("%s\n", ripple::BuildInfo::getVersionString().c_str());
     return 0;
 }

external/rocksdb/conandata.yml

@@ -1,12 +1,27 @@
 sources:
-  "9.7.3":
-    url: "https://github.com/facebook/rocksdb/archive/refs/tags/v9.7.3.tar.gz"
-    sha256: "acfabb989cbfb5b5c4d23214819b059638193ec33dad2d88373c46448d16d38b"
+  "6.29.5":
+    url: "https://github.com/facebook/rocksdb/archive/refs/tags/v6.29.5.tar.gz"
+    sha256: "ddbf84791f0980c0bbce3902feb93a2c7006f6f53bfd798926143e31d4d756f0"
+  "6.27.3":
+    url: "https://github.com/facebook/rocksdb/archive/refs/tags/v6.27.3.tar.gz"
+    sha256: "ee29901749b9132692b26f0a6c1d693f47d1a9ed8e3771e60556afe80282bf58"
+  "6.20.3":
+    url: "https://github.com/facebook/rocksdb/archive/refs/tags/v6.20.3.tar.gz"
+    sha256: "c6502c7aae641b7e20fafa6c2b92273d935d2b7b2707135ebd9a67b092169dca"
+  "8.8.1":
+    url: "https://github.com/facebook/rocksdb/archive/refs/tags/v8.8.1.tar.gz"
+    sha256: "056c7e21ad8ae36b026ac3b94b9d6e0fcc60e1d937fc80330921e4181be5c36e"
 patches:
-  "9.7.3":
-    - patch_file: "patches/9.x.x-0001-exclude-thirdparty.patch"
+  "6.29.5":
+    - patch_file: "patches/6.29.5-0001-add-include-cstdint-for-gcc-13.patch"
+      patch_description: "Fix build with gcc 13 by including cstdint"
+      patch_type: "portability"
+      patch_source: "https://github.com/facebook/rocksdb/pull/11118"
+    - patch_file: "patches/6.29.5-0002-exclude-thirdparty.patch"
       patch_description: "Do not include thirdparty.inc"
       patch_type: "portability"
-    - patch_file: "patches/9.7.3-0001-memory-leak.patch"
-      patch_description: "Fix a leak of obsolete blob files left open until DB::Close()"
+  "6.27.3":
+    - patch_file: "patches/6.27.3-0001-add-include-cstdint-for-gcc-13.patch"
+      patch_description: "Fix build with gcc 13 by including cstdint"
       patch_type: "portability"
+      patch_source: "https://github.com/facebook/rocksdb/pull/11118"

external/rocksdb/conanfile.py

@@ -15,10 +15,10 @@ required_conan_version = ">=1.53.0"
 
 class RocksDBConan(ConanFile):
     name = "rocksdb"
-    description = "A library that provides an embeddable, persistent key-value store for fast storage"
+    homepage = "https://github.com/facebook/rocksdb"
     license = ("GPL-2.0-only", "Apache-2.0")
     url = "https://github.com/conan-io/conan-center-index"
-    homepage = "https://github.com/facebook/rocksdb"
+    description = "A library that provides an embeddable, persistent key-value store for fast storage"
     topics = ("database", "leveldb", "facebook", "key-value")
     package_type = "library"
     settings = "os", "arch", "compiler", "build_type"
@@ -58,12 +58,12 @@ class RocksDBConan(ConanFile):
     @property
     def _compilers_minimum_version(self):
         return {} if self._min_cppstd == "11" else {
-            "apple-clang": "10",
-            "clang": "7",
-            "gcc": "7",
-            "msvc": "191",
-            "Visual Studio": "15",
-        }
+                "apple-clang": "10",
+                "clang": "7",
+                "gcc": "7",
+                "msvc": "191",
+                "Visual Studio": "15",
+            }
 
     def export_sources(self):
         export_conandata_patches(self)
@@ -115,9 +115,9 @@ class RocksDBConan(ConanFile):
         check_min_vs(self, "191")
 
         if self.version == "6.20.3" and \
-                self.settings.os == "Linux" and \
-                self.settings.compiler == "gcc" and \
-                Version(self.settings.compiler.version) < "5":
+           self.settings.os == "Linux" and \
+           self.settings.compiler == "gcc" and \
+           Version(self.settings.compiler.version) < "5":
             raise ConanInvalidConfiguration("Rocksdb 6.20.3 is not compilable with gcc <5.") # See https://github.com/facebook/rocksdb/issues/3522
 
     def source(self):
@@ -163,8 +163,6 @@ class RocksDBConan(ConanFile):
         if self.options.with_jemalloc:
             deps.set_property("jemalloc", "cmake_file_name", "JeMalloc")
             deps.set_property("jemalloc", "cmake_target_name", "JeMalloc::JeMalloc")
-        if self.options.with_zstd:
-            deps.set_property("zstd", "cmake_target_name", "zstd::zstd")
         deps.generate()
 
     def build(self):

external/rocksdb/patches/6.29.5-0001-add-include-cstdint-for-gcc-13.patch

@@ -0,0 +1,30 @@
+--- a/include/rocksdb/utilities/checkpoint.h
++++ b/include/rocksdb/utilities/checkpoint.h
+@@ -8,6 +8,7 @@
+ #pragma once
+ #ifndef ROCKSDB_LITE
+ 
++#include <cstdint>
+ #include <string>
+ #include <vector>
+ #include "rocksdb/status.h"
+--- a/table/block_based/data_block_hash_index.h
++++ b/table/block_based/data_block_hash_index.h
+@@ -5,6 +5,7 @@
+ 
+ #pragma once
+ 
++#include <cstdint>
+ #include <string>
+ #include <vector>
+ 
+--- a/util/string_util.h
++++ b/util/string_util.h
+@@ -6,6 +6,7 @@
+ 
+ #pragma once
+ 
++#include <cstdint>
+ #include <sstream>
+ #include <string>
+ #include <unordered_map>

external/rocksdb/patches/6.29.5-0002-exclude-thirdparty.patch

@@ -0,0 +1,16 @@
+diff --git a/CMakeLists.txt b/CMakeLists.txt
+index ec59d4491..35577c998 100644
+--- a/CMakeLists.txt
++++ b/CMakeLists.txt
+@@ -101 +100,0 @@ if(MSVC)
+-  option(WITH_GFLAGS "build with GFlags" OFF)
+@@ -103,2 +102,2 @@ if(MSVC)
+-  include(${CMAKE_CURRENT_SOURCE_DIR}/thirdparty.inc)
+-else()
++endif()
++
+@@ -117 +116 @@ else()
+-  if(MINGW)
++  if(MINGW OR MSVC)
+@@ -183 +181,0 @@ else()
+-endif()

external/rocksdb/patches/9.7.3-0001-memory-leak.patch

@@ -1,319 +0,0 @@
-diff --git a/HISTORY.md b/HISTORY.md
-index 36d472229..05ad1a202 100644
---- a/HISTORY.md
-+++ b/HISTORY.md
-@@ -1,6 +1,10 @@
- # Rocksdb Change Log
- > NOTE: Entries for next release do not go here. Follow instructions in `unreleased_history/README.txt`
- 
-+## 9.7.4 (10/31/2024)
-+### Bug Fixes
-+* Fix a leak of obsolete blob files left open until DB::Close(). This bug was introduced in version 9.4.0.
-+
- ## 9.7.3 (10/16/2024)
- ### Behavior Changes
- * OPTIONS file to be loaded by remote worker is now preserved so that it does not get purged by the primary host. A similar technique as how we are preserving new SST files from getting purged is used for this. min_options_file_numbers_ is tracked like pending_outputs_ is tracked.
-diff --git a/db/blob/blob_file_cache.cc b/db/blob/blob_file_cache.cc
-index 5f340aadf..1b9faa238 100644
---- a/db/blob/blob_file_cache.cc
-+++ b/db/blob/blob_file_cache.cc
-@@ -42,6 +42,7 @@ Status BlobFileCache::GetBlobFileReader(
-   assert(blob_file_reader);
-   assert(blob_file_reader->IsEmpty());
- 
-+  // NOTE: sharing same Cache with table_cache
-   const Slice key = GetSliceForKey(&blob_file_number);
- 
-   assert(cache_);
-@@ -98,4 +99,13 @@ Status BlobFileCache::GetBlobFileReader(
-   return Status::OK();
- }
- 
-+void BlobFileCache::Evict(uint64_t blob_file_number) {
-+  // NOTE: sharing same Cache with table_cache
-+  const Slice key = GetSliceForKey(&blob_file_number);
-+
-+  assert(cache_);
-+
-+  cache_.get()->Erase(key);
-+}
-+
- }  // namespace ROCKSDB_NAMESPACE
-diff --git a/db/blob/blob_file_cache.h b/db/blob/blob_file_cache.h
-index 740e67ada..6858d012b 100644
---- a/db/blob/blob_file_cache.h
-+++ b/db/blob/blob_file_cache.h
-@@ -36,6 +36,15 @@ class BlobFileCache {
-                            uint64_t blob_file_number,
-                            CacheHandleGuard<BlobFileReader>* blob_file_reader);
- 
-+  // Called when a blob file is obsolete to ensure it is removed from the cache
-+  // to avoid effectively leaking the open file and assicated memory
-+  void Evict(uint64_t blob_file_number);
-+
-+  // Used to identify cache entries for blob files (not normally useful)
-+  static const Cache::CacheItemHelper* GetHelper() {
-+    return CacheInterface::GetBasicHelper();
-+  }
-+
-  private:
-   using CacheInterface =
-       BasicTypedCacheInterface<BlobFileReader, CacheEntryRole::kMisc>;
-diff --git a/db/column_family.h b/db/column_family.h
-index e4b7adde8..86637736a 100644
---- a/db/column_family.h
-+++ b/db/column_family.h
-@@ -401,6 +401,7 @@ class ColumnFamilyData {
-                          SequenceNumber earliest_seq);
- 
-   TableCache* table_cache() const { return table_cache_.get(); }
-+  BlobFileCache* blob_file_cache() const { return blob_file_cache_.get(); }
-   BlobSource* blob_source() const { return blob_source_.get(); }
- 
-   // See documentation in compaction_picker.h
-diff --git a/db/db_impl/db_impl.cc b/db/db_impl/db_impl.cc
-index 261593423..06573ac2e 100644
---- a/db/db_impl/db_impl.cc
-+++ b/db/db_impl/db_impl.cc
-@@ -659,8 +659,9 @@ Status DBImpl::CloseHelper() {
-   // We need to release them before the block cache is destroyed. The block
-   // cache may be destroyed inside versions_.reset(), when column family data
-   // list is destroyed, so leaving handles in table cache after
--  // versions_.reset() may cause issues.
--  // Here we clean all unreferenced handles in table cache.
-+  // versions_.reset() may cause issues. Here we clean all unreferenced handles
-+  // in table cache, and (for certain builds/conditions) assert that no obsolete
-+  // files are hanging around unreferenced (leak) in the table/blob file cache.
-   // Now we assume all user queries have finished, so only version set itself
-   // can possibly hold the blocks from block cache. After releasing unreferenced
-   // handles here, only handles held by version set left and inside
-@@ -668,6 +669,9 @@ Status DBImpl::CloseHelper() {
-   // time a handle is released, we erase it from the cache too. By doing that,
-   // we can guarantee that after versions_.reset(), table cache is empty
-   // so the cache can be safely destroyed.
-+#ifndef NDEBUG
-+  TEST_VerifyNoObsoleteFilesCached(/*db_mutex_already_held=*/true);
-+#endif  // !NDEBUG
-   table_cache_->EraseUnRefEntries();
- 
-   for (auto& txn_entry : recovered_transactions_) {
-@@ -3227,6 +3231,8 @@ Status DBImpl::MultiGetImpl(
-       s = Status::Aborted();
-       break;
-     }
-+    // This could be a long-running operation
-+    ROCKSDB_THREAD_YIELD_HOOK();
-   }
- 
-   // Post processing (decrement reference counts and record statistics)
-diff --git a/db/db_impl/db_impl.h b/db/db_impl/db_impl.h
-index 5e4fa310b..ccc0abfa7 100644
---- a/db/db_impl/db_impl.h
-+++ b/db/db_impl/db_impl.h
-@@ -1241,9 +1241,14 @@ class DBImpl : public DB {
-   static Status TEST_ValidateOptions(const DBOptions& db_options) {
-     return ValidateOptions(db_options);
-   }
--
- #endif  // NDEBUG
- 
-+  // In certain configurations, verify that the table/blob file cache only
-+  // contains entries for live files, to check for effective leaks of open
-+  // files. This can only be called when purging of obsolete files has
-+  // "settled," such as during parts of DB Close().
-+  void TEST_VerifyNoObsoleteFilesCached(bool db_mutex_already_held) const;
-+
-   // persist stats to column family "_persistent_stats"
-   void PersistStats();
- 
-diff --git a/db/db_impl/db_impl_debug.cc b/db/db_impl/db_impl_debug.cc
-index 790a50d7a..67f5b4aaf 100644
---- a/db/db_impl/db_impl_debug.cc
-+++ b/db/db_impl/db_impl_debug.cc
-@@ -9,6 +9,7 @@
- 
- #ifndef NDEBUG
- 
-+#include "db/blob/blob_file_cache.h"
- #include "db/column_family.h"
- #include "db/db_impl/db_impl.h"
- #include "db/error_handler.h"
-@@ -328,5 +329,49 @@ size_t DBImpl::TEST_EstimateInMemoryStatsHistorySize() const {
-   InstrumentedMutexLock l(&const_cast<DBImpl*>(this)->stats_history_mutex_);
-   return EstimateInMemoryStatsHistorySize();
- }
-+
-+void DBImpl::TEST_VerifyNoObsoleteFilesCached(
-+    bool db_mutex_already_held) const {
-+  // This check is somewhat expensive and obscure to make a part of every
-+  // unit test in every build variety. Thus, we only enable it for ASAN builds.
-+  if (!kMustFreeHeapAllocations) {
-+    return;
-+  }
-+
-+  std::optional<InstrumentedMutexLock> l;
-+  if (db_mutex_already_held) {
-+    mutex_.AssertHeld();
-+  } else {
-+    l.emplace(&mutex_);
-+  }
-+
-+  std::vector<uint64_t> live_files;
-+  for (auto cfd : *versions_->GetColumnFamilySet()) {
-+    if (cfd->IsDropped()) {
-+      continue;
-+    }
-+    // Sneakily add both SST and blob files to the same list
-+    cfd->current()->AddLiveFiles(&live_files, &live_files);
-+  }
-+  std::sort(live_files.begin(), live_files.end());
-+
-+  auto fn = [&live_files](const Slice& key, Cache::ObjectPtr, size_t,
-+                          const Cache::CacheItemHelper* helper) {
-+    if (helper != BlobFileCache::GetHelper()) {
-+      // Skip non-blob files for now
-+      // FIXME: diagnose and fix the leaks of obsolete SST files revealed in
-+      // unit tests.
-+      return;
-+    }
-+    // See TableCache and BlobFileCache
-+    assert(key.size() == sizeof(uint64_t));
-+    uint64_t file_number;
-+    GetUnaligned(reinterpret_cast<const uint64_t*>(key.data()), &file_number);
-+    // Assert file is in sorted live_files
-+    assert(
-+        std::binary_search(live_files.begin(), live_files.end(), file_number));
-+  };
-+  table_cache_->ApplyToAllEntries(fn, {});
-+}
- }  // namespace ROCKSDB_NAMESPACE
- #endif  // NDEBUG
-diff --git a/db/db_iter.cc b/db/db_iter.cc
-index e02586377..bf4749eb9 100644
---- a/db/db_iter.cc
-+++ b/db/db_iter.cc
-@@ -540,6 +540,8 @@ bool DBIter::FindNextUserEntryInternal(bool skipping_saved_key,
-     } else {
-       iter_.Next();
-     }
-+    // This could be a long-running operation due to tombstones, etc.
-+    ROCKSDB_THREAD_YIELD_HOOK();
-   } while (iter_.Valid());
- 
-   valid_ = false;
-diff --git a/db/table_cache.cc b/db/table_cache.cc
-index 71fc29c32..8a5be75e8 100644
---- a/db/table_cache.cc
-+++ b/db/table_cache.cc
-@@ -164,6 +164,7 @@ Status TableCache::GetTableReader(
- }
- 
- Cache::Handle* TableCache::Lookup(Cache* cache, uint64_t file_number) {
-+  // NOTE: sharing same Cache with BlobFileCache
-   Slice key = GetSliceForFileNumber(&file_number);
-   return cache->Lookup(key);
- }
-@@ -179,6 +180,7 @@ Status TableCache::FindTable(
-     size_t max_file_size_for_l0_meta_pin, Temperature file_temperature) {
-   PERF_TIMER_GUARD_WITH_CLOCK(find_table_nanos, ioptions_.clock);
-   uint64_t number = file_meta.fd.GetNumber();
-+  // NOTE: sharing same Cache with BlobFileCache
-   Slice key = GetSliceForFileNumber(&number);
-   *handle = cache_.Lookup(key);
-   TEST_SYNC_POINT_CALLBACK("TableCache::FindTable:0",
-diff --git a/db/version_builder.cc b/db/version_builder.cc
-index ed8ab8214..c98f53f42 100644
---- a/db/version_builder.cc
-+++ b/db/version_builder.cc
-@@ -24,6 +24,7 @@
- #include <vector>
- 
- #include "cache/cache_reservation_manager.h"
-+#include "db/blob/blob_file_cache.h"
- #include "db/blob/blob_file_meta.h"
- #include "db/dbformat.h"
- #include "db/internal_stats.h"
-@@ -744,12 +745,9 @@ class VersionBuilder::Rep {
-       return Status::Corruption("VersionBuilder", oss.str());
-     }
- 
--    // Note: we use C++11 for now but in C++14, this could be done in a more
--    // elegant way using generalized lambda capture.
--    VersionSet* const vs = version_set_;
--    const ImmutableCFOptions* const ioptions = ioptions_;
--
--    auto deleter = [vs, ioptions](SharedBlobFileMetaData* shared_meta) {
-+    auto deleter = [vs = version_set_, ioptions = ioptions_,
-+                    bc = cfd_ ? cfd_->blob_file_cache()
-+                              : nullptr](SharedBlobFileMetaData* shared_meta) {
-       if (vs) {
-         assert(ioptions);
-         assert(!ioptions->cf_paths.empty());
-@@ -758,6 +756,9 @@ class VersionBuilder::Rep {
-         vs->AddObsoleteBlobFile(shared_meta->GetBlobFileNumber(),
-                                 ioptions->cf_paths.front().path);
-       }
-+      if (bc) {
-+        bc->Evict(shared_meta->GetBlobFileNumber());
-+      }
- 
-       delete shared_meta;
-     };
-@@ -766,7 +767,7 @@ class VersionBuilder::Rep {
-         blob_file_number, blob_file_addition.GetTotalBlobCount(),
-         blob_file_addition.GetTotalBlobBytes(),
-         blob_file_addition.GetChecksumMethod(),
--        blob_file_addition.GetChecksumValue(), deleter);
-+        blob_file_addition.GetChecksumValue(), std::move(deleter));
- 
-     mutable_blob_file_metas_.emplace(
-         blob_file_number, MutableBlobFileMetaData(std::move(shared_meta)));
-diff --git a/db/version_set.h b/db/version_set.h
-index 9336782b1..024f869e7 100644
---- a/db/version_set.h
-+++ b/db/version_set.h
-@@ -1514,7 +1514,6 @@ class VersionSet {
-   void GetLiveFilesMetaData(std::vector<LiveFileMetaData>* metadata);
- 
-   void AddObsoleteBlobFile(uint64_t blob_file_number, std::string path) {
--    // TODO: Erase file from BlobFileCache?
-     obsolete_blob_files_.emplace_back(blob_file_number, std::move(path));
-   }
- 
-diff --git a/include/rocksdb/version.h b/include/rocksdb/version.h
-index 2a19796b8..0afa2cab1 100644
---- a/include/rocksdb/version.h
-+++ b/include/rocksdb/version.h
-@@ -13,7 +13,7 @@
- // minor or major version number planned for release.
- #define ROCKSDB_MAJOR 9
- #define ROCKSDB_MINOR 7
--#define ROCKSDB_PATCH 3
-+#define ROCKSDB_PATCH 4
- 
- // Do not use these. We made the mistake of declaring macros starting with
- // double underscore. Now we have to live with our choice. We'll deprecate these
-diff --git a/port/port.h b/port/port.h
-index 13aa56d47..141716e5b 100644
---- a/port/port.h
-+++ b/port/port.h
-@@ -19,3 +19,19 @@
- #elif defined(OS_WIN)
- #include "port/win/port_win.h"
- #endif
-+
-+#ifdef OS_LINUX
-+// A temporary hook into long-running RocksDB threads to support modifying their
-+// priority etc. This should become a public API hook once the requirements
-+// are better understood.
-+extern "C" void RocksDbThreadYield() __attribute__((__weak__));
-+#define ROCKSDB_THREAD_YIELD_HOOK() \
-+  {                                 \
-+    if (RocksDbThreadYield) {       \
-+      RocksDbThreadYield();         \
-+    }                               \
-+  }
-+#else
-+#define ROCKSDB_THREAD_YIELD_HOOK() \
-+  {}
-+#endif

external/rocksdb/patches/9.x.x-0001-exclude-thirdparty.patch

@@ -1,30 +0,0 @@
-diff --git a/CMakeLists.txt b/CMakeLists.txt
-index 93b884d..b715cb6 100644
---- a/CMakeLists.txt
-+++ b/CMakeLists.txt
-@@ -106,14 +106,9 @@ endif()
- include(CMakeDependentOption)
-
- if(MSVC)
--  option(WITH_GFLAGS "build with GFlags" OFF)
-   option(WITH_XPRESS "build with windows built in compression" OFF)
--  option(ROCKSDB_SKIP_THIRDPARTY "skip thirdparty.inc" OFF)
--
--  if(NOT ROCKSDB_SKIP_THIRDPARTY)
--    include(${CMAKE_CURRENT_SOURCE_DIR}/thirdparty.inc)
--  endif()
--else()
-+endif()
-+if(TRUE)
-   if(CMAKE_SYSTEM_NAME MATCHES "FreeBSD" AND NOT CMAKE_SYSTEM_NAME MATCHES "kFreeBSD")
-     # FreeBSD has jemalloc as default malloc
-     # but it does not have all the jemalloc files in include/...
-@@ -126,7 +121,7 @@ else()
-     endif()
-   endif()
-
--  if(MINGW)
-+  if(MSVC OR MINGW)
-     option(WITH_GFLAGS "build with GFlags" OFF)
-   else()
-     option(WITH_GFLAGS "build with GFlags" ON)

hook/error.h

@@ -47,5 +47,6 @@
 #define MEM_OVERLAP -43
 #define TOO_MANY_STATE_MODIFICATIONS -44
 #define TOO_MANY_NAMESPACES -45
+#define TOO_LITTLE_ENTROPY -46
 #define HOOK_ERROR_CODES
 #endif //HOOK_ERROR_CODES

hook/extern.h

@@ -2,6 +2,9 @@
 // Generated using generate_extern.sh
 #include <stdint.h>
 #ifndef HOOK_EXTERN
+#ifdef __cplusplus
+extern "C" {
+#endif
 
 extern int32_t __attribute__((noduplicate))
 _g(uint32_t guard_id, uint32_t maxiter);
@@ -336,5 +339,14 @@ prepare(
     uint32_t read_ptr,
     uint32_t read_len);
 
+extern int64_t
+dice(uint32_t sides);
+
+extern int64_t
+util_random(uint32_t write_ptr, uint32_t write_len);
+
+#ifdef __cplusplus
+}
+#endif
 #define HOOK_EXTERN
 #endif  // HOOK_EXTERN

hook/generate_error.sh

@@ -9,7 +9,7 @@ ENUM_FILE="$SCRIPT_DIR/../include/xrpl/hook/Enum.h"
 echo '// For documentation please see: https://xrpl-hooks.readme.io/reference/'
 echo '// Generated using generate_error.sh'
 echo '#ifndef HOOK_ERROR_CODES'
-sed -n '/enum hook_return_code/,/};/p' "$ENUM_FILE" |
+sed -n '/enum class hook_return_code/,/};/p' "$ENUM_FILE" |
     awk '
         function ltrim(s) { sub(/^[[:space:]]+/, "", s); return s }
         function rtrim(s) { sub(/[[:space:]]+$/, "", s); return s }
@@ -31,7 +31,7 @@ sed -n '/enum hook_return_code/,/};/p' "$ENUM_FILE" |
 
         {
             line = $0
-            if (line ~ /enum[[:space:]]+hook_return_code/)
+            if (line ~ /enum[[:space:]]+class[[:space:]]+hook_return_code/)
                 next
             if (line ~ /^[[:space:]]*\{/)
                 next

hook/generate_extern.sh

@@ -11,6 +11,9 @@ APPLY_HOOK="$SCRIPT_DIR/../include/xrpl/hook/hook_api.macro"
     echo '// Generated using generate_extern.sh'
     echo '#include <stdint.h>'
     echo '#ifndef HOOK_EXTERN'
+    echo '#ifdef __cplusplus'
+    echo 'extern "C" {'
+    echo '#endif'
     echo
     awk '
         function trim(s) {
@@ -19,33 +22,36 @@ APPLY_HOOK="$SCRIPT_DIR/../include/xrpl/hook/hook_api.macro"
             return s;
         }
 
-        {
-            line = $0;
-            
-            # Skip block comments
-            if (line ~ /\/\*/) {
-                next;
-            }
-            
-            # Look for comment lines that start with // and contain function signature
-            if (line ~ /^[[:space:]]*\/\/[[:space:]]*[a-zA-Z_][a-zA-Z0-9_]*[[:space:]]+[a-zA-Z_][a-zA-Z0-9_]*[[:space:]]*\(/) {
-                # Remove leading // and trim
-                sub(/^[[:space:]]*\/\/[[:space:]]*/, "", line);
-                line = trim(line);
-                
-                # Check if function name is "_g" to add attribute
-                if (line ~ /[[:space:]]+_g[[:space:]]*\(/) {
-                    # Insert __attribute__((noduplicate)) before _g
-                    sub(/[[:space:]]+_g/, " __attribute__((noduplicate)) _g", line);
-                }
-                
-                # printf("\n");
-                
-                printf("extern %s\n\n", line);
+        # Each entry is HOOK_API_DEFINITION(RET, NAME, (PARAMS), AMENDMENT),
+        # possibly spread over several lines. Collect until the parentheses
+        # balance, then split on the first two commas; the parameter tuple
+        # is the first parenthesised group.
+        function emit(s,    i, ret, name, p, q, params) {
+            sub(/^[[:space:]]*HOOK_API_DEFINITION[[:space:]]*\(/, "", s);
+            gsub(/[[:space:]]+/, " ", s);
+            i = index(s, ","); ret = trim(substr(s, 1, i - 1)); s = substr(s, i + 1);
+            i = index(s, ","); name = trim(substr(s, 1, i - 1)); s = substr(s, i + 1);
+            p = index(s, "("); q = index(s, ")");
+            params = trim(substr(s, p + 1, q - p - 1));
+            if (name == "_g")
+                name = "__attribute__((noduplicate)) _g";
+            printf("extern %s %s(%s);\n\n", ret, name, params);
+        }
+
+        /^[[:space:]]*HOOK_API_DEFINITION[[:space:]]*\(/ { buf = ""; collecting = 1; }
+
+        collecting {
+            buf = buf " " $0;
+            if (gsub(/\(/, "(", buf) == gsub(/\)/, ")", buf)) {
+                collecting = 0;
+                emit(buf);
             }
         }
     ' "$APPLY_HOOK"
 
+    echo '#ifdef __cplusplus'
+    echo '}'
+    echo '#endif'
     echo '#define HOOK_EXTERN'
     echo '#endif  // HOOK_EXTERN'
 } | (

hook/genesis/build_xahau_h.sh

@@ -100,14 +100,14 @@ update_hook_array() {
     echo -e "${BLUE}==> Updating ${hook_name}...${NC}"
 
     # Check if hook already exists
-    if grep -q "static std::vector<uint8_t> const ${hook_name} = {" "${XAHAU_H}"; then
+    if grep -q "static const std::vector<uint8_t> ${hook_name} = {" "${XAHAU_H}"; then
         echo -e "${YELLOW}    Replacing existing ${hook_name}${NC}"
 
         # Use awk to replace the array content
         awk -v hook="${hook_name}" -v hex="${hex_array}" '
         BEGIN { in_array=0 }
         {
-            if ($0 ~ "static std::vector<uint8_t> const " hook " = {") {
+            if ($0 ~ "static const std::vector<uint8_t> " hook " = {") {
                 print $0
                 print hex
                 in_array=1
@@ -133,7 +133,7 @@ update_hook_array() {
         {
             if ($0 ~ /#endif.*XAHAU_GENESIS_HOOKS/) {
                 print ""
-                print "static std::vector<uint8_t> const " hook " = {"
+                print "static const std::vector<uint8_t> " hook " = {"
                 print hex
                 print "};"
                 print ""
@@ -178,7 +178,7 @@ echo -e "${GREEN}    Formatting completed${NC}"
 echo -e "${BLUE}==> Verifying changes...${NC}"
 for hook_entry in "${HOOK_FILES[@]}"; do
     hook_name="${hook_entry%%:*}"
-    if grep -q "static std::vector<uint8_t> const ${hook_name} = {" "${XAHAU_H}"; then
+    if grep -q "static const std::vector<uint8_t> ${hook_name} = {" "${XAHAU_H}"; then
         echo -e "${GREEN}    ✓ ${hook_name} found in xahau.h${NC}"
     else
         echo -e "${RED}    ✗ ${hook_name} NOT found in xahau.h${NC}" >&2

hook/hookapi.h

@@ -38,6 +38,7 @@
 #define KEYLET_HOOK_DEFINITION 24
 #define KEYLET_HOOK_STATE_DIR 25
 #define KEYLET_CRON 26
+#define KEYLET_MANIFEST 37
 
 #define COMPARE_EQUAL 1U
 #define COMPARE_LESS 2U

hook/ls_flags.h

@@ -25,7 +25,6 @@ enum ltACCOUNT_ROOT {
 enum ltOFFER {
     lsfPassive = 0x00010000,
     lsfSell = 0x00020000,
-    lsfHybrid = 0x00040000,
 };
 enum ltRIPPLE_STATE {
     lsfLowReserve = 0x00010000,
@@ -72,8 +71,5 @@ enum ltMPTOKEN {
 enum ltCREDENTIAL {
     lsfAccepted = 0x00010000,
 };
-enum ltVAULT {
-    lsfVaultPrivate = 0x00010000,
-};
 
 #endif // HOOKLSFLAGS_INCLUDED

hook/sfcodes.h

@@ -9,7 +9,6 @@
 #define sfUNLModifyDisabling ((16U << 16U) + 17U)
 #define sfHookResult ((16U << 16U) + 18U)
 #define sfWasLockingChainSend ((16U << 16U) + 19U)
-#define sfWithdrawalPolicy ((16U << 16U) + 20U)
 #define sfLedgerEntryType ((1U << 16U) + 1U)
 #define sfTransactionType ((1U << 16U) + 2U)
 #define sfSignerWeight ((1U << 16U) + 3U)
@@ -23,6 +22,8 @@
 #define sfHookApiVersion ((1U << 16U) + 20U)
 #define sfHookStateScale ((1U << 16U) + 21U)
 #define sfLedgerFixType ((1U << 16U) + 22U)
+#define sfEntropyCount ((1U << 16U) + 99U)
+#define sfEntropyDenominator ((1U << 16U) + 100U)
 #define sfNetworkID ((2U << 16U) + 1U)
 #define sfFlags ((2U << 16U) + 2U)
 #define sfSourceTag ((2U << 16U) + 3U)
@@ -73,7 +74,6 @@
 #define sfLockCount ((2U << 16U) + 49U)
 #define sfFirstNFTokenSequence ((2U << 16U) + 50U)
 #define sfOracleDocumentID ((2U << 16U) + 51U)
-#define sfPermissionValue ((2U << 16U) + 52U)
 #define sfStartTime ((2U << 16U) + 93U)
 #define sfRepeatCount ((2U << 16U) + 94U)
 #define sfDelaySeconds ((2U << 16U) + 95U)
@@ -82,6 +82,7 @@
 #define sfRewardTime ((2U << 16U) + 98U)
 #define sfRewardLgrFirst ((2U << 16U) + 99U)
 #define sfRewardLgrLast ((2U << 16U) + 100U)
+#define sfAppLoaderSequence ((2U << 16U) + 101U)
 #define sfIndexNext ((3U << 16U) + 1U)
 #define sfIndexPrevious ((3U << 16U) + 2U)
 #define sfBookNode ((3U << 16U) + 3U)
@@ -107,7 +108,6 @@
 #define sfMPTAmount ((3U << 16U) + 26U)
 #define sfIssuerNode ((3U << 16U) + 27U)
 #define sfSubjectNode ((3U << 16U) + 28U)
-#define sfLockedAmount ((3U << 16U) + 29U)
 #define sfTouchCount ((3U << 16U) + 97U)
 #define sfAccountIndex ((3U << 16U) + 98U)
 #define sfAccountCount ((3U << 16U) + 99U)
@@ -118,7 +118,6 @@
 #define sfTakerGetsCurrency ((17U << 16U) + 3U)
 #define sfTakerGetsIssuer ((17U << 16U) + 4U)
 #define sfMPTokenIssuanceID ((21U << 16U) + 1U)
-#define sfShareMPTID ((21U << 16U) + 2U)
 #define sfLedgerHash ((5U << 16U) + 1U)
 #define sfParentHash ((5U << 16U) + 2U)
 #define sfTransactionHash ((5U << 16U) + 3U)
@@ -156,8 +155,9 @@
 #define sfEscrowID ((5U << 16U) + 35U)
 #define sfURITokenID ((5U << 16U) + 36U)
 #define sfDomainID ((5U << 16U) + 37U)
-#define sfVaultID ((5U << 16U) + 38U)
-#define sfParentBatchID ((5U << 16U) + 39U)
+#define sfNextRandomDigest ((5U << 16U) + 89U)
+#define sfRandomData ((5U << 16U) + 90U)
+#define sfManifestID ((5U << 16U) + 91U)
 #define sfHookOnOutgoing ((5U << 16U) + 93U)
 #define sfHookOnIncoming ((5U << 16U) + 94U)
 #define sfCron ((5U << 16U) + 95U)
@@ -166,10 +166,6 @@
 #define sfGovernanceMarks ((5U << 16U) + 98U)
 #define sfGovernanceFlags ((5U << 16U) + 99U)
 #define sfNumber ((9U << 16U) + 1U)
-#define sfAssetsAvailable ((9U << 16U) + 2U)
-#define sfAssetsMaximum ((9U << 16U) + 3U)
-#define sfAssetsTotal ((9U << 16U) + 4U)
-#define sfLossUnrealized ((9U << 16U) + 5U)
 #define sfAmount ((6U << 16U) + 1U)
 #define sfBalance ((6U << 16U) + 2U)
 #define sfLimitAmount ((6U << 16U) + 3U)
@@ -231,6 +227,8 @@
 #define sfProvider ((7U << 16U) + 30U)
 #define sfMPTokenMetadata ((7U << 16U) + 31U)
 #define sfCredentialType ((7U << 16U) + 32U)
+#define sfAppLoader ((7U << 16U) + 96U)
+#define sfHookName ((7U << 16U) + 97U)
 #define sfRemarkValue ((7U << 16U) + 98U)
 #define sfRemarkName ((7U << 16U) + 99U)
 #define sfAccount ((8U << 16U) + 1U)
@@ -243,7 +241,6 @@
 #define sfNFTokenMinter ((8U << 16U) + 9U)
 #define sfEmitCallback ((8U << 16U) + 10U)
 #define sfHolder ((8U << 16U) + 11U)
-#define sfDelegate ((8U << 16U) + 12U)
 #define sfHookAccount ((8U << 16U) + 16U)
 #define sfOtherChainSource ((8U << 16U) + 18U)
 #define sfOtherChainDestination ((8U << 16U) + 19U)
@@ -282,7 +279,6 @@
 #define sfNFToken ((14U << 16U) + 12U)
 #define sfEmitDetails ((14U << 16U) + 13U)
 #define sfHook ((14U << 16U) + 14U)
-#define sfPermission ((14U << 16U) + 15U)
 #define sfSigner ((14U << 16U) + 16U)
 #define sfMajority ((14U << 16U) + 18U)
 #define sfDisabledValidator ((14U << 16U) + 19U)
@@ -299,9 +295,8 @@
 #define sfXChainCreateAccountAttestationCollectionElement ((14U << 16U) + 31U)
 #define sfPriceData ((14U << 16U) + 32U)
 #define sfCredential ((14U << 16U) + 33U)
-#define sfRawTransaction ((14U << 16U) + 34U)
-#define sfBatchSigner ((14U << 16U) + 35U)
-#define sfBook ((14U << 16U) + 36U)
+#define sfRandomDigestEntry ((14U << 16U) + 88U)
+#define sfManifest ((14U << 16U) + 90U)
 #define sfAmountEntry ((14U << 16U) + 91U)
 #define sfMintURIToken ((14U << 16U) + 92U)
 #define sfHookEmission ((14U << 16U) + 93U)
@@ -321,7 +316,6 @@
 #define sfNFTokens ((15U << 16U) + 10U)
 #define sfHooks ((15U << 16U) + 11U)
 #define sfVoteSlots ((15U << 16U) + 12U)
-#define sfAdditionalBooks ((15U << 16U) + 13U)
 #define sfMajorities ((15U << 16U) + 16U)
 #define sfDisabledValidators ((15U << 16U) + 17U)
 #define sfHookExecutions ((15U << 16U) + 18U)
@@ -334,9 +328,7 @@
 #define sfAuthorizeCredentials ((15U << 16U) + 26U)
 #define sfUnauthorizeCredentials ((15U << 16U) + 27U)
 #define sfAcceptedCredentials ((15U << 16U) + 28U)
-#define sfPermissions ((15U << 16U) + 29U)
-#define sfRawTransactions ((15U << 16U) + 30U)
-#define sfBatchSigners ((15U << 16U) + 31U)
+#define sfRandomDigests ((15U << 16U) + 91U)
 #define sfAmounts ((15U << 16U) + 92U)
 #define sfHookEmissions ((15U << 16U) + 93U)
 #define sfImportVLKeys ((15U << 16U) + 94U)

hook/tts.h

@@ -61,14 +61,8 @@
 #define ttNFTOKEN_MODIFY 70
 #define ttPERMISSIONED_DOMAIN_SET 71
 #define ttPERMISSIONED_DOMAIN_DELETE 72
-#define ttDELEGATE_SET 73
-#define ttVAULT_CREATE 74
-#define ttVAULT_SET 75
-#define ttVAULT_DELETE 76
-#define ttVAULT_DEPOSIT 77
-#define ttVAULT_WITHDRAW 78
-#define ttVAULT_CLAWBACK 79
-#define ttBATCH 80
+#define ttENTROPY 89
+#define ttMANIFEST_SET 91
 #define ttCRON 92
 #define ttCRON_SET 93
 #define ttREMARKS_SET 94

hook/tx_flags.h

@@ -4,7 +4,6 @@
 
 enum UniversalFlags : uint32_t {
     tfFullyCanonicalSig = 0x80000000,
-    tfInnerBatchTxn = 0x40000000,
 };
 
 enum AccountSetFlags : uint32_t {
@@ -41,7 +40,6 @@ enum OfferCreateFlags : uint32_t {
     tfImmediateOrCancel = 0x00020000,
     tfFillOrKill = 0x00040000,
     tfSell = 0x00080000,
-    tfHybrid = 0x00100000,
 };
 
 enum PaymentFlags : uint32_t {
@@ -117,10 +115,3 @@ enum AMMClawbackFlags : uint32_t {
 enum BridgeModifyFlags : uint32_t {
     tfClearAccountCreateAmount = 0x00010000,
 };
-
-enum BatchFlags : uint32_t {
-    tfAllOrNothing = 0x00010000,
-    tfOnlyOne = 0x00020000,
-    tfUntilFailure = 0x00040000,
-    tfIndependent = 0x00080000,
-};

include/xrpl/basics/BasicConfig.h

@@ -27,6 +27,7 @@
 
 #include <algorithm>
 #include <optional>
+#include <ostream>
 #include <string>
 #include <unordered_map>
 #include <vector>
@@ -367,7 +368,7 @@ get(Section const& section,
 }
 
 inline std::string
-get(Section const& section, std::string const& name, char const* defaultValue)
+get(Section const& section, std::string const& name, const char* defaultValue)
 {
     try
     {

include/xrpl/basics/Buffer.h

@@ -22,9 +22,10 @@
 
 #include <xrpl/basics/Slice.h>
 #include <xrpl/beast/utility/instrumentation.h>
-
 #include <cstdint>
 #include <cstring>
+#include <memory>
+#include <utility>
 
 namespace ripple {
 

include/xrpl/basics/CompressionAlgorithms.h

@@ -21,11 +21,9 @@
 #define RIPPLED_COMPRESSIONALGORITHMS_H_INCLUDED
 
 #include <xrpl/basics/contract.h>
-
-#include <lz4.h>
-
 #include <algorithm>
 #include <cstdint>
+#include <lz4.h>
 #include <stdexcept>
 #include <vector>
 
@@ -55,7 +53,7 @@ lz4Compress(void const* in, std::size_t inSize, BufferFactory&& bf)
     auto compressed = bf(outCapacity);
 
     auto compressedSize = LZ4_compress_default(
-        reinterpret_cast<char const*>(in),
+        reinterpret_cast<const char*>(in),
         reinterpret_cast<char*>(compressed),
         inSize,
         outCapacity);
@@ -89,7 +87,7 @@ lz4Decompress(
         Throw<std::runtime_error>("lz4Decompress: integer overflow (output)");
 
     if (LZ4_decompress_safe(
-            reinterpret_cast<char const*>(in),
+            reinterpret_cast<const char*>(in),
             reinterpret_cast<char*>(decompressed),
             inSize,
             decompressedSize) != decompressedSize)

include/xrpl/basics/CountedObject.h

@@ -1,76 +1,33 @@
-//------------------------------------------------------------------------------
-/*
-    This file is part of rippled: https://github.com/ripple/rippled
-    Copyright (c) 2012, 2013 Ripple Labs Inc.
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose  with  or without fee is hereby granted, provided that the above
-    copyright notice and this permission notice appear in all copies.
-
-    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
-    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
-    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-*/
-//==============================================================================
-
 #ifndef RIPPLE_BASICS_COUNTEDOBJECT_H_INCLUDED
 #define RIPPLE_BASICS_COUNTEDOBJECT_H_INCLUDED
 
 #include <xrpl/beast/type_name.h>
-
 #include <atomic>
+#include <cstddef>
+#include <iterator>
 #include <string>
 #include <utility>
 #include <vector>
 
 namespace ripple {
 
-/** Manages all counted object types. */
 class CountedObjects
 {
 public:
-    static CountedObjects&
-    getInstance() noexcept;
-
-    using Entry = std::pair<std::string, int>;
-    using List = std::vector<Entry>;
-
-    List
-    getCounts(int minimumThreshold) const;
-
-public:
-    /** Implementation for @ref CountedObject.
-
-        @internal
-    */
     class Counter
     {
     public:
-        Counter(std::string name) noexcept : name_(std::move(name)), count_(0)
-        {
-            // Insert ourselves at the front of the lock-free linked list
-            CountedObjects& instance = CountedObjects::getInstance();
-            Counter* head;
-
-            do
-            {
-                head = instance.m_head.load();
-                next_ = head;
-            } while (instance.m_head.exchange(this) != head);
-
-            ++instance.m_count;
-        }
-
-        ~Counter() noexcept = default;
+        Counter(std::string name) noexcept;
 
         int
         increment() noexcept
         {
-            return ++count_;
+            auto const newCount = ++count_;
+
+            if (auto maxCount = maxCount_.load(); newCount > maxCount)
+                maxCount_.compare_exchange_strong(maxCount, newCount);
+
+            return newCount;
         }
 
         int
@@ -80,78 +37,161 @@ public:
         }
 
         int
-        getCount() const noexcept
+        count() const noexcept
         {
             return count_.load();
         }
 
-        Counter*
-        getNext() const noexcept
+        int
+        max() const noexcept
         {
-            return next_;
+            return std::max(count_.load(), maxCount_.load());
         }
 
         std::string const&
-        getName() const noexcept
+        name() const noexcept
         {
             return name_;
         }
 
     private:
-        std::string const name_;
-        std::atomic<int> count_;
+        friend class CountedObjects;
+
         Counter* next_;
+        std::atomic<std::uint32_t> count_ = 0;
+        std::atomic<std::uint32_t> maxCount_ = 0;
+        std::string const name_;
     };
 
-private:
-    CountedObjects() noexcept;
-    ~CountedObjects() noexcept = default;
+    class Iterator
+    {
+    public:
+        using value_type = Counter const;
+        using reference = value_type&;
+        using pointer = value_type*;
+        using difference_type = std::ptrdiff_t;
+        using iterator_category = std::forward_iterator_tag;
+
+        explicit Iterator(Counter* c = nullptr) noexcept : current_(c)
+        {
+        }
+
+        reference
+        operator*() const noexcept
+        {
+            return *current_;
+        }
+        pointer
+        operator->() const noexcept
+        {
+            return current_;
+        }
+
+        Iterator&
+        operator++() noexcept
+        {
+            current_ = current_->next_;
+            return *this;
+        }
+
+        Iterator
+        operator++(int) noexcept
+        {
+            auto tmp = *this;
+            ++*this;
+            return tmp;
+        }
+
+        bool
+        operator==(Iterator const&) const noexcept = default;
+
+    private:
+        Counter* current_;
+    };
+
+    using List = std::vector<std::pair<std::string, int>>;
+
+    constexpr CountedObjects() noexcept = default;
+
+    static CountedObjects&
+    getInstance() noexcept;
+
+    /** Returns the name and count of every counter with at least
+        `minimumThreshold` live instances. */
+    List
+    getCounts(int minimumThreshold) const
+    {
+        List ret;
+
+        for (auto c = head_.load(); c != nullptr; c = c->next_)
+            if (c->count() >= minimumThreshold)
+                ret.emplace_back(c->name(), c->count());
+
+        return ret;
+    }
+
+    auto
+    begin() const noexcept
+    {
+        return Iterator{head_.load()};
+    }
+    auto
+    end() const noexcept
+    {
+        return Iterator{};
+    }
 
 private:
-    std::atomic<int> m_count;
-    std::atomic<Counter*> m_head;
+    friend class Counter;
+
+    std::atomic<Counter*> head_ = nullptr;
 };
 
+inline constinit CountedObjects countedObjects;
+
+inline CountedObjects&
+CountedObjects::getInstance() noexcept
+{
+    return countedObjects;
+}
+
+inline CountedObjects::Counter::Counter(std::string name) noexcept
+    : name_(std::move(name))
+{
+    do
+        next_ = countedObjects.head_.load();
+    while (!countedObjects.head_.compare_exchange_weak(next_, this));
+}
+
 //------------------------------------------------------------------------------
 
-/** Tracks the number of instances of an object.
-
-    Derived classes have their instances counted automatically. This is used
-    for reporting purposes.
-
-    @ingroup ripple_basics
-*/
 template <class Object>
 class CountedObject
 {
-private:
-    static auto&
-    getCounter() noexcept
-    {
-        static CountedObjects::Counter c{beast::type_name<Object>()};
-        return c;
-    }
+    static CountedObjects::Counter counter_;
 
 public:
     CountedObject() noexcept
     {
-        getCounter().increment();
+        counter_.increment();
     }
-
     CountedObject(CountedObject const&) noexcept
     {
-        getCounter().increment();
+        counter_.increment();
     }
-
     CountedObject&
     operator=(CountedObject const&) noexcept = default;
-
     ~CountedObject() noexcept
     {
-        getCounter().decrement();
+        counter_.decrement();
     }
 };
 
+// Instantiation of the static CountedObject<T>::counter_
+template <class Object>
+CountedObjects::Counter CountedObject<Object>::counter_{
+    beast::type_name<Object>()};
+
 }  // namespace ripple
 
 #endif

include/xrpl/basics/Expected.h

@@ -24,7 +24,9 @@
 
 #include <boost/outcome.hpp>
 
+#include <concepts>
 #include <stdexcept>
+#include <type_traits>
 
 namespace ripple {
 
@@ -93,7 +95,7 @@ public:
     {
     }
 
-    constexpr E const&
+    constexpr const E&
     value() const&
     {
         return val_;
@@ -111,7 +113,7 @@ public:
         return std::move(val_);
     }
 
-    constexpr E const&&
+    constexpr const E&&
     value() const&&
     {
         return std::move(val_);

include/xrpl/basics/IntrusivePointer.h

@@ -1,515 +0,0 @@
-//------------------------------------------------------------------------------
-/*
-    This file is part of rippled: https://github.com/ripple/rippled
-    Copyright (c) 2023 Ripple Labs Inc.
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose  with  or without fee is hereby granted, provided that the above
-    copyright notice and this permission notice appear in all copies.
-
-    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
-    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
-    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-*/
-//==============================================================================
-
-#ifndef RIPPLE_BASICS_INTRUSIVEPOINTER_H_INCLUDED
-#define RIPPLE_BASICS_INTRUSIVEPOINTER_H_INCLUDED
-
-#include <concepts>
-#include <cstdint>
-#include <type_traits>
-#include <utility>
-
-namespace ripple {
-
-//------------------------------------------------------------------------------
-
-/** 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.
-*/
-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.
-*/
-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.
-*/
-struct SharedIntrusiveAdoptNoIncrementTag
-{
-};
-
-//------------------------------------------------------------------------------
-//
-
-template <class T>
-concept CAdoptTag = std::is_same_v<T, SharedIntrusiveAdoptIncrementStrongTag> ||
-    std::is_same_v<T, SharedIntrusiveAdoptNoIncrementTag>;
-
-//------------------------------------------------------------------------------
-
-/** 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_poiner 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 rippled, 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
-{
-public:
-    SharedIntrusive() = default;
-
-    template <CAdoptTag TAdoptTag>
-    SharedIntrusive(T* p, TAdoptTag) noexcept;
-
-    SharedIntrusive(SharedIntrusive const& rhs);
-
-    template <class TT>
-    // TODO: convertible_to isn't quite right. That include a static castable.
-    // Find the right concept.
-        requires std::convertible_to<TT*, T*>
-    SharedIntrusive(SharedIntrusive<TT> const& rhs);
-
-    SharedIntrusive(SharedIntrusive&& rhs);
-
-    template <class TT>
-        requires std::convertible_to<TT*, T*>
-    SharedIntrusive(SharedIntrusive<TT>&& rhs);
-
-    SharedIntrusive&
-    operator=(SharedIntrusive const& rhs);
-
-    bool
-    operator!=(std::nullptr_t) const;
-
-    bool
-    operator==(std::nullptr_t) const;
-
-    template <class TT>
-        requires std::convertible_to<TT*, T*>
-    SharedIntrusive&
-    operator=(SharedIntrusive<TT> const& rhs);
-
-    SharedIntrusive&
-    operator=(SharedIntrusive&& rhs);
-
-    template <class TT>
-        requires std::convertible_to<TT*, T*>
-    SharedIntrusive&
-    operator=(SharedIntrusive<TT>&& rhs);
-
-    /** Adopt the raw pointer. The strong reference may or may not be
-        incremented, depending on the TAdoptTag
-     */
-    template <CAdoptTag TAdoptTag = SharedIntrusiveAdoptIncrementStrongTag>
-    void
-    adopt(T* p);
-
-    ~SharedIntrusive();
-
-    /** 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.
-    */
-    template <class TT>
-    SharedIntrusive(StaticCastTagSharedIntrusive, SharedIntrusive<TT>&& rhs);
-
-    /** 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.
-    */
-    template <class TT>
-    SharedIntrusive(DynamicCastTagSharedIntrusive, SharedIntrusive<TT>&& rhs);
-
-    T&
-    operator*() const noexcept;
-
-    T*
-    operator->() const noexcept;
-
-    explicit
-    operator bool() const noexcept;
-
-    /** Set the pointer to null, decrement the strong count, and run the
-        appropriate release action.
-      */
-    void
-    reset();
-
-    /** Get the raw pointer */
-    T*
-    get() const;
-
-    /** Return the strong count */
-    std::size_t
-    use_count() const;
-
-    template <class TT, class... Args>
-    friend SharedIntrusive<TT>
-    make_SharedIntrusive(Args&&... args);
-
-    template <class TT>
-    friend class SharedIntrusive;
-
-    template <class TT>
-    friend class SharedWeakUnion;
-
-    template <class TT>
-    friend class WeakIntrusive;
-
-private:
-    /** Return the raw pointer held by this object. */
-    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.
-     */
-    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.
-     */
-    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.
-     */
-    T*
-    unsafeExchange(T* p);
-
-    /** 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.
-*/
-template <class T>
-class WeakIntrusive
-{
-public:
-    WeakIntrusive() = default;
-
-    WeakIntrusive(WeakIntrusive const& rhs);
-
-    WeakIntrusive(WeakIntrusive&& rhs);
-
-    WeakIntrusive(SharedIntrusive<T> const& rhs);
-
-    // There is no move constructor from a strong intrusive ptr because
-    // moving would be move expensive than copying in this case (the strong
-    // ref would need to be decremented)
-    WeakIntrusive(SharedIntrusive<T> const&& rhs) = delete;
-
-    // Since there are no current use cases for copy assignment in
-    // WeakIntrusive, we delete this operator to simplify the implementation. If
-    // a need arises in the future, we can reintroduce it with proper
-    // consideration."
-    WeakIntrusive&
-    operator=(WeakIntrusive const&) = delete;
-
-    template <class TT>
-        requires std::convertible_to<TT*, T*>
-    WeakIntrusive&
-    operator=(SharedIntrusive<TT> const& rhs);
-
-    /** 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.
-     */
-    SharedIntrusive<T>
-    lock() const;
-
-    /** Return true if the strong count is zero. */
-    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.
-    */
-    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.
-    */
-    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.
-  */
-
-template <class T>
-class SharedWeakUnion
-{
-    // Tagged pointer. Low bit determines if this is a strong or a weak
-    // pointer. The low bit must be masked to zero when converting back to a
-    // pointer. If the low bit is '1', this is a weak pointer.
-    static_assert(
-        alignof(T) >= 2,
-        "Bad alignment: Combo pointer requires low bit to be zero");
-
-public:
-    SharedWeakUnion() = default;
-
-    SharedWeakUnion(SharedWeakUnion const& rhs);
-
-    template <class TT>
-        requires std::convertible_to<TT*, T*>
-    SharedWeakUnion(SharedIntrusive<TT> const& rhs);
-
-    SharedWeakUnion(SharedWeakUnion&& rhs);
-
-    template <class TT>
-        requires std::convertible_to<TT*, T*>
-    SharedWeakUnion(SharedIntrusive<TT>&& rhs);
-
-    SharedWeakUnion&
-    operator=(SharedWeakUnion const& rhs);
-
-    template <class TT>
-        requires std::convertible_to<TT*, T*>
-    SharedWeakUnion&
-    operator=(SharedIntrusive<TT> const& rhs);
-
-    template <class TT>
-        requires std::convertible_to<TT*, T*>
-    SharedWeakUnion&
-    operator=(SharedIntrusive<TT>&& rhs);
-
-    ~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)
-     */
-    SharedIntrusive<T>
-    getStrong() const;
-
-    /** 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.
-     */
-    void
-    reset();
-
-    /** If this is a strong pointer, return the raw pointer. Otherwise
-       return null.
-     */
-    T*
-    get() const;
-
-    /** If this is a strong pointer, return the strong count. Otherwise
-     * return 0
-     */
-    std::size_t
-    use_count() const;
-
-    /** Return true if there is a non-zero strong count. */
-    bool
-    expired() const;
-
-    /** If this is a strong pointer, return the strong pointer. Otherwise
-        attempt to lock the weak pointer.
-     */
-    SharedIntrusive<T>
-    lock() const;
-
-    /** Return true is this represents a strong pointer. */
-    bool
-    isStrong() const;
-
-    /** Return true is this represents a weak pointer. */
-    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.
-      */
-    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.
-      */
-    bool
-    convertToWeak();
-
-private:
-    // Tagged pointer. Low bit determines if this is a strong or a weak
-    // pointer. The low bit must be masked to zero when converting back to a
-    // pointer. If the low bit is '1', this is a weak pointer.
-    std::uintptr_t tp_{0};
-    static constexpr std::uintptr_t tagMask = 1;
-    static constexpr std::uintptr_t ptrMask = ~tagMask;
-
-private:
-    /** Return the raw pointer held by this object.
-     */
-    T*
-    unsafeGetRawPtr() const;
-
-    enum class RefStrength { strong, weak };
-    /** 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).
-     */
-    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.
-     */
-    void
-    unsafeReleaseNoStore();
-};
-
-//------------------------------------------------------------------------------
-
-/** 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>
-make_SharedIntrusive(Args&&... args)
-{
-    auto p = new TT(std::forward<Args>(args)...);
-
-    static_assert(
-        noexcept(SharedIntrusive<TT>(
-            std::declval<TT*>(),
-            std::declval<SharedIntrusiveAdoptNoIncrementTag>())),
-        "SharedIntrusive constructor should not throw or this can leak "
-        "memory");
-
-    return SharedIntrusive<TT>(p, SharedIntrusiveAdoptNoIncrementTag{});
-}
-
-//------------------------------------------------------------------------------
-
-namespace intr_ptr {
-template <class T>
-using SharedPtr = SharedIntrusive<T>;
-
-template <class T>
-using WeakPtr = WeakIntrusive<T>;
-
-template <class T>
-using SharedWeakUnionPtr = SharedWeakUnion<T>;
-
-template <class T, class... A>
-SharedPtr<T>
-make_shared(A&&... args)
-{
-    return make_SharedIntrusive<T>(std::forward<A>(args)...);
-}
-
-template <class T, class TT>
-SharedPtr<T>
-static_pointer_cast(TT const& v)
-{
-    return SharedPtr<T>(StaticCastTagSharedIntrusive{}, v);
-}
-
-template <class T, class TT>
-SharedPtr<T>
-dynamic_pointer_cast(TT const& v)
-{
-    return SharedPtr<T>(DynamicCastTagSharedIntrusive{}, v);
-}
-}  // namespace intr_ptr
-}  // namespace ripple
-#endif

include/xrpl/basics/IntrusivePointer.ipp

@@ -1,740 +0,0 @@
-//------------------------------------------------------------------------------
-/*
-    This file is part of rippled: https://github.com/ripple/rippled
-    Copyright (c) 2023 Ripple Labs Inc.
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose  with  or without fee is hereby granted, provided that the above
-    copyright notice and this permission notice appear in all copies.
-
-    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
-    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
-    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-*/
-//==============================================================================
-
-#ifndef RIPPLE_BASICS_INTRUSIVEPOINTER_IPP_INCLUDED
-#define RIPPLE_BASICS_INTRUSIVEPOINTER_IPP_INCLUDED
-
-#include <xrpl/basics/IntrusivePointer.h>
-#include <xrpl/basics/IntrusiveRefCounts.h>
-
-#include <utility>
-
-namespace ripple {
-
-template <class T>
-template <CAdoptTag TAdoptTag>
-SharedIntrusive<T>::SharedIntrusive(T* p, TAdoptTag) noexcept : ptr_{p}
-{
-    if constexpr (std::is_same_v<
-                      TAdoptTag,
-                      SharedIntrusiveAdoptIncrementStrongTag>)
-    {
-        if (p)
-            p->addStrongRef();
-    }
-}
-
-template <class T>
-SharedIntrusive<T>::SharedIntrusive(SharedIntrusive const& rhs)
-    : ptr_{[&] {
-        auto p = rhs.unsafeGetRawPtr();
-        if (p)
-            p->addStrongRef();
-        return p;
-    }()}
-{
-}
-
-template <class T>
-template <class TT>
-    requires std::convertible_to<TT*, T*>
-SharedIntrusive<T>::SharedIntrusive(SharedIntrusive<TT> const& rhs)
-    : ptr_{[&] {
-        auto p = rhs.unsafeGetRawPtr();
-        if (p)
-            p->addStrongRef();
-        return p;
-    }()}
-{
-}
-
-template <class T>
-SharedIntrusive<T>::SharedIntrusive(SharedIntrusive&& rhs)
-    : ptr_{rhs.unsafeExchange(nullptr)}
-{
-}
-
-template <class T>
-template <class TT>
-    requires std::convertible_to<TT*, T*>
-SharedIntrusive<T>::SharedIntrusive(SharedIntrusive<TT>&& rhs)
-    : ptr_{rhs.unsafeExchange(nullptr)}
-{
-}
-template <class T>
-SharedIntrusive<T>&
-SharedIntrusive<T>::operator=(SharedIntrusive const& rhs)
-{
-    if (this == &rhs)
-        return *this;
-    auto p = rhs.unsafeGetRawPtr();
-    if (p)
-        p->addStrongRef();
-    unsafeReleaseAndStore(p);
-    return *this;
-}
-
-template <class T>
-template <class TT>
-// clang-format off
-requires std::convertible_to<TT*, T*>
-// clang-format on
-SharedIntrusive<T>&
-SharedIntrusive<T>::operator=(SharedIntrusive<TT> const& rhs)
-{
-    if constexpr (std::is_same_v<T, TT>)
-    {
-        // This case should never be hit. The operator above will run instead.
-        // (The normal operator= is needed or it will be marked `deleted`)
-        if (this == &rhs)
-            return *this;
-    }
-    auto p = rhs.unsafeGetRawPtr();
-    if (p)
-        p->addStrongRef();
-    unsafeReleaseAndStore(p);
-    return *this;
-}
-
-template <class T>
-SharedIntrusive<T>&
-SharedIntrusive<T>::operator=(SharedIntrusive&& rhs)
-{
-    if (this == &rhs)
-        return *this;
-
-    unsafeReleaseAndStore(rhs.unsafeExchange(nullptr));
-    return *this;
-}
-
-template <class T>
-template <class TT>
-// clang-format off
-requires std::convertible_to<TT*, T*>
-// clang-format on
-SharedIntrusive<T>&
-SharedIntrusive<T>::operator=(SharedIntrusive<TT>&& rhs)
-{
-    static_assert(
-        !std::is_same_v<T, TT>,
-        "This overload should not be instantiated for T == TT");
-
-    unsafeReleaseAndStore(rhs.unsafeExchange(nullptr));
-    return *this;
-}
-
-template <class T>
-bool
-SharedIntrusive<T>::operator!=(std::nullptr_t) const
-{
-    return this->get() != nullptr;
-}
-
-template <class T>
-bool
-SharedIntrusive<T>::operator==(std::nullptr_t) const
-{
-    return this->get() == nullptr;
-}
-
-template <class T>
-template <CAdoptTag TAdoptTag>
-void
-SharedIntrusive<T>::adopt(T* p)
-{
-    if constexpr (std::is_same_v<
-                      TAdoptTag,
-                      SharedIntrusiveAdoptIncrementStrongTag>)
-    {
-        if (p)
-            p->addStrongRef();
-    }
-    unsafeReleaseAndStore(p);
-}
-
-template <class T>
-SharedIntrusive<T>::~SharedIntrusive()
-{
-    unsafeReleaseAndStore(nullptr);
-};
-
-template <class T>
-template <class TT>
-SharedIntrusive<T>::SharedIntrusive(
-    StaticCastTagSharedIntrusive,
-    SharedIntrusive<TT> const& rhs)
-    : ptr_{[&] {
-        auto p = static_cast<T*>(rhs.unsafeGetRawPtr());
-        if (p)
-            p->addStrongRef();
-        return p;
-    }()}
-{
-}
-
-template <class T>
-template <class TT>
-SharedIntrusive<T>::SharedIntrusive(
-    StaticCastTagSharedIntrusive,
-    SharedIntrusive<TT>&& rhs)
-    : ptr_{static_cast<T*>(rhs.unsafeExchange(nullptr))}
-{
-}
-
-template <class T>
-template <class TT>
-SharedIntrusive<T>::SharedIntrusive(
-    DynamicCastTagSharedIntrusive,
-    SharedIntrusive<TT> const& rhs)
-    : ptr_{[&] {
-        auto p = dynamic_cast<T*>(rhs.unsafeGetRawPtr());
-        if (p)
-            p->addStrongRef();
-        return p;
-    }()}
-{
-}
-
-template <class T>
-template <class TT>
-SharedIntrusive<T>::SharedIntrusive(
-    DynamicCastTagSharedIntrusive,
-    SharedIntrusive<TT>&& rhs)
-{
-    // This can be simplified without the `exchange`, but the `exchange` is kept
-    // in anticipation of supporting atomic operations.
-    auto toSet = rhs.unsafeExchange(nullptr);
-    if (toSet)
-    {
-        ptr_ = dynamic_cast<T*>(toSet);
-        if (!ptr_)
-            // need to set the pointer back or will leak
-            rhs.unsafeExchange(toSet);
-    }
-}
-
-template <class T>
-T&
-SharedIntrusive<T>::operator*() const noexcept
-{
-    return *unsafeGetRawPtr();
-}
-
-template <class T>
-T*
-SharedIntrusive<T>::operator->() const noexcept
-{
-    return unsafeGetRawPtr();
-}
-
-template <class T>
-SharedIntrusive<T>::operator bool() const noexcept
-{
-    return bool(unsafeGetRawPtr());
-}
-
-template <class T>
-void
-SharedIntrusive<T>::reset()
-{
-    unsafeReleaseAndStore(nullptr);
-}
-
-template <class T>
-T*
-SharedIntrusive<T>::get() const
-{
-    return unsafeGetRawPtr();
-}
-
-template <class T>
-std::size_t
-SharedIntrusive<T>::use_count() const
-{
-    if (auto p = unsafeGetRawPtr())
-        return p->use_count();
-    return 0;
-}
-
-template <class T>
-T*
-SharedIntrusive<T>::unsafeGetRawPtr() const
-{
-    return ptr_;
-}
-
-template <class T>
-void
-SharedIntrusive<T>::unsafeSetRawPtr(T* p)
-{
-    ptr_ = p;
-}
-
-template <class T>
-T*
-SharedIntrusive<T>::unsafeExchange(T* p)
-{
-    return std::exchange(ptr_, p);
-}
-
-template <class T>
-void
-SharedIntrusive<T>::unsafeReleaseAndStore(T* next)
-{
-    auto prev = unsafeExchange(next);
-    if (!prev)
-        return;
-
-    using enum ReleaseStrongRefAction;
-    auto action = prev->releaseStrongRef();
-    switch (action)
-    {
-        case noop:
-            break;
-        case destroy:
-            delete prev;
-            break;
-        case partialDestroy:
-            prev->partialDestructor();
-            partialDestructorFinished(&prev);
-            // prev is null and may no longer be used
-            break;
-    }
-}
-
-//------------------------------------------------------------------------------
-
-template <class T>
-WeakIntrusive<T>::WeakIntrusive(WeakIntrusive const& rhs) : ptr_{rhs.ptr_}
-{
-    if (ptr_)
-        ptr_->addWeakRef();
-}
-
-template <class T>
-WeakIntrusive<T>::WeakIntrusive(WeakIntrusive&& rhs) : ptr_{rhs.ptr_}
-{
-    rhs.ptr_ = nullptr;
-}
-
-template <class T>
-WeakIntrusive<T>::WeakIntrusive(SharedIntrusive<T> const& rhs)
-    : ptr_{rhs.unsafeGetRawPtr()}
-{
-    if (ptr_)
-        ptr_->addWeakRef();
-}
-
-template <class T>
-template <class TT>
-// clang-format off
-requires std::convertible_to<TT*, T*>
-// clang-format on
-WeakIntrusive<T>&
-WeakIntrusive<T>::operator=(SharedIntrusive<TT> const& rhs)
-{
-    unsafeReleaseNoStore();
-    auto p = rhs.unsafeGetRawPtr();
-    if (p)
-        p->addWeakRef();
-    return *this;
-}
-
-template <class T>
-void
-WeakIntrusive<T>::adopt(T* ptr)
-{
-    unsafeReleaseNoStore();
-    if (ptr)
-        ptr->addWeakRef();
-    ptr_ = ptr;
-}
-
-template <class T>
-WeakIntrusive<T>::~WeakIntrusive()
-{
-    unsafeReleaseNoStore();
-}
-
-template <class T>
-SharedIntrusive<T>
-WeakIntrusive<T>::lock() const
-{
-    if (ptr_ && ptr_->checkoutStrongRefFromWeak())
-    {
-        return SharedIntrusive<T>{ptr_, SharedIntrusiveAdoptNoIncrementTag{}};
-    }
-    return {};
-}
-
-template <class T>
-bool
-WeakIntrusive<T>::expired() const
-{
-    return (!ptr_ || ptr_->expired());
-}
-
-template <class T>
-void
-WeakIntrusive<T>::reset()
-{
-    unsafeReleaseNoStore();
-    ptr_ = nullptr;
-}
-
-template <class T>
-void
-WeakIntrusive<T>::unsafeReleaseNoStore()
-{
-    if (!ptr_)
-        return;
-
-    using enum ReleaseWeakRefAction;
-    auto action = ptr_->releaseWeakRef();
-    switch (action)
-    {
-        case noop:
-            break;
-        case destroy:
-            delete ptr_;
-            break;
-    }
-}
-
-//------------------------------------------------------------------------------
-
-template <class T>
-SharedWeakUnion<T>::SharedWeakUnion(SharedWeakUnion const& rhs) : tp_{rhs.tp_}
-{
-    auto p = rhs.unsafeGetRawPtr();
-    if (!p)
-        return;
-
-    if (rhs.isStrong())
-        p->addStrongRef();
-    else
-        p->addWeakRef();
-}
-
-template <class T>
-template <class TT>
-    requires std::convertible_to<TT*, T*>
-SharedWeakUnion<T>::SharedWeakUnion(SharedIntrusive<TT> const& rhs)
-{
-    auto p = rhs.unsafeGetRawPtr();
-    if (p)
-        p->addStrongRef();
-    unsafeSetRawPtr(p, RefStrength::strong);
-}
-
-template <class T>
-SharedWeakUnion<T>::SharedWeakUnion(SharedWeakUnion&& rhs) : tp_{rhs.tp_}
-{
-    rhs.unsafeSetRawPtr(nullptr);
-}
-
-template <class T>
-template <class TT>
-    requires std::convertible_to<TT*, T*>
-SharedWeakUnion<T>::SharedWeakUnion(SharedIntrusive<TT>&& rhs)
-{
-    auto p = rhs.unsafeGetRawPtr();
-    if (p)
-        unsafeSetRawPtr(p, RefStrength::strong);
-    rhs.unsafeSetRawPtr(nullptr);
-}
-
-template <class T>
-SharedWeakUnion<T>&
-SharedWeakUnion<T>::operator=(SharedWeakUnion const& rhs)
-{
-    if (this == &rhs)
-        return *this;
-    unsafeReleaseNoStore();
-
-    if (auto p = rhs.unsafeGetRawPtr())
-    {
-        if (rhs.isStrong())
-        {
-            p->addStrongRef();
-            unsafeSetRawPtr(p, RefStrength::strong);
-        }
-        else
-        {
-            p->addWeakRef();
-            unsafeSetRawPtr(p, RefStrength::weak);
-        }
-    }
-    else
-    {
-        unsafeSetRawPtr(nullptr);
-    }
-    return *this;
-}
-
-template <class T>
-template <class TT>
-// clang-format off
-requires std::convertible_to<TT*, T*>
-// clang-format on
-SharedWeakUnion<T>&
-SharedWeakUnion<T>::operator=(SharedIntrusive<TT> const& rhs)
-{
-    unsafeReleaseNoStore();
-    auto p = rhs.unsafeGetRawPtr();
-    if (p)
-        p->addStrongRef();
-    unsafeSetRawPtr(p, RefStrength::strong);
-    return *this;
-}
-
-template <class T>
-template <class TT>
-// clang-format off
-requires std::convertible_to<TT*, T*>
-// clang-format on
-SharedWeakUnion<T>&
-SharedWeakUnion<T>::operator=(SharedIntrusive<TT>&& rhs)
-{
-    unsafeReleaseNoStore();
-    unsafeSetRawPtr(rhs.unsafeGetRawPtr(), RefStrength::strong);
-    rhs.unsafeSetRawPtr(nullptr);
-    return *this;
-}
-
-template <class T>
-SharedWeakUnion<T>::~SharedWeakUnion()
-{
-    unsafeReleaseNoStore();
-};
-
-// 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)
-template <class T>
-SharedIntrusive<T>
-SharedWeakUnion<T>::getStrong() const
-{
-    SharedIntrusive<T> result;
-    auto p = unsafeGetRawPtr();
-    if (p && isStrong())
-    {
-        result.template adopt<SharedIntrusiveAdoptIncrementStrongTag>(p);
-    }
-    return result;
-}
-
-template <class T>
-SharedWeakUnion<T>::operator bool() const noexcept
-{
-    return bool(get());
-}
-
-template <class T>
-void
-SharedWeakUnion<T>::reset()
-{
-    unsafeReleaseNoStore();
-    unsafeSetRawPtr(nullptr);
-}
-
-template <class T>
-T*
-SharedWeakUnion<T>::get() const
-{
-    return isStrong() ? unsafeGetRawPtr() : nullptr;
-}
-
-template <class T>
-std::size_t
-SharedWeakUnion<T>::use_count() const
-{
-    if (auto p = get())
-        return p->use_count();
-    return 0;
-}
-
-template <class T>
-bool
-SharedWeakUnion<T>::expired() const
-{
-    auto p = unsafeGetRawPtr();
-    return (!p || p->expired());
-}
-
-template <class T>
-SharedIntrusive<T>
-SharedWeakUnion<T>::lock() const
-{
-    SharedIntrusive<T> result;
-    auto p = unsafeGetRawPtr();
-    if (!p)
-        return result;
-
-    if (isStrong())
-    {
-        result.template adopt<SharedIntrusiveAdoptIncrementStrongTag>(p);
-        return result;
-    }
-
-    if (p->checkoutStrongRefFromWeak())
-    {
-        result.template adopt<SharedIntrusiveAdoptNoIncrementTag>(p);
-        return result;
-    }
-    return result;
-}
-
-template <class T>
-bool
-SharedWeakUnion<T>::isStrong() const
-{
-    return !(tp_ & tagMask);
-}
-
-template <class T>
-bool
-SharedWeakUnion<T>::isWeak() const
-{
-    return tp_ & tagMask;
-}
-
-template <class T>
-bool
-SharedWeakUnion<T>::convertToStrong()
-{
-    if (isStrong())
-        return true;
-
-    auto p = unsafeGetRawPtr();
-    if (p && p->checkoutStrongRefFromWeak())
-    {
-        [[maybe_unused]] auto action = p->releaseWeakRef();
-        XRPL_ASSERT(
-            (action == ReleaseWeakRefAction::noop),
-            "ripple::SharedWeakUnion::convertToStrong : "
-            "action is noop");
-        unsafeSetRawPtr(p, RefStrength::strong);
-        return true;
-    }
-    return false;
-}
-
-template <class T>
-bool
-SharedWeakUnion<T>::convertToWeak()
-{
-    if (isWeak())
-        return true;
-
-    auto p = unsafeGetRawPtr();
-    if (!p)
-        return false;
-
-    using enum ReleaseStrongRefAction;
-    auto action = p->addWeakReleaseStrongRef();
-    switch (action)
-    {
-        case noop:
-            break;
-        case destroy:
-            // We just added a weak ref. How could we destroy?
-            UNREACHABLE(
-                "ripple::SharedWeakUnion::convertToWeak : destroying freshly "
-                "added ref");
-            delete p;
-            unsafeSetRawPtr(nullptr);
-            return true;  // Should never happen
-        case partialDestroy:
-            // This is a weird case. We just converted the last strong
-            // pointer to a weak pointer.
-            p->partialDestructor();
-            partialDestructorFinished(&p);
-            // p is null and may no longer be used
-            break;
-    }
-    unsafeSetRawPtr(p, RefStrength::weak);
-    return true;
-}
-
-template <class T>
-T*
-SharedWeakUnion<T>::unsafeGetRawPtr() const
-{
-    return reinterpret_cast<T*>(tp_ & ptrMask);
-}
-
-template <class T>
-void
-SharedWeakUnion<T>::unsafeSetRawPtr(T* p, RefStrength rs)
-{
-    tp_ = reinterpret_cast<std::uintptr_t>(p);
-    if (tp_ && rs == RefStrength::weak)
-        tp_ |= tagMask;
-}
-
-template <class T>
-void
-SharedWeakUnion<T>::unsafeSetRawPtr(std::nullptr_t)
-{
-    tp_ = 0;
-}
-
-template <class T>
-void
-SharedWeakUnion<T>::unsafeReleaseNoStore()
-{
-    auto p = unsafeGetRawPtr();
-    if (!p)
-        return;
-
-    if (isStrong())
-    {
-        using enum ReleaseStrongRefAction;
-        auto strongAction = p->releaseStrongRef();
-        switch (strongAction)
-        {
-            case noop:
-                break;
-            case destroy:
-                delete p;
-                break;
-            case partialDestroy:
-                p->partialDestructor();
-                partialDestructorFinished(&p);
-                // p is null and may no longer be used
-                break;
-        }
-    }
-    else
-    {
-        using enum ReleaseWeakRefAction;
-        auto weakAction = p->releaseWeakRef();
-        switch (weakAction)
-        {
-            case noop:
-                break;
-            case destroy:
-                delete p;
-                break;
-        }
-    }
-}
-
-}  // namespace ripple
-#endif

include/xrpl/basics/IntrusiveRefCounts.h

@@ -1,502 +0,0 @@
-//------------------------------------------------------------------------------
-/*
-    This file is part of rippled: https://github.com/ripple/rippled
-    Copyright (c) 2023 Ripple Labs Inc.
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose  with  or without fee is hereby granted, provided that the above
-    copyright notice and this permission notice appear in all copies.
-
-    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
-    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
-    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-*/
-//==============================================================================
-
-#ifndef RIPPLE_BASICS_INTRUSIVEREFCOUNTS_H_INCLUDED
-#define RIPPLE_BASICS_INTRUSIVEREFCOUNTS_H_INCLUDED
-
-#include <xrpl/beast/utility/instrumentation.h>
-
-#include <atomic>
-#include <cstdint>
-
-namespace ripple {
-
-/** 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.
- */
-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 a ripple::IntrusivePointer by
-    inheriting from this class.
-  */
-struct IntrusiveRefCounts
-{
-    virtual ~IntrusiveRefCounts() noexcept;
-
-    // This must be `noexcept` or the make_SharedIntrusive function could leak
-    // memory.
-    void
-    addStrongRef() const noexcept;
-
-    void
-    addWeakRef() const noexcept;
-
-    ReleaseStrongRefAction
-    releaseStrongRef() const;
-
-    // Same as:
-    // {
-    //   addWeakRef();
-    //   return releaseStrongRef;
-    // }
-    // done as one atomic operation
-    ReleaseStrongRefAction
-    addWeakReleaseStrongRef() const;
-
-    ReleaseWeakRefAction
-    releaseWeakRef() const;
-
-    // Returns true is able to checkout a strong ref. False otherwise
-    bool
-    checkoutStrongRefFromWeak() const noexcept;
-
-    bool
-    expired() const noexcept;
-
-    std::size_t
-    use_count() const noexcept;
-
-    // This function MUST be called after a partial destructor finishes running.
-    // Calling this function may cause other threads to delete the object
-    // pointed to by `o`, so `o` should never be used after calling this
-    // function. The parameter will be set to a `nullptr` after calling this
-    // function to emphasize that it should not be used.
-    // Note: This is intentionally NOT called at the end of `partialDestructor`.
-    // The reason for this is if new classes are written to support this smart
-    // pointer class, they need to write their own `partialDestructor` function
-    // and ensure `partialDestructorFinished` is called at the end. Putting this
-    // call inside the smart pointer class itself is expected to be less error
-    // prone.
-    // Note: The "two-star" programming is intentional. It emphasizes that `o`
-    // may be deleted and the unergonomic API is meant to signal the special
-    // nature of this function call to callers.
-    // Note: This is a template to support incompletely defined classes.
-    template <class T>
-    friend void
-    partialDestructorFinished(T** o);
-
-private:
-    // TODO: We may need to use a uint64_t for both counts. This will reduce the
-    // memory savings. We need to audit the code to make sure 16 bit counts are
-    // enough for strong pointers and 14 bit counts are enough for weak
-    // pointers. Use type aliases to make it easy to switch types.
-    using CountType = std::uint16_t;
-    static constexpr size_t StrongCountNumBits = sizeof(CountType) * 8;
-    static constexpr size_t WeakCountNumBits = StrongCountNumBits - 2;
-    using FieldType = std::uint32_t;
-    static constexpr size_t FieldTypeBits = sizeof(FieldType) * 8;
-    static constexpr FieldType one = 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.
-
-         */
-
-    mutable std::atomic<FieldType> refCounts{strongDelta};
-
-    /**  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 strongDelta = 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
-      */
-    static constexpr FieldType weakDelta = (one << StrongCountNumBits);
-
-    /**  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 partialDestroyStartedMask =
-        (one << (FieldTypeBits - 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.
-      */
-    static constexpr FieldType partialDestroyFinishedMask =
-        (one << (FieldTypeBits - 2));
-
-    /** Mask that will zero out all the `count` bits and leave the tag bits
-        unchanged.
-      */
-    static constexpr FieldType tagMask =
-        partialDestroyStartedMask | partialDestroyFinishedMask;
-
-    /** Mask that will zero out the `tag` bits and leave the count bits
-        unchanged.
-      */
-    static constexpr FieldType valueMask = ~tagMask;
-
-    /** Mask that will zero out everything except the strong count.
-     */
-    static constexpr FieldType strongMask =
-        ((one << StrongCountNumBits) - 1) & valueMask;
-
-    /** Mask that will zero out everything except the weak count.
-     */
-    static constexpr FieldType weakMask =
-        (((one << WeakCountNumBits) - 1) << StrongCountNumBits) & valueMask;
-
-    /** 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`.
-         */
-        FieldType partialDestroyStartedBit{0};
-        /**  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. */
-        FieldType
-        combinedValue() const noexcept;
-
-        static constexpr CountType maxStrongValue =
-            static_cast<CountType>((one << StrongCountNumBits) - 1);
-        static constexpr CountType maxWeakValue =
-            static_cast<CountType>((one << WeakCountNumBits) - 1);
-        /**  Put an extra margin to detect when running up against limits.
-             This is only used in debug code, and is useful if we reduce the
-             number of bits in the strong and weak counts (to 16 and 14 bits).
-         */
-        static constexpr CountType checkStrongMaxValue = maxStrongValue - 32;
-        static constexpr CountType checkWeakMaxValue = maxWeakValue - 32;
-    };
-};
-
-inline void
-IntrusiveRefCounts::addStrongRef() const noexcept
-{
-    refCounts.fetch_add(strongDelta, std::memory_order_acq_rel);
-}
-
-inline void
-IntrusiveRefCounts::addWeakRef() const noexcept
-{
-    refCounts.fetch_add(weakDelta, std::memory_order_acq_rel);
-}
-
-inline ReleaseStrongRefAction
-IntrusiveRefCounts::releaseStrongRef() const
-{
-    // Subtract `strongDelta` from refCounts. If this releases the last strong
-    // ref, set the `partialDestroyStarted` bit. It is important that the ref
-    // count and the `partialDestroyStartedBit` are changed atomically (hence
-    // the loop and `compare_exchange` op). If this didn't need to be done
-    // atomically, the loop could be replaced with a `fetch_sub` and a
-    // conditional `fetch_or`. This loop will almost always run once.
-
-    using enum ReleaseStrongRefAction;
-    auto prevIntVal = refCounts.load(std::memory_order_acquire);
-    while (1)
-    {
-        RefCountPair const prevVal{prevIntVal};
-        XRPL_ASSERT(
-            (prevVal.strong >= strongDelta),
-            "ripple::IntrusiveRefCounts::releaseStrongRef : previous ref "
-            "higher than new");
-        auto nextIntVal = prevIntVal - strongDelta;
-        ReleaseStrongRefAction action = noop;
-        if (prevVal.strong == 1)
-        {
-            if (prevVal.weak == 0)
-            {
-                action = destroy;
-            }
-            else
-            {
-                nextIntVal |= partialDestroyStartedMask;
-                action = partialDestroy;
-            }
-        }
-
-        if (refCounts.compare_exchange_weak(
-                prevIntVal, nextIntVal, std::memory_order_acq_rel))
-        {
-            // Can't be in partial destroy because only decrementing the strong
-            // count to zero can start a partial destroy, and that can't happen
-            // twice.
-            XRPL_ASSERT(
-                (action == noop) || !(prevIntVal & partialDestroyStartedMask),
-                "ripple::IntrusiveRefCounts::releaseStrongRef : not in partial "
-                "destroy");
-            return action;
-        }
-    }
-}
-
-inline ReleaseStrongRefAction
-IntrusiveRefCounts::addWeakReleaseStrongRef() const
-{
-    using enum ReleaseStrongRefAction;
-
-    static_assert(weakDelta > strongDelta);
-    auto constexpr delta = weakDelta - strongDelta;
-    auto prevIntVal = refCounts.load(std::memory_order_acquire);
-    // This loop will almost always run once. The loop is needed to atomically
-    // change the counts and flags (the count could be atomically changed, but
-    // the flags depend on the current value of the counts).
-    //
-    // Note: If this becomes a perf bottleneck, the `partialDestoryStartedMask`
-    // may be able to be set non-atomically. But it is easier to reason about
-    // the code if the flag is set atomically.
-    while (1)
-    {
-        RefCountPair const prevVal{prevIntVal};
-        // Converted the last strong pointer to a weak pointer.
-        //
-        // Can't be in partial destroy because only decrementing the
-        // strong count to zero can start a partial destroy, and that
-        // can't happen twice.
-        XRPL_ASSERT(
-            (!prevVal.partialDestroyStartedBit),
-            "ripple::IntrusiveRefCounts::addWeakReleaseStrongRef : not in "
-            "partial destroy");
-
-        auto nextIntVal = prevIntVal + delta;
-        ReleaseStrongRefAction action = noop;
-        if (prevVal.strong == 1)
-        {
-            if (prevVal.weak == 0)
-            {
-                action = noop;
-            }
-            else
-            {
-                nextIntVal |= partialDestroyStartedMask;
-                action = partialDestroy;
-            }
-        }
-        if (refCounts.compare_exchange_weak(
-                prevIntVal, nextIntVal, std::memory_order_acq_rel))
-        {
-            XRPL_ASSERT(
-                (!(prevIntVal & partialDestroyStartedMask)),
-                "ripple::IntrusiveRefCounts::addWeakReleaseStrongRef : not "
-                "started partial destroy");
-            return action;
-        }
-    }
-}
-
-inline ReleaseWeakRefAction
-IntrusiveRefCounts::releaseWeakRef() const
-{
-    auto prevIntVal = refCounts.fetch_sub(weakDelta, std::memory_order_acq_rel);
-    RefCountPair prev = prevIntVal;
-    if (prev.weak == 1 && prev.strong == 0)
-    {
-        if (!prev.partialDestroyStartedBit)
-        {
-            // This case should only be hit if the partialDestroyStartedBit is
-            // set non-atomically (and even then very rarely). The code is kept
-            // in case we need to set the flag non-atomically for perf reasons.
-            refCounts.wait(prevIntVal, std::memory_order_acquire);
-            prevIntVal = refCounts.load(std::memory_order_acquire);
-            prev = RefCountPair{prevIntVal};
-        }
-        if (!prev.partialDestroyFinishedBit)
-        {
-            // partial destroy MUST finish before running a full destroy (when
-            // using weak pointers)
-            refCounts.wait(prevIntVal - weakDelta, std::memory_order_acquire);
-        }
-        return ReleaseWeakRefAction::destroy;
-    }
-    return ReleaseWeakRefAction::noop;
-}
-
-inline bool
-IntrusiveRefCounts::checkoutStrongRefFromWeak() const noexcept
-{
-    auto curValue = RefCountPair{1, 1}.combinedValue();
-    auto desiredValue = RefCountPair{2, 1}.combinedValue();
-
-    while (!refCounts.compare_exchange_weak(
-        curValue, desiredValue, std::memory_order_acq_rel))
-    {
-        RefCountPair const prev{curValue};
-        if (!prev.strong)
-            return false;
-
-        desiredValue = curValue + strongDelta;
-    }
-    return true;
-}
-
-inline bool
-IntrusiveRefCounts::expired() const noexcept
-{
-    RefCountPair const val = refCounts.load(std::memory_order_acquire);
-    return val.strong == 0;
-}
-
-inline std::size_t
-IntrusiveRefCounts::use_count() const noexcept
-{
-    RefCountPair const val = refCounts.load(std::memory_order_acquire);
-    return val.strong;
-}
-
-inline IntrusiveRefCounts::~IntrusiveRefCounts() noexcept
-{
-#ifndef NDEBUG
-    auto v = refCounts.load(std::memory_order_acquire);
-    XRPL_ASSERT(
-        (!(v & valueMask)),
-        "ripple::IntrusiveRefCounts::~IntrusiveRefCounts : count must be zero");
-    auto t = v & tagMask;
-    XRPL_ASSERT(
-        (!t || t == tagMask),
-        "ripple::IntrusiveRefCounts::~IntrusiveRefCounts : valid tag");
-#endif
-}
-
-//------------------------------------------------------------------------------
-
-inline IntrusiveRefCounts::RefCountPair::RefCountPair(
-    IntrusiveRefCounts::FieldType v) noexcept
-    : strong{static_cast<CountType>(v & strongMask)}
-    , weak{static_cast<CountType>((v & weakMask) >> StrongCountNumBits)}
-    , partialDestroyStartedBit{v & partialDestroyStartedMask}
-    , partialDestroyFinishedBit{v & partialDestroyFinishedMask}
-{
-    XRPL_ASSERT(
-        (strong < checkStrongMaxValue && weak < checkWeakMaxValue),
-        "ripple::IntrusiveRefCounts::RefCountPair(FieldType) : inputs inside "
-        "range");
-}
-
-inline IntrusiveRefCounts::RefCountPair::RefCountPair(
-    IntrusiveRefCounts::CountType s,
-    IntrusiveRefCounts::CountType w) noexcept
-    : strong{s}, weak{w}
-{
-    XRPL_ASSERT(
-        (strong < checkStrongMaxValue && weak < checkWeakMaxValue),
-        "ripple::IntrusiveRefCounts::RefCountPair(CountType, CountType) : "
-        "inputs inside range");
-}
-
-inline IntrusiveRefCounts::FieldType
-IntrusiveRefCounts::RefCountPair::combinedValue() const noexcept
-{
-    XRPL_ASSERT(
-        (strong < checkStrongMaxValue && weak < checkWeakMaxValue),
-        "ripple::IntrusiveRefCounts::RefCountPair::combinedValue : inputs "
-        "inside range");
-    return (static_cast<IntrusiveRefCounts::FieldType>(weak)
-            << IntrusiveRefCounts::StrongCountNumBits) |
-        static_cast<IntrusiveRefCounts::FieldType>(strong) |
-        partialDestroyStartedBit | partialDestroyFinishedBit;
-}
-
-template <class T>
-inline void
-partialDestructorFinished(T** o)
-{
-    T& self = **o;
-    IntrusiveRefCounts::RefCountPair p =
-        self.refCounts.fetch_or(IntrusiveRefCounts::partialDestroyFinishedMask);
-    XRPL_ASSERT(
-        (!p.partialDestroyFinishedBit && p.partialDestroyStartedBit &&
-         !p.strong),
-        "ripple::partialDestructorFinished : not a weak ref");
-    if (!p.weak)
-    {
-        // There was a weak count before the partial destructor ran (or we would
-        // have run the full destructor) and now there isn't a weak count. Some
-        // thread is waiting to run the destructor.
-        self.refCounts.notify_one();
-    }
-    // Set the pointer to null to emphasize that the object shouldn't be used
-    // after calling this function as it may be destroyed in another thread.
-    *o = nullptr;
-}
-//------------------------------------------------------------------------------
-
-}  // namespace ripple
-#endif

include/xrpl/basics/LocalValue.h

@@ -21,7 +21,6 @@
 #define RIPPLE_BASICS_LOCALVALUE_H_INCLUDED
 
 #include <boost/thread/tss.hpp>
-
 #include <memory>
 #include <unordered_map>
 

include/xrpl/basics/Log.h

@@ -22,10 +22,8 @@
 
 #include <xrpl/basics/UnorderedContainers.h>
 #include <xrpl/beast/utility/Journal.h>
-
 #include <boost/beast/core/string.hpp>
 #include <boost/filesystem.hpp>
-
 #include <fstream>
 #include <map>
 #include <memory>

include/xrpl/basics/MathUtilities.h

@@ -23,9 +23,66 @@
 #include <algorithm>
 #include <cassert>
 #include <cstddef>
+#include <cstdint>
+#include <limits>
+#include <optional>
 
 namespace ripple {
 
+/** Add two signed 64-bit integers, returning std::nullopt when the exact
+ *  mathematical sum is not representable in std::int64_t.
+ */
+[[nodiscard]] constexpr std::optional<std::int64_t>
+checkedAdd(std::int64_t a, std::int64_t b) noexcept
+{
+    using L = std::numeric_limits<std::int64_t>;
+
+    if ((b > 0 && a > L::max() - b) || (b < 0 && a < L::min() - b))
+        return std::nullopt;
+
+    return a + b;
+}
+
+/** Subtract two signed 64-bit integers, returning std::nullopt when the exact
+ *  mathematical difference is not representable in std::int64_t.
+ */
+[[nodiscard]] constexpr std::optional<std::int64_t>
+checkedSub(std::int64_t a, std::int64_t b) noexcept
+{
+    using L = std::numeric_limits<std::int64_t>;
+
+    if ((b > 0 && a < L::min() + b) || (b < 0 && a > L::max() + b))
+        return std::nullopt;
+
+    return a - b;
+}
+
+namespace detail {
+using i64_limits = std::numeric_limits<std::int64_t>;
+
+static_assert(checkedAdd(0, 0) == 0);
+static_assert(checkedAdd(1, -1) == 0);
+static_assert(checkedAdd(-5, 2) == -3);
+static_assert(!checkedAdd(i64_limits::max(), 1).has_value());
+static_assert(!checkedAdd(i64_limits::min(), -1).has_value());
+static_assert(checkedAdd(i64_limits::max() - 1, 1) == i64_limits::max());
+static_assert(checkedAdd(i64_limits::min(), i64_limits::max()) == -1);
+static_assert(checkedAdd(i64_limits::max(), i64_limits::min()) == -1);
+static_assert(!checkedAdd(i64_limits::max(), i64_limits::max()).has_value());
+static_assert(!checkedAdd(i64_limits::min(), i64_limits::min()).has_value());
+
+static_assert(checkedSub(0, 0) == 0);
+static_assert(checkedSub(1, 1) == 0);
+static_assert(checkedSub(-5, 2) == -7);
+static_assert(checkedSub(-5, -2) == -3);
+static_assert(!checkedSub(i64_limits::min(), 1).has_value());
+static_assert(!checkedSub(i64_limits::max(), -1).has_value());
+static_assert(checkedSub(i64_limits::min() + 1, 1) == i64_limits::min());
+static_assert(checkedSub(-1, i64_limits::max()) == i64_limits::min());
+static_assert(!checkedSub(i64_limits::max(), i64_limits::min()).has_value());
+static_assert(!checkedSub(i64_limits::min(), i64_limits::max()).has_value());
+}  // namespace detail
+
 /** 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

include/xrpl/basics/ReaderPreferringSharedMutex.h

@@ -0,0 +1,105 @@
+#pragma once
+
+#include <shared_mutex>
+
+// On Linux (glibc), std::shared_mutex wraps pthread_rwlock_t initialised
+// with PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP.  This means a
+// pending exclusive lock() blocks new shared (reader) acquisitions,
+// causing reader starvation when writers contend frequently.
+//
+// On macOS / ARM (libc++), std::shared_mutex is already reader-preferring,
+// so the same code behaves differently across platforms.
+//
+// This header provides ReaderPreferringSharedMutex:
+//   - On Linux it wraps pthread_rwlock_t initialised with
+//     PTHREAD_RWLOCK_PREFER_READER_NP, matching macOS semantics.
+//   - On all other platforms it is a type alias for std::shared_mutex.
+//
+// The interface is identical to std::shared_mutex, so it works with
+// std::shared_lock and std::unique_lock.
+
+#if defined(__linux__)
+
+#include <cerrno>
+#include <pthread.h>
+#include <system_error>
+
+namespace ripple {
+
+class ReaderPreferringSharedMutex
+{
+    pthread_rwlock_t rwlock_;
+
+public:
+    ReaderPreferringSharedMutex()
+    {
+        pthread_rwlockattr_t attr;
+        pthread_rwlockattr_init(&attr);
+        pthread_rwlockattr_setkind_np(&attr, PTHREAD_RWLOCK_PREFER_READER_NP);
+        int rc = pthread_rwlock_init(&rwlock_, &attr);
+        pthread_rwlockattr_destroy(&attr);
+        if (rc != 0)
+            throw std::system_error(
+                rc, std::system_category(), "pthread_rwlock_init");
+    }
+
+    ~ReaderPreferringSharedMutex()
+    {
+        pthread_rwlock_destroy(&rwlock_);
+    }
+
+    ReaderPreferringSharedMutex(ReaderPreferringSharedMutex const&) = delete;
+    ReaderPreferringSharedMutex&
+    operator=(ReaderPreferringSharedMutex const&) = delete;
+
+    // Exclusive (writer) locking
+    void
+    lock()
+    {
+        pthread_rwlock_wrlock(&rwlock_);
+    }
+
+    bool
+    try_lock()
+    {
+        return pthread_rwlock_trywrlock(&rwlock_) == 0;
+    }
+
+    void
+    unlock()
+    {
+        pthread_rwlock_unlock(&rwlock_);
+    }
+
+    // Shared (reader) locking
+    void
+    lock_shared()
+    {
+        pthread_rwlock_rdlock(&rwlock_);
+    }
+
+    bool
+    try_lock_shared()
+    {
+        return pthread_rwlock_tryrdlock(&rwlock_) == 0;
+    }
+
+    void
+    unlock_shared()
+    {
+        pthread_rwlock_unlock(&rwlock_);
+    }
+};
+
+}  // namespace ripple
+
+#else  // !__linux__
+
+namespace ripple {
+
+// macOS, Windows, etc. — std::shared_mutex is already reader-preferring.
+using ReaderPreferringSharedMutex = std::shared_mutex;
+
+}  // namespace ripple
+
+#endif

include/xrpl/basics/Resolver.h

@@ -20,11 +20,11 @@
 #ifndef RIPPLE_BASICS_RESOLVER_H_INCLUDED
 #define RIPPLE_BASICS_RESOLVER_H_INCLUDED
 
-#include <xrpl/beast/net/IPEndpoint.h>
-
 #include <functional>
 #include <vector>
 
+#include <xrpl/beast/net/IPEndpoint.h>
+
 namespace ripple {
 
 class Resolver

include/xrpl/basics/ResolverAsio.h

@@ -23,7 +23,7 @@
 #include <xrpl/basics/Resolver.h>
 #include <xrpl/beast/utility/Journal.h>
 
-#include <boost/asio/io_service.hpp>
+#include <boost/asio/io_context.hpp>
 
 namespace ripple {
 
@@ -33,7 +33,7 @@ public:
     explicit ResolverAsio() = default;
 
     static std::unique_ptr<ResolverAsio>
-    New(boost::asio::io_service&, beast::Journal);
+    New(boost::asio::io_context&, beast::Journal);
 };
 
 }  // namespace ripple

include/xrpl/basics/SHAMapHash.h

@@ -113,7 +113,7 @@ template <>
 inline std::size_t
 extract(SHAMapHash const& key)
 {
-    return *reinterpret_cast<std::size_t const*>(key.as_uint256().data());
+    return extract(key.as_uint256());
 }
 
 }  // namespace ripple

include/xrpl/basics/SharedWeakCachePointer.h

@@ -1,135 +0,0 @@
-//------------------------------------------------------------------------------
-/*
-    This file is part of rippled: https://github.com/ripple/rippled
-    Copyright (c) 2023 Ripple Labs Inc.
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose  with  or without fee is hereby granted, provided that the above
-    copyright notice and this permission notice appear in all copies.
-
-    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
-    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
-    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-*/
-//==============================================================================
-
-#ifndef RIPPLE_BASICS_SHAREDWEAKCACHEPOINTER_H_INCLUDED
-#define RIPPLE_BASICS_SHAREDWEAKCACHEPOINTER_H_INCLUDED
-
-#include <memory>
-#include <variant>
-
-namespace ripple {
-
-/** A combination of a std::shared_ptr and a std::weak_pointer.
-
-
-This class is a wrapper to a `std::variant<std::shared_ptr,std::weak_ptr>`
-This class is useful for storing intrusive pointers in tagged caches using less
-memory than storing both pointers directly.
-*/
-
-template <class T>
-class SharedWeakCachePointer
-{
-public:
-    SharedWeakCachePointer() = default;
-
-    SharedWeakCachePointer(SharedWeakCachePointer const& rhs);
-
-    template <class TT>
-        requires std::convertible_to<TT*, T*>
-    SharedWeakCachePointer(std::shared_ptr<TT> const& rhs);
-
-    SharedWeakCachePointer(SharedWeakCachePointer&& rhs);
-
-    template <class TT>
-        requires std::convertible_to<TT*, T*>
-    SharedWeakCachePointer(std::shared_ptr<TT>&& rhs);
-
-    SharedWeakCachePointer&
-    operator=(SharedWeakCachePointer const& rhs);
-
-    template <class TT>
-        requires std::convertible_to<TT*, T*>
-    SharedWeakCachePointer&
-    operator=(std::shared_ptr<TT> const& rhs);
-
-    template <class TT>
-        requires std::convertible_to<TT*, T*>
-    SharedWeakCachePointer&
-    operator=(std::shared_ptr<TT>&& rhs);
-
-    ~SharedWeakCachePointer();
-
-    /** 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)
-     */
-    std::shared_ptr<T> const&
-    getStrong() const;
-
-    /** 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.
-     */
-    void
-    reset();
-
-    /** If this is a strong pointer, return the raw pointer. Otherwise return
-        null.
-     */
-    T*
-    get() const;
-
-    /** If this is a strong pointer, return the strong count. Otherwise return 0
-     */
-    std::size_t
-    use_count() const;
-
-    /** Return true if there is a non-zero strong count. */
-    bool
-    expired() const;
-
-    /** If this is a strong pointer, return the strong pointer. Otherwise
-        attempt to lock the weak pointer.
-     */
-    std::shared_ptr<T>
-    lock() const;
-
-    /** Return true is this represents a strong pointer. */
-    bool
-    isStrong() const;
-
-    /** Return true is this represents a weak pointer. */
-    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.
-      */
-    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.
-      */
-    bool
-    convertToWeak();
-
-private:
-    std::variant<std::shared_ptr<T>, std::weak_ptr<T>> combo_;
-};
-}  // namespace ripple
-#endif

include/xrpl/basics/SharedWeakCachePointer.ipp

@@ -1,192 +0,0 @@
-//------------------------------------------------------------------------------
-/*
-    This file is part of rippled: https://github.com/ripple/rippled
-    Copyright (c) 2023 Ripple Labs Inc.
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose  with  or without fee is hereby granted, provided that the above
-    copyright notice and this permission notice appear in all copies.
-
-    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
-    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
-    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-*/
-//==============================================================================
-
-#ifndef RIPPLE_BASICS_SHAREDWEAKCACHEPOINTER_IPP_INCLUDED
-#define RIPPLE_BASICS_SHAREDWEAKCACHEPOINTER_IPP_INCLUDED
-
-#include <xrpl/basics/SharedWeakCachePointer.h>
-
-namespace ripple {
-template <class T>
-SharedWeakCachePointer<T>::SharedWeakCachePointer(
-    SharedWeakCachePointer const& rhs) = default;
-
-template <class T>
-template <class TT>
-    requires std::convertible_to<TT*, T*>
-SharedWeakCachePointer<T>::SharedWeakCachePointer(
-    std::shared_ptr<TT> const& rhs)
-    : combo_{rhs}
-{
-}
-
-template <class T>
-SharedWeakCachePointer<T>::SharedWeakCachePointer(
-    SharedWeakCachePointer&& rhs) = default;
-
-template <class T>
-template <class TT>
-    requires std::convertible_to<TT*, T*>
-SharedWeakCachePointer<T>::SharedWeakCachePointer(std::shared_ptr<TT>&& rhs)
-    : combo_{std::move(rhs)}
-{
-}
-
-template <class T>
-SharedWeakCachePointer<T>&
-SharedWeakCachePointer<T>::operator=(SharedWeakCachePointer const& rhs) =
-    default;
-
-template <class T>
-template <class TT>
-    requires std::convertible_to<TT*, T*>
-SharedWeakCachePointer<T>&
-SharedWeakCachePointer<T>::operator=(std::shared_ptr<TT> const& rhs)
-{
-    combo_ = rhs;
-    return *this;
-}
-
-template <class T>
-template <class TT>
-    requires std::convertible_to<TT*, T*>
-SharedWeakCachePointer<T>&
-SharedWeakCachePointer<T>::operator=(std::shared_ptr<TT>&& rhs)
-{
-    combo_ = std::move(rhs);
-    return *this;
-}
-
-template <class T>
-SharedWeakCachePointer<T>::~SharedWeakCachePointer() = default;
-
-// 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)
-template <class T>
-std::shared_ptr<T> const&
-SharedWeakCachePointer<T>::getStrong() const
-{
-    static std::shared_ptr<T> const empty;
-    if (auto p = std::get_if<std::shared_ptr<T>>(&combo_))
-        return *p;
-    return empty;
-}
-
-template <class T>
-SharedWeakCachePointer<T>::operator bool() const noexcept
-{
-    return !!std::get_if<std::shared_ptr<T>>(&combo_);
-}
-
-template <class T>
-void
-SharedWeakCachePointer<T>::reset()
-{
-    combo_ = std::shared_ptr<T>{};
-}
-
-template <class T>
-T*
-SharedWeakCachePointer<T>::get() const
-{
-    return std::get_if<std::shared_ptr<T>>(&combo_).get();
-}
-
-template <class T>
-std::size_t
-SharedWeakCachePointer<T>::use_count() const
-{
-    if (auto p = std::get_if<std::shared_ptr<T>>(&combo_))
-        return p->use_count();
-    return 0;
-}
-
-template <class T>
-bool
-SharedWeakCachePointer<T>::expired() const
-{
-    if (auto p = std::get_if<std::weak_ptr<T>>(&combo_))
-        return p->expired();
-    return !std::get_if<std::shared_ptr<T>>(&combo_);
-}
-
-template <class T>
-std::shared_ptr<T>
-SharedWeakCachePointer<T>::lock() const
-{
-    if (auto p = std::get_if<std::shared_ptr<T>>(&combo_))
-        return *p;
-
-    if (auto p = std::get_if<std::weak_ptr<T>>(&combo_))
-        return p->lock();
-
-    return {};
-}
-
-template <class T>
-bool
-SharedWeakCachePointer<T>::isStrong() const
-{
-    if (auto p = std::get_if<std::shared_ptr<T>>(&combo_))
-        return !!p->get();
-    return false;
-}
-
-template <class T>
-bool
-SharedWeakCachePointer<T>::isWeak() const
-{
-    return !isStrong();
-}
-
-template <class T>
-bool
-SharedWeakCachePointer<T>::convertToStrong()
-{
-    if (isStrong())
-        return true;
-
-    if (auto p = std::get_if<std::weak_ptr<T>>(&combo_))
-    {
-        if (auto s = p->lock())
-        {
-            combo_ = std::move(s);
-            return true;
-        }
-    }
-    return false;
-}
-
-template <class T>
-bool
-SharedWeakCachePointer<T>::convertToWeak()
-{
-    if (isWeak())
-        return true;
-
-    if (auto p = std::get_if<std::shared_ptr<T>>(&combo_))
-    {
-        combo_ = std::weak_ptr<T>(*p);
-        return true;
-    }
-
-    return false;
-}
-}  // namespace ripple
-#endif

include/xrpl/basics/SlabAllocator.h

@@ -21,195 +21,443 @@
 #define RIPPLE_BASICS_SLABALLOCATOR_H_INCLUDED
 
 #include <xrpl/basics/ByteUtilities.h>
-#include <xrpl/beast/type_name.h>
+#include <xrpl/basics/spinlock.h>
 #include <xrpl/beast/utility/instrumentation.h>
 
 #include <boost/align.hpp>
-#include <boost/container/static_vector.hpp>
-#include <boost/predef.h>
+#include <boost/predef/os.h>
 
-#include <algorithm>
+#include <array>
 #include <atomic>
-#include <cstdint>
-#include <cstring>
-#include <mutex>
-#include <vector>
+#include <bit>
 
-#if BOOST_OS_LINUX
+#include <limits>
+#include <new>
+
+#ifdef BOOST_OS_LINUX
 #include <sys/mman.h>
 #endif
 
 namespace ripple {
+namespace slab {
+namespace detail {
 
-template <typename Type>
-class SlabAllocator
+/// Alignment for hugepage support.
+inline constexpr std::size_t pageSize = megabytes(std::size_t(2));
+
+/** Allocate a new 2MB-aligned data buffer.
+
+    @param size Size of the buffer to allocate in bytes.
+    @return Pointer to allocated memory, or nullptr on failure.
+
+    @note On Linux, advises the kernel to back the allocation with
+          transparent huge pages if available.
+ */
+[[nodiscard, gnu::malloc]] inline std::uint8_t*
+allocateBuffer(std::size_t size) noexcept
 {
-    static_assert(
-        sizeof(Type) >= sizeof(std::uint8_t*),
-        "SlabAllocator: the requested object must be larger than a pointer.");
+    auto ptr = reinterpret_cast<std::uint8_t*>(
+        boost::alignment::aligned_alloc(pageSize, size));
 
-    static_assert(alignof(Type) == 8 || alignof(Type) == 4);
+#if BOOST_OS_LINUX
+    if (ptr != nullptr) [[likely]]
+        madvise(ptr, size, MADV_HUGEPAGE);
+#endif
 
-    /** A block of memory that is owned by a slab allocator */
-    struct SlabBlock
+    return ptr;
+}
+
+/** Deallocate a buffer previously allocated by allocateBuffer.
+
+    @param ptr Pointer to buffer, or nullptr (no-op).
+ */
+inline void
+deallocateBuffer(std::uint8_t* ptr) noexcept
+{
+    boost::alignment::aligned_free(ptr);
+}
+
+//------------------------------------------------------------------------------
+
+/** A block of memory metadata for slab allocators.
+
+    Each block manages a single slab buffer and its associated free list.
+    Blocks are linked together to form a list of slabs per allocator.
+
+    @note slab_t instances are intentionally never destroyed or reclaimed
+          once allocated, to support lock-free iteration of lists of slabs
+          without introducing ABA hazards. The data buffer the class holds
+          can be released independently.
+ */
+struct slab_t
+{
+    /** A node in the intrusive free list.
+
+        Constructed in-place within free memory blocks. The next pointer
+        is const because nodes are never modified after construction;
+        they are simply constructed anew when reused.
+     */
+    struct item_t
     {
-        // A mutex to protect the freelist for this block:
-        std::mutex m_;
+        item_t* const next;
 
-        // A linked list of appropriately sized free buffers:
-        std::uint8_t* l_ = nullptr;
-
-        // The next memory block
-        SlabBlock* next_;
-
-        // The underlying memory block:
-        std::uint8_t const* const p_ = nullptr;
-
-        // The extent of the underlying memory block:
-        std::size_t const size_;
-
-        SlabBlock(
-            SlabBlock* next,
-            std::uint8_t* data,
-            std::size_t size,
-            std::size_t item)
-            : next_(next), p_(data), size_(size)
+        constexpr explicit item_t(item_t* n) noexcept : next(n)
         {
-            // We don't need to grab the mutex here, since we're the only
-            // ones with access at this moment.
-
-            while (data + item <= p_ + size_)
-            {
-                // Use memcpy to avoid unaligned UB
-                // (will optimize to equivalent code)
-                std::memcpy(data, &l_, sizeof(std::uint8_t*));
-                l_ = data;
-                data += item;
-            }
-        }
-
-        ~SlabBlock()
-        {
-            // Calling this destructor will release the allocated memory but
-            // will not properly destroy any objects that are constructed in
-            // the block itself.
-        }
-
-        SlabBlock(SlabBlock const& other) = delete;
-        SlabBlock&
-        operator=(SlabBlock const& other) = delete;
-
-        SlabBlock(SlabBlock&& other) = delete;
-        SlabBlock&
-        operator=(SlabBlock&& other) = delete;
-
-        /** Determines whether the given pointer belongs to this allocator */
-        bool
-        own(std::uint8_t const* p) const noexcept
-        {
-            return (p >= p_) && (p < p_ + size_);
-        }
-
-        std::uint8_t*
-        allocate() noexcept
-        {
-            std::uint8_t* ret;
-
-            {
-                std::lock_guard l(m_);
-
-                ret = l_;
-
-                if (ret)
-                {
-                    // Use memcpy to avoid unaligned UB
-                    // (will optimize to equivalent code)
-                    std::memcpy(&l_, ret, sizeof(std::uint8_t*));
-                }
-            }
-
-            return ret;
-        }
-
-        /** Return an item to this allocator's freelist.
-
-            @param ptr The pointer to the chunk of memory being deallocated.
-
-            @note This is a dangerous, private interface; the item being
-                  returned should belong to this allocator. Debug builds
-                  will check and assert if this is not the case. Release
-                  builds will not.
-         */
-        void
-        deallocate(std::uint8_t* ptr) noexcept
-        {
-            XRPL_ASSERT(
-                own(ptr),
-                "ripple::SlabAllocator::SlabBlock::deallocate : own input");
-
-            std::lock_guard l(m_);
-
-            // Use memcpy to avoid unaligned UB
-            // (will optimize to equivalent code)
-            std::memcpy(ptr, &l_, sizeof(std::uint8_t*));
-            l_ = ptr;
         }
     };
 
-private:
-    // A linked list of slabs
-    std::atomic<SlabBlock*> slabs_ = nullptr;
+    // We need this to be trivially destructible so that we do not
+    // have to explicitly invoke the destructor when popping items
+    // from the free list or when deallocating the slab buffer.
+    static_assert(std::is_trivially_destructible_v<item_t>);
 
-    // The alignment requirements of the item we're allocating:
-    std::size_t const itemAlignment_;
+    item_t* head_ = nullptr;
+    slab_t* const next_ = nullptr;
+    std::atomic<std::uint8_t*> data_{nullptr};
+    std::atomic<std::uint8_t> lock_{0};
+    std::uint16_t cycles_ = 0;
+    std::uint32_t outstanding_ = 0;
 
-    // The size of an item, including the extra bytes requested and
-    // any padding needed for alignment purposes:
-    std::size_t const itemSize_;
+    /** Construct a block that is unlinked. */
+    constexpr slab_t() noexcept = default;
 
-    // The size of each individual slab:
-    std::size_t const slabSize_;
+    /** Construct a block with a link to the next block in the chain.
+
+        @param next Pointer to the next block, or nullptr for the tail.
+     */
+    constexpr explicit slab_t(slab_t* next) noexcept : next_(next)
+    {
+    }
+
+    ~slab_t() = default;
+
+    slab_t(slab_t const&) = delete;
+    slab_t&
+    operator=(slab_t const&) = delete;
+    slab_t(slab_t&&) = delete;
+    slab_t&
+    operator=(slab_t&&) = delete;
+
+    /** Attempt to acquire the block's spinlock.
+
+        @return true if lock was acquired, false if already held.
+     */
+    [[nodiscard]] bool
+    try_lock() noexcept
+    {
+        return spin_try_lock(lock_);
+    }
+
+    /** Acquire the block's spinlock, blocking until available. */
+    void
+    lock() noexcept
+    {
+        spin_lock(lock_);
+    }
+
+    /** Release the block's spinlock. */
+    void
+    unlock() noexcept
+    {
+        spin_unlock(lock_);
+    }
+
+    /** Attempt to assign a buffer to this block.
+
+        If the block has no buffer, takes ownership and initializes
+        the free list.
+
+        @param buffer Pointer to the buffer to assign.
+        @param slabSize Size of the buffer in bytes.
+        @param itemSize Size of each item in bytes.
+        @return Pointer to first item if assigned, nullptr if block already
+                has a buffer.
+     */
+    [[nodiscard]] std::uint8_t*
+    try_assign(
+        std::uint8_t* buffer,
+        std::size_t slabSize,
+        std::size_t itemSize) noexcept
+    {
+        std::uint8_t* expected = nullptr;
+
+        if (!data_.compare_exchange_strong(
+                expected, buffer, std::memory_order::acquire))
+            return nullptr;
+
+        spin_lock(lock_);
+
+        head_ = nullptr;
+        outstanding_ = 1;
+
+        auto p = buffer;
+
+        for (std::size_t n = (slabSize / itemSize) - 1; n--; p += itemSize)
+            head_ = std::construct_at(reinterpret_cast<item_t*>(p), head_);
+
+        spin_unlock(lock_);
+
+        return p;
+    }
+
+    /** Attempt to allocate from this block.
+
+        @return Pointer to allocated memory, or nullptr if block is empty.
+     */
+    [[nodiscard]] std::uint8_t*
+    try_allocate() noexcept
+    {
+        spin_lock(lock_);
+
+        auto ret = head_;
+
+        if (ret)
+        {
+            head_ = ret->next;
+            ++outstanding_;
+        }
+
+        spin_unlock(lock_);
+
+        return reinterpret_cast<std::uint8_t*>(ret);
+    }
+
+    /** Attempt to return a pointer to this block.
+
+        @param ptr Pointer to memory block.
+        @param slabSize Size of the slab's data buffer.
+        @param releaseBuffer Callback invoked with a pointer to the block's
+                             buffer so that it can be released.
+        @return true if ptr belonged to this block and was freed,
+                false otherwise.
+     */
+    template <typename ReleaseFunc>
+    [[nodiscard]] bool
+    try_deallocate(
+        std::uint8_t* ptr,
+        std::size_t slabSize,
+        ReleaseFunc&& releaseBuffer) noexcept
+    {
+        auto data = data_.load(std::memory_order::acquire);
+
+        if (!data || ptr < data || ptr >= data + slabSize)
+            return false;
+
+        std::uint8_t* buf = nullptr;
+
+        spin_lock(lock_);
+
+        assert(ptr != nullptr);
+        assert(outstanding_ > 0);
+
+        head_ = std::construct_at(reinterpret_cast<item_t*>(ptr), head_);
+
+        // If this block became empty and it is not the first block, we
+        // release its buffer. The first block (at the tail of the list
+        // with next_ == nullptr) is exempt to keep one block ready.
+        if (--outstanding_ == 0 && next_ != nullptr)
+        {
+            head_ = nullptr;
+            buf = data_.exchange(buf, std::memory_order::relaxed);
+            cycles_ += (cycles_ < std::numeric_limits<std::uint16_t>::max());
+        }
+
+        spin_unlock(lock_);
+
+        if (buf != nullptr)
+            releaseBuffer(buf);
+
+        return true;
+    }
+};
+
+//------------------------------------------------------------------------------
+
+/** Global pool of slab_t objects shared by all slab allocators.
+
+    Provides a fixed-size array of pre-allocated slabs with fallback
+    to heap allocation if exhausted.
+ */
+class slab_pool_t
+{
+    std::array<slab_t, 32768> blocks_{};
+    std::atomic<std::size_t> count_{0};
+
+public:
+    constexpr slab_pool_t() = default;
+
+    slab_pool_t(slab_pool_t const&) = delete;
+    slab_pool_t&
+    operator=(slab_pool_t const&) = delete;
+    slab_pool_t(slab_pool_t&&) = delete;
+    slab_pool_t&
+    operator=(slab_pool_t&&) = delete;
+
+    /** Acquire a slab from the pool.
+
+        @param next Pointer to link as the slab's next pointer.
+        @return Pointer to acquired block, or nullptr if allocation failed.
+     */
+    [[nodiscard]] slab_t*
+    acquire(slab_t* next) noexcept
+    {
+        auto idx = count_.load(std::memory_order::relaxed);
+
+        while (idx < blocks_.size())
+        {
+            if (count_.compare_exchange_weak(
+                    idx, idx + 1, std::memory_order::relaxed))
+            {
+                return std::construct_at(&blocks_[idx], next);
+            }
+        }
+
+        // Pool exhausted (unlikely!) so fall back to heap
+        return new (std::nothrow) slab_t(next);
+    }
+};
+
+/// Single global block pool for all slab allocators.
+inline constinit slab_pool_t globalSlabPool;
+
+}  // namespace detail
+
+//------------------------------------------------------------------------------
+
+/** A slab allocator for fixed-size memory blocks.
+
+    Allocates memory in large slabs (multiples of 2MB) and sub-allocates
+    fixed-size blocks from them. Provides fast allocation with minimal
+    fragmentation for objects of uniform size.
+
+    @tparam Type The type used to determine minimum block size and alignment.
+    @tparam Align Alignment for allocated blocks (must be >= alignof(Type)).
+ */
+template <typename Type, std::size_t Align = alignof(Type)>
+    requires(
+        sizeof(Type) >= sizeof(void*) && Align >= alignof(Type) &&
+        std::has_single_bit(Align))
+class sized_allocator_t
+{
+    /// Linked list of slabs for this allocator.
+    std::atomic<detail::slab_t*> slabs_{nullptr};
+
+    /// Cached buffer to avoid thrashing when oscillating around block
+    /// boundaries.
+    std::atomic<std::uint8_t*> cachedBuffer_{nullptr};
+
+    /// Spinlock to serialize the slow allocation path.
+    std::atomic<std::uint8_t> blockLock_{0};
+
+    /// Item size (sizeof(Type) + extra, rounded up for alignment).
+    std::size_t itemSize_;
+
+    /// Size of each slab's data buffer (multiple of 2 MB).
+    std::size_t slabSize_;
+
+    /** Allocate a memory block from the existing slabs.
+
+        Fast path allocation that doesn't acquire the global lock.
+
+        @return Pointer to allocated memory, or nullptr if all slabs are full.
+     */
+    [[nodiscard]] std::uint8_t*
+    fast_allocate() noexcept
+    {
+        for (auto slab = slabs_.load(std::memory_order::acquire); slab;
+             slab = slab->next_)
+        {
+            if (auto ret = slab->try_allocate())
+                return ret;
+        }
+
+        return nullptr;
+    }
+
+    /** Allocate a memory block, potentially creating new capacity.
+
+        Slow path allocation that may allocate a new buffer or slab.
+        Must be called with blockLock_ held.
+
+        @return Pointer to allocated memory, or nullptr on failure.
+     */
+    [[nodiscard]] std::uint8_t*
+    slow_allocate() noexcept
+    {
+        if (auto ret = fast_allocate())
+            return ret;
+
+        // Use a cached buffer first, if we have one, or allocate memory
+        // from the operating system.
+        auto buf = cachedBuffer_.exchange(nullptr, std::memory_order::acquire);
+
+        if (!buf)
+            buf = detail::allocateBuffer(slabSize_);
+
+        if (!buf) [[unlikely]]
+            return nullptr;
+
+        // Try to give buffer to an existing empty slab
+        for (auto slab = slabs_.load(std::memory_order::acquire); slab;
+             slab = slab->next_)
+        {
+            if (auto ret = slab->try_assign(buf, slabSize_, itemSize_))
+                return ret;
+        }
+
+        // Create new slab from global pool
+        auto* slab = detail::globalSlabPool.acquire(
+            slabs_.load(std::memory_order::relaxed));
+
+        if (!slab) [[unlikely]]
+        {
+            detail::deallocateBuffer(buf);
+            return nullptr;
+        }
+
+        auto ret = slab->try_assign(buf, slabSize_, itemSize_);
+        assert(ret);
+
+        // Link the new slab. Since we hold the lock, we can just do a
+        // direct assignment here.
+        slabs_.store(slab, std::memory_order::release);
+
+        return ret;
+    }
 
 public:
     /** Constructs a slab allocator able to allocate objects of a fixed size
 
-        @param count the number of items the slab allocator can allocate; note
-                     that a count of 0 is valid and means that the allocator
-                     is, effectively, disabled. This can be very useful in some
-                     contexts (e.g. when mimimal memory usage is needed) and
-                     allows for graceful failure.
+        @param extra Extra bytes per item beyond sizeof(Type).
+        @param minItems Minimum number of items per slab (rounded up to 2MB).
      */
-    constexpr explicit SlabAllocator(
+    constexpr explicit sized_allocator_t(
         std::size_t extra,
-        std::size_t alloc = 0,
-        std::size_t align = 0)
-        : itemAlignment_(align ? align : alignof(Type))
-        , itemSize_(
-              boost::alignment::align_up(sizeof(Type) + extra, itemAlignment_))
-        , slabSize_(alloc)
+        std::size_t minItems)
+        : itemSize_(boost::alignment::align_up(sizeof(Type) + extra, Align))
+        , slabSize_(boost::alignment::align_up(
+              itemSize_ * minItems,
+              detail::pageSize))
     {
-        XRPL_ASSERT(
-            (itemAlignment_ & (itemAlignment_ - 1)) == 0,
-            "ripple::SlabAllocator::SlabAllocator : valid alignment");
     }
 
-    SlabAllocator(SlabAllocator const& other) = delete;
-    SlabAllocator&
-    operator=(SlabAllocator const& other) = delete;
+    // Data buffers are intentionally not released. C++ destruction order
+    // does not guarantee that all items allocated from this allocator
+    // have been freed by the time this destructor runs.
+    ~sized_allocator_t() = default;
 
-    SlabAllocator(SlabAllocator&& other) = delete;
-    SlabAllocator&
-    operator=(SlabAllocator&& other) = delete;
+    sized_allocator_t(sized_allocator_t const&) = delete;
+    sized_allocator_t&
+    operator=(sized_allocator_t const&) = delete;
+    sized_allocator_t(sized_allocator_t&&) = delete;
+    sized_allocator_t&
+    operator=(sized_allocator_t&&) = delete;
 
-    ~SlabAllocator()
-    {
-        // FIXME: We can't destroy the memory blocks we've allocated, because
-        //        we can't be sure that they are not being used. Cleaning the
-        //        shutdown process up could make this possible.
-    }
+    /** Returns the size of memory blocks returned by this allocator.
 
-    /** Returns the size of the memory block this allocator returns. */
-    constexpr std::size_t
+        @return Size of each allocated block in bytes.
+     */
+    [[nodiscard]] constexpr std::size_t
     size() const noexcept
     {
         return itemSize_;
@@ -217,87 +465,36 @@ public:
 
     /** Returns a suitably aligned pointer, if one is available.
 
-        @return a pointer to a block of memory from the allocator, or
-                nullptr if the allocator can't satisfy this request.
+        @return Pointer to allocated memory, or nullptr on failure.
+
+        @note The gnu::malloc attribute is an optimization hint that can
+              be leveraged by GCC and Clang.
      */
-    std::uint8_t*
+    [[nodiscard, gnu::malloc]] std::uint8_t*
     allocate() noexcept
     {
-        auto slab = slabs_.load();
+        // Fast path: try existing slabs
+        auto ret = fast_allocate();
 
-        while (slab != nullptr)
+        if (ret == nullptr)
         {
-            if (auto ret = slab->allocate())
-                return ret;
-
-            slab = slab->next_;
+            // Slow path: need new capacity. Grab the lock to serialize access
+            // to this code path because it is expensive. Then re-check in case
+            // another thread added capacity while we waited.
+            spin_lock(blockLock_);
+            ret = slow_allocate();
+            spin_unlock(blockLock_);
         }
 
-        // No slab can satisfy our request, so we attempt to allocate a new
-        // one here:
-        std::size_t size = slabSize_;
-
-        // We want to allocate the memory at a 2 MiB boundary, to make it
-        // possible to use hugepage mappings on Linux:
-        auto buf =
-            boost::alignment::aligned_alloc(megabytes(std::size_t(2)), size);
-
-        // clang-format off
-        if (!buf) [[unlikely]]
-            return nullptr;
-            // clang-format on
-
-#if BOOST_OS_LINUX
-        // When allocating large blocks, attempt to leverage Linux's
-        // transparent hugepage support. It is unclear and difficult
-        // to accurately determine if doing this impacts performance
-        // enough to justify using platform-specific tricks.
-        if (size >= megabytes(std::size_t(4)))
-            madvise(buf, size, MADV_HUGEPAGE);
-#endif
-
-        // We need to carve out a bit of memory for the slab header
-        // and then align the rest appropriately:
-        auto slabData = reinterpret_cast<void*>(
-            reinterpret_cast<std::uint8_t*>(buf) + sizeof(SlabBlock));
-        auto slabSize = size - sizeof(SlabBlock);
-
-        // This operation is essentially guaranteed not to fail but
-        // let's be careful anyways.
-        if (!boost::alignment::align(
-                itemAlignment_, itemSize_, slabData, slabSize))
-        {
-            boost::alignment::aligned_free(buf);
-            return nullptr;
-        }
-
-        slab = new (buf) SlabBlock(
-            slabs_.load(),
-            reinterpret_cast<std::uint8_t*>(slabData),
-            slabSize,
-            itemSize_);
-
-        // Link the new slab
-        while (!slabs_.compare_exchange_weak(
-            slab->next_,
-            slab,
-            std::memory_order_release,
-            std::memory_order_relaxed))
-        {
-            ;  // Nothing to do
-        }
-
-        return slab->allocate();
+        return ret;
     }
 
     /** Returns the memory block to the allocator.
 
-        @param ptr A pointer to a memory block.
-        @param size If non-zero, a hint as to the size of the block.
-        @return true if this memory block belonged to the allocator and has
-                     been released; false otherwise.
+        @param ptr Pointer to memory block.
+        @return true if the block belonged to this allocator and was freed.
      */
-    bool
+    [[nodiscard]] bool
     deallocate(std::uint8_t* ptr) noexcept
     {
         XRPL_ASSERT(
@@ -305,112 +502,135 @@ public:
             "ripple::SlabAllocator::SlabAllocator::deallocate : non-null "
             "input");
 
-        for (auto slab = slabs_.load(); slab != nullptr; slab = slab->next_)
+        auto release = [this](std::uint8_t* buf) {
+            std::uint8_t* expected = nullptr;
+
+            if (buf != nullptr &&
+                !cachedBuffer_.compare_exchange_strong(
+                    expected, buf, std::memory_order::release))
+                detail::deallocateBuffer(buf);
+        };
+
+        for (auto slab = slabs_.load(std::memory_order::acquire); slab;
+             slab = slab->next_)
         {
-            if (slab->own(ptr))
-            {
-                slab->deallocate(ptr);
+            if (slab->try_deallocate(ptr, slabSize_, release))
                 return true;
-            }
         }
 
         return false;
     }
 };
 
-/** A collection of slab allocators of various sizes for a given type. */
-template <typename Type>
-class SlabAllocatorSet
+//------------------------------------------------------------------------------
+
+/** Configuration for a single slab allocator.
+
+    @tparam MinItems Minimum number of items per slab (must be > 0).
+    @tparam Extra Extra bytes per item beyond sizeof(Type).
+ */
+template <std::size_t MinItems, std::size_t Extra = 0>
+    requires(MinItems > 0)
+struct config
 {
-private:
-    // The list of allocators that belong to this set
-    boost::container::static_vector<SlabAllocator<Type>, 64> allocators_;
+    static constexpr std::size_t minItems = MinItems;
+    static constexpr std::size_t extra = Extra;
+};
 
-    std::size_t maxSize_ = 0;
+/** Concept for valid slab configuration types. */
+template <typename T>
+concept SlabConfig = requires {
+    { T::minItems } -> std::convertible_to<std::size_t>;
+    { T::extra } -> std::convertible_to<std::size_t>;
+    requires T::minItems > 0;
+};
 
-public:
-    class SlabConfig
-    {
-        friend class SlabAllocatorSet;
+/** Validate slab configurations at compile time.
 
-    private:
-        std::size_t extra;
-        std::size_t alloc;
-        std::size_t align;
+    Checks that configurations produce strictly increasing sizes after
+    alignment. This catches both unsorted configs and configs that
+    collapse to the same size after alignment.
 
-    public:
-        constexpr SlabConfig(
-            std::size_t extra_,
-            std::size_t alloc_ = 0,
-            std::size_t align_ = alignof(Type))
-            : extra(extra_), alloc(alloc_), align(align_)
-        {
-        }
+    @tparam Type The type used to determine base size.
+    @tparam Align Alignment for allocated blocks.
+    @tparam Configs Configuration types to validate.
+    @return true if configurations are valid, false otherwise.
+ */
+template <typename Type, std::size_t Align, SlabConfig... Configs>
+consteval bool
+validate_slab_config()
+{
+    constexpr auto align_up = [](std::size_t n, std::size_t a) {
+        return (n + a - 1) & ~(a - 1);
     };
 
-    constexpr SlabAllocatorSet(std::vector<SlabConfig> cfg)
-    {
-        // Ensure that the specified allocators are sorted from smallest to
-        // largest by size:
-        std::sort(
-            std::begin(cfg),
-            std::end(cfg),
-            [](SlabConfig const& a, SlabConfig const& b) {
-                return a.extra < b.extra;
-            });
+    constexpr std::array<std::size_t, sizeof...(Configs)> sizes{
+        align_up(sizeof(Type) + Configs::extra, Align)...};
 
-        // We should never have two slabs of the same size
-        if (std::adjacent_find(
-                std::begin(cfg),
-                std::end(cfg),
-                [](SlabConfig const& a, SlabConfig const& b) {
-                    return a.extra == b.extra;
-                }) != cfg.end())
-        {
-            throw std::runtime_error(
-                "SlabAllocatorSet<" + beast::type_name<Type>() +
-                ">: duplicate slab size");
-        }
+    for (std::size_t i = 1; i < sizes.size(); ++i)
+        if (sizes[i - 1] >= sizes[i])
+            return false;
 
-        for (auto const& c : cfg)
-        {
-            auto& a = allocators_.emplace_back(c.extra, c.alloc, c.align);
+    return true;
+}
 
-            if (a.size() > maxSize_)
-                maxSize_ = a.size();
-        }
-    }
+//------------------------------------------------------------------------------
 
-    SlabAllocatorSet(SlabAllocatorSet const& other) = delete;
-    SlabAllocatorSet&
-    operator=(SlabAllocatorSet const& other) = delete;
+/** A collection of slab allocators for different sizes.
 
-    SlabAllocatorSet(SlabAllocatorSet&& other) = delete;
-    SlabAllocatorSet&
-    operator=(SlabAllocatorSet&& other) = delete;
+    Manages multiple sized_allocator_t instances, each configured for a
+    different block size. Allocations are routed to the smallest allocator
+    that can satisfy the request.
 
-    ~SlabAllocatorSet()
+    @tparam Type The type used to determine minimum block size and alignment.
+    @tparam Align Alignment for allocated blocks (must be >= alignof(Type)).
+    @tparam Configs Configuration types specifying each size class.
+ */
+template <typename Type, std::size_t Align, SlabConfig... Configs>
+    requires(
+        sizeof(Type) >= sizeof(void*) && Align >= alignof(Type) &&
+        std::has_single_bit(Align) && sizeof...(Configs) > 0 &&
+        validate_slab_config<Type, Align, Configs...>())
+class aligned_allocator_t
+{
+    std::array<sized_allocator_t<Type, Align>, sizeof...(Configs)> allocators_;
+
+public:
+    /** Construct an allocator set. */
+    constexpr aligned_allocator_t()
+        : allocators_{sized_allocator_t<Type, Align>(
+              Configs::extra,
+              Configs::minItems)...}
     {
     }
 
-    /** Returns a suitably aligned pointer, if one is available.
+    ~aligned_allocator_t() = default;
 
-        @param extra The number of extra bytes, above and beyond the size of
-                     the object, that should be returned by the allocator.
+    aligned_allocator_t(aligned_allocator_t const&) = delete;
+    aligned_allocator_t&
+    operator=(aligned_allocator_t const&) = delete;
+    aligned_allocator_t(aligned_allocator_t&&) = delete;
+    aligned_allocator_t&
+    operator=(aligned_allocator_t&&) = delete;
 
-        @return a pointer to a block of memory, or nullptr if the allocator
-                can't satisfy this request.
+    /** Allocate memory for an object with extra bytes.
+
+        @param extra Extra bytes needed beyond sizeof(Type).
+        @return Pointer to memory, or nullptr if no suitable allocator
+                or allocation failed.
+
+        @note The gnu::malloc attribute is an optimization hint that can
+              be leveraged by GCC and Clang.
      */
-    std::uint8_t*
+    [[nodiscard, gnu::malloc]] std::uint8_t*
     allocate(std::size_t extra) noexcept
     {
-        if (auto const size = sizeof(Type) + extra; size <= maxSize_)
+        auto const size = sizeof(Type) + extra;
+
+        for (auto& a : allocators_)
         {
-            for (auto& a : allocators_)
-            {
-                if (a.size() >= size)
-                    return a.allocate();
-            }
+            if (a.size() >= size)
+                return a.allocate();
         }
 
         return nullptr;
@@ -418,12 +638,10 @@ public:
 
     /** Returns the memory block to the allocator.
 
-        @param ptr A pointer to a memory block.
-
-        @return true if this memory block belonged to one of the allocators
-                     in this set and has been released; false otherwise.
+        @param ptr Pointer to memory block.
+        @return true if memory belonged to this set and was freed.
      */
-    bool
+    [[nodiscard]] bool
     deallocate(std::uint8_t* ptr) noexcept
     {
         for (auto& a : allocators_)
@@ -431,11 +649,16 @@ public:
             if (a.deallocate(ptr))
                 return true;
         }
-
         return false;
     }
 };
 
+/** Alias for aligned_allocator_t with default alignment. */
+template <typename Type, SlabConfig... Configs>
+using allocator_t = aligned_allocator_t<Type, alignof(Type), Configs...>;
+
+}  // namespace slab
+
 }  // namespace ripple
 
 #endif  // RIPPLE_BASICS_SLABALLOCATOR_H_INCLUDED

include/xrpl/basics/Slice.h

@@ -23,7 +23,6 @@
 #include <xrpl/basics/contract.h>
 #include <xrpl/basics/strHex.h>
 #include <xrpl/beast/utility/instrumentation.h>
-
 #include <algorithm>
 #include <array>
 #include <cstdint>

include/xrpl/basics/StringUtilities.h

@@ -77,7 +77,7 @@ strUnHex(std::size_t strSize, Iterator begin, Iterator end)
 
     if (strSize & 1)
     {
-        int c = unxtab[*iter++];
+        int c = unxtab[static_cast<unsigned char>(*iter++)];
 
         if (c < 0)
             return {};
@@ -87,12 +87,12 @@ strUnHex(std::size_t strSize, Iterator begin, Iterator end)
 
     while (iter != end)
     {
-        int cHigh = unxtab[*iter++];
+        int cHigh = unxtab[static_cast<unsigned char>(*iter++)];
 
         if (cHigh < 0)
             return {};
 
-        int cLow = unxtab[*iter++];
+        int cLow = unxtab[static_cast<unsigned char>(*iter++)];
 
         if (cLow < 0)
             return {};

include/xrpl/basics/TaggedCache.h

@@ -20,14 +20,11 @@
 #ifndef RIPPLE_BASICS_TAGGEDCACHE_H_INCLUDED
 #define RIPPLE_BASICS_TAGGEDCACHE_H_INCLUDED
 
-#include <xrpl/basics/IntrusivePointer.h>
 #include <xrpl/basics/Log.h>
-#include <xrpl/basics/SharedWeakCachePointer.ipp>
 #include <xrpl/basics/UnorderedContainers.h>
 #include <xrpl/basics/hardened_hash.h>
 #include <xrpl/beast/clock/abstract_clock.h>
 #include <xrpl/beast/insight/Insight.h>
-
 #include <atomic>
 #include <functional>
 #include <mutex>
@@ -53,8 +50,6 @@ template <
     class Key,
     class T,
     bool IsKeyCache = false,
-    class SharedWeakUnionPointerType = SharedWeakCachePointer<T>,
-    class SharedPointerType = std::shared_ptr<T>,
     class Hash = hardened_hash<>,
     class KeyEqual = std::equal_to<Key>,
     class Mutex = std::recursive_mutex>
@@ -65,8 +60,6 @@ public:
     using key_type = Key;
     using mapped_type = T;
     using clock_type = beast::abstract_clock<std::chrono::steady_clock>;
-    using shared_weak_combo_pointer_type = SharedWeakUnionPointerType;
-    using shared_pointer_type = SharedPointerType;
 
 public:
     TaggedCache(
@@ -76,48 +69,231 @@ public:
         clock_type& clock,
         beast::Journal journal,
         beast::insight::Collector::ptr const& collector =
-            beast::insight::NullCollector::New());
+            beast::insight::NullCollector::New())
+        : m_journal(journal)
+        , m_clock(clock)
+        , m_stats(
+              name,
+              std::bind(&TaggedCache::collect_metrics, this),
+              collector)
+        , m_name(name)
+        , m_target_size(size)
+        , m_target_age(expiration)
+        , m_cache_count(0)
+        , m_hits(0)
+        , m_misses(0)
+    {
+    }
 
 public:
     /** Return the clock associated with the cache. */
     clock_type&
-    clock();
+    clock()
+    {
+        return m_clock;
+    }
 
     /** Returns the number of items in the container. */
     std::size_t
-    size() const;
+    size() const
+    {
+        std::lock_guard lock(m_mutex);
+        return m_cache.size();
+    }
+
+    void
+    setTargetSize(int s)
+    {
+        std::lock_guard lock(m_mutex);
+        m_target_size = s;
+
+        if (s > 0)
+        {
+            for (auto& partition : m_cache.map())
+            {
+                partition.rehash(static_cast<std::size_t>(
+                    (s + (s >> 2)) /
+                        (partition.max_load_factor() * m_cache.partitions()) +
+                    1));
+            }
+        }
+
+        JLOG(m_journal.debug()) << m_name << " target size set to " << s;
+    }
+
+    clock_type::duration
+    getTargetAge() const
+    {
+        std::lock_guard lock(m_mutex);
+        return m_target_age;
+    }
+
+    void
+    setTargetAge(clock_type::duration s)
+    {
+        std::lock_guard lock(m_mutex);
+        m_target_age = s;
+        JLOG(m_journal.debug())
+            << m_name << " target age set to " << m_target_age.count();
+    }
 
     int
-    getCacheSize() const;
+    getCacheSize() const
+    {
+        std::lock_guard lock(m_mutex);
+        return m_cache_count;
+    }
 
     int
-    getTrackSize() const;
+    getTrackSize() const
+    {
+        std::lock_guard lock(m_mutex);
+        return m_cache.size();
+    }
 
     float
-    getHitRate();
+    getHitRate()
+    {
+        std::lock_guard lock(m_mutex);
+        auto const total = static_cast<float>(m_hits + m_misses);
+        return m_hits * (100.0f / std::max(1.0f, total));
+    }
 
     void
-    clear();
+    clear()
+    {
+        std::lock_guard lock(m_mutex);
+        m_cache.clear();
+        m_cache_count = 0;
+    }
 
     void
-    reset();
+    reset()
+    {
+        std::lock_guard lock(m_mutex);
+        m_cache.clear();
+        m_cache_count = 0;
+        m_hits = 0;
+        m_misses = 0;
+    }
 
     /** Refresh the last access time on a key if present.
         @return `true` If the key was found.
     */
     template <class KeyComparable>
     bool
-    touch_if_exists(KeyComparable const& key);
+    touch_if_exists(KeyComparable const& key)
+    {
+        std::lock_guard lock(m_mutex);
+        auto const iter(m_cache.find(key));
+        if (iter == m_cache.end())
+        {
+            ++m_stats.misses;
+            return false;
+        }
+        iter->second.touch(m_clock.now());
+        ++m_stats.hits;
+        return true;
+    }
 
-    using SweptPointersVector = std::vector<SharedWeakUnionPointerType>;
+    using SweptPointersVector = std::pair<
+        std::vector<std::shared_ptr<mapped_type>>,
+        std::vector<std::weak_ptr<mapped_type>>>;
 
     void
-    sweep();
+    sweep()
+    {
+        // Keep references to all the stuff we sweep
+        // For performance, each worker thread should exit before the swept data
+        // is destroyed but still within the main cache lock.
+        std::vector<SweptPointersVector> allStuffToSweep(m_cache.partitions());
+
+        clock_type::time_point const now(m_clock.now());
+        clock_type::time_point when_expire;
+
+        auto const start = std::chrono::steady_clock::now();
+        {
+            std::lock_guard lock(m_mutex);
+
+            if (m_target_size == 0 ||
+                (static_cast<int>(m_cache.size()) <= m_target_size))
+            {
+                when_expire = now - m_target_age;
+            }
+            else
+            {
+                when_expire =
+                    now - m_target_age * m_target_size / m_cache.size();
+
+                clock_type::duration const minimumAge(std::chrono::seconds(1));
+                if (when_expire > (now - minimumAge))
+                    when_expire = now - minimumAge;
+
+                JLOG(m_journal.trace())
+                    << m_name << " is growing fast " << m_cache.size() << " of "
+                    << m_target_size << " aging at "
+                    << (now - when_expire).count() << " of "
+                    << m_target_age.count();
+            }
+
+            std::vector<std::thread> workers;
+            workers.reserve(m_cache.partitions());
+            std::atomic<int> allRemovals = 0;
+
+            for (std::size_t p = 0; p < m_cache.partitions(); ++p)
+            {
+                workers.push_back(sweepHelper(
+                    when_expire,
+                    now,
+                    m_cache.map()[p],
+                    allStuffToSweep[p],
+                    allRemovals,
+                    lock));
+            }
+            for (std::thread& worker : workers)
+                worker.join();
+
+            m_cache_count -= allRemovals;
+        }
+        // At this point allStuffToSweep will go out of scope outside the lock
+        // and decrement the reference count on each strong pointer.
+        JLOG(m_journal.debug())
+            << m_name << " TaggedCache sweep lock duration "
+            << std::chrono::duration_cast<std::chrono::milliseconds>(
+                   std::chrono::steady_clock::now() - start)
+                   .count()
+            << "ms";
+    }
 
     bool
-    del(key_type const& key, bool valid);
+    del(const key_type& key, bool valid)
+    {
+        // Remove from cache, if !valid, remove from map too. Returns true if
+        // removed from cache
+        std::lock_guard lock(m_mutex);
+
+        auto cit = m_cache.find(key);
+
+        if (cit == m_cache.end())
+            return false;
+
+        Entry& entry = cit->second;
+
+        bool ret = false;
+
+        if (entry.isCached())
+        {
+            --m_cache_count;
+            entry.ptr.reset();
+            ret = true;
+        }
+
+        if (!valid || entry.isExpired())
+            m_cache.erase(cit);
+
+        return ret;
+    }
 
-public:
     /** Replace aliased objects with originals.
 
         Due to concurrency it is possible for two separate objects with
@@ -131,23 +307,100 @@ public:
 
         @return `true` If the key already existed.
     */
-    template <class R>
+public:
     bool
     canonicalize(
-        key_type const& key,
-        SharedPointerType& data,
-        R&& replaceCallback);
+        const key_type& key,
+        std::shared_ptr<T>& data,
+        std::function<bool(std::shared_ptr<T> const&)>&& replace)
+    {
+        // Return canonical value, store if needed, refresh in cache
+        // Return values: true=we had the data already
+        std::lock_guard lock(m_mutex);
+
+        auto cit = m_cache.find(key);
+
+        if (cit == m_cache.end())
+        {
+            m_cache.emplace(
+                std::piecewise_construct,
+                std::forward_as_tuple(key),
+                std::forward_as_tuple(m_clock.now(), data));
+            ++m_cache_count;
+            return false;
+        }
+
+        Entry& entry = cit->second;
+        entry.touch(m_clock.now());
+
+        if (entry.isCached())
+        {
+            if (replace(entry.ptr))
+            {
+                entry.ptr = data;
+                entry.weak_ptr = data;
+            }
+            else
+            {
+                data = entry.ptr;
+            }
+
+            return true;
+        }
+
+        auto cachedData = entry.lock();
+
+        if (cachedData)
+        {
+            if (replace(entry.ptr))
+            {
+                entry.ptr = data;
+                entry.weak_ptr = data;
+            }
+            else
+            {
+                entry.ptr = cachedData;
+                data = cachedData;
+            }
+
+            ++m_cache_count;
+            return true;
+        }
+
+        entry.ptr = data;
+        entry.weak_ptr = data;
+        ++m_cache_count;
+
+        return false;
+    }
 
     bool
     canonicalize_replace_cache(
-        key_type const& key,
-        SharedPointerType const& data);
+        const key_type& key,
+        std::shared_ptr<T> const& data)
+    {
+        return canonicalize(
+            key,
+            const_cast<std::shared_ptr<T>&>(data),
+            [](std::shared_ptr<T> const&) { return true; });
+    }
 
     bool
-    canonicalize_replace_client(key_type const& key, SharedPointerType& data);
+    canonicalize_replace_client(const key_type& key, std::shared_ptr<T>& data)
+    {
+        return canonicalize(
+            key, data, [](std::shared_ptr<T> const&) { return false; });
+    }
 
-    SharedPointerType
-    fetch(key_type const& key);
+    std::shared_ptr<T>
+    fetch(const key_type& key)
+    {
+        std::lock_guard<mutex_type> l(m_mutex);
+        auto ret = initialFetch(key, l);
+        if (!ret)
+            ++m_misses;
+        return ret;
+    }
 
     /** Insert the element into the container.
         If the key already exists, nothing happens.
@@ -156,11 +409,26 @@ public:
     template <class ReturnType = bool>
     auto
     insert(key_type const& key, T const& value)
-        -> std::enable_if_t<!IsKeyCache, ReturnType>;
+        -> std::enable_if_t<!IsKeyCache, ReturnType>
+    {
+        auto p = std::make_shared<T>(std::cref(value));
+        return canonicalize_replace_client(key, p);
+    }
 
     template <class ReturnType = bool>
     auto
-    insert(key_type const& key) -> std::enable_if_t<IsKeyCache, ReturnType>;
+    insert(key_type const& key) -> std::enable_if_t<IsKeyCache, ReturnType>
+    {
+        std::lock_guard lock(m_mutex);
+        clock_type::time_point const now(m_clock.now());
+        auto [it, inserted] = m_cache.emplace(
+            std::piecewise_construct,
+            std::forward_as_tuple(key),
+            std::forward_as_tuple(now));
+        if (!inserted)
+            it->second.last_access = now;
+        return inserted;
+    }
 
     // VFALCO NOTE It looks like this returns a copy of the data in
     //             the output parameter 'data'. This could be expensive.
@@ -168,18 +436,50 @@ public:
     //             simply return an iterator.
     //
     bool
-    retrieve(key_type const& key, T& data);
+    retrieve(const key_type& key, T& data)
+    {
+        // retrieve the value of the stored data
+        auto entry = fetch(key);
+
+        if (!entry)
+            return false;
+
+        data = *entry;
+        return true;
+    }
 
     mutex_type&
-    peekMutex();
+    peekMutex()
+    {
+        return m_mutex;
+    }
 
     std::vector<key_type>
-    getKeys() const;
+    getKeys() const
+    {
+        std::vector<key_type> v;
+
+        {
+            std::lock_guard lock(m_mutex);
+            v.reserve(m_cache.size());
+            for (auto const& _ : m_cache)
+                v.push_back(_.first);
+        }
+
+        return v;
+    }
 
     // CachedSLEs functions.
     /** Returns the fraction of cache hits. */
     double
-    rate() const;
+    rate() const
+    {
+        std::lock_guard lock(m_mutex);
+        auto const tot = m_hits + m_misses;
+        if (tot == 0)
+            return 0;
+        return double(m_hits) / tot;
+    }
 
     /** Fetch an item from the cache.
         If the digest was not found, Handler
@@ -187,16 +487,73 @@ public:
             std::shared_ptr<SLE const>(void)
     */
     template <class Handler>
-    SharedPointerType
-    fetch(key_type const& digest, Handler const& h);
+    std::shared_ptr<T>
+    fetch(key_type const& digest, Handler const& h)
+    {
+        {
+            std::lock_guard l(m_mutex);
+            if (auto ret = initialFetch(digest, l))
+                return ret;
+        }
+
+        auto sle = h();
+        if (!sle)
+            return {};
+
+        std::lock_guard l(m_mutex);
+        ++m_misses;
+        auto const [it, inserted] =
+            m_cache.emplace(digest, Entry(m_clock.now(), std::move(sle)));
+        if (!inserted)
+            it->second.touch(m_clock.now());
+        return it->second.ptr;
+    }
     // End CachedSLEs functions.
 
 private:
-    SharedPointerType
-    initialFetch(key_type const& key, std::lock_guard<mutex_type> const& l);
+    std::shared_ptr<T>
+    initialFetch(key_type const& key, std::lock_guard<mutex_type> const& l)
+    {
+        auto cit = m_cache.find(key);
+        if (cit == m_cache.end())
+            return {};
+
+        Entry& entry = cit->second;
+        if (entry.isCached())
+        {
+            ++m_hits;
+            entry.touch(m_clock.now());
+            return entry.ptr;
+        }
+        entry.ptr = entry.lock();
+        if (entry.isCached())
+        {
+            // independent of cache size, so not counted as a hit
+            ++m_cache_count;
+            entry.touch(m_clock.now());
+            return entry.ptr;
+        }
+
+        m_cache.erase(cit);
+        return {};
+    }
 
     void
-    collect_metrics();
+    collect_metrics()
+    {
+        m_stats.size.set(getCacheSize());
+
+        {
+            beast::insight::Gauge::value_type hit_rate(0);
+            {
+                std::lock_guard lock(m_mutex);
+                auto const total(m_hits + m_misses);
+                if (total != 0)
+                    hit_rate = (m_hits * 100) / total;
+            }
+            m_stats.hit_rate.set(hit_rate);
+        }
+    }
 
 private:
     struct Stats
@@ -242,37 +599,36 @@ private:
     class ValueEntry
     {
     public:
-        shared_weak_combo_pointer_type ptr;
+        std::shared_ptr<mapped_type> ptr;
+        std::weak_ptr<mapped_type> weak_ptr;
         clock_type::time_point last_access;
 
         ValueEntry(
             clock_type::time_point const& last_access_,
-            shared_pointer_type const& ptr_)
-            : ptr(ptr_), last_access(last_access_)
+            std::shared_ptr<mapped_type> const& ptr_)
+            : ptr(ptr_), weak_ptr(ptr_), last_access(last_access_)
         {
         }
 
         bool
         isWeak() const
         {
-            if (!ptr)
-                return true;
-            return ptr.isWeak();
+            return ptr == nullptr;
         }
         bool
         isCached() const
         {
-            return ptr && ptr.isStrong();
+            return ptr != nullptr;
         }
         bool
         isExpired() const
         {
-            return ptr.expired();
+            return weak_ptr.expired();
         }
-        SharedPointerType
+        std::shared_ptr<mapped_type>
         lock()
         {
-            return ptr.lock();
+            return weak_ptr.lock();
         }
         void
         touch(clock_type::time_point const& now)
@@ -301,7 +657,72 @@ private:
         typename KeyValueCacheType::map_type& partition,
         SweptPointersVector& stuffToSweep,
         std::atomic<int>& allRemovals,
-        std::lock_guard<std::recursive_mutex> const&);
+        std::lock_guard<std::recursive_mutex> const&)
+    {
+        return std::thread([&, this]() {
+            int cacheRemovals = 0;
+            int mapRemovals = 0;
+
+            // Keep references to all the stuff we sweep
+            // so that we can destroy them outside the lock.
+            stuffToSweep.first.reserve(partition.size());
+            stuffToSweep.second.reserve(partition.size());
+            {
+                auto cit = partition.begin();
+                while (cit != partition.end())
+                {
+                    if (cit->second.isWeak())
+                    {
+                        // weak
+                        if (cit->second.isExpired())
+                        {
+                            stuffToSweep.second.push_back(
+                                std::move(cit->second.weak_ptr));
+                            ++mapRemovals;
+                            cit = partition.erase(cit);
+                        }
+                        else
+                        {
+                            ++cit;
+                        }
+                    }
+                    else if (cit->second.last_access <= when_expire)
+                    {
+                        // strong, expired
+                        ++cacheRemovals;
+                        if (cit->second.ptr.use_count() == 1)
+                        {
+                            stuffToSweep.first.push_back(
+                                std::move(cit->second.ptr));
+                            ++mapRemovals;
+                            cit = partition.erase(cit);
+                        }
+                        else
+                        {
+                            // remains weakly cached
+                            cit->second.ptr.reset();
+                            ++cit;
+                        }
+                    }
+                    else
+                    {
+                        // strong, not expired
+                        ++cit;
+                    }
+                }
+            }
+
+            if (mapRemovals || cacheRemovals)
+            {
+                JLOG(m_journal.debug())
+                    << "TaggedCache partition sweep " << m_name
+                    << ": cache = " << partition.size() << "-" << cacheRemovals
+                    << ", map-=" << mapRemovals;
+            }
+
+            allRemovals += cacheRemovals;
+        });
+    }
 
     [[nodiscard]] std::thread
     sweepHelper(
@@ -310,7 +731,45 @@ private:
         typename KeyOnlyCacheType::map_type& partition,
         SweptPointersVector&,
         std::atomic<int>& allRemovals,
-        std::lock_guard<std::recursive_mutex> const&);
+        std::lock_guard<std::recursive_mutex> const&)
+    {
+        return std::thread([&, this]() {
+            int cacheRemovals = 0;
+            int mapRemovals = 0;
+
+            // Keep references to all the stuff we sweep
+            // so that we can destroy them outside the lock.
+            {
+                auto cit = partition.begin();
+                while (cit != partition.end())
+                {
+                    if (cit->second.last_access > now)
+                    {
+                        cit->second.last_access = now;
+                        ++cit;
+                    }
+                    else if (cit->second.last_access <= when_expire)
+                    {
+                        cit = partition.erase(cit);
+                    }
+                    else
+                    {
+                        ++cit;
+                    }
+                }
+            }
+
+            if (mapRemovals || cacheRemovals)
+            {
+                JLOG(m_journal.debug())
+                    << "TaggedCache partition sweep " << m_name
+                    << ": cache = " << partition.size() << "-" << cacheRemovals
+                    << ", map-=" << mapRemovals;
+            }
+
+            allRemovals += cacheRemovals;
+        });
+    };
 
     beast::Journal m_journal;
     clock_type& m_clock;
@@ -322,10 +781,10 @@ private:
     std::string m_name;
 
     // Desired number of cache entries (0 = ignore)
-    int const m_target_size;
+    int m_target_size;
 
     // Desired maximum cache age
-    clock_type::duration const m_target_age;
+    clock_type::duration m_target_age;
 
     // Number of items cached
     int m_cache_count;

include/xrpl/basics/UTF8.h

@@ -0,0 +1,60 @@
+//------------------------------------------------------------------------------
+/*
+    This file is part of rippled: https://github.com/ripple/rippled
+    Copyright (c) 2025 XRPL Labs
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose  with  or without fee is hereby granted, provided that the above
+    copyright notice and this permission notice appear in all copies.
+
+    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
+    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
+    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+//==============================================================================
+
+#ifndef RIPPLE_BASICS_UTF8_H_INCLUDED
+#define RIPPLE_BASICS_UTF8_H_INCLUDED
+
+#include <xrpl/basics/Slice.h>
+
+namespace ripple {
+
+/** Check that a byte sequence is well-formed UTF-8, excluding the two
+    noncharacters U+FFFE and U+FFFF.
+
+    Rejects:
+      - overlong encodings;
+      - UTF-16 surrogate halves (U+D800..U+DFFF);
+      - scalar values above U+10FFFF, and 0xF5..0xFF lead bytes;
+      - stray continuation bytes;
+      - multi-byte sequences truncated by the end of the buffer;
+      - U+FFFE and U+FFFF (EF BF BE, EF BF BF).
+
+    U+FFFE and U+FFFF are well-formed, but have no use in a URI or a name
+    and exist to be misread: U+FFFE is a byte-swapped BOM, so a client that
+    transcodes to UTF-16/32 and sniffs the byte order can be pushed into
+    decoding the rest of the string with the wrong endianness, and both are
+    commonly used as in-band sentinels. They have always been rejected by
+    URIToken and HookName validation, and this function preserves that.
+
+    This is consensus-critical. For every input the previous decoder could
+    evaluate without reading past the end of the buffer, the result is
+    identical to it. The only difference is that truncated trailing
+    sequences, where the previous decoder read out of bounds, are now always
+    rejected. Any further change to what this accepts needs an amendment.
+
+    @param s The bytes to check.
+
+    @note Total: every byte read is within s.
+*/
+bool
+isValidUTF8(Slice const& s) noexcept;
+
+}  // namespace ripple
+
+#endif

include/xrpl/basics/UnorderedContainers.h

@@ -25,7 +25,6 @@
 #include <xrpl/beast/hash/hash_append.h>
 #include <xrpl/beast/hash/uhash.h>
 #include <xrpl/beast/hash/xxhasher.h>
-
 #include <unordered_map>
 #include <unordered_set>
 

include/xrpl/basics/chrono.h

@@ -20,16 +20,17 @@
 #ifndef RIPPLE_BASICS_CHRONO_H_INCLUDED
 #define RIPPLE_BASICS_CHRONO_H_INCLUDED
 
+#include <date/date.h>
+
 #include <xrpl/beast/clock/abstract_clock.h>
 #include <xrpl/beast/clock/basic_seconds_clock.h>
 #include <xrpl/beast/clock/manual_clock.h>
 
-#include <date/date.h>
-
 #include <chrono>
 #include <cstdint>
 #include <ratio>
 #include <string>
+#include <type_traits>
 
 namespace ripple {
 

include/xrpl/basics/comparators.h

@@ -43,7 +43,7 @@ struct less
     using result_type = bool;
 
     constexpr bool
-    operator()(T const& left, T const& right) const
+    operator()(const T& left, const T& right) const
     {
         return std::less<T>()(left, right);
     }
@@ -55,7 +55,7 @@ struct equal_to
     using result_type = bool;
 
     constexpr bool
-    operator()(T const& left, T const& right) const
+    operator()(const T& left, const T& right) const
     {
         return std::equal_to<T>()(left, right);
     }

include/xrpl/basics/contract.h

@@ -21,9 +21,10 @@
 #define RIPPLE_BASICS_CONTRACT_H_INCLUDED
 
 #include <xrpl/beast/type_name.h>
-
 #include <exception>
 #include <string>
+#include <type_traits>
+#include <typeinfo>
 #include <utility>
 
 namespace ripple {
@@ -52,7 +53,7 @@ Rethrow()
 }
 
 template <class E, class... Args>
-[[noreturn]] inline void
+[[noreturn]] constexpr void
 Throw(Args&&... args)
 {
     static_assert(
@@ -60,10 +61,15 @@ Throw(Args&&... args)
         "Exception must derive from std::exception.");
 
     E e(std::forward<Args>(args)...);
-    LogThrow(
-        std::string(
-            "Throwing exception of type " + beast::type_name<E>() + ": ") +
-        e.what());
+
+    // Skip logging when evaluated at compile time, so that `Throw` can be
+    // called from constexpr/consteval functions.
+    if (!std::is_constant_evaluated())
+        LogThrow(
+            std::string(
+                "Throwing exception of type " + beast::type_name<E>() + ": ") +
+            e.what());
+
     throw e;
 }
 

include/xrpl/basics/make_SSLContext.h

@@ -21,7 +21,6 @@
 #define RIPPLE_BASICS_MAKE_SSLCONTEXT_H_INCLUDED
 
 #include <boost/asio/ssl/context.hpp>
-
 #include <string>
 
 namespace ripple {

include/xrpl/basics/partitioned_unordered_map.h

@@ -22,7 +22,6 @@
 
 #include <xrpl/beast/hash/uhash.h>
 #include <xrpl/beast/utility/instrumentation.h>
-
 #include <functional>
 #include <optional>
 #include <string>
@@ -52,7 +51,7 @@ template <
     typename Value,
     typename Hash,
     typename Pred = std::equal_to<Key>,
-    typename Alloc = std::allocator<std::pair<Key const, Value>>>
+    typename Alloc = std::allocator<std::pair<const Key, Value>>>
 class partitioned_unordered_map
 {
     std::size_t partitions_;

include/xrpl/basics/random.h

@@ -22,9 +22,9 @@
 
 #include <xrpl/beast/utility/instrumentation.h>
 #include <xrpl/beast/xor_shift_engine.h>
-
 #include <cstddef>
 #include <cstdint>
+#include <cstring>
 #include <limits>
 #include <mutex>
 #include <random>

include/xrpl/basics/spinlock.h

@@ -19,8 +19,8 @@
 #define RIPPLE_BASICS_SPINLOCK_H_INCLUDED
 
 #include <xrpl/beast/utility/instrumentation.h>
-
 #include <atomic>
+#include <concepts>
 #include <limits>
 #include <type_traits>
 
@@ -31,6 +31,7 @@
 namespace ripple {
 
 namespace detail {
+
 /** Inform the processor that we are in a tight spin-wait loop.
 
     Spinlocks caught in tight loops can result in the processor's pipeline
@@ -53,11 +54,130 @@ spin_pause() noexcept
 
 }  // namespace detail
 
-/** @{ */
-/** Classes to handle arrays of spinlocks packed into a single atomic integer:
+/** Attempt to acquire a spinlock without blocking.
 
-    Packed spinlocks allow for tremendously space-efficient lock-sharding
-    but they come at a cost.
+    @tparam T An unsigned integral type.
+    @param lock The atomic variable used as the lock.
+    @return true if the lock was acquired, false if it was already held.
+ */
+template <typename T>
+    requires(std::is_unsigned_v<T> && std::atomic<T>::is_always_lock_free)
+[[nodiscard]] bool
+spin_try_lock(std::atomic<T>& lock) noexcept
+{
+    T expected = 0;
+
+    return lock.compare_exchange_strong(
+        expected,
+        std::numeric_limits<T>::max(),
+        std::memory_order::acquire,
+        std::memory_order::relaxed);
+}
+
+/** Acquire a spinlock, blocking until available.
+
+    Uses a TTAS (test-and-test-and-set) pattern to reduce cache coherency
+    traffic during contention.
+
+    @tparam T An unsigned integral type.
+    @param lock The atomic variable used as the lock.
+ */
+template <typename T>
+    requires(std::is_unsigned_v<T> && std::atomic<T>::is_always_lock_free)
+void
+spin_lock(std::atomic<T>& lock) noexcept
+{
+    T expected = 0;
+
+    while (!lock.compare_exchange_weak(
+        expected,
+        std::numeric_limits<T>::max(),
+        std::memory_order::acquire,
+        std::memory_order::relaxed))
+    {
+        expected = 0;
+
+        while (lock.load(std::memory_order::relaxed) != 0)
+            detail::spin_pause();
+    }
+}
+
+/** Release a spinlock.
+
+    @tparam T An unsigned integral type.
+    @param lock The atomic variable used as the lock.
+ */
+template <typename T>
+    requires(std::is_unsigned_v<T> && std::atomic<T>::is_always_lock_free)
+void
+spin_unlock(std::atomic<T>& lock) noexcept
+{
+    lock.store(0, std::memory_order::release);
+}
+
+//------------------------------------------------------------------------------
+
+/** A Lockable interface to a spinlock implemented on top of an atomic.
+
+    @tparam T An unsigned integral type.
+
+    @note Using `packed_spinlock` and `spinlock` against the same underlying
+          atomic integer can result in `spinlock` not being able to actually
+          acquire the lock during periods of high contention, because of how
+          the two locks operate: `spinlock` will spin trying to grab all the
+          bits at once, whereas any given `packed_spinlock` will only try to
+          grab one bit at a time. Caveat emptor.
+
+    This class meets the requirements of Lockable:
+        https://en.cppreference.com/w/cpp/named_req/Lockable
+ */
+template <typename T>
+    requires(std::is_unsigned_v<T> && std::atomic<T>::is_always_lock_free)
+class spinlock
+{
+    std::atomic<T>& lock_;
+
+public:
+    spinlock(spinlock const&) = delete;
+    spinlock&
+    operator=(spinlock const&) = delete;
+
+    /** Construct a spinlock handle.
+
+        @param lock The atomic integer to spin against.
+
+        @note For performance reasons, you should strive to have `lock` be
+              on a cacheline by itself.
+     */
+    explicit spinlock(std::atomic<T>& lock) noexcept : lock_(lock)
+    {
+    }
+
+    [[nodiscard]] bool
+    try_lock() noexcept
+    {
+        return spin_try_lock(lock_);
+    }
+
+    void
+    lock() noexcept
+    {
+        spin_lock(lock_);
+    }
+
+    void
+    unlock() noexcept
+    {
+        spin_unlock(lock_);
+    }
+};
+
+//------------------------------------------------------------------------------
+
+/** A Lockable interface to a packed spinlock implemented on top of an atomic.
+
+    Packed spinlocks offer tremendous space-efficient lock-sharding but
+    they come at a cost.
 
     First, the implementation is necessarily low-level and uses advanced
     features like memory ordering and highly platform-specific tricks to
@@ -79,26 +199,19 @@ spin_pause() noexcept
     that it can, usually, outperform spinlocks.
 
     @tparam T An unsigned integral type (e.g. std::uint16_t)
- */
-
-/** A class that grabs a single packed spinlock from an atomic integer.
 
     This class meets the requirements of Lockable:
         https://en.cppreference.com/w/cpp/named_req/Lockable
  */
-template <class T>
+template <typename T>
+    requires(
+        std::is_unsigned_v<T> && std::atomic<T>::is_always_lock_free &&
+        requires(std::atomic<T>& a, T v) {
+            { a.fetch_or(v) } -> std::same_as<T>;
+            { a.fetch_and(v) } -> std::same_as<T>;
+        })
 class packed_spinlock
 {
-    // clang-format off
-    static_assert(std::is_unsigned_v<T>);
-    static_assert(std::atomic<T>::is_always_lock_free);
-    static_assert(
-        std::is_same_v<decltype(std::declval<std::atomic<T>&>().fetch_or(0)), T> &&
-        std::is_same_v<decltype(std::declval<std::atomic<T>&>().fetch_and(0)), T>,
-        "std::atomic<T>::fetch_and(T) and std::atomic<T>::fetch_and(T) are required by packed_spinlock");
-    // clang-format on
-
-private:
     std::atomic<T>& bits_;
     T const mask_;
 
@@ -115,7 +228,7 @@ public:
         @note For performance reasons, you should strive to have `lock` be
               on a cacheline by itself.
      */
-    packed_spinlock(std::atomic<T>& lock, int index)
+    packed_spinlock(std::atomic<T>& lock, int index) noexcept
         : bits_(lock), mask_(static_cast<T>(1) << index)
     {
         XRPL_ASSERT(
@@ -124,13 +237,13 @@ public:
     }
 
     [[nodiscard]] bool
-    try_lock()
+    try_lock() noexcept
     {
-        return (bits_.fetch_or(mask_, std::memory_order_acquire) & mask_) == 0;
+        return (bits_.fetch_or(mask_, std::memory_order::acquire) & mask_) == 0;
     }
 
     void
-    lock()
+    lock() noexcept
     {
         while (!try_lock())
         {
@@ -138,89 +251,18 @@ public:
             // serves to help reduce cache coherency traffic during times
             // of contention by avoiding writes that would definitely not
             // result in the lock being acquired.
-            while ((bits_.load(std::memory_order_relaxed) & mask_) != 0)
+            while ((bits_.load(std::memory_order::relaxed) & mask_) != 0)
                 detail::spin_pause();
         }
     }
 
     void
-    unlock()
+    unlock() noexcept
     {
-        bits_.fetch_and(~mask_, std::memory_order_release);
+        bits_.fetch_and(~mask_, std::memory_order::release);
     }
 };
 
-/** A spinlock implemented on top of an atomic integer.
-
-    @note Using `packed_spinlock` and `spinlock` against the same underlying
-          atomic integer can result in `spinlock` not being able to actually
-          acquire the lock during periods of high contention, because of how
-          the two locks operate: `spinlock` will spin trying to grab all the
-          bits at once, whereas any given `packed_spinlock` will only try to
-          grab one bit at a time. Caveat emptor.
-
-    This class meets the requirements of Lockable:
-        https://en.cppreference.com/w/cpp/named_req/Lockable
- */
-template <class T>
-class spinlock
-{
-    static_assert(std::is_unsigned_v<T>);
-    static_assert(std::atomic<T>::is_always_lock_free);
-
-private:
-    std::atomic<T>& lock_;
-
-public:
-    spinlock(spinlock const&) = delete;
-    spinlock&
-    operator=(spinlock const&) = delete;
-
-    /** Grabs the
-
-        @param lock The atomic integer to spin against.
-
-        @note For performance reasons, you should strive to have `lock` be
-              on a cacheline by itself.
-     */
-    spinlock(std::atomic<T>& lock) : lock_(lock)
-    {
-    }
-
-    [[nodiscard]] bool
-    try_lock()
-    {
-        T expected = 0;
-
-        return lock_.compare_exchange_weak(
-            expected,
-            std::numeric_limits<T>::max(),
-            std::memory_order_acquire,
-            std::memory_order_relaxed);
-    }
-
-    void
-    lock()
-    {
-        while (!try_lock())
-        {
-            // The use of relaxed memory ordering here is intentional and
-            // serves to help reduce cache coherency traffic during times
-            // of contention by avoiding writes that would definitely not
-            // result in the lock being acquired.
-            while (lock_.load(std::memory_order_relaxed) != 0)
-                detail::spin_pause();
-        }
-    }
-
-    void
-    unlock()
-    {
-        lock_.store(0, std::memory_order_release);
-    }
-};
-/** @} */
-
 }  // namespace ripple
 
 #endif

include/xrpl/basics/tagged_integer.h

@@ -21,9 +21,7 @@
 #define BEAST_UTILITY_TAGGED_INTEGER_H_INCLUDED
 
 #include <xrpl/beast/hash/hash_append.h>
-
 #include <boost/operators.hpp>
-
 #include <functional>
 #include <iostream>
 #include <type_traits>
@@ -76,13 +74,13 @@ public:
     }
 
     bool
-    operator<(tagged_integer const& rhs) const noexcept
+    operator<(const tagged_integer& rhs) const noexcept
     {
         return m_value < rhs.m_value;
     }
 
     bool
-    operator==(tagged_integer const& rhs) const noexcept
+    operator==(const tagged_integer& rhs) const noexcept
     {
         return m_value == rhs.m_value;
     }
@@ -144,14 +142,14 @@ public:
     }
 
     tagged_integer&
-    operator<<=(tagged_integer const& rhs) noexcept
+    operator<<=(const tagged_integer& rhs) noexcept
     {
         m_value <<= rhs.m_value;
         return *this;
     }
 
     tagged_integer&
-    operator>>=(tagged_integer const& rhs) noexcept
+    operator>>=(const tagged_integer& rhs) noexcept
     {
         m_value >>= rhs.m_value;
         return *this;

include/xrpl/beast/asio/io_latency_probe.h

@@ -21,9 +21,9 @@
 #define BEAST_ASIO_IO_LATENCY_PROBE_H_INCLUDED
 
 #include <xrpl/beast/utility/instrumentation.h>
-
 #include <boost/asio/basic_waitable_timer.hpp>
-#include <boost/asio/io_service.hpp>
+#include <boost/asio/io_context.hpp>
+#include <boost/asio/post.hpp>
 
 #include <chrono>
 #include <condition_variable>
@@ -32,7 +32,7 @@
 
 namespace beast {
 
-/** Measures handler latency on an io_service queue. */
+/** Measures handler latency on an io_context queue. */
 template <class Clock>
 class io_latency_probe
 {
@@ -44,12 +44,12 @@ private:
     std::condition_variable_any m_cond;
     std::size_t m_count;
     duration const m_period;
-    boost::asio::io_service& m_ios;
+    boost::asio::io_context& m_ios;
     boost::asio::basic_waitable_timer<std::chrono::steady_clock> m_timer;
     bool m_cancel;
 
 public:
-    io_latency_probe(duration const& period, boost::asio::io_service& ios)
+    io_latency_probe(duration const& period, boost::asio::io_context& ios)
         : m_count(1)
         , m_period(period)
         , m_ios(ios)
@@ -64,16 +64,16 @@ public:
         cancel(lock, true);
     }
 
-    /** Return the io_service associated with the latency probe. */
+    /** Return the io_context associated with the latency probe. */
     /** @{ */
-    boost::asio::io_service&
-    get_io_service()
+    boost::asio::io_context&
+    get_io_context()
     {
         return m_ios;
     }
 
-    boost::asio::io_service const&
-    get_io_service() const
+    boost::asio::io_context const&
+    get_io_context() const
     {
         return m_ios;
     }
@@ -109,8 +109,10 @@ public:
         std::lock_guard lock(m_mutex);
         if (m_cancel)
             throw std::logic_error("io_latency_probe is canceled");
-        m_ios.post(sample_op<Handler>(
-            std::forward<Handler>(handler), Clock::now(), false, this));
+        boost::asio::post(
+            m_ios,
+            sample_op<Handler>(
+                std::forward<Handler>(handler), Clock::now(), false, this));
     }
 
     /** Initiate continuous i/o latency sampling.
@@ -124,8 +126,10 @@ public:
         std::lock_guard lock(m_mutex);
         if (m_cancel)
             throw std::logic_error("io_latency_probe is canceled");
-        m_ios.post(sample_op<Handler>(
-            std::forward<Handler>(handler), Clock::now(), true, this));
+        boost::asio::post(
+            m_ios,
+            sample_op<Handler>(
+                std::forward<Handler>(handler), Clock::now(), true, this));
     }
 
 private:
@@ -236,12 +240,13 @@ private:
                     // The latency is too high to maintain the desired
                     // period so don't bother with a timer.
                     //
-                    m_probe->m_ios.post(
+                    boost::asio::post(
+                        m_probe->m_ios,
                         sample_op<Handler>(m_handler, now, m_repeat, m_probe));
                 }
                 else
                 {
-                    m_probe->m_timer.expires_from_now(when - now);
+                    m_probe->m_timer.expires_after(when - now);
                     m_probe->m_timer.async_wait(
                         sample_op<Handler>(m_handler, now, m_repeat, m_probe));
                 }
@@ -254,7 +259,8 @@ private:
             if (!m_probe)
                 return;
             typename Clock::time_point const now(Clock::now());
-            m_probe->m_ios.post(
+            boost::asio::post(
+                m_probe->m_ios,
                 sample_op<Handler>(m_handler, now, m_repeat, m_probe));
         }
     };

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

@@ -25,11 +25,9 @@
 #include <xrpl/beast/container/detail/aged_associative_container.h>
 #include <xrpl/beast/container/detail/aged_container_iterator.h>
 #include <xrpl/beast/container/detail/empty_base_optimization.h>
-
 #include <boost/intrusive/list.hpp>
 #include <boost/intrusive/set.hpp>
 #include <boost/version.hpp>
-
 #include <algorithm>
 #include <functional>
 #include <initializer_list>

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

@@ -25,10 +25,8 @@
 #include <xrpl/beast/container/detail/aged_associative_container.h>
 #include <xrpl/beast/container/detail/aged_container_iterator.h>
 #include <xrpl/beast/container/detail/empty_base_optimization.h>
-
 #include <boost/intrusive/list.hpp>
 #include <boost/intrusive/unordered_set.hpp>
-
 #include <algorithm>
 #include <cmath>
 #include <functional>

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

@@ -11,7 +11,6 @@
 #define BEAST_CONTAINER_DETAIL_EMPTY_BASE_OPTIMIZATION_H_INCLUDED
 
 #include <boost/type_traits/is_final.hpp>
-
 #include <type_traits>
 #include <utility>
 

include/xrpl/beast/core/LexicalCast.h

@@ -23,7 +23,6 @@
 #include <xrpl/beast/utility/instrumentation.h>
 
 #include <boost/core/detail/string_view.hpp>
-
 #include <algorithm>
 #include <cerrno>
 #include <charconv>

include/xrpl/beast/core/List.h

@@ -21,6 +21,7 @@
 #define BEAST_INTRUSIVE_LIST_H_INCLUDED
 
 #include <iterator>
+#include <type_traits>
 
 namespace beast {
 

include/xrpl/beast/core/LockFreeStack.h

@@ -1,307 +0,0 @@
-//------------------------------------------------------------------------------
-/*
-    This file is part of Beast: https://github.com/vinniefalco/Beast
-    Copyright 2013, Vinnie Falco <vinnie.falco@gmail.com>
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose  with  or without fee is hereby granted, provided that the above
-    copyright notice and this permission notice appear in all copies.
-
-    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
-    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
-    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-*/
-//==============================================================================
-
-#ifndef BEAST_INTRUSIVE_LOCKFREESTACK_H_INCLUDED
-#define BEAST_INTRUSIVE_LOCKFREESTACK_H_INCLUDED
-
-#include <atomic>
-#include <iterator>
-#include <type_traits>
-
-namespace beast {
-
-//------------------------------------------------------------------------------
-
-template <class Container, bool IsConst>
-class LockFreeStackIterator
-{
-protected:
-    using Node = typename Container::Node;
-    using NodePtr =
-        typename std::conditional<IsConst, Node const*, Node*>::type;
-
-public:
-    using iterator_category = std::forward_iterator_tag;
-    using value_type = typename Container::value_type;
-    using difference_type = typename Container::difference_type;
-    using pointer = typename std::conditional<
-        IsConst,
-        typename Container::const_pointer,
-        typename Container::pointer>::type;
-    using reference = typename std::conditional<
-        IsConst,
-        typename Container::const_reference,
-        typename Container::reference>::type;
-
-    LockFreeStackIterator() : m_node()
-    {
-    }
-
-    LockFreeStackIterator(NodePtr node) : m_node(node)
-    {
-    }
-
-    template <bool OtherIsConst>
-    explicit LockFreeStackIterator(
-        LockFreeStackIterator<Container, OtherIsConst> const& other)
-        : m_node(other.m_node)
-    {
-    }
-
-    LockFreeStackIterator&
-    operator=(NodePtr node)
-    {
-        m_node = node;
-        return static_cast<LockFreeStackIterator&>(*this);
-    }
-
-    LockFreeStackIterator&
-    operator++()
-    {
-        m_node = m_node->m_next.load();
-        return static_cast<LockFreeStackIterator&>(*this);
-    }
-
-    LockFreeStackIterator
-    operator++(int)
-    {
-        LockFreeStackIterator result(*this);
-        m_node = m_node->m_next;
-        return result;
-    }
-
-    NodePtr
-    node() const
-    {
-        return m_node;
-    }
-
-    reference
-    operator*() const
-    {
-        return *this->operator->();
-    }
-
-    pointer
-    operator->() const
-    {
-        return static_cast<pointer>(m_node);
-    }
-
-private:
-    NodePtr m_node;
-};
-
-//------------------------------------------------------------------------------
-
-template <class Container, bool LhsIsConst, bool RhsIsConst>
-bool
-operator==(
-    LockFreeStackIterator<Container, LhsIsConst> const& lhs,
-    LockFreeStackIterator<Container, RhsIsConst> const& rhs)
-{
-    return lhs.node() == rhs.node();
-}
-
-template <class Container, bool LhsIsConst, bool RhsIsConst>
-bool
-operator!=(
-    LockFreeStackIterator<Container, LhsIsConst> const& lhs,
-    LockFreeStackIterator<Container, RhsIsConst> const& rhs)
-{
-    return lhs.node() != rhs.node();
-}
-
-//------------------------------------------------------------------------------
-
-/** Multiple Producer, Multiple Consumer (MPMC) intrusive stack.
-
-    This stack is implemented using the same intrusive interface as List.
-    All mutations are lock-free.
-
-    The caller is responsible for preventing the "ABA" problem:
-        http://en.wikipedia.org/wiki/ABA_problem
-
-    @param Tag  A type name used to distinguish lists and nodes, for
-                putting objects in multiple lists. If this parameter is
-                omitted, the default tag is used.
-*/
-template <class Element, class Tag = void>
-class LockFreeStack
-{
-public:
-    class Node
-    {
-    public:
-        Node() : m_next(nullptr)
-        {
-        }
-
-        explicit Node(Node* next) : m_next(next)
-        {
-        }
-
-        Node(Node const&) = delete;
-        Node&
-        operator=(Node const&) = delete;
-
-    private:
-        friend class LockFreeStack;
-
-        template <class Container, bool IsConst>
-        friend class LockFreeStackIterator;
-
-        std::atomic<Node*> m_next;
-    };
-
-public:
-    using value_type = Element;
-    using pointer = Element*;
-    using reference = Element&;
-    using const_pointer = Element const*;
-    using const_reference = Element const&;
-    using size_type = std::size_t;
-    using difference_type = std::ptrdiff_t;
-    using iterator = LockFreeStackIterator<LockFreeStack<Element, Tag>, false>;
-    using const_iterator =
-        LockFreeStackIterator<LockFreeStack<Element, Tag>, true>;
-
-    LockFreeStack() : m_end(nullptr), m_head(&m_end)
-    {
-    }
-
-    LockFreeStack(LockFreeStack const&) = delete;
-    LockFreeStack&
-    operator=(LockFreeStack const&) = delete;
-
-    /** Returns true if the stack is empty. */
-    bool
-    empty() const
-    {
-        return m_head.load() == &m_end;
-    }
-
-    /** Push a node onto the stack.
-        The caller is responsible for preventing the ABA problem.
-        This operation is lock-free.
-        Thread safety:
-            Safe to call from any thread.
-
-        @param node The node to push.
-
-        @return `true` if the stack was previously empty. If multiple threads
-                are attempting to push, only one will receive `true`.
-    */
-    // VFALCO NOTE Fix this, shouldn't it be a reference like intrusive list?
-    bool
-    push_front(Node* node)
-    {
-        bool first;
-        Node* old_head = m_head.load(std::memory_order_relaxed);
-        do
-        {
-            first = (old_head == &m_end);
-            node->m_next = old_head;
-        } while (!m_head.compare_exchange_strong(
-            old_head,
-            node,
-            std::memory_order_release,
-            std::memory_order_relaxed));
-        return first;
-    }
-
-    /** Pop an element off the stack.
-        The caller is responsible for preventing the ABA problem.
-        This operation is lock-free.
-        Thread safety:
-            Safe to call from any thread.
-
-        @return The element that was popped, or `nullptr` if the stack
-                was empty.
-    */
-    Element*
-    pop_front()
-    {
-        Node* node = m_head.load();
-        Node* new_head;
-        do
-        {
-            if (node == &m_end)
-                return nullptr;
-            new_head = node->m_next.load();
-        } while (!m_head.compare_exchange_strong(
-            node,
-            new_head,
-            std::memory_order_release,
-            std::memory_order_relaxed));
-        return static_cast<Element*>(node);
-    }
-
-    /** Return a forward iterator to the beginning or end of the stack.
-        Undefined behavior results if push_front or pop_front is called
-        while an iteration is in progress.
-        Thread safety:
-            Caller is responsible for synchronization.
-    */
-    /** @{ */
-    iterator
-    begin()
-    {
-        return iterator(m_head.load());
-    }
-
-    iterator
-    end()
-    {
-        return iterator(&m_end);
-    }
-
-    const_iterator
-    begin() const
-    {
-        return const_iterator(m_head.load());
-    }
-
-    const_iterator
-    end() const
-    {
-        return const_iterator(&m_end);
-    }
-
-    const_iterator
-    cbegin() const
-    {
-        return const_iterator(m_head.load());
-    }
-
-    const_iterator
-    cend() const
-    {
-        return const_iterator(&m_end);
-    }
-    /** @} */
-
-private:
-    Node m_end;
-    std::atomic<Node*> m_head;
-};
-
-}  // namespace beast
-
-#endif

include/xrpl/beast/hash/hash_append.h

@@ -23,7 +23,6 @@
 
 #include <boost/container/flat_set.hpp>
 #include <boost/endian/conversion.hpp>
-
 #include <array>
 #include <chrono>
 #include <cstdint>

include/xrpl/beast/hash/uhash.h

@@ -30,7 +30,7 @@ namespace beast {
 template <class Hasher = xxhasher>
 struct uhash
 {
-    uhash() = default;
+    explicit uhash() = default;
 
     using result_type = typename Hasher::result_type;
 

include/xrpl/beast/hash/xxhasher.h

@@ -21,7 +21,6 @@
 #define BEAST_HASH_XXHASHER_H_INCLUDED
 
 #include <boost/endian/conversion.hpp>
-
 #include <xxhash.h>
 
 #include <cstddef>

include/xrpl/beast/insight/Meter.h

@@ -20,10 +20,10 @@
 #ifndef BEAST_INSIGHT_METER_H_INCLUDED
 #define BEAST_INSIGHT_METER_H_INCLUDED
 
-#include <xrpl/beast/insight/MeterImpl.h>
-
 #include <memory>
 
+#include <xrpl/beast/insight/MeterImpl.h>
+
 namespace beast {
 namespace insight {
 

include/xrpl/beast/insight/StatsDCollector.h

@@ -21,6 +21,7 @@
 #define BEAST_INSIGHT_STATSDCOLLECTOR_H_INCLUDED
 
 #include <xrpl/beast/insight/Collector.h>
+
 #include <xrpl/beast/net/IPEndpoint.h>
 #include <xrpl/beast/utility/Journal.h>
 

include/xrpl/beast/net/IPAddress.h

@@ -25,10 +25,8 @@
 #include <xrpl/beast/net/IPAddressV4.h>
 #include <xrpl/beast/net/IPAddressV6.h>
 #include <xrpl/beast/utility/instrumentation.h>
-
 #include <boost/asio/ip/address.hpp>
 #include <boost/functional/hash.hpp>
-
 #include <cstdint>
 #include <ios>
 #include <sstream>

include/xrpl/beast/net/IPAddressConversion.h

@@ -22,6 +22,8 @@
 
 #include <xrpl/beast/net/IPEndpoint.h>
 
+#include <sstream>
+
 #include <boost/asio.hpp>
 
 namespace beast {

include/xrpl/beast/net/IPAddressV4.h

@@ -21,9 +21,7 @@
 #define BEAST_NET_IPADDRESSV4_H_INCLUDED
 
 #include <xrpl/beast/hash/hash_append.h>
-
 #include <boost/asio/ip/address_v4.hpp>
-
 #include <cstdint>
 #include <functional>
 #include <ios>

include/xrpl/beast/net/IPAddressV6.h

@@ -21,9 +21,7 @@
 #define BEAST_NET_IPADDRESSV6_H_INCLUDED
 
 #include <xrpl/beast/utility/instrumentation.h>
-
 #include <boost/asio/ip/address_v6.hpp>
-
 #include <cstdint>
 #include <functional>
 #include <ios>

include/xrpl/beast/net/IPEndpoint.h

@@ -215,7 +215,7 @@ namespace std {
 template <>
 struct hash<::beast::IP::Endpoint>
 {
-    hash() = default;
+    explicit hash() = default;
 
     std::size_t
     operator()(::beast::IP::Endpoint const& endpoint) const
@@ -230,7 +230,7 @@ namespace boost {
 template <>
 struct hash<::beast::IP::Endpoint>
 {
-    hash() = default;
+    explicit hash() = default;
 
     std::size_t
     operator()(::beast::IP::Endpoint const& endpoint) const

include/xrpl/beast/rfc2616.h

@@ -20,6 +20,10 @@
 #ifndef BEAST_RFC2616_HPP
 #define BEAST_RFC2616_HPP
 
+// TODO: This include <cstdint> is a workaround for beast compilation bug.
+// Remove when fix https://github.com/boostorg/beast/pull/2682/ is available.
+#include <cstdint>
+
 #include <boost/beast/http/message.hpp>
 #include <boost/beast/http/rfc7230.hpp>
 #include <boost/range/algorithm/equal.hpp>
@@ -28,7 +32,6 @@
 
 #include <algorithm>
 #include <cctype>
-#include <cstdint>
 #include <iterator>
 #include <string>
 #include <utility>

include/xrpl/beast/test/yield_to.h

@@ -8,9 +8,11 @@
 #ifndef BEAST_TEST_YIELD_TO_HPP
 #define BEAST_TEST_YIELD_TO_HPP
 
-#include <boost/asio/io_service.hpp>
+#include <boost/asio/executor_work_guard.hpp>
+#include <boost/asio/io_context.hpp>
 #include <boost/asio/spawn.hpp>
 #include <boost/optional.hpp>
+#include <boost/thread/csbl/memory/allocator_arg.hpp>
 
 #include <condition_variable>
 #include <functional>
@@ -30,10 +32,12 @@ namespace test {
 class enable_yield_to
 {
 protected:
-    boost::asio::io_service ios_;
+    boost::asio::io_context ios_;
 
 private:
-    boost::optional<boost::asio::io_service::work> work_;
+    boost::optional<boost::asio::executor_work_guard<
+        boost::asio::io_context::executor_type>>
+        work_;
     std::vector<std::thread> threads_;
     std::mutex m_;
     std::condition_variable cv_;
@@ -43,7 +47,8 @@ public:
     /// The type of yield context passed to functions.
     using yield_context = boost::asio::yield_context;
 
-    explicit enable_yield_to(std::size_t concurrency = 1) : work_(ios_)
+    explicit enable_yield_to(std::size_t concurrency = 1)
+        : work_(boost::asio::make_work_guard(ios_))
     {
         threads_.reserve(concurrency);
         while (concurrency--)
@@ -57,9 +62,9 @@ public:
             t.join();
     }
 
-    /// Return the `io_service` associated with the object
-    boost::asio::io_service&
-    get_io_service()
+    /// Return the `io_context` associated with the object
+    boost::asio::io_context&
+    get_io_context()
     {
         return ios_;
     }
@@ -112,13 +117,18 @@ enable_yield_to::spawn(F0&& f, FN&&... fn)
 {
     boost::asio::spawn(
         ios_,
+        boost::allocator_arg,
+        boost::context::fixedsize_stack(2 * 1024 * 1024),
         [&](yield_context yield) {
             f(yield);
             std::lock_guard lock{m_};
             if (--running_ == 0)
                 cv_.notify_all();
         },
-        boost::coroutines::attributes(2 * 1024 * 1024));
+        [](std::exception_ptr e) {
+            if (e)
+                std::rethrow_exception(e);
+        });
     spawn(fn...);
 }
 

include/xrpl/beast/unit_test/match.h

@@ -9,7 +9,6 @@
 #define BEAST_UNIT_TEST_MATCH_HPP
 
 #include <xrpl/beast/unit_test/suite_info.h>
-
 #include <string>
 
 namespace beast {

include/xrpl/beast/unit_test/reporter.h

@@ -10,10 +10,8 @@
 
 #include <xrpl/beast/unit_test/amount.h>
 #include <xrpl/beast/unit_test/recorder.h>
-
 #include <boost/lexical_cast.hpp>
 #include <boost/optional.hpp>
-
 #include <algorithm>
 #include <chrono>
 #include <functional>

include/xrpl/beast/unit_test/runner.h

@@ -9,9 +9,7 @@
 #define BEAST_UNIT_TEST_RUNNER_H_INCLUDED
 
 #include <xrpl/beast/unit_test/suite_info.h>
-
 #include <boost/assert.hpp>
-
 #include <mutex>
 #include <ostream>
 #include <string>