Test

Signed-off-by: JCW <a1q123456@users.noreply.github.com>

.clang-format

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

.codecov.yml

@@ -7,13 +7,13 @@ comment:
   show_carryforward_flags: false
 
 coverage:
-  range: "60..80"
+  range: "70..85"
   precision: 1
   round: nearest
   status:
     project:
       default:
-        target: 60%
+        target: 75%
         threshold: 2%
     patch:
       default:

.github/CODEOWNERS

@@ -0,0 +1,8 @@
+# Allow anyone to review any change by default.
+*
+
+# Require the rpc-reviewers team to review changes to the rpc code.
+include/xrpl/protocol/ @xrplf/rpc-reviewers
+src/libxrpl/protocol/ @xrplf/rpc-reviewers
+src/xrpld/rpc/ @xrplf/rpc-reviewers
+src/xrpld/app/misc/ @xrplf/rpc-reviewers

.github/actions/dependencies/action.yml

@@ -6,36 +6,32 @@ inputs:
 runs:
   using: composite
   steps:
-    - name: unlock Conan
-      shell: bash
-      run: conan remove --locks
     - name: export custom recipes
       shell: bash
       run: |
-        conan config set general.revisions_enabled=1
+        conan export --version 1.1.10 external/snappy
-        conan export external/snappy snappy/1.1.10@
+        conan export --version 9.7.3 external/rocksdb
-        conan export external/rocksdb rocksdb/6.29.5@
+        conan export --version 4.0.3 external/soci
-        conan export external/soci soci/4.0.3@
-        conan export external/nudb nudb/2.0.8@
     - name: add Ripple Conan remote
+      if: env.CONAN_URL != ''
       shell: bash
       run: |
-        conan remote list
+        if conan remote list | grep -q "ripple"; then
-        conan remote remove ripple || true
+            conan remote remove ripple
-        # Do not quote the URL. An empty string will be accepted (with
+            echo "Removed conan remote ripple"
-        # a non-fatal warning), but a missing argument will not.
+        fi
-        conan remote add ripple ${{ env.CONAN_URL }} --insert 0
+        conan remote add --index 0 ripple "${CONAN_URL}"
+        echo "Added conan remote ripple at ${CONAN_URL}"
+
     - name: try to authenticate to Ripple Conan remote
+      if: env.CONAN_URL != '' && env.CONAN_LOGIN_USERNAME_RIPPLE != '' && env.CONAN_PASSWORD_RIPPLE != ''
       id: remote
       shell: bash
       run: |
-        # `conan user` implicitly uses the environment variables
+        echo "Authenticating to ripple remote..."
-        # CONAN_LOGIN_USERNAME_<REMOTE> and CONAN_PASSWORD_<REMOTE>.
+        conan remote auth ripple --force
-        # https://docs.conan.io/1/reference/commands/misc/user.html#using-environment-variables
+        conan remote list-users
-        # https://docs.conan.io/1/reference/env_vars.html#conan-login-username-conan-login-username-remote-name
+
-        # https://docs.conan.io/1/reference/env_vars.html#conan-password-conan-password-remote-name
-        echo outcome=$(conan user --remote ripple --password >&2 \
-          && echo success || echo failure) | tee ${GITHUB_OUTPUT}
     - name: list missing binaries
       id: binaries
       shell: bash
@@ -51,11 +47,7 @@ runs:
         conan install \
           --output-folder . \
           --build missing \
-          --options tests=True \
+          --options:host "&:tests=True" \
-          --options xrpld=True \
+          --options:host "&:xrpld=True" \
-          --settings build_type=${{ inputs.configuration }} \
+          --settings:all build_type=${{ inputs.configuration }} \
           ..
-    - name: upload dependencies to remote
-      if: (steps.binaries.outputs.missing != '[]') && (steps.remote.outputs.outcome == 'success')
-      shell: bash
-      run: conan upload --remote ripple '*' --all --parallel --confirm

.github/workflows/clang-format.yml

@@ -1,30 +1,30 @@
 name: clang-format
 
-on: [push, pull_request]
+on:
+  push:
+  pull_request:
+    types: [opened, reopened, synchronize, ready_for_review]
 
 jobs:
   check:
+    if: ${{ github.event_name == 'push' || github.event.pull_request.draft != true || contains(github.event.pull_request.labels.*.name, 'DraftRunCI') }}
     runs-on: ubuntu-24.04
-    env:
+    container: ghcr.io/xrplf/ci/tools-rippled-clang-format
-      CLANG_VERSION: 18
     steps:
       - uses: actions/checkout@v4
-      - name: Install clang-format
-        run: |
-          codename=$( lsb_release --codename --short )
-          sudo tee /etc/apt/sources.list.d/llvm.list >/dev/null <<EOF
-          deb http://apt.llvm.org/${codename}/ llvm-toolchain-${codename}-${CLANG_VERSION} main
-          deb-src http://apt.llvm.org/${codename}/ llvm-toolchain-${codename}-${CLANG_VERSION} main
-          EOF
-          wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | sudo apt-key add
-          sudo apt-get update
-          sudo apt-get install clang-format-${CLANG_VERSION}
       - name: Format first-party sources
-        run: find include src -type f \( -name '*.cpp' -o -name '*.hpp' -o -name '*.h' -o -name '*.ipp' \) -exec clang-format-${CLANG_VERSION} -i {} +
+        run: |
+          clang-format --version
+          find include src tests -type f \( -name '*.cpp' -o -name '*.hpp' -o -name '*.h' -o -name '*.ipp' \) -exec clang-format -i {} +
       - name: Check for differences
         id: assert
+        shell: bash
         run: |
           set -o pipefail
+          pwd
+          whoami
+          ls -la .git
+          git branch
           git diff --exit-code | tee "clang-format.patch"
       - name: Upload patch
         if: failure() && steps.assert.outcome == 'failure'
@@ -54,6 +54,6 @@ jobs:
                in your repo, commit, and push.
         run: |
           echo "${PREAMBLE}"
-          clang-format-${CLANG_VERSION} --version
+          clang-format --version
           echo "${SUGGESTION}"
           exit 1

.github/workflows/doxygen.yml

@@ -10,11 +10,11 @@ concurrency:
   cancel-in-progress: true
 
 jobs:
-  job:
+  documentation:
     runs-on: ubuntu-latest
     permissions:
       contents: write
-    container: rippleci/rippled-build-ubuntu:aaf5e3e
+    container: ghcr.io/xrplf/rippled-build-ubuntu:aaf5e3e
     steps:
       - name: checkout
         uses: actions/checkout@v4

.github/workflows/levelization.yml

@@ -1,9 +1,13 @@
 name: levelization
 
-on: [push, pull_request]
+on:
+  push:
+  pull_request:
+    types: [opened, reopened, synchronize, ready_for_review]
 
 jobs:
   check:
+    if: ${{ github.event_name == 'push' || github.event.pull_request.draft != true || contains(github.event.pull_request.labels.*.name, 'DraftRunCI') }}
     runs-on: ubuntu-latest
     env:
       CLANG_VERSION: 10

.github/workflows/libxrpl.yml

@@ -1,6 +1,6 @@
 name: Check libXRPL compatibility with Clio
 env:
-  CONAN_URL: http://18.143.149.228:8081/artifactory/api/conan/conan-non-prod
+  CONAN_URL: http://18.143.149.228:8081/artifactory/api/conan/dev
   CONAN_LOGIN_USERNAME_RIPPLE: ${{ secrets.CONAN_USERNAME }}
   CONAN_PASSWORD_RIPPLE: ${{ secrets.CONAN_TOKEN }}
 on:
@@ -8,19 +8,21 @@ on:
     paths:
       - 'src/libxrpl/protocol/BuildInfo.cpp'
       - '.github/workflows/libxrpl.yml'
+    types: [opened, reopened, synchronize, ready_for_review]
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
   cancel-in-progress: true
 
 jobs:
   publish:
+    if: ${{ github.event_name == 'push' || github.event.pull_request.draft != true || contains(github.event.pull_request.labels.*.name, 'DraftRunCI') }}
     name: Publish libXRPL
     outputs:
       outcome: ${{ steps.upload.outputs.outcome }}
       version: ${{ steps.version.outputs.version }}
       channel: ${{ steps.channel.outputs.channel }}
     runs-on: [self-hosted, heavy]
-    container: rippleci/rippled-build-ubuntu:aaf5e3e
+    container: ghcr.io/xrplf/rippled-build-ubuntu:aaf5e3e
     steps:
       - name: Wait for essential checks to succeed
         uses: lewagon/wait-on-check-action@v1.3.4
@@ -85,4 +87,5 @@ jobs:
         run: |
           gh api --method POST -H "Accept: application/vnd.github+json" -H "X-GitHub-Api-Version: 2022-11-28" \
           /repos/xrplf/clio/dispatches -f "event_type=check_libxrpl" \
-          -F "client_payload[version]=${{ needs.publish.outputs.version }}@${{ needs.publish.outputs.channel }}"
+          -F "client_payload[version]=${{ needs.publish.outputs.version }}@${{ needs.publish.outputs.channel }}" \
+          -F "client_payload[pr]=${{ github.event.pull_request.number }}"

.github/workflows/macos.yml

@@ -1,6 +1,7 @@
 name: macos
 on:
   pull_request:
+    types: [opened, reopened, synchronize, ready_for_review]
   push:
     # If the branches list is ever changed, be sure to change it on all
     # build/test jobs (nix, macos, windows, instrumentation)
@@ -14,10 +15,25 @@ on:
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
   cancel-in-progress: true
+# This part of Conan configuration is specific to this workflow only; we do not want
+# to pollute conan/profiles directory with settings which might not work for others
+env:
+  #CONAN_URL: http://18.143.149.228:8081/artifactory/api/conan/dev
+  CONAN_LOGIN_USERNAME_RIPPLE: ${{ secrets.CONAN_USERNAME }}
+  CONAN_PASSWORD_RIPPLE: ${{ secrets.CONAN_TOKEN }}
+  CONAN_GLOBAL_CONF: |
+    core.download:parallel={{os.cpu_count()}}
+    core.upload:parallel={{os.cpu_count()}}
+    core:default_build_profile=libxrpl
+    core:default_profile=libxrpl
+    tools.build:jobs={{ (os.cpu_count() * 4/5) | int }}
+    tools.build:verbosity=verbose
+    tools.compilation:verbosity=verbose
 
 jobs:
 
   test:
+    if: ${{ github.event_name == 'push' || github.event.pull_request.draft != true || contains(github.event.pull_request.labels.*.name, 'DraftRunCI') }}
     strategy:
       matrix:
         platform:
@@ -26,18 +42,17 @@ jobs:
           - Ninja
         configuration:
           - Release
-    runs-on: [self-hosted, macOS]
+    runs-on: [self-hosted, macOS, mac-runner-m1]
     env:
       # The `build` action requires these variables.
       build_dir: .build
       NUM_PROCESSORS: 12
     steps:
       - name: checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
       - name: install Conan
         run: |
-          brew install conan@1
+          brew install conan
-          echo '/opt/homebrew/opt/conan@1/bin' >> $GITHUB_PATH
       - name: install Ninja
         if: matrix.generator == 'Ninja'
         run: brew install ninja
@@ -69,17 +84,32 @@ jobs:
           nproc --version
           echo -n "nproc returns: "
           nproc
+          system_profiler SPHardwareDataType
+          sysctl -n hw.logicalcpu
+          clang --version
       - name: configure Conan
         run : |
-          conan profile new default --detect || true
+          echo "${CONAN_GLOBAL_CONF}" >> $(conan config home)/global.conf
-          conan profile update settings.compiler.cppstd=20 default
+          conan config install conan/profiles/ -tf $(conan config home)/profiles/
-          conan profile update 'conf.tools.build:cxxflags+=["-DBOOST_ASIO_DISABLE_CONCEPTS"]' default
+          conan profile show
+      - name: export custom recipes
+        shell: bash
+        run: |
+          conan export --version 1.1.10 external/snappy
+          conan export --version 9.7.3 external/rocksdb
+          conan export --version 4.0.3 external/soci
+      - name: add Ripple Conan remote
+        if: env.CONAN_URL != ''
+        shell: bash
+        run: |
+          if conan remote list | grep -q "ripple"; then
+              conan remote remove ripple
+              echo "Removed conan remote ripple"
+          fi
+          conan remote add --index 0 ripple "${CONAN_URL}"
+          echo "Added conan remote ripple at ${CONAN_URL}"
       - name: build dependencies
         uses: ./.github/actions/dependencies
-        env:
-          CONAN_URL: http://18.143.149.228:8081/artifactory/api/conan/conan-non-prod
-          CONAN_LOGIN_USERNAME_RIPPLE: ${{ secrets.CONAN_USERNAME }}
-          CONAN_PASSWORD_RIPPLE: ${{ secrets.CONAN_TOKEN }}
         with:
           configuration: ${{ matrix.configuration }}
       - name: build
@@ -92,4 +122,7 @@ jobs:
         run: |
           n=$(nproc)
           echo "Using $n test jobs"
-          ${build_dir}/rippled --unittest --unittest-jobs $n
+
+          cd ${build_dir}
+          ./rippled --unittest --unittest-jobs $n
+          ctest -j $n --output-on-failure

.github/workflows/nix.yml

@@ -1,6 +1,7 @@
 name: nix
 on:
   pull_request:
+    types: [opened, reopened, synchronize, ready_for_review]
   push:
     # If the branches list is ever changed, be sure to change it on all
     # build/test jobs (nix, macos, windows)
@@ -15,6 +16,21 @@ concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
   cancel-in-progress: true
 
+# This part of Conan configuration is specific to this workflow only; we do not want
+# to pollute conan/profiles directory with settings which might not work for others
+env:
+  #CONAN_URL: http://18.143.149.228:8081/artifactory/api/conan/dev
+  CONAN_LOGIN_USERNAME_RIPPLE: ${{ secrets.CONAN_USERNAME }}
+  CONAN_PASSWORD_RIPPLE: ${{ secrets.CONAN_TOKEN }}
+  CONAN_GLOBAL_CONF: |
+    core.download:parallel={{ os.cpu_count() }}
+    core.upload:parallel={{ os.cpu_count() }}
+    core:default_build_profile=libxrpl
+    core:default_profile=libxrpl
+    tools.build:jobs={{ (os.cpu_count() * 4/5) | int }}
+    tools.build:verbosity=verbose
+    tools.compilation:verbosity=verbose
+
 # This workflow has multiple job matrixes.
 # They can be considered phases because most of the matrices ("test",
 # "coverage", "conan", ) depend on the first ("dependencies").
@@ -39,6 +55,7 @@ concurrency:
 
 jobs:
   dependencies:
+    if: ${{ github.event_name == 'push' || github.event.pull_request.draft != true || contains(github.event.pull_request.labels.*.name, 'DraftRunCI') }}
     strategy:
       fail-fast: false
       matrix:
@@ -52,59 +69,46 @@ jobs:
           - Release
         include:
           - compiler: gcc
-            profile:
+            compiler_version: 12
-              version: 11
+            distro: ubuntu
-              cc: /usr/bin/gcc
+            codename: jammy
-              cxx: /usr/bin/g++
           - compiler: clang
-            profile:
+            compiler_version: 17
-              version: 14
+            distro: debian
-              cc: /usr/bin/clang-14
+            codename: bookworm
-              cxx: /usr/bin/clang++-14
     runs-on: [self-hosted, heavy]
-    container: rippleci/rippled-build-ubuntu:aaf5e3e
+    container: ghcr.io/xrplf/ci/${{ matrix.distro }}-${{ matrix.codename }}:${{ matrix.compiler }}-${{ matrix.compiler_version }}
     env:
       build_dir: .build
     steps:
-      - name: upgrade conan
-        run: |
-          pip install --upgrade "conan<2"
       - name: checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
       - name: check environment
         run: |
           echo ${PATH} | tr ':' '\n'
           lsb_release -a || true
-          ${{ matrix.profile.cc }} --version
+          ${{ matrix.compiler }}-${{ matrix.compiler_version }} --version
           conan --version
           cmake --version
           env | sort
       - name: configure Conan
         run: |
-          conan profile new default --detect
+          echo "${CONAN_GLOBAL_CONF}" >> $(conan config home)/global.conf
-          conan profile update settings.compiler.cppstd=20 default
+          conan config install conan/profiles/ -tf $(conan config home)/profiles/
-          conan profile update settings.compiler=${{ matrix.compiler }} default
+          conan profile show
-          conan profile update settings.compiler.version=${{ matrix.profile.version }} default
-          conan profile update settings.compiler.libcxx=libstdc++11 default
-          conan profile update env.CC=${{ matrix.profile.cc }} default
-          conan profile update env.CXX=${{ matrix.profile.cxx }} default
-          conan profile update conf.tools.build:compiler_executables='{"c": "${{ matrix.profile.cc }}", "cpp": "${{ matrix.profile.cxx }}"}' default
       - name: archive profile
         # Create this archive before dependencies are added to the local cache.
-        run: tar -czf conan.tar -C ~/.conan .
+        run: tar -czf conan.tar.gz -C ${CONAN_HOME} .
       - name: build dependencies
         uses: ./.github/actions/dependencies
-        env:
+
-          CONAN_URL: http://18.143.149.228:8081/artifactory/api/conan/conan-non-prod
-          CONAN_LOGIN_USERNAME_RIPPLE: ${{ secrets.CONAN_USERNAME }}
-          CONAN_PASSWORD_RIPPLE: ${{ secrets.CONAN_TOKEN }}
         with:
           configuration: ${{ matrix.configuration }}
       - name: upload archive
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02
         with:
           name: ${{ matrix.platform }}-${{ matrix.compiler }}-${{ matrix.configuration }}
-          path: conan.tar
+          path: conan.tar.gz
           if-no-files-found: error
 
   test:
@@ -119,26 +123,32 @@ jobs:
         configuration:
           - Debug
           - Release
+        include:
+          - compiler: gcc
+            compiler_version: 12
+            distro: ubuntu
+            codename: jammy
+          - compiler: clang
+            compiler_version: 17
+            distro: debian
+            codename: bookworm
         cmake-args:
           -
           - "-Dunity=ON"
     needs: dependencies
     runs-on: [self-hosted, heavy]
-    container: rippleci/rippled-build-ubuntu:aaf5e3e
+    container: ghcr.io/xrplf/ci/${{ matrix.distro }}-${{ matrix.codename }}:${{ matrix.compiler }}-${{ matrix.compiler_version }}
     env:
       build_dir: .build
     steps:
-      - name: upgrade conan
-        run: |
-          pip install --upgrade "conan<2"
       - name: download cache
-        uses: actions/download-artifact@v4
+        uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093
         with:
           name: ${{ matrix.platform }}-${{ matrix.compiler }}-${{ matrix.configuration }}
       - name: extract cache
         run: |
-          mkdir -p ~/.conan
+          mkdir -p ${CONAN_HOME}
-          tar -xzf conan.tar -C ~/.conan
+          tar -xzf conan.tar.gz -C ${CONAN_HOME}
       - name: check environment
         run: |
           env | sort
@@ -146,11 +156,70 @@ jobs:
           conan --version
           cmake --version
       - name: checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
       - name: dependencies
         uses: ./.github/actions/dependencies
+        with:
+          configuration: ${{ matrix.configuration }}
+      - name: build
+        uses: ./.github/actions/build
+        with:
+          generator: Ninja
+          configuration: ${{ matrix.configuration }}
+          cmake-args: "-Dassert=TRUE -Dwerr=TRUE ${{ matrix.cmake-args }}"
+      - name: check linking
+        run: |
+          cd ${build_dir}
+          ldd ./rippled
+          if [ "$(ldd ./rippled | grep -E '(libstdc\+\+|libgcc)' | wc -l)" -eq 0 ]; then
+            echo 'The binary is statically linked.'
+          else
+            echo 'The binary is dynamically linked.'
+            exit 1
+          fi
+      - name: test
+        run: |
+          cd ${build_dir}
+          ./rippled --unittest --unittest-jobs $(nproc)
+          ctest -j $(nproc) --output-on-failure
+
+  reference-fee-test:
+    strategy:
+      fail-fast: false
+      matrix:
+        platform:
+          - linux
+        compiler:
+          - gcc
+        configuration:
+          - Debug
+        cmake-args:
+          - "-DUNIT_TEST_REFERENCE_FEE=200"
+          - "-DUNIT_TEST_REFERENCE_FEE=1000"
+    needs: dependencies
+    runs-on: [self-hosted, heavy]
+    container: ghcr.io/xrplf/ci/ubuntu-jammy:gcc-12
     env:
-          CONAN_URL: http://18.143.149.228:8081/artifactory/api/conan/conan-non-prod
+      build_dir: .build
+    steps:
+      - name: download cache
+        uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093
+        with:
+          name: ${{ matrix.platform }}-${{ matrix.compiler }}-${{ matrix.configuration }}
+      - name: extract cache
+        run: |
+          mkdir -p ${CONAN_HOME}
+          tar -xzf conan.tar.gz -C ${CONAN_HOME}
+      - name: check environment
+        run: |
+          env | sort
+          echo ${PATH} | tr ':' '\n'
+          conan --version
+          cmake --version
+      - name: checkout
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
+      - name: dependencies
+        uses: ./.github/actions/dependencies
         with:
           configuration: ${{ matrix.configuration }}
       - name: build
@@ -161,7 +230,9 @@ jobs:
           cmake-args: "-Dassert=TRUE -Dwerr=TRUE ${{ matrix.cmake-args }}"
       - name: test
         run: |
-          ${build_dir}/rippled --unittest --unittest-jobs $(nproc)
+          cd ${build_dir}
+          ./rippled --unittest --unittest-jobs $(nproc)
+          ctest -j $(nproc) --output-on-failure
 
   coverage:
     strategy:
@@ -175,23 +246,18 @@ jobs:
           - Debug
     needs: dependencies
     runs-on: [self-hosted, heavy]
-    container: rippleci/rippled-build-ubuntu:aaf5e3e
+    container: ghcr.io/xrplf/ci/ubuntu-jammy:gcc-12
     env:
       build_dir: .build
     steps:
-      - name: upgrade conan
-        run: |
-          pip install --upgrade "conan<2"
       - name: download cache
-        uses: actions/download-artifact@v4
+        uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093
         with:
           name: ${{ matrix.platform }}-${{ matrix.compiler }}-${{ matrix.configuration }}
       - name: extract cache
         run: |
-          mkdir -p ~/.conan
+          mkdir -p ${CONAN_HOME}
-          tar -xzf conan.tar -C ~/.conan
+          tar -xzf conan.tar.gz -C ${CONAN_HOME}
-      - name: install gcovr
-        run: pip install "gcovr>=7,<8"
       - name: check environment
         run: |
           echo ${PATH} | tr ':' '\n'
@@ -199,13 +265,11 @@ jobs:
           cmake --version
           gcovr --version
           env | sort
-          ls ~/.conan
+          ls ${CONAN_HOME}
       - name: checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
       - name: dependencies
         uses: ./.github/actions/dependencies
-        env:
-          CONAN_URL: http://18.143.149.228:8081/artifactory/api/conan/conan-non-prod
         with:
           configuration: ${{ matrix.configuration }}
       - name: build
@@ -227,7 +291,7 @@ jobs:
         run: |
           mv "${build_dir}/coverage.xml" ./
       - name: archive coverage report
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02
         with:
           name: coverage.xml
           path: coverage.xml
@@ -249,22 +313,23 @@ jobs:
   conan:
     needs: dependencies
     runs-on: [self-hosted, heavy]
-    container: rippleci/rippled-build-ubuntu:aaf5e3e
+    container:
+      image: ghcr.io/xrplf/ci/ubuntu-jammy:gcc-12
     env:
       build_dir: .build
+      platform: linux
+      compiler: gcc
+      compiler_version: 12
       configuration: Release
     steps:
-      - name: upgrade conan
-        run: |
-          pip install --upgrade "conan<2"
       - name: download cache
-        uses: actions/download-artifact@v4
+        uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093
         with:
-          name: linux-gcc-${{ env.configuration }}
+          name: ${{ env.platform }}-${{ env.compiler }}-${{ env.configuration }}
       - name: extract cache
         run: |
-          mkdir -p ~/.conan
+          mkdir -p ${CONAN_HOME}
-          tar -xzf conan.tar -C ~/.conan
+          tar -xzf conan.tar.gz -C ${CONAN_HOME}
       - name: check environment
         run: |
           env | sort
@@ -272,27 +337,22 @@ jobs:
           conan --version
           cmake --version
       - name: checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
       - name: dependencies
         uses: ./.github/actions/dependencies
-        env:
-          CONAN_URL: http://18.143.149.228:8081/artifactory/api/conan/conan-non-prod
         with:
           configuration: ${{ env.configuration }}
       - name: export
         run: |
-          version=$(conan inspect --raw version .)
+          conan export . --version head
-          reference="xrpl/${version}@local/test"
-          conan remove -f ${reference} || true
-          conan export . local/test
-          echo "reference=${reference}" >> "${GITHUB_ENV}"
       - name: build
         run: |
-          cd examples/example
+          cd tests/conan
-          mkdir ${build_dir}
+          mkdir ${build_dir} && cd ${build_dir}
-          cd ${build_dir}
+          conan install .. \
-          conan install .. --output-folder . \
+            --settings:all build_type=${configuration} \
-            --require-override ${reference} --build missing
+            --output-folder . \
+            --build missing
           cmake .. \
             -DCMAKE_TOOLCHAIN_FILE:FILEPATH=./build/${configuration}/generators/conan_toolchain.cmake \
             -DCMAKE_BUILD_TYPE=${configuration}
@@ -304,62 +364,32 @@ jobs:
   # later
 
   instrumentation-build:
-    env:
+    if: ${{ github.event_name == 'push' || github.event.pull_request.draft != true || contains(github.event.pull_request.labels.*.name, 'DraftRunCI') }}
-      CLANG_RELEASE: 16
-    strategy:
-      fail-fast: false
     runs-on: [self-hosted, heavy]
-    container: debian:bookworm
+    container: ghcr.io/xrplf/ci/debian-bookworm:clang-17
-    steps:
-        - name: install prerequisites
-          env:
-            DEBIAN_FRONTEND: noninteractive
-          run: |
-            apt-get update
-            apt-get install --yes --no-install-recommends \
-              clang-${CLANG_RELEASE} clang++-${CLANG_RELEASE} \
-              python3-pip python-is-python3 make cmake git wget
-            apt-get clean
-            update-alternatives --install \
-              /usr/bin/clang clang /usr/bin/clang-${CLANG_RELEASE} 100 \
-              --slave /usr/bin/clang++ clang++ /usr/bin/clang++-${CLANG_RELEASE}
-            update-alternatives --auto clang
-            pip install --no-cache --break-system-packages "conan<2"
 
+    steps:
         - name: checkout
-          uses: actions/checkout@v4
+          uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
 
         - name: prepare environment
           run: |
             mkdir ${GITHUB_WORKSPACE}/.build
             echo "SOURCE_DIR=$GITHUB_WORKSPACE" >> $GITHUB_ENV
             echo "BUILD_DIR=$GITHUB_WORKSPACE/.build" >> $GITHUB_ENV
-            echo "CC=/usr/bin/clang" >> $GITHUB_ENV
-            echo "CXX=/usr/bin/clang++" >> $GITHUB_ENV
 
         - name: configure Conan
           run: |
-            conan profile new --detect default
+            echo "${CONAN_GLOBAL_CONF}" >> $(conan config home)/global.conf
-            conan profile update settings.compiler=clang default
+            conan config install conan/profiles/ -tf $(conan config home)/profiles/
-            conan profile update settings.compiler.version=${CLANG_RELEASE} default
+            conan profile show
-            conan profile update settings.compiler.libcxx=libstdc++11 default
-            conan profile update settings.compiler.cppstd=20 default
-            conan profile update options.rocksdb=False default
-            conan profile update \
-              'conf.tools.build:compiler_executables={"c": "/usr/bin/clang", "cpp": "/usr/bin/clang++"}' default
-            conan profile update 'env.CXXFLAGS="-DBOOST_ASIO_DISABLE_CONCEPTS"' default
-            conan profile update 'conf.tools.build:cxxflags+=["-DBOOST_ASIO_DISABLE_CONCEPTS"]' default
-            conan export external/snappy snappy/1.1.10@
-            conan export external/soci soci/4.0.3@
-
         - name: build dependencies
           run: |
             cd ${BUILD_DIR}
             conan install ${SOURCE_DIR} \
               --output-folder ${BUILD_DIR} \
-              --install-folder ${BUILD_DIR} \
               --build missing \
-              --settings build_type=Debug
+              --settings:all build_type=Debug
 
         - name: build with instrumentation
           run: |
@@ -384,3 +414,4 @@ jobs:
           run: |
             cd ${BUILD_DIR}
             ./rippled -u --unittest-jobs $(( $(nproc)/4 ))
+            ctest -j $(nproc) --output-on-failure

.github/workflows/windows.yml

@@ -2,6 +2,7 @@ name: windows
 
 on:
   pull_request:
+    types: [opened, reopened, synchronize, ready_for_review]
   push:
     # If the branches list is ever changed, be sure to change it on all
     # build/test jobs (nix, macos, windows, instrumentation)
@@ -17,10 +18,25 @@ on:
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
   cancel-in-progress: true
+# This part of Conan configuration is specific to this workflow only; we do not want
+# to pollute conan/profiles directory with settings which might not work for others
+env:
+  #CONAN_URL: http://18.143.149.228:8081/artifactory/api/conan/dev
+  CONAN_LOGIN_USERNAME_RIPPLE: ${{ secrets.CONAN_USERNAME }}
+  CONAN_PASSWORD_RIPPLE: ${{ secrets.CONAN_TOKEN }}
+  CONAN_GLOBAL_CONF: |
+    core.download:parallel={{os.cpu_count()}}
+    core.upload:parallel={{os.cpu_count()}}
+    core:default_build_profile=libxrpl
+    core:default_profile=libxrpl
+    tools.build:jobs=24
+    tools.build:verbosity=verbose
+    tools.compilation:verbosity=verbose
 
 jobs:
 
   test:
+    if: ${{ github.event_name == 'push' || github.event.pull_request.draft != true || contains(github.event.pull_request.labels.*.name, 'DraftRunCI') }}
     strategy:
       fail-fast: false
       matrix:
@@ -40,11 +56,11 @@ jobs:
       build_dir: .build
     steps:
       - name: checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
       - name: choose Python
-        uses: actions/setup-python@v5
+        uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065
         with:
-          python-version: 3.9
+          python-version: 3.13
       - name: learn Python cache directory
         id: pip-cache
         shell: bash
@@ -52,12 +68,12 @@ jobs:
           python -m pip install --upgrade pip
           echo "dir=$(pip cache dir)" | tee ${GITHUB_OUTPUT}
       - name: restore Python cache directory
-        uses: actions/cache@v4
+        uses: actions/cache@5a3ec84eff668545956fd18022155c47e93e2684
         with:
             path: ${{ steps.pip-cache.outputs.dir }}
             key: ${{ runner.os }}-${{ hashFiles('.github/workflows/windows.yml') }}
       - name: install Conan
-        run: pip install wheel 'conan<2'
+        run: pip install wheel conan
       - name: check environment
         run: |
           dir env:
@@ -68,17 +84,27 @@ jobs:
       - name: configure Conan
         shell: bash
         run: |
-          conan profile new default --detect
+          echo "${CONAN_GLOBAL_CONF}" >> $(conan config home)/global.conf
-          conan profile update settings.compiler.cppstd=20 default
+          conan config install conan/profiles/ -tf $(conan config home)/profiles/
-          conan profile update \
+          conan profile show
-            settings.compiler.runtime=MT${{ matrix.configuration.runtime }} \
+      - name: export custom recipes
-            default
+        shell: bash
+        run: |
+          conan export --version 1.1.10 external/snappy
+          conan export --version 9.7.3 external/rocksdb
+          conan export --version 4.0.3 external/soci
+      - name: add Ripple Conan remote
+        if: env.CONAN_URL != ''
+        shell: bash
+        run: |
+          if conan remote list | grep -q "ripple"; then
+              conan remote remove ripple
+              echo "Removed conan remote ripple"
+          fi
+          conan remote add --index 0 ripple "${CONAN_URL}"
+          echo "Added conan remote ripple at ${CONAN_URL}"
       - name: build dependencies
         uses: ./.github/actions/dependencies
-        env:
-          CONAN_URL: http://18.143.149.228:8081/artifactory/api/conan/conan-non-prod
-          CONAN_LOGIN_USERNAME_RIPPLE: ${{ secrets.CONAN_USERNAME }}
-          CONAN_PASSWORD_RIPPLE: ${{ secrets.CONAN_TOKEN }}
         with:
           configuration: ${{ matrix.configuration.type }}
       - name: build
@@ -93,5 +119,6 @@ jobs:
         shell: bash
         if: ${{ matrix.configuration.tests }}
         run: |
-          ${build_dir}/${{ matrix.configuration.type }}/rippled --unittest \
+          cd ${build_dir}/${{ matrix.configuration.type }}
-              --unittest-jobs $(nproc)
+          ./rippled --unittest --unittest-jobs $(nproc)
+          ctest -j $(nproc) --output-on-failure

.pre-commit-config.yaml

@@ -1,6 +1,6 @@
 # .pre-commit-config.yaml
 repos:
 - repo: https://github.com/pre-commit/mirrors-clang-format
-  rev: v18.1.3
+  rev: v18.1.8
   hooks:
   - id: clang-format

API-CHANGELOG.md

@@ -83,9 +83,17 @@ 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
 
-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).
+[Version 2.4.0](https://github.com/XRPLF/rippled/releases/tag/2.4.0) was released on March 4, 2025.
 
 ### Additions and bugfixes in 2.4.0
 

BUILD.md

@@ -167,8 +167,6 @@ It does not explicitly link the C++ standard library,
 which allows you to statically link it with GCC, if you want.
 
    ```
-   # Conan 1.x
-   conan export external/snappy snappy/1.1.10@
    # Conan 2.x
    conan export --version 1.1.10 external/snappy
    ```
@@ -177,33 +175,18 @@ Export our [Conan recipe for RocksDB](./external/rocksdb).
 It does not override paths to dependencies when building with Visual Studio.
 
    ```
-   # Conan 1.x
-   conan export external/rocksdb rocksdb/6.29.5@
    # Conan 2.x
-   conan export --version 6.29.5 external/rocksdb
+   conan export --version 9.7.3 external/rocksdb
    ```
 
 Export our [Conan recipe for SOCI](./external/soci).
 It patches their CMake to correctly import its dependencies.
 
    ```
-   # Conan 1.x
-   conan export external/soci soci/4.0.3@
    # Conan 2.x
    conan export --version 4.0.3 external/soci
    ```
 
-Export our [Conan recipe for NuDB](./external/nudb).
-It fixes some source files to add missing `#include`s.
-
-
-   ```
-   # Conan 1.x
-   conan export external/nudb nudb/2.0.8@
-   # Conan 2.x
-   conan export --version 2.0.8 external/nudb
-   ```
-
 ### Build and Test
 
 1. Create a build directory and move into it.
@@ -288,7 +271,7 @@ It fixes some source files to add missing `#include`s.
    Single-config generators:
 
    ```
-   cmake --build .
+   cmake --build . -j $(nproc)
    ```
 
    Multi-config generators:

Builds/levelization/results/loops.txt

@@ -14,10 +14,10 @@ Loop: xrpld.app xrpld.net
   xrpld.app > xrpld.net
 
 Loop: xrpld.app xrpld.overlay
-  xrpld.overlay == xrpld.app
+  xrpld.overlay > xrpld.app
 
 Loop: xrpld.app xrpld.peerfinder
-  xrpld.app > xrpld.peerfinder
+  xrpld.peerfinder ~= xrpld.app
 
 Loop: xrpld.app xrpld.rpc
   xrpld.rpc > xrpld.app

Builds/levelization/results/ordering.txt

@@ -6,6 +6,7 @@ libxrpl.protocol > xrpl.basics
 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
@@ -42,6 +43,7 @@ test.consensus > xrpl.basics
 test.consensus > xrpld.app
 test.consensus > xrpld.consensus
 test.consensus > xrpld.ledger
+test.consensus > xrpl.json
 test.core > test.jtx
 test.core > test.toplevel
 test.core > test.unit_test
@@ -58,7 +60,6 @@ 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
@@ -131,6 +132,7 @@ test.shamap > xrpl.protocol
 test.toplevel > test.csf
 test.toplevel > xrpl.json
 test.unit_test > xrpl.basics
+tests.libxrpl > xrpl.basics
 xrpl.json > xrpl.basics
 xrpl.protocol > xrpl.basics
 xrpl.protocol > xrpl.json
@@ -158,7 +160,6 @@ 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
@@ -183,7 +184,6 @@ 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

CMakeLists.txt

@@ -16,6 +16,18 @@ set(CMAKE_CXX_EXTENSIONS OFF)
 set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED 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)
@@ -78,6 +90,11 @@ set_target_properties(OpenSSL::SSL PROPERTIES
   INTERFACE_COMPILE_DEFINITIONS OPENSSL_NO_SSL2
 )
 set(SECP256K1_INSTALL TRUE)
+set(SECP256K1_BUILD_BENCHMARK FALSE)
+set(SECP256K1_BUILD_TESTS FALSE)
+set(SECP256K1_BUILD_EXHAUSTIVE_TESTS FALSE)
+set(SECP256K1_BUILD_CTIME_TESTS FALSE)
+set(SECP256K1_BUILD_EXAMPLES FALSE)
 add_subdirectory(external/secp256k1)
 add_library(secp256k1::secp256k1 ALIAS secp256k1)
 add_subdirectory(external/ed25519-donna)
@@ -132,3 +149,8 @@ set(PROJECT_EXPORT_SET RippleExports)
 include(RippledCore)
 include(RippledInstall)
 include(RippledValidatorKeys)
+
+if(tests)
+  include(CTest)
+  add_subdirectory(src/tests/libxrpl)
+endif()

README.md

@@ -1,3 +1,5 @@
+[![codecov](https://codecov.io/gh/XRPLF/rippled/graph/badge.svg?token=WyFr5ajq3O)](https://codecov.io/gh/XRPLF/rippled)
+
 # The XRP Ledger
 
 The [XRP Ledger](https://xrpl.org/) is a decentralized cryptographic ledger powered by a network of peer-to-peer nodes. The XRP Ledger uses a novel Byzantine Fault Tolerant consensus algorithm to settle and record transactions in a secure distributed database without a central operator.

SECURITY.md

@@ -83,7 +83,7 @@ To report a qualifying bug, please send a detailed report to:
 |Long Key ID  | `0xCD49A0AFC57929BE`                                |
 |Fingerprint  | `24E6 3B02 37E0 FA9C 5E96 8974 CD49 A0AF C579 29BE` |
 
-The full PGP key for this address, which is also available on several key servers (e.g. on [keys.gnupg.net](https://keys.gnupg.net)), is: 
+The full PGP key for this address, which is also available on several key servers (e.g. on [keyserver.ubuntu.com](https://keyserver.ubuntu.com)), is: 
 ```
 -----BEGIN PGP PUBLIC KEY BLOCK-----
 mQINBFUwGHYBEAC0wpGpBPkd8W1UdQjg9+cEFzeIEJRaoZoeuJD8mofwI5Ejnjdt

cfg/rippled-example.cfg

@@ -420,6 +420,7 @@
 #     - r.ripple.com 51235
 #     - sahyadri.isrdc.in 51235
 #     - hubs.xrpkuwait.com 51235
+#     - hub.xrpl-commons.org 51235
 #
 #   Examples:
 #

cfg/validators-example.txt

@@ -26,7 +26,7 @@
 #
 #   Examples:
 #    https://vl.ripple.com
-#    https://vl.xrplf.org
+#    https://unl.xrplf.org
 #    http://127.0.0.1:8000
 #    file:///etc/opt/ripple/vl.txt
 #

cmake/CodeCoverage.cmake

@@ -98,6 +98,9 @@
 # 2024-04-03, Bronek Kozicki
 #     - add support for output formats: jacoco, clover, lcov
 #
+# 2025-05-12, Jingchen Wu
+#     - add -fprofile-update=atomic to ensure atomic profile generation
+#
 # USAGE:
 #
 # 1. Copy this file into your cmake modules path.
@@ -200,15 +203,27 @@ set(COVERAGE_COMPILER_FLAGS "-g --coverage"
     CACHE INTERNAL "")
 if(CMAKE_CXX_COMPILER_ID MATCHES "(GNU|Clang)")
     include(CheckCXXCompilerFlag)
+    include(CheckCCompilerFlag)
+
     check_cxx_compiler_flag(-fprofile-abs-path HAVE_cxx_fprofile_abs_path)
     if(HAVE_cxx_fprofile_abs_path)
         set(COVERAGE_CXX_COMPILER_FLAGS "${COVERAGE_COMPILER_FLAGS} -fprofile-abs-path")
     endif()
-    include(CheckCCompilerFlag)
+
     check_c_compiler_flag(-fprofile-abs-path HAVE_c_fprofile_abs_path)
     if(HAVE_c_fprofile_abs_path)
         set(COVERAGE_C_COMPILER_FLAGS "${COVERAGE_COMPILER_FLAGS} -fprofile-abs-path")
     endif()
+
+    check_cxx_compiler_flag(-fprofile-update HAVE_cxx_fprofile_update)
+    if(HAVE_cxx_fprofile_update)
+        set(COVERAGE_CXX_COMPILER_FLAGS "${COVERAGE_COMPILER_FLAGS}  -fprofile-update=atomic")
+    endif()
+
+    check_c_compiler_flag(-fprofile-update HAVE_c_fprofile_update)
+    if(HAVE_c_fprofile_update)
+        set(COVERAGE_C_COMPILER_FLAGS "${COVERAGE_COMPILER_FLAGS} -fprofile-update=atomic")
+    endif()
 endif()
 
 set(CMAKE_Fortran_FLAGS_COVERAGE

cmake/RippledCore.cmake

@@ -136,6 +136,9 @@ 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/RippledDocs.cmake

@@ -53,9 +53,9 @@ set(download_script "${CMAKE_BINARY_DIR}/docs/download-cppreference.cmake")
 file(WRITE
   "${download_script}"
   "file(DOWNLOAD \
-    http://upload.cppreference.com/mwiki/images/b/b2/html_book_20190607.zip \
+    https://github.com/PeterFeicht/cppreference-doc/releases/download/v20250209/html-book-20250209.zip \
     ${CMAKE_BINARY_DIR}/docs/cppreference.zip \
-    EXPECTED_HASH MD5=82b3a612d7d35a83e3cb1195a63689ab \
+    EXPECTED_HASH MD5=bda585f72fbca4b817b29a3d5746567b \
   )\n \
   execute_process( \
     COMMAND \"${CMAKE_COMMAND}\" -E tar -xf cppreference.zip \

cmake/RippledSanity.cmake

@@ -2,16 +2,6 @@
    convenience variables and sanity checks
 #]===================================================================]
 
-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)
 
 set (CMAKE_CONFIGURATION_TYPES "Debug;Release" CACHE STRING "" FORCE)

cmake/RippledSettings.cmake

@@ -11,8 +11,14 @@ 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)
+option(unity "Creates a build using UNITY support in cmake." OFF)
 if(unity)
   if(NOT is_ci)
     set(CMAKE_UNITY_BUILD_BATCH_SIZE 15 CACHE STRING "")

cmake/deps/Boost.cmake

@@ -2,7 +2,6 @@ find_package(Boost 1.82 REQUIRED
   COMPONENTS
     chrono
     container
-    context
     coroutine
     date_time
     filesystem
@@ -24,7 +23,7 @@ endif()
 
 target_link_libraries(ripple_boost
   INTERFACE
-    Boost::boost
+    Boost::headers
     Boost::chrono
     Boost::container
     Boost::coroutine

cmake/xrpl_add_test.cmake

@@ -0,0 +1,41 @@
+include(isolate_headers)
+
+function(xrpl_add_test name)
+  set(target ${PROJECT_NAME}.test.${name})
+
+  file(GLOB_RECURSE sources CONFIGURE_DEPENDS
+  "${CMAKE_CURRENT_SOURCE_DIR}/${name}/*.cpp"
+  "${CMAKE_CURRENT_SOURCE_DIR}/${name}.cpp"
+  )
+  add_executable(${target} EXCLUDE_FROM_ALL ${ARGN} ${sources})
+
+  isolate_headers(
+    ${target}
+    "${CMAKE_SOURCE_DIR}"
+    "${CMAKE_SOURCE_DIR}/tests/${name}"
+    PRIVATE
+  )
+
+  # Make sure the test isn't optimized away in unity builds
+  set_target_properties(${target} PROPERTIES
+    UNITY_BUILD_MODE GROUP
+    UNITY_BUILD_BATCH_SIZE 0)  # Adjust as needed
+
+  add_test(NAME ${target} COMMAND ${target})
+  set_tests_properties(
+    ${target} PROPERTIES
+    FIXTURES_REQUIRED ${target}_fixture
+  )
+
+  add_test(
+    NAME ${target}.build
+    COMMAND
+      ${CMAKE_COMMAND}
+      --build ${CMAKE_BINARY_DIR}
+      --config $<CONFIG>
+      --target ${target}
+  )
+  set_tests_properties(${target}.build PROPERTIES
+    FIXTURES_SETUP ${target}_fixture
+  )
+endfunction()

conan/profiles/libxrpl

@@ -0,0 +1,19 @@
+{% set os = detect_api.detect_os() %}
+{% set arch = detect_api.detect_arch() %}
+{% set compiler, version, compiler_exe = detect_api.detect_default_compiler() %}
+{% set compiler_version = version %}
+{% if os == "Linux" %}
+{% set compiler_version = detect_api.default_compiler_version(compiler, version) %}
+{% endif %}
+
+[settings]
+os={{ os }}
+arch={{ arch }}
+compiler={{compiler}}
+compiler.version={{ compiler_version }}
+compiler.cppstd=20
+{% if os == "Windows" %}
+compiler.runtime=static
+{% else %}
+compiler.libcxx={{detect_api.detect_libcxx(compiler, version, compiler_exe)}}
+{% endif %}

conanfile.py

@@ -1,4 +1,4 @@
-from conan import ConanFile
+from conan import ConanFile, __version__ as conan_version
 from conan.tools.cmake import CMake, CMakeToolchain, cmake_layout
 import re
 
@@ -24,18 +24,20 @@ class Xrpl(ConanFile):
     }
 
     requires = [
-        'date/3.0.3',
+        'grpc/1.72.0',
-        'grpc/1.50.1',
+        'libarchive/3.8.1',
-        'libarchive/3.7.6',
+        'nudb/2.0.9',
-        'nudb/2.0.8',
+        'openssl/1.1.1w',
-        'openssl/1.1.1v',
         'soci/4.0.3',
-        'xxhash/0.8.2',
         'zlib/1.3.1',
     ]
 
+    test_requires = [
+        'doctest/2.4.11',
+    ]
+
     tool_requires = [
-        'protobuf/3.21.9',
+        'protobuf/6.30.1',
     ]
 
     default_options = {
@@ -87,9 +89,10 @@ class Xrpl(ConanFile):
     }
 
     def set_version(self):
+        if self.version is None:
             path = f'{self.recipe_folder}/src/libxrpl/protocol/BuildInfo.cpp'
             regex = r'versionString\s?=\s?\"(.*)\"'
-        with open(path, 'r') as file:
+            with open(path, encoding='utf-8') 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)
@@ -99,14 +102,18 @@ class Xrpl(ConanFile):
             self.options['boost'].visibility = 'global'
 
     def requirements(self):
-        self.requires('boost/1.83.0', force=True)
+        # Conan 2 requires transitive headers to be specified
+        transitive_headers_opt = {'transitive_headers': True} if conan_version.split('.')[0] == '2' else {}
+        self.requires('boost/1.83.0', force=True, **transitive_headers_opt)
+        self.requires('date/3.0.4', **transitive_headers_opt)
         self.requires('lz4/1.10.0', force=True)
-        self.requires('protobuf/3.21.9', force=True)
+        self.requires('protobuf/6.30.1', force=True)
-        self.requires('sqlite3/3.47.0', force=True)
+        self.requires('sqlite3/3.49.1', force=True)
         if self.options.jemalloc:
             self.requires('jemalloc/5.3.0')
         if self.options.rocksdb:
-            self.requires('rocksdb/6.29.5')
+            self.requires('rocksdb/9.7.3')
+        self.requires('xxhash/0.8.3', **transitive_headers_opt)
 
     exports_sources = (
         'CMakeLists.txt',
@@ -136,6 +143,8 @@ class Xrpl(ConanFile):
         tc.variables['static'] = self.options.static
         tc.variables['unity'] = self.options.unity
         tc.variables['xrpld'] = self.options.xrpld
+        if self.settings.compiler == 'clang' and self.settings.compiler.version == 16:
+            tc.extra_cxxflags = ["-DBOOST_ASIO_DISABLE_CONCEPTS"]
         tc.generate()
 
     def build(self):
@@ -161,7 +170,17 @@ class Xrpl(ConanFile):
         # `include/`, not `include/ripple/proto/`.
         libxrpl.includedirs = ['include', 'include/ripple/proto']
         libxrpl.requires = [
-            'boost::boost',
+            'boost::headers',
+            'boost::chrono',
+            'boost::container',
+            'boost::coroutine',
+            'boost::date_time',
+            'boost::filesystem',
+            'boost::json',
+            'boost::program_options',
+            'boost::regex',
+            'boost::system',
+            'boost::thread',
             'date::date',
             'grpc::grpc++',
             'libarchive::libarchive',

docs/build/environment.md

@@ -23,7 +23,7 @@ direction.
 
 ```
 apt update
-apt install --yes curl git libssl-dev python3.10-dev python3-pip make g++-11 libprotobuf-dev protobuf-compiler
+apt install --yes curl git libssl-dev pipx 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,7 +35,8 @@ make --jobs $(nproc)
 make install
 cd ..
 
-pip3 install 'conan<2'
+pipx install 'conan<2'
+pipx ensurepath
 ```
 
 [1]: https://github.com/thejohnfreeman/rippled-docker/blob/master/ubuntu-22.04/install.sh

docs/consensus.md

@@ -558,7 +558,7 @@ struct ConsensusResult
     ConsensusTimer roundTime;
 
     // Indicates state in which consensus ended.  Once in the accept phase
-    // will be either Yes or MovedOn
+    // will be either Yes or MovedOn or Expired
     ConsensusState state = ConsensusState::No;
 };
 

examples/example/conanfile.py

@@ -1,59 +0,0 @@
-from conan import ConanFile, conan_version
-from conan.tools.cmake import CMake, cmake_layout
-
-class Example(ConanFile):
-
-    def set_name(self):
-        if self.name is None:
-            self.name = 'example'
-
-    def set_version(self):
-        if self.version is None:
-            self.version = '0.1.0'
-
-    license = 'ISC'
-    author = 'John Freeman <jfreeman08@gmail.com>'
-
-    settings = 'os', 'compiler', 'build_type', 'arch'
-    options = {'shared': [True, False], 'fPIC': [True, False]}
-    default_options = {
-        'shared': False,
-        'fPIC': True,
-        'xrpl:xrpld': False,
-    }
-
-    requires = ['xrpl/2.2.0-rc1@jfreeman/nodestore']
-    generators = ['CMakeDeps', 'CMakeToolchain']
-
-    exports_sources = [
-        'CMakeLists.txt',
-        'cmake/*',
-        'external/*',
-        'include/*',
-        'src/*',
-    ]
-
-    # For out-of-source build.
-    # https://docs.conan.io/en/latest/reference/build_helpers/cmake.html#configure
-    no_copy_source = True
-
-    def layout(self):
-        cmake_layout(self)
-
-    def config_options(self):
-        if self.settings.os == 'Windows':
-            del self.options.fPIC
-
-    def build(self):
-        cmake = CMake(self)
-        cmake.configure(variables={'BUILD_TESTING': 'NO'})
-        cmake.build()
-
-    def package(self):
-        cmake = CMake(self)
-        cmake.install()
-
-    def package_info(self):
-        path = f'{self.package_folder}/share/{self.name}/cpp_info.py'
-        with open(path, 'r') as file:
-            exec(file.read(), {}, {'self': self.cpp_info})

external/antithesis-sdk/CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.25)
+cmake_minimum_required(VERSION 3.18)
 
 # Note, version set explicitly by rippled project
 project(antithesis-sdk-cpp VERSION 0.4.4 LANGUAGES CXX)

external/nudb/conandata.yml

@@ -1,10 +0,0 @@
-sources:
-  "2.0.8":
-    url: "https://github.com/CPPAlliance/NuDB/archive/2.0.8.tar.gz"
-    sha256: "9b71903d8ba111cd893ab064b9a8b6ac4124ed8bd6b4f67250205bc43c7f13a8"
-patches:
-  "2.0.8":
-    - patch_file: "patches/2.0.8-0001-add-include-stdexcept-for-msvc.patch"
-      patch_description: "Fix build for MSVC by including stdexcept"
-      patch_type: "portability"
-      patch_source: "https://github.com/cppalliance/NuDB/pull/100/files"

external/nudb/conanfile.py

@@ -1,72 +0,0 @@
-import os
-
-from conan import ConanFile
-from conan.tools.build import check_min_cppstd
-from conan.tools.files import apply_conandata_patches, copy, export_conandata_patches, get
-from conan.tools.layout import basic_layout
-
-required_conan_version = ">=1.52.0"
-
-
-class NudbConan(ConanFile):
-    name = "nudb"
-    description = "A fast key/value insert-only database for SSD drives in C++11"
-    license = "BSL-1.0"
-    url = "https://github.com/conan-io/conan-center-index"
-    homepage = "https://github.com/CPPAlliance/NuDB"
-    topics = ("header-only", "KVS", "insert-only")
-
-    package_type = "header-library"
-    settings = "os", "arch", "compiler", "build_type"
-    no_copy_source = True
-
-    @property
-    def _min_cppstd(self):
-        return 11
-
-    def export_sources(self):
-        export_conandata_patches(self)
-
-    def layout(self):
-        basic_layout(self, src_folder="src")
-
-    def requirements(self):
-        self.requires("boost/1.83.0")
-
-    def package_id(self):
-        self.info.clear()
-
-    def validate(self):
-        if self.settings.compiler.cppstd:
-            check_min_cppstd(self, self._min_cppstd)
-
-    def source(self):
-        get(self, **self.conan_data["sources"][self.version], strip_root=True)
-
-    def build(self):
-        apply_conandata_patches(self)
-
-    def package(self):
-        copy(self, "LICENSE*",
-             dst=os.path.join(self.package_folder, "licenses"),
-             src=self.source_folder)
-        copy(self, "*",
-             dst=os.path.join(self.package_folder, "include"),
-             src=os.path.join(self.source_folder, "include"))
-
-    def package_info(self):
-        self.cpp_info.bindirs = []
-        self.cpp_info.libdirs = []
-
-        self.cpp_info.set_property("cmake_target_name", "NuDB")
-        self.cpp_info.set_property("cmake_target_aliases", ["NuDB::nudb"])
-        self.cpp_info.set_property("cmake_find_mode", "both")
-
-        self.cpp_info.components["core"].set_property("cmake_target_name", "nudb")
-        self.cpp_info.components["core"].names["cmake_find_package"] = "nudb"
-        self.cpp_info.components["core"].names["cmake_find_package_multi"] = "nudb"
-        self.cpp_info.components["core"].requires = ["boost::thread", "boost::system"]
-
-        # TODO: to remove in conan v2 once cmake_find_package_* generators removed
-        self.cpp_info.names["cmake_find_package"] = "NuDB"
-        self.cpp_info.names["cmake_find_package_multi"] = "NuDB"

external/nudb/patches/2.0.8-0001-add-include-stdexcept-for-msvc.patch

@@ -1,24 +0,0 @@
-diff --git a/include/nudb/detail/stream.hpp b/include/nudb/detail/stream.hpp
-index 6c07bf1..e0ce8ed 100644
---- a/include/nudb/detail/stream.hpp
-+++ b/include/nudb/detail/stream.hpp
-@@ -14,6 +14,7 @@
- #include <cstdint>
- #include <cstring>
- #include <memory>
-+#include <stdexcept>
- 
- namespace nudb {
- namespace detail {
-diff --git a/include/nudb/impl/context.ipp b/include/nudb/impl/context.ipp
-index beb7058..ffde0b3 100644
---- a/include/nudb/impl/context.ipp
-+++ b/include/nudb/impl/context.ipp
-@@ -9,6 +9,7 @@
- #define NUDB_IMPL_CONTEXT_IPP
- 
- #include <nudb/detail/store_base.hpp>
-+#include <stdexcept>
- 
- namespace nudb {
- 

external/rocksdb/conandata.yml

@@ -1,27 +1,12 @@
 sources:
-  "6.29.5":
+  "9.7.3":
-    url: "https://github.com/facebook/rocksdb/archive/refs/tags/v6.29.5.tar.gz"
+    url: "https://github.com/facebook/rocksdb/archive/refs/tags/v9.7.3.tar.gz"
-    sha256: "ddbf84791f0980c0bbce3902feb93a2c7006f6f53bfd798926143e31d4d756f0"
+    sha256: "acfabb989cbfb5b5c4d23214819b059638193ec33dad2d88373c46448d16d38b"
-  "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:
-  "6.29.5":
+  "9.7.3":
-    - patch_file: "patches/6.29.5-0001-add-include-cstdint-for-gcc-13.patch"
+    - patch_file: "patches/9.x.x-0001-exclude-thirdparty.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"
-  "6.27.3":
+    - patch_file: "patches/9.7.3-0001-memory-leak.patch"
-    - patch_file: "patches/6.27.3-0001-add-include-cstdint-for-gcc-13.patch"
+      patch_description: "Fix a leak of obsolete blob files left open until DB::Close()"
-      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"
-    homepage = "https://github.com/facebook/rocksdb"
+    description = "A library that provides an embeddable, persistent key-value store for fast storage"
     license = ("GPL-2.0-only", "Apache-2.0")
     url = "https://github.com/conan-io/conan-center-index"
-    description = "A library that provides an embeddable, persistent key-value store for fast storage"
+    homepage = "https://github.com/facebook/rocksdb"
     topics = ("database", "leveldb", "facebook", "key-value")
     package_type = "library"
     settings = "os", "arch", "compiler", "build_type"
@@ -163,6 +163,8 @@ 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

@@ -1,30 +0,0 @@
---- 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

@@ -1,16 +0,0 @@
-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

@@ -0,0 +1,319 @@
+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

@@ -0,0 +1,30 @@
+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)

include/xrpl/basics/BasicConfig.h

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

include/xrpl/basics/Buffer.h

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

include/xrpl/basics/CountedObject.h

@@ -21,6 +21,7 @@
 #define RIPPLE_BASICS_COUNTEDOBJECT_H_INCLUDED
 
 #include <xrpl/beast/type_name.h>
+
 #include <atomic>
 #include <string>
 #include <utility>

include/xrpl/basics/Expected.h

@@ -22,11 +22,19 @@
 
 #include <xrpl/basics/contract.h>
 
+#if defined(__clang__)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated"
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+#endif
+
 #include <boost/outcome.hpp>
 
-#include <concepts>
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#endif
+
 #include <stdexcept>
-#include <type_traits>
 
 namespace ripple {
 
@@ -95,7 +103,7 @@ public:
     {
     }
 
-    constexpr const E&
+    constexpr E const&
     value() const&
     {
         return val_;
@@ -113,7 +121,7 @@ public:
         return std::move(val_);
     }
 
-    constexpr const E&&
+    constexpr E const&&
     value() const&&
     {
         return std::move(val_);

include/xrpl/basics/IntrusivePointer.h

@@ -0,0 +1,515 @@
+//------------------------------------------------------------------------------
+/*
+    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

@@ -0,0 +1,740 @@
+//------------------------------------------------------------------------------
+/*
+    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

@@ -0,0 +1,502 @@
+//------------------------------------------------------------------------------
+/*
+    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,6 +21,7 @@
 #define RIPPLE_BASICS_LOCALVALUE_H_INCLUDED
 
 #include <boost/thread/tss.hpp>
+
 #include <memory>
 #include <unordered_map>
 

include/xrpl/basics/Log.h

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

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

@@ -22,6 +22,7 @@
 
 #include <xrpl/basics/Resolver.h>
 #include <xrpl/beast/utility/Journal.h>
+
 #include <boost/asio/io_service.hpp>
 
 namespace ripple {

include/xrpl/basics/SharedWeakCachePointer.h

@@ -0,0 +1,135 @@
+//------------------------------------------------------------------------------
+/*
+    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

@@ -0,0 +1,192 @@
+//------------------------------------------------------------------------------
+/*
+    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/Slice.h

@@ -23,6 +23,7 @@
 #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

@@ -29,7 +29,6 @@
 #include <array>
 #include <cstdint>
 #include <optional>
-#include <sstream>
 #include <string>
 
 namespace ripple {

include/xrpl/basics/TaggedCache.h

@@ -20,11 +20,14 @@
 #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>
@@ -50,6 +53,8 @@ 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>
@@ -60,6 +65,8 @@ 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(
@@ -69,231 +76,48 @@ 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::pair<
+    using SweptPointersVector = std::vector<SharedWeakUnionPointerType>;
-        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(const key_type& key, bool valid)
+    del(key_type const& 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
@@ -307,100 +131,23 @@ public:
 
         @return `true` If the key already existed.
     */
-public:
+    template <class R>
     bool
     canonicalize(
-        const key_type& key,
+        key_type const& key,
-        std::shared_ptr<T>& data,
+        SharedPointerType& data,
-        std::function<bool(std::shared_ptr<T> const&)>&& replace)
+        R&& replaceCallback);
-    {
-        // 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(
-        const key_type& key,
+        key_type const& key,
-        std::shared_ptr<T> const& data)
+        SharedPointerType const& data);
-    {
-        return canonicalize(
-            key,
-            const_cast<std::shared_ptr<T>&>(data),
-            [](std::shared_ptr<T> const&) { return true; });
-    }
 
     bool
-    canonicalize_replace_client(const key_type& key, std::shared_ptr<T>& data)
+    canonicalize_replace_client(key_type const& key, SharedPointerType& data);
-    {
-        return canonicalize(
-            key, data, [](std::shared_ptr<T> const&) { return false; });
-    }
 
-    std::shared_ptr<T>
+    SharedPointerType
-    fetch(const key_type& key)
+    fetch(key_type const& 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.
@@ -409,26 +156,11 @@ 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.
@@ -436,50 +168,18 @@ public:
     //             simply return an iterator.
     //
     bool
-    retrieve(const key_type& key, T& data)
+    retrieve(key_type const& 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
@@ -487,73 +187,16 @@ public:
             std::shared_ptr<SLE const>(void)
     */
     template <class Handler>
-    std::shared_ptr<T>
+    SharedPointerType
-    fetch(key_type const& digest, Handler const& h)
+    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:
-    std::shared_ptr<T>
+    SharedPointerType
-    initialFetch(key_type const& key, std::lock_guard<mutex_type> const& l)
+    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
@@ -599,36 +242,37 @@ private:
     class ValueEntry
     {
     public:
-        std::shared_ptr<mapped_type> ptr;
+        shared_weak_combo_pointer_type ptr;
-        std::weak_ptr<mapped_type> weak_ptr;
         clock_type::time_point last_access;
 
         ValueEntry(
             clock_type::time_point const& last_access_,
-            std::shared_ptr<mapped_type> const& ptr_)
+            shared_pointer_type const& ptr_)
-            : ptr(ptr_), weak_ptr(ptr_), last_access(last_access_)
+            : ptr(ptr_), last_access(last_access_)
         {
         }
 
         bool
         isWeak() const
         {
-            return ptr == nullptr;
+            if (!ptr)
+                return true;
+            return ptr.isWeak();
         }
         bool
         isCached() const
         {
-            return ptr != nullptr;
+            return ptr && ptr.isStrong();
         }
         bool
         isExpired() const
         {
-            return weak_ptr.expired();
+            return ptr.expired();
         }
-        std::shared_ptr<mapped_type>
+        SharedPointerType
         lock()
         {
-            return weak_ptr.lock();
+            return ptr.lock();
         }
         void
         touch(clock_type::time_point const& now)
@@ -657,72 +301,7 @@ 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(
@@ -731,45 +310,7 @@ 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;
@@ -781,10 +322,10 @@ private:
     std::string m_name;
 
     // Desired number of cache entries (0 = ignore)
-    int m_target_size;
+    int const m_target_size;
 
     // Desired maximum cache age
-    clock_type::duration m_target_age;
+    clock_type::duration const m_target_age;
 
     // Number of items cached
     int m_cache_count;

include/xrpl/basics/UnorderedContainers.h

@@ -25,6 +25,7 @@
 #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/algorithm.h

@@ -20,7 +20,6 @@
 #ifndef RIPPLE_ALGORITHM_H_INCLUDED
 #define RIPPLE_ALGORITHM_H_INCLUDED
 
-#include <iterator>
 #include <utility>
 
 namespace ripple {

include/xrpl/basics/base_uint.h

@@ -33,12 +33,13 @@
 #include <xrpl/basics/strHex.h>
 #include <xrpl/beast/utility/Zero.h>
 #include <xrpl/beast/utility/instrumentation.h>
+
 #include <boost/endian/conversion.hpp>
 #include <boost/functional/hash.hpp>
+
 #include <algorithm>
 #include <array>
 #include <cstring>
-#include <functional>
 #include <type_traits>
 
 namespace ripple {
@@ -373,7 +374,7 @@ public:
     }
 
     base_uint&
-    operator^=(const base_uint& b)
+    operator^=(base_uint const& b)
     {
         for (int i = 0; i < WIDTH; i++)
             data_[i] ^= b.data_[i];
@@ -382,7 +383,7 @@ public:
     }
 
     base_uint&
-    operator&=(const base_uint& b)
+    operator&=(base_uint const& b)
     {
         for (int i = 0; i < WIDTH; i++)
             data_[i] &= b.data_[i];
@@ -391,7 +392,7 @@ public:
     }
 
     base_uint&
-    operator|=(const base_uint& b)
+    operator|=(base_uint const& b)
     {
         for (int i = 0; i < WIDTH; i++)
             data_[i] |= b.data_[i];
@@ -414,11 +415,11 @@ public:
         return *this;
     }
 
-    const base_uint
+    base_uint const
     operator++(int)
     {
         // postfix operator
-        const base_uint ret = *this;
+        base_uint const ret = *this;
         ++(*this);
 
         return ret;
@@ -440,11 +441,11 @@ public:
         return *this;
     }
 
-    const base_uint
+    base_uint const
     operator--(int)
     {
         // postfix operator
-        const base_uint ret = *this;
+        base_uint const ret = *this;
         --(*this);
 
         return ret;
@@ -465,7 +466,7 @@ public:
     }
 
     base_uint&
-    operator+=(const base_uint& b)
+    operator+=(base_uint const& b)
     {
         std::uint64_t carry = 0;
 
@@ -510,7 +511,7 @@ public:
     }
 
     [[nodiscard]] constexpr bool
-    parseHex(const char* str)
+    parseHex(char const* str)
     {
         return parseHex(std::string_view{str});
     }

include/xrpl/basics/chrono.h

@@ -20,17 +20,16 @@
 #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()(const T& left, const T& right) const
+    operator()(T const& left, T const& right) const
     {
         return std::less<T>()(left, right);
     }
@@ -55,7 +55,7 @@ struct equal_to
     using result_type = bool;
 
     constexpr bool
-    operator()(const T& left, const T& right) const
+    operator()(T const& left, T const& right) const
     {
         return std::equal_to<T>()(left, right);
     }

include/xrpl/basics/contract.h

@@ -21,9 +21,9 @@
 #define RIPPLE_BASICS_CONTRACT_H_INCLUDED
 
 #include <xrpl/beast/type_name.h>
+
 #include <exception>
 #include <string>
-#include <typeinfo>
 #include <utility>
 
 namespace ripple {

include/xrpl/basics/hardened_hash.h

@@ -24,12 +24,8 @@
 #include <xrpl/beast/hash/xxhasher.h>
 
 #include <cstdint>
-#include <functional>
 #include <mutex>
 #include <random>
-#include <type_traits>
-#include <unordered_map>
-#include <unordered_set>
 #include <utility>
 
 namespace ripple {

include/xrpl/basics/make_SSLContext.h

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

include/xrpl/basics/mulDiv.h

@@ -23,7 +23,6 @@
 #include <cstdint>
 #include <limits>
 #include <optional>
-#include <utility>
 
 namespace ripple {
 auto constexpr muldiv_max = std::numeric_limits<std::uint64_t>::max();

include/xrpl/basics/partitioned_unordered_map.h

@@ -22,6 +22,7 @@
 
 #include <xrpl/beast/hash/uhash.h>
 #include <xrpl/beast/utility/instrumentation.h>
+
 #include <functional>
 #include <optional>
 #include <string>
@@ -51,7 +52,7 @@ template <
     typename Value,
     typename Hash,
     typename Pred = std::equal_to<Key>,
-    typename Alloc = std::allocator<std::pair<const Key, Value>>>
+    typename Alloc = std::allocator<std::pair<Key const, 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,6 +19,7 @@
 #define RIPPLE_BASICS_SPINLOCK_H_INCLUDED
 
 #include <xrpl/beast/utility/instrumentation.h>
+
 #include <atomic>
 #include <limits>
 #include <type_traits>

include/xrpl/basics/tagged_integer.h

@@ -21,11 +21,11 @@
 #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>
-#include <utility>
 
 namespace ripple {
 
@@ -74,13 +74,13 @@ public:
     }
 
     bool
-    operator<(const tagged_integer& rhs) const noexcept
+    operator<(tagged_integer const& rhs) const noexcept
     {
         return m_value < rhs.m_value;
     }
 
     bool
-    operator==(const tagged_integer& rhs) const noexcept
+    operator==(tagged_integer const& rhs) const noexcept
     {
         return m_value == rhs.m_value;
     }
@@ -142,14 +142,14 @@ public:
     }
 
     tagged_integer&
-    operator<<=(const tagged_integer& rhs) noexcept
+    operator<<=(tagged_integer const& rhs) noexcept
     {
         m_value <<= rhs.m_value;
         return *this;
     }
 
     tagged_integer&
-    operator>>=(const tagged_integer& rhs) noexcept
+    operator>>=(tagged_integer const& rhs) noexcept
     {
         m_value >>= rhs.m_value;
         return *this;

include/xrpl/beast/asio/io_latency_probe.h

@@ -21,6 +21,7 @@
 #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/xrpl/beast/clock/abstract_clock.h

@@ -20,9 +20,6 @@
 #ifndef BEAST_CHRONO_ABSTRACT_CLOCK_H_INCLUDED
 #define BEAST_CHRONO_ABSTRACT_CLOCK_H_INCLUDED
 
-#include <chrono>
-#include <string>
-
 namespace beast {
 
 /** Abstract interface to a clock.

include/xrpl/beast/clock/manual_clock.h

@@ -23,6 +23,8 @@
 #include <xrpl/beast/clock/abstract_clock.h>
 #include <xrpl/beast/utility/instrumentation.h>
 
+#include <chrono>
+
 namespace beast {
 
 /** Manual clock implementation.

include/xrpl/beast/container/aged_container_utility.h

@@ -22,6 +22,7 @@
 
 #include <xrpl/beast/container/aged_container.h>
 
+#include <chrono>
 #include <type_traits>
 
 namespace beast {

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

@@ -20,8 +20,6 @@
 #ifndef BEAST_CONTAINER_DETAIL_AGED_ASSOCIATIVE_CONTAINER_H_INCLUDED
 #define BEAST_CONTAINER_DETAIL_AGED_ASSOCIATIVE_CONTAINER_H_INCLUDED
 
-#include <type_traits>
-
 namespace beast {
 namespace detail {
 

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

@@ -25,13 +25,14 @@
 #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 <iterator>
 #include <memory>
 #include <type_traits>
 #include <utility>

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

@@ -25,8 +25,10 @@
 #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,6 +11,7 @@
 #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,16 +23,15 @@
 #include <xrpl/beast/utility/instrumentation.h>
 
 #include <boost/core/detail/string_view.hpp>
+
 #include <algorithm>
 #include <cerrno>
 #include <charconv>
 #include <cstdlib>
 #include <iterator>
-#include <limits>
 #include <string>
 #include <type_traits>
 #include <typeinfo>
-#include <utility>
 
 namespace beast {
 

include/xrpl/beast/core/List.h

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

include/xrpl/beast/hash/hash_append.h

@@ -23,14 +23,37 @@
 
 #include <boost/container/flat_set.hpp>
 #include <boost/endian/conversion.hpp>
+
+/*
+
+Workaround for overzealous clang warning, which trips on libstdc++ headers
+
+  In file included from
+  /usr/lib/gcc/x86_64-linux-gnu/12/../../../../include/c++/12/bits/stl_algo.h:61:
+  /usr/lib/gcc/x86_64-linux-gnu/12/../../../../include/c++/12/bits/stl_tempbuf.h:263:8:
+  error: 'get_temporary_buffer<std::pair<ripple::Quality, const
+  std::vector<std::unique_ptr<ripple::Step>> *>>' is deprecated
+  [-Werror,-Wdeprecated-declarations] 263 |
+  std::get_temporary_buffer<value_type>(_M_original_len));
+       ^
+*/
+
+#if defined(__clang__)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated"
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+#endif
+
+#include <functional>
+
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#endif
+
 #include <array>
 #include <chrono>
-#include <cstdint>
 #include <cstring>
-#include <functional>
-#include <map>
 #include <memory>
-#include <set>
 #include <string>
 #include <system_error>
 #include <tuple>

include/xrpl/beast/hash/uhash.h

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

include/xrpl/beast/hash/xxhasher.h

@@ -21,6 +21,7 @@
 #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 <memory>
-
 #include <xrpl/beast/insight/MeterImpl.h>
 
+#include <memory>
+
 namespace beast {
 namespace insight {
 

include/xrpl/beast/insight/StatsDCollector.h

@@ -21,7 +21,6 @@
 #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,13 +25,11 @@
 #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 <string>
-#include <typeinfo>
 
 //------------------------------------------------------------------------------
 

include/xrpl/beast/net/IPAddressConversion.h

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

include/xrpl/beast/net/IPAddressV4.h

@@ -21,12 +21,8 @@
 #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 <string>
-#include <utility>
 
 namespace beast {
 namespace IP {

include/xrpl/beast/net/IPAddressV6.h

@@ -21,12 +21,8 @@
 #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 <string>
-#include <utility>
 
 namespace beast {
 namespace IP {

include/xrpl/beast/net/IPEndpoint.h

@@ -25,7 +25,6 @@
 #include <xrpl/beast/net/IPAddress.h>
 
 #include <cstdint>
-#include <ios>
 #include <optional>
 #include <string>
 
@@ -215,7 +214,7 @@ namespace std {
 template <>
 struct hash<::beast::IP::Endpoint>
 {
-    explicit hash() = default;
+    hash() = default;
 
     std::size_t
     operator()(::beast::IP::Endpoint const& endpoint) const
@@ -230,7 +229,7 @@ namespace boost {
 template <>
 struct hash<::beast::IP::Endpoint>
 {
-    explicit hash() = default;
+    hash() = default;
 
     std::size_t
     operator()(::beast::IP::Endpoint const& endpoint) const

include/xrpl/beast/rfc2616.h

@@ -20,10 +20,6 @@
 #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>
@@ -34,7 +30,6 @@
 #include <cctype>
 #include <iterator>
 #include <string>
-#include <utility>
 #include <vector>
 
 namespace beast {

include/xrpl/beast/test/yield_to.h

@@ -11,8 +11,8 @@
 #include <boost/asio/io_service.hpp>
 #include <boost/asio/spawn.hpp>
 #include <boost/optional.hpp>
+
 #include <condition_variable>
-#include <functional>
 #include <mutex>
 #include <thread>
 #include <vector>

include/xrpl/beast/unit_test/match.h

@@ -9,6 +9,7 @@
 #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,11 +10,12 @@
 
 #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 <iomanip>
 #include <iostream>
 #include <sstream>

include/xrpl/beast/unit_test/runner.h

@@ -9,9 +9,10 @@
 #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>
 
 namespace beast {