style: Compare connection_ to nullptr explicitly

Resolve the PeerReservationTable.h conflict with develop's naming and
member-init changes. Use insertOrAssign in the new error text, and add the
direct includes that misc-include-cleaner needs for the new Throw, JLOG
and std::runtime_error uses.

.clang-tidy

@@ -90,6 +90,13 @@ CheckOptions:
   readability-identifier-naming.ClassCase: CamelCase
   readability-identifier-naming.StructCase: CamelCase
   readability-identifier-naming.UnionCase: CamelCase
+  readability-identifier-naming.TypeAliasCase: CamelCase
+  readability-identifier-naming.TypedefCase: CamelCase
+  # Member type names mandated by std/Boost concepts. Subtrees that need more
+  # than these carry their own .clang-tidy (include/xrpl/{beast,basics,protocol,
+  # peerfinder}, src/test/beast); one-off cases use an inline NOLINT.
+  readability-identifier-naming.TypeAliasIgnoredRegexp: "^(const_iterator|const_reference|difference_type|duration|iterator|iterator_category|key_type|mapped_type|period|pointer|reference|rep|result_type|size_type|time_point|value_type)$"
+  readability-identifier-naming.TypedefIgnoredRegexp: "^(const_iterator|const_reference|difference_type|duration|iterator|iterator_category|key_type|mapped_type|period|pointer|reference|rep|result_type|size_type|time_point|value_type)$"
   readability-identifier-naming.EnumCase: CamelCase
   readability-identifier-naming.EnumConstantCase: CamelCase
   readability-identifier-naming.ScopedEnumConstantCase: CamelCase
@@ -122,5 +129,5 @@ CheckOptions:
   readability-identifier-naming.GlobalFunctionIgnoredRegexp: "^(to_string|hash_append|tuple_hash)$"
 
 HeaderFilterRegex: '^.*/(tests?|xrpl|xrpld)/.*\.(h|hpp|ipp)$'
-ExcludeHeaderFilterRegex: '^.*/protocol_autogen/.*\.(h|hpp)$'
+ExcludeHeaderFilterRegex: '^.*/protocol_autogen/.*\.(h|hpp)$|^.*\.pb\.h$'
 WarningsAsErrors: "*"

.cspell.config.yaml

@@ -166,6 +166,7 @@ words:
   - legleux
   - levelization
   - levelized
+  - lgrdb
   - libpb
   - libxrpl
   - llection

.github/actions/release-info/action.yml

@@ -15,30 +15,25 @@ outputs:
 runs:
   using: composite
   steps:
-    # A tag names its own version. Anything else takes it from BuildInfo.cpp and
-    # appends the commit hash as build metadata, joined with a plus sign because a
-    # Conan version cannot contain two hyphens.
+    # A tag names its own version. Anything else is a development build named by
+    # its commit hash, matching what cmake/XrplVersion.cmake derives: the head of
+    # a pull request rather than the merge commit GitHub creates for it.
     - name: Determine version
       id: version
       shell: bash
       env:
         IS_TAG: ${{ startsWith(github.ref, 'refs/tags/') }}
         REF_NAME: ${{ github.ref_name }}
-        SHA: ${{ github.sha }}
+        SHA: ${{ github.event.pull_request.head.sha || github.sha }}
       run: |
         if [[ "${IS_TAG}" == "true" ]]; then
             version="${REF_NAME}"
         else
-            version="$(awk -F'"' '/versionString =/ { print $2 }' src/libxrpl/protocol/BuildInfo.cpp)"
-            if [[ -z "${version}" ]]; then
-                echo "Unable to read versionString from BuildInfo.cpp." >&2
-                exit 1
-            fi
-            version="${version}+${SHA:0:7}"
+            version="0.0.0-dev+${SHA:0:7}"
         fi
 
         echo "version=${version}" | tee -a "${GITHUB_OUTPUT}"
 
     - name: Determine release channel and package release
       id: release_info
-      uses: XRPLF/actions/release-info@7cc0e4a8d9d0b838f92c48d312856b190341bbba
+      uses: XRPLF/actions/release-info@ebcf6cea14eee258697308a51fea55cad777581b

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

@@ -194,6 +194,9 @@ tests.libxrpl > xrpl.resource
 tests.libxrpl > xrpl.server
 tests.libxrpl > xrpl.shamap
 tests.libxrpl > xrpl.tx
+tests.xrpld > xrpld.rpc
+tests.xrpld > xrpl.json
+tests.xrpld > xrpl.protocol
 xrpl.conditions > xrpl.basics
 xrpl.conditions > xrpl.protocol
 xrpl.config > xrpl.basics

.github/scripts/releasing/check-no-copied-release-commits.sh

@@ -0,0 +1,47 @@
+#!/bin/bash
+
+# Exit the script as soon as an error occurs.
+set -euo pipefail
+
+# This script fails if the commits in <base>..<head> copy commits from a release or staging branch
+# (e.g. by rebasing or cherry-picking them) instead of merging that branch, see RELEASING.md.
+# Commits are compared by patch-id,
+# and only against release and staging commits that <head> does not already contain.
+# Usage: .github/scripts/releasing/check-no-copied-release-commits.sh <base> <head>
+
+if [ "$#" -ne 2 ]; then
+    echo "Usage: $0 <base> <head>"
+    exit 1
+fi
+
+BASE=$1
+HEAD=$2
+
+patch_ids() {
+    git log --no-merges --patch --no-color --no-ext-diff "$@" | git patch-id --stable | sort
+}
+
+mapfile -t BRANCHES < <(git for-each-ref --format='%(refname)' 'refs/remotes/*/release/*' 'refs/remotes/*/staging/*')
+if [ "${#BRANCHES[@]}" -eq 0 ]; then
+    echo "Error: No release or staging branches found."
+    exit 1
+fi
+
+# Each line is "<patch-id> <commit>".
+RELEASE_PATCHES=$(patch_ids "${BRANCHES[@]}" --not "${HEAD}")
+PR_PATCHES=$(patch_ids "${BASE}..${HEAD}")
+
+# Each line is "<patch-id> <release commit> <PR commit>".
+COPIES=$(join <(echo "${RELEASE_PATCHES}") <(echo "${PR_PATCHES}"))
+if [ -z "${COPIES}" ]; then
+    echo "No copied release commits found."
+    exit 0
+fi
+
+echo "These commits copy release commits instead of merging them:"
+while read -r _ RELEASE_COMMIT PR_COMMIT; do
+    echo "  $(git log -1 --format='%h %s' "${PR_COMMIT}") (copies ${RELEASE_COMMIT:0:10})"
+done <<<"${COPIES}"
+echo
+echo "Merge the release tag (or branch) instead, see RELEASING.md."
+exit 1

.github/scripts/releasing/check-releases-merged.sh

@@ -0,0 +1,46 @@
+#!/bin/bash
+
+# Exit the script as soon as an error occurs.
+set -euo pipefail
+
+# This script fails if a final release (a tag like 3.4.0) on a release branch
+# is not merged back into <develop> within a few days, see RELEASING.md.
+# Usage: .github/scripts/releasing/check-releases-merged.sh <develop>
+
+if [ "$#" -ne 1 ]; then
+    echo "Usage: $0 <develop>"
+    exit 1
+fi
+
+DEVELOP=$1
+GRACE_DAYS=3
+
+mapfile -t MERGED_ARGS < <(git for-each-ref --format='--merged=%(refname)' 'refs/remotes/*/release/*')
+if [ "${#MERGED_ARGS[@]}" -eq 0 ]; then
+    echo "Error: No release branches found."
+    exit 1
+fi
+
+# Tags on a release branch that <develop> does not contain.
+TAGS=$(git for-each-ref --format='%(refname:short) %(creatordate:unix)' \
+    "${MERGED_ARGS[@]}" --no-merged="${DEVELOP}" 'refs/tags/[0-9]*')
+
+MISSING=0
+while read -r TAG CREATED; do
+    if ! [[ "${TAG}" =~ ^[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
+        continue
+    fi
+    if (($(date +%s) - CREATED < GRACE_DAYS * 86400)); then
+        echo "${TAG}: not merged yet, still within the ${GRACE_DAYS}-day grace period."
+    else
+        echo "${TAG}: not merged into develop."
+        MISSING=1
+    fi
+done <<<"${TAGS}"
+
+if [ "${MISSING}" -ne 0 ]; then
+    echo
+    echo "Merge the missing releases back into develop, see RELEASING.md."
+    exit 1
+fi
+echo "No releases past the grace period are missing from develop."

.github/scripts/rename/config.sh

@@ -62,7 +62,7 @@ ${SED_COMMAND} -i 's@ripple/@xrpld/@g' src/test/core/Config_test.cpp
 ${SED_COMMAND} -i 's/Rippled/File/g' src/test/core/Config_test.cpp
 
 # Restore the old config file name in the code that maintains support for now.
-${SED_COMMAND} -i 's/kConfigLegacyName = "xrpld.cfg"/kConfigLegacyName = "rippled.cfg"/g' src/xrpld/core/detail/Config.cpp
+${SED_COMMAND} -i 's/kConfigLegacyName = "xrpld.cfg"/kConfigLegacyName = "rippled.cfg"/g' src/xrpld/core/Config.h
 
 # Restore an URL.
 ${SED_COMMAND} -i 's/connect-your-xrpld-to-the-xrp-test-net.html/connect-your-rippled-to-the-xrp-test-net.html/g' cfg/xrpld-example.cfg

.github/scripts/rename/docs.sh

@@ -90,7 +90,7 @@ ${SED_COMMAND} -i 's/www.ripple.com/www.xrpl.org/g' src/test/protocol/Seed_test.
 # Restore specific changes.
 ${SED_COMMAND} -i 's@b5efcc/src/xrpld@b5efcc/src/ripple@' include/xrpl/protocol/README.md
 ${SED_COMMAND} -i 's/dbPrefix_ = "xrpldb"/dbPrefix_ = "rippledb"/' src/xrpld/app/misc/SHAMapStoreImp.h # cspell: disable-line
-${SED_COMMAND} -i 's/kConfigLegacyName = "xrpld.cfg"/kConfigLegacyName = "rippled.cfg"/' src/xrpld/core/detail/Config.cpp
+${SED_COMMAND} -i 's/kConfigLegacyName = "xrpld.cfg"/kConfigLegacyName = "rippled.cfg"/' src/xrpld/core/Config.h
 
 popd
 echo "Renaming complete."

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

@@ -74,7 +74,7 @@
         "extra_cmake_args": "-Dvalidator_keys=ON",
         "package": {
           "type": "deb",
-          "image": "ghcr.io/xrplf/xrpld/packaging-debian:sha-49cdc10"
+          "image": "ghcr.io/xrplf/xrpld/packaging-debian:sha-3a2d19f"
         }
       },
       {
@@ -86,7 +86,7 @@
         "extra_cmake_args": "-Dvalidator_keys=ON -Dassert=ON",
         "package": {
           "type": "deb",
-          "image": "ghcr.io/xrplf/xrpld/packaging-debian:sha-49cdc10",
+          "image": "ghcr.io/xrplf/xrpld/packaging-debian:sha-3a2d19f",
           "variant": "assert"
         }
       }
@@ -101,7 +101,7 @@
         "extra_cmake_args": "-Dvalidator_keys=ON",
         "package": {
           "type": "rpm",
-          "image": "ghcr.io/xrplf/xrpld/packaging-rhel:sha-49cdc10"
+          "image": "ghcr.io/xrplf/xrpld/packaging-rhel:sha-3a2d19f"
         }
       }
     ]

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

@@ -58,7 +58,7 @@ jobs:
             base_image: debian:bookworm
           - name: rhel
             base_image: registry.access.redhat.com/ubi9/ubi:latest
-    uses: XRPLF/actions/.github/workflows/build-multiarch-image.yml@034e87065fcd0100214cf0672923bd38d193cf78
+    uses: XRPLF/actions/.github/workflows/build-multiarch-image.yml@696384b292577293292daed06af0306d1b83bd7d
     with:
       image_name: xrpld/nix-${{ matrix.distro.name }}
       dockerfile: nix/docker/Dockerfile

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

@@ -7,12 +7,12 @@ on:
     paths:
       - ".github/workflows/build-packaging-images.yml"
       - "bin/install-packaging-tools.sh"
-      - "package/docker/**"
+      - "package/images/packaging/**"
   pull_request:
     paths:
       - ".github/workflows/build-packaging-images.yml"
       - "bin/install-packaging-tools.sh"
-      - "package/docker/**"
+      - "package/images/packaging/**"
   workflow_dispatch:
 
 concurrency:
@@ -41,9 +41,9 @@ jobs:
           # AlmaLinux rather than UBI, which does not ship rpm-sign.
           - name: rhel
             base_image: almalinux:10
-    uses: XRPLF/actions/.github/workflows/build-multiarch-image.yml@034e87065fcd0100214cf0672923bd38d193cf78
+    uses: XRPLF/actions/.github/workflows/build-multiarch-image.yml@696384b292577293292daed06af0306d1b83bd7d
     with:
       image_name: xrpld/packaging-${{ matrix.distro.name }}
-      dockerfile: package/docker/Dockerfile
+      dockerfile: package/images/packaging/Dockerfile
       base_image: ${{ matrix.distro.base_image }}
       push: ${{ github.event_name == 'push' }}

.github/workflows/build-pre-commit-image.yml

@@ -30,7 +30,7 @@ jobs:
     permissions:
       contents: read
       packages: write
-    uses: XRPLF/actions/.github/workflows/build-multiarch-image.yml@034e87065fcd0100214cf0672923bd38d193cf78
+    uses: XRPLF/actions/.github/workflows/build-multiarch-image.yml@696384b292577293292daed06af0306d1b83bd7d
     with:
       image_name: xrpld/pre-commit
       dockerfile: bin/pre-commit/Dockerfile

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

@@ -13,7 +13,6 @@ on:
       - ready_for_review
     branches:
       - develop
-      - "release-*"
       - "release/*"
       - "staging/*"
 

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

@@ -13,7 +13,6 @@ on:
       - ready_for_review
     branches:
       - develop
-      - "release-*"
       - "release/*"
       - "staging/*"
 

.github/workflows/check-releases-merged.yml

@@ -0,0 +1,60 @@
+# This workflow checks that every final release on a release branch
+# has been merged back into develop, see RELEASING.md.
+name: Check releases merged
+
+on:
+  schedule:
+    # 06:47 UTC every Monday.
+    - cron: "47 6 * * 1"
+  push:
+    branches:
+      - "develop"
+  workflow_dispatch:
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+defaults:
+  run:
+    shell: bash
+
+env:
+  OUTPUT_FILE: /tmp/releases-merged.txt
+  ISSUE_FILE: /tmp/releases-merged-issue.md
+
+jobs:
+  releases-merged:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      # Needed to open an issue on scheduled failures.
+      issues: write
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        with:
+          # The check needs the full history of develop, the release branches and tags.
+          fetch-depth: 0
+
+      - name: Check releases are merged into develop
+        run: |
+          set -o pipefail
+          .github/scripts/releasing/check-releases-merged.sh origin/develop | tee "${OUTPUT_FILE}"
+
+      - name: Prepare issue body
+        if: ${{ failure() && github.event_name == 'schedule' && github.repository == 'XRPLF/rippled' }}
+        run: |
+          {
+              echo '```'
+              cat "${OUTPUT_FILE}"
+              echo '```'
+          } >"${ISSUE_FILE}"
+
+      - name: Create issue
+        if: ${{ failure() && github.event_name == 'schedule' && github.repository == 'XRPLF/rippled' }}
+        uses: XRPLF/actions/create-issue@2b8bc36af85b88bca0dd7bfac2e2dc05f94ad712
+        with:
+          title: "Releases not merged back into develop"
+          body_file: ${{ env.ISSUE_FILE }}
+          labels: "Bug"

.github/workflows/on-pr.yml

@@ -150,6 +150,27 @@ jobs:
     if: ${{ needs.should-run.outputs.go == 'true' }}
     uses: ./.github/workflows/reusable-check-rename.yml
 
+  # Runs regardless of the changed files.
+  # PRs into staging branches are skipped, since fixes may be cherry-picked between release lines.
+  check-release-commits:
+    needs: should-run
+    if: ${{ github.event.pull_request.base.ref == 'develop' || github.event.merge_group.base_ref == 'refs/heads/develop' }}
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        with:
+          # The check needs the full history of the release and staging branches.
+          fetch-depth: 0
+          persist-credentials: false
+      - name: Check for copied release commits
+        env:
+          BASE: ${{ github.event.pull_request.base.sha || github.event.merge_group.base_sha }}
+          HEAD: ${{ github.event.pull_request.head.sha || github.event.merge_group.head_sha }}
+        run: .github/scripts/releasing/check-no-copied-release-commits.sh "${BASE}" "${HEAD}"
+
   clang-tidy:
     needs: should-run
     if: ${{ needs.should-run.outputs.go == 'true' }}
@@ -230,6 +251,7 @@ jobs:
       - check-autogen
       - check-levelization
       - check-rename
+      - check-release-commits
       - clang-tidy
       - build-test
       - rust

.github/workflows/on-tag.yml

@@ -1,9 +1,12 @@
 # When a versioned tag is pushed, this workflow:
 #
-#   - uploads the libxrpl recipe to the Conan remote
 #   - builds and tests the release binaries
+#   - uploads the libxrpl recipe to the Conan remote
 #   - builds the DEB and RPM packages
 #   - publishes those packages to the XRPLF package repositories
+#
+# Nothing is published unless the build passes, which is also where CMake
+# rejects a tag that is not a valid version, e.g. 3.2.01.
 name: Tag
 
 on:
@@ -22,6 +25,7 @@ defaults:
 jobs:
   upload-recipe:
     if: ${{ github.repository == 'XRPLF/rippled' }}
+    needs: build-test
     uses: ./.github/workflows/reusable-upload-recipe.yml
     secrets:
       remote_username: ${{ secrets.NEXUS_REMOTE_USERNAME }}
@@ -50,3 +54,7 @@ jobs:
       remote_username: ${{ secrets.NEXUS_REMOTE_USERNAME }}
       remote_password: ${{ secrets.NEXUS_REMOTE_PASSWORD }}
       signing_key: ${{ secrets.NEXUS_PACKAGES_PRIVATE_KEY }}
+      dockerhub_token: ${{ secrets.DOCKERHUB_TOKEN }}
+      antithesis_docker_host: ${{ secrets.ANTITHESIS_DOCKER_HOST }}
+      antithesis_docker_path: ${{ secrets.ANTITHESIS_DOCKER_PATH }}
+      antithesis_docker_credentials: ${{ secrets.ANTITHESIS_DOCKER_CREDENTIALS }}

.github/workflows/on-trigger.yml

@@ -129,3 +129,7 @@ jobs:
       remote_username: ${{ secrets.NEXUS_REMOTE_USERNAME }}
       remote_password: ${{ secrets.NEXUS_REMOTE_PASSWORD }}
       signing_key: ${{ secrets.NEXUS_PACKAGES_PRIVATE_KEY }}
+      dockerhub_token: ${{ secrets.DOCKERHUB_TOKEN }}
+      antithesis_docker_host: ${{ secrets.ANTITHESIS_DOCKER_HOST }}
+      antithesis_docker_path: ${{ secrets.ANTITHESIS_DOCKER_PATH }}
+      antithesis_docker_credentials: ${{ secrets.ANTITHESIS_DOCKER_CREDENTIALS }}

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

@@ -196,6 +196,19 @@ jobs:
         env:
           BUILD_TYPE: ${{ inputs.build_type }}
           CMAKE_ARGS: ${{ inputs.cmake_args }}
+          # GitHub creates a merge commit for a PR
+          # https://www.kenmuse.com/blog/the-many-shas-of-a-github-pull-request/
+          #
+          # We:
+          # - explicitly provide branch name
+          # - use `github.event.pull_request.head.sha` to get the SHA of last commit in the PR branch
+          #
+          # This way it works both for PRs and pushes to branches.
+          GITHUB_BRANCH_NAME: "${{ github.head_ref || github.ref_name }}"
+          GITHUB_HEAD_SHA: "${{ github.event.pull_request.head.sha || github.sha }}"
+          #
+          # If tag is being pushed, we use that version.
+          FORCE_XRPLD_VERSION: ${{ startsWith(github.ref, 'refs/tags/') && github.ref_name || '' }}
         run: |
           cmake \
               -G '${{ runner.os == 'Windows' && 'Visual Studio 18 2026' || 'Ninja' }}' \
@@ -257,6 +270,7 @@ jobs:
         run: |
           ./bin/check-nix-store-refs.sh "${BUILD_DIR}/xrpld"
           ./bin/check-nix-store-refs.sh "${BUILD_DIR}/xrpl_tests"
+          ./bin/check-nix-store-refs.sh "${BUILD_DIR}/xrpld_tests"
 
       - name: Show ccache statistics
         if: ${{ inputs.ccache_enabled }}
@@ -338,7 +352,9 @@ jobs:
       - name: Run the separate tests
         if: ${{ !inputs.build_only }}
         working-directory: ${{ runner.os == 'Windows' && format('{0}/{1}', env.BUILD_DIR, inputs.build_type) || env.BUILD_DIR }}
-        run: ./xrpl_tests
+        run: |
+          ./xrpl_tests
+          ./xrpld_tests
 
       - name: Run the embedded tests
         if: ${{ !inputs.build_only }}

.github/workflows/reusable-package.yml

@@ -1,5 +1,5 @@
 # Build, verify and publish Linux packages from the pre-built xrpld and
-# validator-keys artifacts, in three stages:
+# validator-keys artifacts, in these stages:
 #
 #   - 'package' builds and signs one format per config that carries a "package"
 #     map in linux.json; that map names the container image and the format
@@ -9,6 +9,9 @@
 #     never reaches Nexus
 #   - 'publish' uploads with the image's publish_pkg.py, doing a --dry-run
 #     unless 'publish: true'
+#   - 'docker' builds an Ubuntu image from the tested DEB, and one with the
+#     voidstar binary for Antithesis, pushing them to Docker Hub and to the
+#     Antithesis registry only with 'publish: true'
 #
 # Only linux/amd64 is supported; the runner is hardcoded in the jobs below.
 name: Package
@@ -35,7 +38,19 @@ on:
         description: "The password or token for that Nexus account."
         required: false
       signing_key:
-        description: "Armoured PGP private key used to sign the RPMs. Required when publishing."
+        description: "Armoured PGP private key used to sign the RPMs."
+        required: false
+      dockerhub_token:
+        description: "A Docker Hub organization access token for xrplf, with push access to xrplf/xrpld."
+        required: false
+      antithesis_docker_host:
+        description: "The host of the Antithesis container registry, e.g. us-central1-docker.pkg.dev."
+        required: false
+      antithesis_docker_path:
+        description: "The repository path in that registry, the image name excluded."
+        required: false
+      antithesis_docker_credentials:
+        description: "The JSON key of a service account with push access to that repository."
         required: false
 
 defaults:
@@ -198,9 +213,6 @@ jobs:
     strategy:
       fail-fast: false
       matrix: ${{ fromJson(needs.generate-matrix.outputs.matrix) }}
-    # The name says which of the two this is, because the job runs either way:
-    # with publish false it passes --dry-run and uploads nothing, and a job
-    # called "publish ..." succeeding on a pull request reads like a release.
     name: "publish ${{ matrix.xrpld_artifact_name }}${{ !inputs.publish && ' (dry run)' || '' }}"
     permissions:
       contents: read
@@ -242,3 +254,86 @@ jobs:
               --package-dir "${PACKAGE_DIR}" \
               --nexus-url "${NEXUS_URL}" \
               ${DRY_RUN_OPTION}
+
+  docker:
+    needs: [test-install-deb, test-install-rpm]
+    strategy:
+      fail-fast: false
+      matrix:
+        target: [xrpld, voidstar]
+    name: "docker ${{ matrix.target }}${{ !inputs.publish && ' (dry run)' || '' }}"
+    permissions:
+      contents: read
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
+    env:
+      CONTEXT: image-context
+      IMAGE: ${{ matrix.target == 'voidstar' && 'xrpld-voidstar' || 'xrplf/xrpld' }}:${{ github.ref_type == 'tag' && github.ref_name || 'develop' }}
+      # Docker Hub is public, so a private build never reaches it;
+      # the Antithesis registry is not.
+      PUSH: ${{ inputs.publish && (matrix.target == 'voidstar' || github.event.repository.visibility == 'public') }}
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+
+      - name: Download package artifacts
+        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
+        with:
+          pattern: "*-pkg"
+          merge-multiple: true
+          path: ${{ env.PACKAGE_DIR }}
+
+      - name: Download voidstar binary
+        if: ${{ matrix.target == 'voidstar' }}
+        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
+        with:
+          name: xrpld-ubuntu-clang-debug-amd64-voidstar
+          path: ${{ env.CONTEXT }}
+
+      - name: Build image
+        env:
+          TARGET: ${{ matrix.target }}
+        run: |
+          mkdir -p "${CONTEXT}"
+          find "${PACKAGE_DIR}" -type f -name 'xrpld_[0-9]*.deb' -exec cp {} "${CONTEXT}/" \;
+          docker build --pull --file package/images/xrpld/Dockerfile --target "${TARGET}" --tag "${IMAGE}" "${CONTEXT}"
+
+      - name: Start the server
+        run: |
+          container="$(docker run --detach "${IMAGE}" --standalone --silent --conf /etc/xrpld/xrpld.cfg)"
+          trap 'docker rm --force "${container}" >/dev/null' EXIT
+
+          for _ in $(seq 30); do
+              output="$(docker exec "${container}" xrpld --conf /etc/xrpld/xrpld.cfg server_info || true)"
+              if [[ "${output}" == *'"status" : "success"'* ]]; then
+                  exit 0
+              fi
+              sleep 2
+          done
+
+          docker logs "${container}"
+          exit 1
+
+      - name: Log in to Docker Hub
+        if: ${{ env.PUSH == 'true' && matrix.target == 'xrpld' }}
+        uses: docker/login-action@dbcb813823bdd20940b903addbd779551569679f # v4.6.0
+        with:
+          username: xrplf
+          password: ${{ secrets.dockerhub_token }}
+
+      - name: Log in to the Antithesis registry
+        if: ${{ env.PUSH == 'true' && matrix.target == 'voidstar' }}
+        uses: docker/login-action@dbcb813823bdd20940b903addbd779551569679f # v4.6.0
+        with:
+          registry: ${{ secrets.antithesis_docker_host }}
+          username: _json_key
+          password: ${{ secrets.antithesis_docker_credentials }}
+
+      - name: Push image
+        if: ${{ env.PUSH == 'true' }}
+        env:
+          REGISTRY: ${{ matrix.target == 'voidstar' && format('{0}/{1}/', secrets.antithesis_docker_host, secrets.antithesis_docker_path) || '' }}
+        run: |
+          docker tag "${IMAGE}" "${REGISTRY}${IMAGE}"
+          docker push "${REGISTRY}${IMAGE}"

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

@@ -68,33 +68,17 @@ jobs:
         run: conan remote login "${REMOTE_NAME}" "${CONAN_LOGIN_USERNAME_XRPLF}" --password "${CONAN_PASSWORD_XRPLF}"
 
       - name: Upload Conan recipe (version)
+        env:
+          VERSION: ${{ steps.release_info.outputs.version }}
         run: |
-          conan export . --version=${{ steps.release_info.outputs.version }}
-          conan upload --confirm --check --remote="${REMOTE_NAME}" xrpl/${{ steps.release_info.outputs.version }}
+          conan export . --version="${VERSION}"
+          conan upload --confirm --check --remote="${REMOTE_NAME}" "xrpl/${VERSION}"
 
-      # When this workflow is triggered by a push event, it will always be when merging into the
-      # 'develop' branch, see on-trigger.yml.
       - name: Upload Conan recipe (develop)
-        if: ${{ github.event_name == 'push' }}
+        if: ${{ github.ref == 'refs/heads/develop' }}
         run: |
           conan export . --version=develop
           conan upload --confirm --check --remote="${REMOTE_NAME}" xrpl/develop
 
-      # When this workflow is triggered by a pull request event, it will always be when merging into
-      # one of the 'release' branches, see on-pr.yml.
-      - name: Upload Conan recipe (rc)
-        if: ${{ github.event_name == 'pull_request' }}
-        run: |
-          conan export . --version=rc
-          conan upload --confirm --check --remote="${REMOTE_NAME}" xrpl/rc
-
-      # When this workflow is triggered by a push event, it will always be when tagging a final
-      # release, see on-tag.yml.
-      - name: Upload Conan recipe (release)
-        if: ${{ startsWith(github.ref, 'refs/tags/') }}
-        run: |
-          conan export . --version=release
-          conan upload --confirm --check --remote="${REMOTE_NAME}" xrpl/release
-
     outputs:
       ref: xrpl/${{ steps.release_info.outputs.version }}

.pre-commit-config.yaml

@@ -60,7 +60,7 @@ repos:
         types_or: [c++, c]
 
   - repo: https://github.com/pre-commit/mirrors-clang-format
-    rev: f4d7745e17a28aad7eed2f4874ca8d1568c11c4c # frozen: v22.1.8
+    rev: e2b496dc2bd8340c2524cb9a2d2a943cde1bb6df # frozen: v23.1.1
     hooks:
       - id: clang-format
         args: [--style=file]
@@ -82,12 +82,12 @@ repos:
         files: ^crates/.*\.rs$
 
   - repo: https://github.com/BlankSpruce/gersemi-pre-commit
-    rev: e98930bdc210d3387007f9252d8c1694ea7e410f # frozen: 0.27.7
+    rev: f1c4833f8cf23c6d952673abc73525411a5719e8 # frozen: 0.29.1
     hooks:
       - id: gersemi
 
   - repo: https://github.com/rbubley/mirrors-prettier
-    rev: 9337a74165b178ae2c766f60bee7252a0f06f3e8 # frozen: v3.9.5
+    rev: ef4a397f916211b4a39ccf9d3d9cbb6562157251 # frozen: v3.9.9
     hooks:
       - id: prettier
         args: [--end-of-line=auto]
@@ -95,7 +95,7 @@ repos:
   # Scoped to package/: the rest of the repo's Python has pre-existing findings,
   # so widening these is its own change.
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: 7c55798a78262d14b2074abf623d8a992ebb70d4 # frozen: v0.16.2
+    rev: a56c0b927e6465d37cae3e97d35d4d18ab2b96cd # frozen: v0.16.9
     hooks:
       - id: ruff-check
         args: [--fix]
@@ -107,14 +107,14 @@ repos:
       - id: black
 
   - repo: https://github.com/pre-commit/mirrors-mypy
-    rev: 41e691678310dfd3833f7ab4e180ddb014310356 # frozen: v2.3.0
+    rev: 7ff8d35ae36a7d2b968f2f90b4c723e292e594ee # frozen: v2.3.1
     hooks:
       - id: mypy
         args: [--strict]
         files: ^package/.*\.py$
 
   - repo: https://github.com/scop/pre-commit-shfmt
-    rev: 05c1426671b9237fb5e1444dd63aa5731bec0dfb # frozen: v3.13.1-1
+    rev: 479be5958357ba5ab65ce47172117348516860e9 # frozen: v3.14.1-1
     hooks:
       - id: shfmt
         args: [--write, --indent=4, --case-indent=true]
@@ -133,7 +133,7 @@ repos:
         files: \.md$
 
   - repo: https://github.com/streetsidesoftware/cspell-cli
-    rev: ea11f9efc0bec520073405bc30552da887ba71bc # frozen: v10.0.1
+    rev: f5c5d72342f35643988a9ffa0705c05bd3ff8383 # frozen: v10.3.0
     hooks:
       - id: cspell
         name: check changed files spelling

BUILD.md

@@ -51,6 +51,12 @@ git checkout release/3.2.x
 For a stable release, choose one of the [tagged
 releases](https://github.com/XRPLF/rippled/releases).
 
+A build reports `0.0.0-dev` with its short commit hash as build metadata, e.g.
+`0.0.0-dev+0123abc`. Only builds of a release, from a tag in CI or a versioned
+Conan reference, report a release version. To use another version, set the
+`FORCE_XRPLD_VERSION` environment variable when running CMake, e.g.
+`FORCE_XRPLD_VERSION=3.4.0`.
+
 ### Set Up Conan
 
 Once your [development environment](./docs/build/environment.md) is ready, set

CMakeLists.txt

@@ -77,7 +77,6 @@ endif()
 include(PatchNixBinary)
 
 include(XrplSanity)
-include(XrplVersion)
 include(XrplSettings)
 # this check has to remain in the top-level cmake because of the early return statement
 if(packages_only)
@@ -115,6 +114,7 @@ find_package(secp256k1 REQUIRED)
 find_package(SOCI REQUIRED)
 find_package(SQLite3 REQUIRED)
 find_package(xxHash REQUIRED)
+find_package(xrpl-rpc-spec REQUIRED)
 
 target_link_libraries(
     xrpl_libs
@@ -175,6 +175,7 @@ include(XrplPackaging)
 if(tests)
     include(CTest)
     add_subdirectory(src/tests/libxrpl)
+    add_subdirectory(src/tests/xrpld)
 endif()
 
 if(benchmark)

CONTRIBUTING.md

@@ -479,8 +479,12 @@ exists, then no other unit test will be executed, apart from `TestSuiteName`.
     elsewhere in the codebase.
 12. Use clear and self-explanatory names for functions, variables,
     structs and classes.
-13. Use TitleCase for classes, structs and filenames, camelCase for
-    function and variable names, lower case for namespaces and folders.
+13. Use TitleCase for classes, structs, type aliases and filenames,
+    camelCase for function and variable names, lower case for namespaces and
+    folders. The exception is a type alias that generic code looks up by name
+    (`value_type`, `iterator`, `result_type`, and the rest of the standard
+    container, hash and clock members), which keeps its snake_case spelling;
+    `.clang-tidy` lists the names that are allowed.
 14. Provide as many comments as you feel that a competent programmer
     would need to understand what your code does.
 

bin/git/update-version.sh

@@ -1,56 +0,0 @@
-#!/bin/bash
-
-if [[ $# -ne 3 || "$1" == "--help" || "$1" = "-h" ]]; then
-    name=$(basename $0)
-    cat <<-USAGE
-    Usage: $name workbranch base/branch version
-
-    * workbranch will be created locally from base/branch. If it exists,
-        it will be reused, so make sure you don't overwrite any work.
-    * base/branch may be specified as user:branch to allow easy copying
-        from Github PRs.
-USAGE
-    exit 0
-fi
-
-work="$1"
-shift
-
-base=$(echo "$1" | sed "s/:/\//")
-shift
-
-version=$1
-shift
-
-set -e
-
-git fetch upstreams
-
-git checkout -B "${work}" --no-track "${base}"
-
-push=$(git rev-parse --abbrev-ref --symbolic-full-name '@{push}' \
-    2>/dev/null) || true
-if [[ "${push}" != "" ]]; then
-    echo "Warning: ${push} may already exist."
-fi
-
-build=$(find -name BuildInfo.cpp)
-sed 's/\(^.*versionString =\).*$/\1 "'${version}'"/' ${build} >version.cpp &&
-    diff "${build}" version.cpp && exit 1 ||
-    mv -vi version.cpp ${build}
-
-git diff
-
-git add ${build}
-
-git commit -S -m "Set version to ${version}"
-
-git log --oneline --first-parent ${base}^..
-
-cat <<PUSH
-
--------------------------------------------------------------------
-This script will not push. Verify everything is correct, then push
-to your repo, and create a PR as described in CONTRIBUTING.md.
--------------------------------------------------------------------
-PUSH

cmake/GitInfo.cmake

@@ -1,28 +0,0 @@
-include_guard()
-
-set(GIT_BUILD_BRANCH "")
-set(GIT_COMMIT_HASH "")
-
-find_package(Git)
-if(NOT Git_FOUND)
-    message(WARNING "Git not found. Git branch and commit hash will be empty.")
-    return()
-endif()
-
-set(GIT_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/.git)
-
-execute_process(
-    COMMAND
-        ${GIT_EXECUTABLE} --git-dir=${GIT_DIRECTORY} rev-parse --abbrev-ref HEAD
-    OUTPUT_STRIP_TRAILING_WHITESPACE
-    OUTPUT_VARIABLE GIT_BUILD_BRANCH
-)
-
-execute_process(
-    COMMAND ${GIT_EXECUTABLE} --git-dir=${GIT_DIRECTORY} rev-parse HEAD
-    OUTPUT_STRIP_TRAILING_WHITESPACE
-    OUTPUT_VARIABLE GIT_COMMIT_HASH
-)
-
-message(STATUS "Git branch: ${GIT_BUILD_BRANCH}")
-message(STATUS "Git commit hash: ${GIT_COMMIT_HASH}")

cmake/XrplCore.cmake

@@ -81,7 +81,7 @@ include(target_link_modules)
 add_module(xrpl beast)
 target_link_libraries(xrpl.libxrpl.beast PUBLIC xrpl.imports.main)
 
-include(GitInfo)
+include(XrplVersion)
 add_module(xrpl git)
 target_compile_definitions(
     xrpl.libxrpl.git
@@ -111,6 +111,11 @@ target_link_libraries(
     xrpl.libxrpl.protocol
     PUBLIC xrpl.libxrpl.crypto xrpl.libxrpl.git xrpl.libxrpl.json
 )
+# Only on BuildInfo.cpp, so a new version does not rebuild the whole module.
+set_source_files_properties(
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/libxrpl/protocol/BuildInfo.cpp
+    PROPERTIES COMPILE_DEFINITIONS XRPLD_VERSION="${XRPLD_VERSION}"
+)
 
 # Level 05
 add_module(xrpl protocol_autogen)
@@ -296,7 +301,14 @@ if(xrpld)
         target_sources(xrpld PRIVATE ${sources})
     endif()
 
-    target_link_libraries(xrpld Xrpl::boost Xrpl::opts Xrpl::libs xrpl.libxrpl)
+    target_link_libraries(
+        xrpld
+        Xrpl::boost
+        Xrpl::opts
+        Xrpl::libs
+        xrpl.libxrpl
+        rpcspec::rpcspec
+    )
     exclude_if_included(xrpld)
     # define a macro for tests that might need to
     # be excluded or run differently in CI environment

cmake/XrplCov.cmake

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

cmake/XrplVersion.cmake

@@ -1,15 +1,75 @@
-#[===================================================================[
-   read version from source
-#]===================================================================]
+find_package(Git)
 
-file(STRINGS src/libxrpl/protocol/BuildInfo.cpp BUILD_INFO)
-foreach(line_ ${BUILD_INFO})
-    if(line_ MATCHES "versionString[ ]*=[ ]*\"(.+)\"")
-        set(xrpld_version ${CMAKE_MATCH_1})
-    endif()
-endforeach()
-if(xrpld_version)
-    message(STATUS "xrpld version: ${xrpld_version}")
-else()
-    message(FATAL_ERROR "unable to determine xrpld version")
+set(GIT_BUILD_BRANCH "")
+set(GIT_COMMIT_HASH "")
+
+if(DEFINED ENV{GITHUB_BRANCH_NAME})
+    set(GIT_BUILD_BRANCH $ENV{GITHUB_BRANCH_NAME})
+    set(GIT_COMMIT_HASH $ENV{GITHUB_HEAD_SHA})
+elseif(Git_FOUND AND EXISTS "${CMAKE_CURRENT_LIST_DIR}/../.git")
+    execute_process(
+        COMMAND ${GIT_EXECUTABLE} rev-parse --abbrev-ref HEAD
+        WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR}/..
+        OUTPUT_VARIABLE GIT_BUILD_BRANCH
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+        COMMAND_ERROR_IS_FATAL ANY
+    )
+
+    execute_process(
+        COMMAND ${GIT_EXECUTABLE} rev-parse HEAD
+        WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR}/..
+        OUTPUT_VARIABLE GIT_COMMIT_HASH
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+        COMMAND_ERROR_IS_FATAL ANY
+    )
 endif()
+
+message(STATUS "Git branch: ${GIT_BUILD_BRANCH}")
+message(STATUS "Git commit hash: ${GIT_COMMIT_HASH}")
+
+if(
+    DEFINED ENV{FORCE_XRPLD_VERSION}
+    AND NOT "$ENV{FORCE_XRPLD_VERSION}" STREQUAL ""
+)
+    message(
+        STATUS
+        "Using explicitly provided '$ENV{FORCE_XRPLD_VERSION}' as xrpld version"
+    )
+
+    set(XRPLD_VERSION "$ENV{FORCE_XRPLD_VERSION}")
+
+    # The rules beast::SemanticVersion::parse applies, so that an invalid version
+    # fails here rather than when xrpld starts. It reads each number as an int.
+    set(SEMVER_NUMBER "(0|[1-9][0-9]*)")
+    set(SEMVER_PRE_RELEASE "[A-Za-z1-9-][A-Za-z0-9-]*")
+    set(SEMVER_METADATA "[A-Za-z0-9-]+")
+    set(SEMVER_NUMBER_MAX 2147483647)
+    if(
+        NOT XRPLD_VERSION
+            MATCHES
+            "^${SEMVER_NUMBER}\\.${SEMVER_NUMBER}\\.${SEMVER_NUMBER}(-${SEMVER_PRE_RELEASE}(\\.${SEMVER_PRE_RELEASE})*)?(\\+${SEMVER_METADATA}(\\.${SEMVER_METADATA})*)?$"
+        OR CMAKE_MATCH_1 GREATER SEMVER_NUMBER_MAX
+        OR CMAKE_MATCH_2 GREATER SEMVER_NUMBER_MAX
+        OR CMAKE_MATCH_3 GREATER SEMVER_NUMBER_MAX
+    )
+        message(
+            FATAL_ERROR
+            "FORCE_XRPLD_VERSION '${XRPLD_VERSION}' is not a semantic version xrpld accepts, see https://semver.org"
+        )
+    endif()
+else()
+    message(STATUS "Using '0.0.0-dev+<git short rev>' as xrpld version")
+
+    if(GIT_COMMIT_HASH STREQUAL "")
+        message(
+            FATAL_ERROR
+            "Unable to determine xrpld version without git, set FORCE_XRPLD_VERSION"
+        )
+    endif()
+
+    string(SUBSTRING ${GIT_COMMIT_HASH} 0 7 GIT_COMMIT_HASH_SHORT)
+
+    set(XRPLD_VERSION "0.0.0-dev+${GIT_COMMIT_HASH_SHORT}")
+endif()
+
+message(STATUS "Build version: ${XRPLD_VERSION}")

cmake/scripts/codegen/generate_tx_classes.py

@@ -59,7 +59,7 @@ def create_transaction_parser():
 # the members that differ from these.
 SETTING_DEFAULTS = {
     "delegable": "Delegation::NotDelegable",
-    "amendment": "uint256{}",
+    "amendment": "UInt256{}",
     "privileges": "Privilege::NoPriv",
 }
 

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

@@ -209,7 +209,7 @@ ${field['typeData']['setter_type']} ${field['paramName']}${',' if i < len(requir
      * @return The constructed ledger entry wrapper.
      */
     ${name}
-    build(uint256 const& index)
+    build(UInt256 const& index)
     {
         return ${name}{std::make_shared<SLE>(std::move(object_), index)};
     }

cmake/scripts/codegen/templates/LedgerEntryTests.cpp.mako

@@ -31,7 +31,7 @@ namespace xrpl::ledger_entries {
 // builder's STObject and the wrapper's SLE.
 TEST(${name}Tests, BuilderSettersRoundTrip)
 {
-    uint256 const index{1u};
+    UInt256 const index{1u};
 
 % for field in fields:
     auto const ${field["paramName"]}Value = ${canonical_expr(field)};
@@ -85,7 +85,7 @@ TEST(${name}Tests, BuilderSettersRoundTrip)
 // from that SLE, build a new wrapper, and verify all fields (and validate()).
 TEST(${name}Tests, BuilderFromSleRoundTrip)
 {
-    uint256 const index{2u};
+    UInt256 const index{2u};
 
 % for field in fields:
     auto const ${field["paramName"]}Value = ${canonical_expr(field)};
@@ -146,7 +146,7 @@ TEST(${name}Tests, BuilderFromSleRoundTrip)
 // 3) Verify wrapper throws when constructed from wrong ledger entry type.
 TEST(${name}Tests, WrapperThrowsOnWrongEntryType)
 {
-    uint256 const index{3u};
+    UInt256 const index{3u};
 
     // Build a valid ledger entry of a different type
     // Ticket requires: Account, OwnerNode, TicketSequence, PreviousTxnID, PreviousTxnLgrSeq
@@ -177,7 +177,7 @@ TEST(${name}Tests, WrapperThrowsOnWrongEntryType)
 // 4) Verify builder throws when constructed from wrong ledger entry type.
 TEST(${name}Tests, BuilderThrowsOnWrongEntryType)
 {
-    uint256 const index{4u};
+    UInt256 const index{4u};
 
     // Build a valid ledger entry of a different type
 % if wrong_le_include == "Ticket":
@@ -207,7 +207,7 @@ TEST(${name}Tests, BuilderThrowsOnWrongEntryType)
 // 5) Build with only required fields and verify optional fields return nullopt.
 TEST(${name}Tests, OptionalFieldsReturnNullopt)
 {
-    uint256 const index{3u};
+    UInt256 const index{3u};
 
 % for field in required_fields:
     auto const ${field["paramName"]}Value = ${canonical_expr(field)};

conan.lock

@@ -3,6 +3,7 @@
     "requires": [
         "zlib/1.3.2#1cb806da49011867778ffb6ac7190fcb%1782392402.122708",
         "xxhash/0.8.3#681d36a0a6111fc56e5e45ea182c19cc%1782392402.420688",
+        "xrpl-rpc-spec/0.1.19#870b2d3abcfbbf13b61c2d3c69495060%1790348286.187549",
         "sqlite3/3.53.0#324ada52333108388a9a6108bfa96734%1782392403.185447",
         "soci/4.0.3#e726491a03468795453f7c83fc924a96%1782392402.679521",
         "snappy/1.1.10#968fef506ff261592ec30c574d4a7809%1782307151.633168",
@@ -19,8 +20,8 @@
         "libarchive/3.8.7#c446109bd1f1d8ba7936c94189bc50e6%1782392403.066892",
         "jemalloc/5.3.1#1fc58d55316041f10fbc1e8a2eae632a%1776700028.228",
         "gtest/1.17.0#5224b3b3ff3b4ce1133cbdd27d53ee7d%1782392402.791979",
-        "grpc/1.81.1#f729f6d75992d20f9c72828e9142d62f%1783945160.094135",
-        "fast_float/8.2.10#f6f28d6bb22112078e7dbda611caf681%1782494504.298",
+        "grpc/1.81.1#b87796a4269034856cbc1a2522db16eb%1788275071.530512",
+        "fast_float/8.2.10#f6f28d6bb22112078e7dbda611caf681%1785888854.601666",
         "ed25519/2015.03#ae761bdc52730a843f0809bdf6c1b1f6%1782307148.15562",
         "date/3.0.4#862e11e80030356b53c2c38599ceb32b%1782392402.538492",
         "corrosion/0.6.1#bfa292df0a957bc70a450ff316cd9435%1786119416.131296",
@@ -45,6 +46,10 @@
     ],
     "python_requires": [],
     "overrides": {
+        "boost/1.91.0#ea540ca2133d831b560036aa24dece3c": [
+            null,
+            "boost/1.91.0#ea540ca2133d831b560036aa24dece3c"
+        ],
         "protobuf/[>=5.27.0 <7]": [
             "protobuf/6.33.5"
         ],

conanfile.py

@@ -1,9 +1,13 @@
+import os
 import re
 
 from conan.tools.cmake import CMake, CMakeToolchain, cmake_layout
+from conan.tools.env import Environment
 
 from conan import ConanFile
 
+DEV_VERSION = "0.0.0-dev"
+
 
 class Xrpl(ConanFile):
     name = "xrpl"
@@ -36,6 +40,7 @@ class Xrpl(ConanFile):
         "nudb/2.0.9",
         "openssl/3.6.3",
         "soci/4.0.3",
+        "xrpl-rpc-spec/0.1.19",
         "zlib/1.3.2",
     ]
 
@@ -114,17 +119,12 @@ class Xrpl(ConanFile):
         "soci/*:shared": False,
         "soci/*:with_sqlite3": True,
         "soci/*:with_boost": True,
+        "xrpl-rpc-spec/*:server": "xrpld",
         "xxhash/*:shared": False,
     }
 
     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, 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)
+        self.version = self.version or DEV_VERSION
 
     def configure(self):
         if self.settings.compiler == "apple-clang":
@@ -167,6 +167,17 @@ class Xrpl(ConanFile):
     generators = "CMakeDeps"
 
     def generate(self):
+        # The sources in the Conan cache have no git history, so the version
+        # comes from the reference, unless it is not one, like 'develop'.
+        if not os.path.exists(os.path.join(self.source_folder, ".git")):
+            version = str(self.version)
+            env = Environment()
+            env.define(
+                "FORCE_XRPLD_VERSION",
+                version if re.match(r"\d+\.\d+\.\d+", version) else DEV_VERSION,
+            )
+            env.vars(self).save_script("xrpld_version")
+
         tc = CMakeToolchain(self)
         tc.variables["tests"] = self.options.tests
         tc.variables["benchmark"] = self.options.benchmark

crates/Cargo.lock

@@ -57,9 +57,9 @@ dependencies = [
 
 [[package]]
 name = "cxx"
-version = "1.0.199"
+version = "1.0.202"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "824894a4a85dca76d4c95c2b9098c036f5a29f627b30c12780774f6654e60974"
+checksum = "13f6de320895f42e6e081abb5c7983bedcf0b6d0ff9323de0d33f620c8ac1199"
 dependencies = [
  "cc",
  "cxx-build",
@@ -72,9 +72,9 @@ dependencies = [
 
 [[package]]
 name = "cxx-build"
-version = "1.0.199"
+version = "1.0.202"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f1ae0b651ea5b0000b19513aef5a03f194d7e3486f2d9258b658da8677fe9036"
+checksum = "4fde53ca86b9704a943fef0f1e1d836239a6aedca5de3c65fa9f97ec0bd46d39"
 dependencies = [
  "cc",
  "codespan-reporting",
@@ -87,9 +87,9 @@ dependencies = [
 
 [[package]]
 name = "cxxbridge-cmd"
-version = "1.0.199"
+version = "1.0.202"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fb05f91d3fb8435d9bab6ac5ce6ac1868be774325fb7fb2a91be39393b21388e"
+checksum = "07bae89236c811fd4d08ed3441759ac4ac98d752cbfd3de341315ba16ad20ec3"
 dependencies = [
  "clap",
  "codespan-reporting",
@@ -101,15 +101,15 @@ dependencies = [
 
 [[package]]
 name = "cxxbridge-flags"
-version = "1.0.199"
+version = "1.0.202"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bf293202e0e3e98495785745389e8d0755b217e66f19194a5c695c25e03282ef"
+checksum = "49045042e5fced01b80742aba5508de82aa4f13677ed3fa2b4cda709c40c5918"
 
 [[package]]
 name = "cxxbridge-macro"
-version = "1.0.199"
+version = "1.0.202"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ca001d746947c7249ed9d332a10f7a59daedbafeb0ec68c5c18a7db7a93f6ccc"
+checksum = "b181252e2e3d3b5d183afbdc033a3958b445eb3e1a0ae65fc3d4f5259f5da6fd"
 dependencies = [
  "indexmap",
  "proc-macro2",

docs/Docker.md

@@ -1,5 +1,19 @@
 # `xrpld` Docker Image
 
-- Some info relating to Docker containers can be found here: [../Builds/containers](../Builds/containers)
-- Images for building and testing xrpld can be found here: [thejohnfreeman/rippled-docker](https://github.com/thejohnfreeman/rippled-docker/)
-  - These images do not have xrpld. They have all the tools necessary to build xrpld.
+`xrpld` is published to Docker Hub as [`xrplf/xrpld`](https://hub.docker.com/r/xrplf/xrpld):
+the `xrpld` DEB package installed on Ubuntu 26.04, running as the `xrpld` user.
+Each release is tagged with its version, `xrplf/xrpld:<version>`, and
+`xrplf/xrpld:develop` follows the `develop` branch.
+See [`package/README.md`](../package/README.md#docker-images) for how it is built
+and tagged.
+
+```bash
+docker run --detach --name xrpld \
+    --volume xrpld-db:/var/lib/xrpld \
+    --publish 2459:2459 \
+    xrplf/xrpld:develop
+```
+
+The admin ports (5005, 6006 and 50051) listen on `127.0.0.1` in the shipped
+configuration; to reach them from outside the container, mount your own over
+`/etc/xrpld/xrpld.cfg`.

include/xrpl/basics/.clang-tidy

@@ -0,0 +1,11 @@
+# basics' container adapters (TaggedCache, partitioned_unordered_map,
+# base_uint) model std concepts, which mandate
+# snake_case member type names.
+#
+# clang-tidy replaces rather than merges this option, so the list is the
+# top-level one restated plus the 6 name(s) needed only here:
+#   allocator_type const_pointer const_reverse_iterator hasher key_equal reverse_iterator
+InheritParentConfig: true
+CheckOptions:
+  readability-identifier-naming.TypeAliasIgnoredRegexp: "^(allocator_type|const_iterator|const_pointer|const_reference|const_reverse_iterator|difference_type|duration|hasher|iterator|iterator_category|key_equal|key_type|mapped_type|period|pointer|reference|rep|result_type|reverse_iterator|size_type|time_point|value_type)$"
+  readability-identifier-naming.TypedefIgnoredRegexp: "^(allocator_type|const_iterator|const_pointer|const_reference|const_reverse_iterator|difference_type|duration|hasher|iterator|iterator_category|key_equal|key_type|mapped_type|period|pointer|reference|rep|result_type|reverse_iterator|size_type|time_point|value_type)$"

include/xrpl/basics/IntrusivePointer.ipp

@@ -618,13 +618,16 @@ SharedWeakUnion<T>::convertToWeak()
             unsafeSetRawPtr(nullptr);
             return true;  // Should never happen
             // LCOV_EXCL_STOP
-        case PartialDestroy:
-            // This is a weird case. We just converted the last strong
-            // pointer to a weak pointer.
+        case PartialDestroy: {
+            // We just converted the last strong pointer to a weak pointer.
+            // The weak ref we now hold keeps the object from being fully
+            // destroyed, so `p` stays valid; only the copy passed to
+            // `partialDestructorFinished` is nulled.
             p->partialDestructor();
-            partialDestructorFinished(&p);
-            // p is null and may no longer be used
+            auto finished = p;
+            partialDestructorFinished(&finished);
             break;
+        }
     }
     unsafeSetRawPtr(p, RefStrength::Weak);
     return true;

include/xrpl/basics/IntrusiveRefCounts.h

@@ -77,21 +77,13 @@ struct IntrusiveRefCounts
     std::size_t
     useCount() 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.
+    // MUST be called after `partialDestructor` returns. Another thread may
+    // then delete the object, so `*o` is nulled and must not be used after
+    // (unless the caller holds its own weak ref, e.g.
+    // SharedWeakUnion::convertToWeak). Called by the smart pointers, not
+    // `partialDestructor`, so custom partial destructors can't forget it.
+    // The two-star API signals that `*o` may be deleted. Templated to
+    // support incomplete types.
     template <class T>
     friend void
     partialDestructorFinished(T** o);
@@ -334,15 +326,11 @@ IntrusiveRefCounts::addWeakReleaseStrongRef() const
         ReleaseStrongRefAction action = NoOp;
         if (prevVal.strong == 1)
         {
-            if (prevVal.weak == 0)
-            {
-                action = NoOp;
-            }
-            else
-            {
-                nextIntVal |= kPartialDestroyStartedMask;
-                action = PartialDestroy;
-            }
+            // The weak ref added here keeps the weak count non-zero, so
+            // releasing the last strong ref always starts a partial destroy,
+            // regardless of the previous weak count.
+            nextIntVal |= kPartialDestroyStartedMask;
+            action = PartialDestroy;
         }
         if (refCounts_.compare_exchange_weak(prevIntVal, nextIntVal, std::memory_order_acq_rel))
         {
@@ -358,24 +346,26 @@ IntrusiveRefCounts::addWeakReleaseStrongRef() const
 inline ReleaseWeakRefAction
 IntrusiveRefCounts::releaseWeakRef() const
 {
-    auto prevIntVal = refCounts_.fetch_sub(kWeakDelta, std::memory_order_acq_rel);
-    RefCountPair prev = prevIntVal;
+    auto const prevIntVal = refCounts_.fetch_sub(kWeakDelta, std::memory_order_acq_rel);
+    RefCountPair const prev = prevIntVal;
     if (prev.weak == 1 && prev.strong == 0)
     {
+        // `wait` blocks while the value equals its argument, so it must be
+        // given the value as it is after the decrement above.
+        auto curIntVal = prevIntVal - kWeakDelta;
         if (prev.partialDestroyStartedBit == 0u)
         {
             // 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};
+            refCounts_.wait(curIntVal, std::memory_order_acquire);
+            curIntVal = refCounts_.load(std::memory_order_acquire);
         }
-        if (prev.partialDestroyFinishedBit == 0u)
+        if (RefCountPair{curIntVal}.partialDestroyFinishedBit == 0u)
         {
             // partial destroy MUST finish before running a full destroy (when
             // using weak pointers)
-            refCounts_.wait(prevIntVal - kWeakDelta, std::memory_order_acquire);
+            refCounts_.wait(curIntVal, std::memory_order_acquire);
         }
         return ReleaseWeakRefAction::Destroy;
     }

include/xrpl/basics/KeyCache.h

@@ -5,6 +5,6 @@
 
 namespace xrpl {
 
-using KeyCache = TaggedCache<uint256, int, true>;
+using KeyCache = TaggedCache<UInt256, int, true>;
 
 }  // namespace xrpl

include/xrpl/basics/Number.h

@@ -350,10 +350,10 @@ concept Integral64 = std::is_same_v<T, std::int64_t> || std::is_same_v<T, std::u
 class Number final
 {
     using rep = std::int64_t;
-    using internalrep = MantissaRange::rep;
+    using InternalRep = MantissaRange::rep;
 
     bool negative_{false};
-    internalrep mantissa_{0};
+    InternalRep mantissa_{0};
     int exponent_{std::numeric_limits<int>::lowest()};
 
 public:
@@ -361,10 +361,10 @@ public:
     static constexpr int kMinExponent = -32768;
     static constexpr int kMaxExponent = 32768;
 
-    static constexpr internalrep kMaxRep = std::numeric_limits<rep>::max();
+    static constexpr InternalRep kMaxRep = std::numeric_limits<rep>::max();
     static_assert(kMaxRep == 9'223'372'036'854'775'807);
     static_assert(-kMaxRep == std::numeric_limits<rep>::min() + 1);
-    static constexpr internalrep kMaxRepUp = ((kMaxRep / 10) + 1) * 10;
+    static constexpr InternalRep kMaxRepUp = ((kMaxRep / 10) + 1) * 10;
     static_assert(kMaxRepUp == 9'223'372'036'854'775'810ULL);
 
     // May need to make unchecked private
@@ -388,15 +388,15 @@ public:
     explicit Number(rep mantissa, int exponent);
     explicit constexpr Number(
         bool negative,
-        internalrep mantissa,
+        InternalRep mantissa,
         int exponent,
         Unchecked) noexcept;
     // Assume unsigned values are... unsigned. i.e. positive
-    explicit constexpr Number(internalrep mantissa, int exponent, Unchecked) noexcept;
+    explicit constexpr Number(InternalRep mantissa, int exponent, Unchecked) noexcept;
     // Only unit tests are expected to use this ctor
-    explicit Number(bool negative, internalrep mantissa, int exponent, Normalized);
+    explicit Number(bool negative, InternalRep mantissa, int exponent, Normalized);
     // Assume unsigned values are... unsigned. i.e. positive
-    explicit Number(internalrep mantissa, int exponent, Normalized);
+    explicit Number(InternalRep mantissa, int exponent, Normalized);
 
     [[nodiscard]] constexpr rep
     mantissa() const noexcept;
@@ -558,13 +558,13 @@ public:
     static void
     setMantissaScale(MantissaRange::MantissaScale scale);
 
-    static internalrep
+    static InternalRep
     minMantissa()
     {
         return kRange.get().min;
     }
 
-    static internalrep
+    static InternalRep
     maxMantissa()
     {
         return kRange.get().max;
@@ -591,7 +591,7 @@ public:
     // is negative, returns the positive value. This takes a little extra work
     // because converting std::numeric_limits<std::int64_t>::min() flirts with
     // UB, and can vary across compilers.
-    static internalrep
+    static InternalRep
     externalToInternal(rep mantissa);
 
 private:
@@ -625,8 +625,8 @@ private:
         bool& negative,
         T& mantissa,
         int& exponent,
-        internalrep const& minMantissa,
-        internalrep const& maxMantissa,
+        InternalRep const& minMantissa,
+        InternalRep const& maxMantissa,
         MantissaRange::CuspRoundingFix cuspRoundingFix);
 
     template <class T>
@@ -650,25 +650,25 @@ private:
     shiftExponent(int exponentDelta) const;
 };
 
-constexpr Number::Number(bool negative, internalrep mantissa, int exponent, Unchecked) noexcept
+constexpr Number::Number(bool negative, InternalRep mantissa, int exponent, Unchecked) noexcept
     : negative_(negative), mantissa_{mantissa}, exponent_{exponent}
 {
 }
 
-constexpr Number::Number(internalrep mantissa, int exponent, Unchecked) noexcept
+constexpr Number::Number(InternalRep mantissa, int exponent, Unchecked) noexcept
     : Number(false, mantissa, exponent, Unchecked{})
 {
 }
 
 static constexpr Number kNumZero{};
 
-inline Number::Number(bool negative, internalrep mantissa, int exponent, Normalized)
+inline Number::Number(bool negative, InternalRep mantissa, int exponent, Normalized)
     : Number(negative, mantissa, exponent, Unchecked{})
 {
     normalize(kRange);
 }
 
-inline Number::Number(internalrep mantissa, int exponent, Normalized)
+inline Number::Number(InternalRep mantissa, int exponent, Normalized)
     : Number(false, mantissa, exponent, Normalized{})
 {
 }
@@ -853,7 +853,7 @@ Number::normalizeToRange() const
     static_assert((kMAX + 1) / 10 == kMIN);
 
     bool negative = negative_;
-    internalrep mantissa = mantissa_;
+    InternalRep mantissa = mantissa_;
     int exponent = exponent_;
 
     if constexpr (std::is_unsigned_v<T>)

include/xrpl/basics/README.md

@@ -21,11 +21,11 @@ The module xrpl/basics should contain no dependencies on other modules.
 - `std::set`
   - For sorted containers.
 
-- `xrpl::hash_set`
+- `xrpl::HashSet`
   - Where inserts and contains need to be O(1).
   - For "small" sets, `std::set` might be faster and smaller.
 
-- `xrpl::hardened_hash_set`
+- `xrpl::HardenedHashSet`
   - For data sets where the key could be manipulated by an attacker
     in an attempt to mount an algorithmic complexity attack: see
     http://en.wikipedia.org/wiki/Algorithmic_complexity_attack
@@ -33,5 +33,5 @@ The module xrpl/basics should contain no dependencies on other modules.
 The following container is deprecated
 
 - `std::unordered_set`
-- Use `xrpl::hash_set` instead, which uses a better hashing algorithm.
-- Or use `xrpl::hardened_hash_set` to prevent algorithmic complexity attacks.
+- Use `xrpl::HashSet` instead, which uses a better hashing algorithm.
+- Or use `xrpl::HardenedHashSet` to prevent algorithmic complexity attacks.

include/xrpl/basics/SHAMapHash.h

@@ -14,20 +14,20 @@ namespace xrpl {
 
 class SHAMapHash
 {
-    uint256 hash_;
+    UInt256 hash_;
 
 public:
     SHAMapHash() = default;
-    explicit SHAMapHash(uint256 const& hash) : hash_(hash)
+    explicit SHAMapHash(UInt256 const& hash) : hash_(hash)
     {
     }
 
-    [[nodiscard]] uint256 const&
+    [[nodiscard]] UInt256 const&
     asUInt256() const
     {
         return hash_;
     }
-    uint256&
+    UInt256&
     asUInt256()
     {
         return hash_;

include/xrpl/basics/TaggedCache.h

@@ -59,34 +59,34 @@ template <
     class T,
     bool IsKeyCache = false,
     class SharedWeakUnionPointerType = SharedWeakCachePointer<T>,
-    class SharedPointerType = std::shared_ptr<T>,
+    class SharedPointer = std::shared_ptr<T>,
     class Hash = HardenedHash<>,
     class KeyEqual = std::equal_to<Key>,
     class Mutex = std::recursive_mutex>
 class TaggedCache
 {
 public:
-    using mutex_type = Mutex;
+    using MutexType = Mutex;
     using key_type = Key;
     using mapped_type = T;
-    using clock_type = beast::AbstractClock<std::chrono::steady_clock>;
-    using shared_weak_combo_pointer_type = SharedWeakUnionPointerType;
-    using shared_pointer_type = SharedPointerType;
+    using ClockType = beast::AbstractClock<std::chrono::steady_clock>;
+    using SharedWeakComboPointerType = SharedWeakUnionPointerType;
+    using SharedPointerType = SharedPointer;
 
 public:
     TaggedCache(
         std::string const& name,
         int size,
-        clock_type::duration expiration,
-        clock_type& clock,
+        ClockType::duration expiration,
+        ClockType& clock,
         beast::Journal journal,
-        beast::insight::Collector::ptr const& collector = beast::insight::NullCollector::make());
+        beast::insight::Collector::Ptr const& collector = beast::insight::NullCollector::make());
 
 public:
     /**
      * Return the clock associated with the cache.
      */
-    clock_type&
+    ClockType&
     clock();
 
     /**
@@ -239,7 +239,7 @@ public:
     bool
     retrieve(key_type const& key, T& data);
 
-    mutex_type&
+    MutexType&
     peekMutex();
 
     std::vector<key_type>
@@ -265,7 +265,7 @@ public:
 
 private:
     SharedPointerType
-    initialFetch(key_type const& key, std::scoped_lock<mutex_type> const& l);
+    initialFetch(key_type const& key, std::scoped_lock<MutexType> const& l);
 
     void
     collectMetrics();
@@ -277,7 +277,7 @@ private:
         Stats(
             std::string const& prefix,
             Handler const& handler,
-            beast::insight::Collector::ptr const& collector)
+            beast::insight::Collector::Ptr const& collector)
             : hook(collector->makeHook(handler))
             , size(collector->makeGauge(prefix, "size"))
             , hitRate(collector->makeGauge(prefix, "hit_rate"))
@@ -296,14 +296,14 @@ private:
     class KeyOnlyEntry
     {
     public:
-        clock_type::time_point lastAccess;
+        ClockType::time_point lastAccess;
 
-        explicit KeyOnlyEntry(clock_type::time_point const& lastAccess) : lastAccess(lastAccess)
+        explicit KeyOnlyEntry(ClockType::time_point const& lastAccess) : lastAccess(lastAccess)
         {
         }
 
         void
-        touch(clock_type::time_point const& now)
+        touch(ClockType::time_point const& now)
         {
             lastAccess = now;
         }
@@ -312,10 +312,10 @@ private:
     class ValueEntry
     {
     public:
-        shared_weak_combo_pointer_type ptr;
-        clock_type::time_point lastAccess;
+        SharedWeakComboPointerType ptr;
+        ClockType::time_point lastAccess;
 
-        ValueEntry(clock_type::time_point const& lastAccess, shared_pointer_type const& ptr)
+        ValueEntry(ClockType::time_point const& lastAccess, SharedPointerType const& ptr)
             : ptr(ptr), lastAccess(lastAccess)
         {
         }
@@ -343,7 +343,7 @@ private:
             return ptr.lock();
         }
         void
-        touch(clock_type::time_point const& now)
+        touch(ClockType::time_point const& now)
         {
             lastAccess = now;
         }
@@ -351,35 +351,35 @@ private:
 
     using Entry = std::conditional_t<IsKeyCache, KeyOnlyEntry, ValueEntry>;
 
-    using KeyOnlyCacheType = hardened_partitioned_hash_map<key_type, KeyOnlyEntry, Hash, KeyEqual>;
+    using KeyOnlyCacheType = HardenedPartitionedHashMap<key_type, KeyOnlyEntry, Hash, KeyEqual>;
 
-    using KeyValueCacheType = hardened_partitioned_hash_map<key_type, ValueEntry, Hash, KeyEqual>;
+    using KeyValueCacheType = HardenedPartitionedHashMap<key_type, ValueEntry, Hash, KeyEqual>;
 
-    using cache_type = hardened_partitioned_hash_map<key_type, Entry, Hash, KeyEqual>;
+    using CacheType = HardenedPartitionedHashMap<key_type, Entry, Hash, KeyEqual>;
 
     [[nodiscard]] std::thread
     sweepHelper(
-        clock_type::time_point const& whenExpire,
-        [[maybe_unused]] clock_type::time_point const& now,
-        KeyValueCacheType::map_type& partition,
+        ClockType::time_point const& whenExpire,
+        [[maybe_unused]] ClockType::time_point const& now,
+        KeyValueCacheType::MapType& partition,
         SweptPointersVector& stuffToSweep,
         std::atomic<int>& allRemovals,
         std::scoped_lock<std::recursive_mutex> const&);
 
     [[nodiscard]] std::thread
     sweepHelper(
-        clock_type::time_point const& whenExpire,
-        clock_type::time_point const& now,
-        KeyOnlyCacheType::map_type& partition,
+        ClockType::time_point const& whenExpire,
+        ClockType::time_point const& now,
+        KeyOnlyCacheType::MapType& partition,
         SweptPointersVector&,
         std::atomic<int>& allRemovals,
         std::scoped_lock<std::recursive_mutex> const&);
 
     beast::Journal journal_;
-    clock_type& clock_;
+    ClockType& clock_;
     Stats stats_;
 
-    mutex_type mutable mutex_;
+    MutexType mutable mutex_;
 
     // Used for logging
     std::string name_;
@@ -388,11 +388,11 @@ private:
     int const targetSize_;
 
     // Desired maximum cache age
-    clock_type::duration const targetAge_;
+    ClockType::duration const targetAge_;
 
     // Number of items cached
     int cacheCount_{0};
-    cache_type cache_;  // Hold strong reference to recent objects
+    CacheType cache_;  // Hold strong reference to recent objects
     std::uint64_t hits_{0};
     std::uint64_t misses_{0};
 };

include/xrpl/basics/TaggedCache.ipp

@@ -54,10 +54,10 @@ inline TaggedCache<
     TaggedCache(
         std::string const& name,
         int size,
-        clock_type::duration expiration,
-        clock_type& clock,
+        ClockType::duration expiration,
+        ClockType& clock,
         beast::Journal journal,
-        beast::insight::Collector::ptr const& collector)
+        beast::insight::Collector::Ptr const& collector)
     : journal_(journal)
     , clock_(clock)
     , stats_(
@@ -81,7 +81,7 @@ template <
     class Mutex>
 inline auto
 TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
-    clock() -> clock_type&
+    clock() -> ClockType&
 {
     return clock_;
 }
@@ -237,8 +237,8 @@ TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash,
     // is destroyed but still within the main cache lock.
     std::vector<SweptPointersVector> allStuffToSweep(cache_.partitions());
 
-    clock_type::time_point const now(clock_.now());
-    clock_type::time_point whenExpire;
+    ClockType::time_point const now(clock_.now());
+    ClockType::time_point whenExpire;
 
     auto const start = std::chrono::steady_clock::now();
     {
@@ -252,7 +252,7 @@ TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash,
         {
             whenExpire = now - (targetAge_ * targetSize_ / cache_.size());
 
-            clock_type::duration const minimumAge(std::chrono::seconds(1));
+            ClockType::duration const minimumAge(std::chrono::seconds(1));
             if (whenExpire > (now - minimumAge))
                 whenExpire = now - minimumAge;
 
@@ -487,7 +487,7 @@ inline SharedPointerType
 TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
     fetch(key_type const& key)
 {
-    std::scoped_lock<mutex_type> const l(mutex_);
+    std::scoped_lock<MutexType> const l(mutex_);
     auto ret = initialFetch(key, l);
     if (!ret)
         ++misses_;
@@ -541,7 +541,7 @@ TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash,
     requires IsKeyCache
 {
     std::scoped_lock const lock(mutex_);
-    clock_type::time_point const now(clock_.now());
+    ClockType::time_point const now(clock_.now());
     auto [it, inserted] = cache_.emplace(
         std::piecewise_construct, std::forward_as_tuple(key), std::forward_as_tuple(now));
     if (!inserted)
@@ -583,7 +583,7 @@ template <
     class Mutex>
 inline auto
 TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
-    peekMutex() -> mutex_type&
+    peekMutex() -> MutexType&
 {
     return mutex_;
 }
@@ -711,7 +711,7 @@ template <
     class Mutex>
 inline SharedPointerType
 TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
-    initialFetch(key_type const& key, std::scoped_lock<mutex_type> const& l)
+    initialFetch(key_type const& key, std::scoped_lock<MutexType> const& l)
 {
     auto cit = cache_.find(key);
     if (cit == cache_.end())
@@ -776,9 +776,9 @@ template <
 inline std::thread
 TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
     sweepHelper(
-        clock_type::time_point const& whenExpire,
-        [[maybe_unused]] clock_type::time_point const& now,
-        KeyValueCacheType::map_type& partition,
+        ClockType::time_point const& whenExpire,
+        [[maybe_unused]] ClockType::time_point const& now,
+        KeyValueCacheType::MapType& partition,
         SweptPointersVector& stuffToSweep,
         std::atomic<int>& allRemovals,
         std::scoped_lock<std::recursive_mutex> const&)
@@ -856,9 +856,9 @@ template <
 inline std::thread
 TaggedCache<Key, T, IsKeyCache, SharedWeakUnionPointer, SharedPointerType, Hash, KeyEqual, Mutex>::
     sweepHelper(
-        clock_type::time_point const& whenExpire,
-        clock_type::time_point const& now,
-        KeyOnlyCacheType::map_type& partition,
+        ClockType::time_point const& whenExpire,
+        ClockType::time_point const& now,
+        KeyOnlyCacheType::MapType& partition,
         SweptPointersVector&,
         std::atomic<int>& allRemovals,
         std::scoped_lock<std::recursive_mutex> const&)

include/xrpl/basics/UnorderedContainers.h

@@ -33,7 +33,7 @@ template <
     class Hash = beast::Uhash<>,
     class Pred = std::equal_to<Key>,
     class Allocator = std::allocator<std::pair<Key const, Value>>>
-using hash_map = std::unordered_map<Key, Value, Hash, Pred, Allocator>;
+using HashMap = std::unordered_map<Key, Value, Hash, Pred, Allocator>;
 
 template <
     class Key,
@@ -41,62 +41,62 @@ template <
     class Hash = beast::Uhash<>,
     class Pred = std::equal_to<Key>,
     class Allocator = std::allocator<std::pair<Key const, Value>>>
-using hash_multimap = std::unordered_multimap<Key, Value, Hash, Pred, Allocator>;
+using HashMultimap = std::unordered_multimap<Key, Value, Hash, Pred, Allocator>;
 
 template <
     class Value,
     class Hash = beast::Uhash<>,
     class Pred = std::equal_to<Value>,
     class Allocator = std::allocator<Value>>
-using hash_set = std::unordered_set<Value, Hash, Pred, Allocator>;
+using HashSet = std::unordered_set<Value, Hash, Pred, Allocator>;
 
 template <
     class Value,
     class Hash = beast::Uhash<>,
     class Pred = std::equal_to<Value>,
     class Allocator = std::allocator<Value>>
-using hash_multiset = std::unordered_multiset<Value, Hash, Pred, Allocator>;
+using HashMultiset = std::unordered_multiset<Value, Hash, Pred, Allocator>;
 
 // hardened_hash containers
 
-using strong_hash = beast::Xxhasher;
+using StrongHash = beast::Xxhasher;
 
 template <
     class Key,
     class Value,
-    class Hash = HardenedHash<strong_hash>,
+    class Hash = HardenedHash<StrongHash>,
     class Pred = std::equal_to<Key>,
     class Allocator = std::allocator<std::pair<Key const, Value>>>
-using hardened_hash_map = std::unordered_map<Key, Value, Hash, Pred, Allocator>;
+using HardenedHashMap = std::unordered_map<Key, Value, Hash, Pred, Allocator>;
 
 template <
     class Key,
     class Value,
-    class Hash = HardenedHash<strong_hash>,
+    class Hash = HardenedHash<StrongHash>,
     class Pred = std::equal_to<Key>,
     class Allocator = std::allocator<std::pair<Key const, Value>>>
-using hardened_partitioned_hash_map = PartitionedUnorderedMap<Key, Value, Hash, Pred, Allocator>;
+using HardenedPartitionedHashMap = PartitionedUnorderedMap<Key, Value, Hash, Pred, Allocator>;
 
 template <
     class Key,
     class Value,
-    class Hash = HardenedHash<strong_hash>,
+    class Hash = HardenedHash<StrongHash>,
     class Pred = std::equal_to<Key>,
     class Allocator = std::allocator<std::pair<Key const, Value>>>
-using hardened_hash_multimap = std::unordered_multimap<Key, Value, Hash, Pred, Allocator>;
+using HardenedHashMultimap = std::unordered_multimap<Key, Value, Hash, Pred, Allocator>;
 
 template <
     class Value,
-    class Hash = HardenedHash<strong_hash>,
+    class Hash = HardenedHash<StrongHash>,
     class Pred = std::equal_to<Value>,
     class Allocator = std::allocator<Value>>
-using hardened_hash_set = std::unordered_set<Value, Hash, Pred, Allocator>;
+using HardenedHashSet = std::unordered_set<Value, Hash, Pred, Allocator>;
 
 template <
     class Value,
-    class Hash = HardenedHash<strong_hash>,
+    class Hash = HardenedHash<StrongHash>,
     class Pred = std::equal_to<Value>,
     class Allocator = std::allocator<Value>>
-using hardened_hash_multiset = std::unordered_multiset<Value, Hash, Pred, Allocator>;
+using HardenedHashMultiset = std::unordered_multiset<Value, Hash, Pred, Allocator>;
 
 }  // namespace xrpl

include/xrpl/basics/base_uint.h

@@ -111,7 +111,7 @@ public:
     using const_iterator = const_pointer;
     using reverse_iterator = std::reverse_iterator<iterator>;
     using const_reverse_iterator = std::reverse_iterator<const_iterator>;
-    using tag_type = Tag;
+    using TagType = Tag;
 
     pointer
     data()
@@ -575,10 +575,16 @@ public:
     }
 };
 
-using uint128 = BaseUInt<128>;
-using uint160 = BaseUInt<160>;
-using uint256 = BaseUInt<256>;
-using uint192 = BaseUInt<192>;
+using UInt128 = BaseUInt<128>;
+using UInt160 = BaseUInt<160>;
+using UInt256 = BaseUInt<256>;
+using UInt192 = BaseUInt<192>;
+
+// TODO [#8340]: Legacy names still used by external consumers of libxrpl (e.g. rpc-spec).
+// Do not use in new code; remove once those consumers have migrated.
+using uint160 = UInt160;  // NOLINT(readability-identifier-naming)
+using uint256 = UInt256;  // NOLINT(readability-identifier-naming)
+using uint192 = UInt192;  // NOLINT(readability-identifier-naming)
 
 template <std::size_t Bits, class Tag>
 [[nodiscard]] constexpr std::strong_ordering
@@ -670,7 +676,7 @@ operator<<(std::ostream& out, BaseUInt<Bits, Tag> const& u)
 
 template <>
 inline std::size_t
-extract(uint256 const& key)
+extract(UInt256 const& key)
 {
     std::size_t result = 0;
     // Use memcpy to avoid unaligned UB
@@ -680,10 +686,10 @@ extract(uint256 const& key)
 }
 
 #ifndef __INTELLISENSE__
-static_assert(sizeof(uint128) == 128 / 8, "There should be no padding bytes");
-static_assert(sizeof(uint160) == 160 / 8, "There should be no padding bytes");
-static_assert(sizeof(uint192) == 192 / 8, "There should be no padding bytes");
-static_assert(sizeof(uint256) == 256 / 8, "There should be no padding bytes");
+static_assert(sizeof(UInt128) == 128 / 8, "There should be no padding bytes");
+static_assert(sizeof(UInt160) == 160 / 8, "There should be no padding bytes");
+static_assert(sizeof(UInt192) == 192 / 8, "There should be no padding bytes");
+static_assert(sizeof(UInt256) == 256 / 8, "There should be no padding bytes");
 #endif
 
 }  // namespace xrpl

include/xrpl/basics/chrono.h

@@ -16,10 +16,10 @@ namespace xrpl {
 
 // A few handy aliases
 
-using days =
+using Days =
     std::chrono::duration<int, std::ratio_multiply<std::chrono::hours::period, std::ratio<24>>>;
 
-using weeks = std::chrono::duration<int, std::ratio_multiply<days::period, std::ratio<7>>>;
+using Weeks = std::chrono::duration<int, std::ratio_multiply<Days::period, std::ratio<7>>>;
 
 /**
  * Clock for measuring the network time.

include/xrpl/basics/hardened_hash.h

@@ -11,10 +11,10 @@ namespace xrpl {
 
 namespace detail {
 
-using seed_pair = std::pair<std::uint64_t, std::uint64_t>;
+using SeedPair = std::pair<std::uint64_t, std::uint64_t>;
 
 template <bool = true>
-seed_pair
+SeedPair
 makeSeedPair() noexcept
 {
     struct StateT
@@ -71,7 +71,7 @@ template <class HashAlgorithm = beast::Xxhasher>
 class HardenedHash
 {
 private:
-    detail::seed_pair seeds_{detail::makeSeedPair<>()};
+    detail::SeedPair seeds_{detail::makeSeedPair<>()};
 
 public:
     using result_type = HashAlgorithm::result_type;

include/xrpl/basics/partitioned_unordered_map.h

@@ -53,19 +53,19 @@ public:
     using const_reference = value_type const&;
     using pointer = value_type*;
     using const_pointer = value_type const*;
-    using map_type = std::unordered_map<key_type, mapped_type, hasher, key_equal, allocator_type>;
-    using partition_map_type = std::vector<map_type>;
+    using MapType = std::unordered_map<key_type, mapped_type, hasher, key_equal, allocator_type>;
+    using PartitionMapType = std::vector<MapType>;
 
     struct Iterator
     {
         using iterator_category = std::forward_iterator_tag;
-        partition_map_type* map{nullptr};
-        partition_map_type::iterator ait{};
-        map_type::iterator mit;
+        PartitionMapType* map{nullptr};
+        PartitionMapType::iterator ait{};
+        MapType::iterator mit;
 
         Iterator() = default;
 
-        Iterator(partition_map_type* m) : map(m)
+        Iterator(PartitionMapType* m) : map(m)
         {
         }
 
@@ -122,13 +122,13 @@ public:
     {
         using iterator_category = std::forward_iterator_tag;
 
-        partition_map_type* map{nullptr};
-        partition_map_type::iterator ait{};
-        map_type::iterator mit;
+        PartitionMapType* map{nullptr};
+        PartitionMapType::iterator ait{};
+        MapType::iterator mit;
 
         ConstIterator() = default;
 
-        ConstIterator(partition_map_type* m) : map(m)
+        ConstIterator(PartitionMapType* m) : map(m)
         {
         }
 
@@ -234,7 +234,7 @@ public:
         return partitions_;
     }
 
-    partition_map_type&
+    PartitionMapType&
     map()
     {
         return map_;
@@ -377,7 +377,7 @@ public:
     }
 
 private:
-    mutable partition_map_type map_{};
+    mutable PartitionMapType map_{};
 };
 
 }  // namespace xrpl

include/xrpl/basics/random.h

@@ -14,13 +14,13 @@ namespace xrpl {
 #ifndef __INTELLISENSE__
 static_assert(
     // NOLINTNEXTLINE(misc-redundant-expression)
-    std::is_integral_v<beast::xor_shift_engine::result_type> &&
-        std::is_unsigned_v<beast::xor_shift_engine::result_type>,
+    std::is_integral_v<beast::XorShiftEngine::result_type> &&
+        std::is_unsigned_v<beast::XorShiftEngine::result_type>,
     "The XRPL default PRNG engine must return an unsigned integral type.");
 
 static_assert(
     // NOLINTNEXTLINE(misc-redundant-expression)
-    std::numeric_limits<beast::xor_shift_engine::result_type>::max() >=
+    std::numeric_limits<beast::XorShiftEngine::result_type>::max() >=
         std::numeric_limits<std::uint64_t>::max(),
     "The XRPL default PRNG engine return must be at least 64 bits wide.");
 #endif
@@ -30,7 +30,7 @@ namespace detail {
 // Determines if a type can be called like an Engine
 // NOLINTNEXTLINE(readability-redundant-typename): typename required by MSVC
 template <class Engine, class Result = typename Engine::result_type>
-using is_engine = std::is_invocable_r<Result, Engine>;
+using IsEngine = std::is_invocable_r<Result, Engine>;
 }  // namespace detail
 
 /**
@@ -44,28 +44,28 @@ using is_engine = std::is_invocable_r<Result, Engine>;
  * Each thread gets its own instance of the engine which
  * will be randomly seeded.
  */
-inline beast::xor_shift_engine&
+inline beast::XorShiftEngine&
 defaultPrng()
 {
     // This is used to seed the thread-specific PRNGs on demand
-    static beast::xor_shift_engine kSeeder = [] {
+    static beast::XorShiftEngine kSeeder = [] {
         std::random_device rng;
         std::uniform_int_distribution<std::uint64_t> distribution{1};
-        return beast::xor_shift_engine(distribution(rng));
+        return beast::XorShiftEngine(distribution(rng));
     }();
 
     // This protects the seeder
     static std::mutex kM;
 
     // The thread-specific PRNGs:
-    thread_local beast::xor_shift_engine kEngine = [] {
+    thread_local beast::XorShiftEngine kEngine = [] {
         std::uint64_t seed = 0;
         {
             std::scoped_lock const lk(kM);
             std::uniform_int_distribution<std::uint64_t> distribution{1};
             seed = distribution(kSeeder);
         }
-        return beast::xor_shift_engine{seed};
+        return beast::XorShiftEngine{seed};
     }();
 
     return kEngine;
@@ -95,7 +95,7 @@ defaultPrng()
 template <class Engine, class Integral>
 Integral
 randInt(Engine& engine, Integral min, Integral max)
-    requires(std::is_integral_v<Integral> && detail::is_engine<Engine>::value)
+    requires(std::is_integral_v<Integral> && detail::IsEngine<Engine>::value)
 {
     XRPL_ASSERT(max > min, "xrpl::randInt : max over min inputs");
 
@@ -116,7 +116,7 @@ randInt(Integral min, Integral max)
 template <class Engine, class Integral>
 Integral
 randInt(Engine& engine, Integral max)
-    requires(std::is_integral_v<Integral> && detail::is_engine<Engine>::value)
+    requires(std::is_integral_v<Integral> && detail::IsEngine<Engine>::value)
 {
     return randInt(engine, Integral(0), max);
 }
@@ -132,7 +132,7 @@ randInt(Integral max)
 template <class Integral, class Engine>
 Integral
 randInt(Engine& engine)
-    requires(std::is_integral_v<Integral> && detail::is_engine<Engine>::value)
+    requires(std::is_integral_v<Integral> && detail::IsEngine<Engine>::value)
 {
     return randInt(engine, std::numeric_limits<Integral>::max());
 }
@@ -155,7 +155,7 @@ Byte
 randByte(Engine& engine)
     requires(
         (std::is_same_v<Byte, unsigned char> || std::is_same_v<Byte, std::uint8_t>) &&
-        detail::is_engine<Engine>::value)
+        detail::IsEngine<Engine>::value)
 {
     return static_cast<Byte>(randInt<Engine, std::uint32_t>(
         engine, std::numeric_limits<Byte>::min(), std::numeric_limits<Byte>::max()));

include/xrpl/basics/tagged_integer.h

@@ -40,7 +40,7 @@ private:
 
 public:
     using value_type = Int;
-    using tag_type = Tag;
+    using TagType = Tag;
 
     TaggedInteger() = default;
 

include/xrpl/beast/.clang-tidy

@@ -0,0 +1,10 @@
+# beast's containers, clocks and Journal streambuf model std concepts, which mandate
+# snake_case member type names.
+#
+# clang-tidy replaces rather than merges this option, so the list is the
+# top-level one restated plus the 20 name(s) needed only here:
+#   allocator_type argument_type char_type const_local_iterator const_pointer const_reverse_iterator first_argument_type hasher int_type key_compare key_equal local_iterator native_handle_type off_type pos_type reverse_iterator second_argument_type traits_type type value_compare
+InheritParentConfig: true
+CheckOptions:
+  readability-identifier-naming.TypeAliasIgnoredRegexp: "^(allocator_type|argument_type|char_type|const_iterator|const_local_iterator|const_pointer|const_reference|const_reverse_iterator|difference_type|duration|first_argument_type|hasher|int_type|iterator|iterator_category|key_compare|key_equal|key_type|local_iterator|mapped_type|native_handle_type|off_type|period|pointer|pos_type|reference|rep|result_type|reverse_iterator|second_argument_type|size_type|time_point|traits_type|type|value_compare|value_type)$"
+  readability-identifier-naming.TypedefIgnoredRegexp: "^(allocator_type|argument_type|char_type|const_iterator|const_local_iterator|const_pointer|const_reference|const_reverse_iterator|difference_type|duration|first_argument_type|hasher|int_type|iterator|iterator_category|key_compare|key_equal|key_type|local_iterator|mapped_type|native_handle_type|off_type|period|pointer|pos_type|reference|rep|result_type|reverse_iterator|second_argument_type|size_type|time_point|traits_type|type|value_compare|value_type)$"

include/xrpl/beast/clock/abstract_clock.h

@@ -9,7 +9,7 @@ namespace beast {
  * an instance of the class can be dependency injected, facilitating
  * unit tests where time may be controlled.
  *
- * An abstract_clock inherits all the nested types of the Clock
+ * An AbstractClock inherits all the nested types of the Clock
  * template parameter.
  *
  * Example:
@@ -18,9 +18,9 @@ namespace beast {
  *
  * struct Implementation
  * {
- *     using clock_type = abstract_clock <std::chrono::steady_clock>;
- *     clock_type& clock_;
- *     explicit Implementation (clock_type& clock)
+ *     using ClockType = AbstractClock<std::chrono::steady_clock>;
+ *     ClockType& clock_;
+ *     explicit Implementation(ClockType& clock)
  *         : clock_(clock)
  *     {
  *     }
@@ -39,7 +39,7 @@ public:
     using period = Clock::period;
     using duration = Clock::duration;
     using time_point = Clock::time_point;
-    using clock_type = Clock;
+    using ClockType = Clock;
 
     static bool const is_steady = Clock::is_steady;  // NOLINT(readability-identifier-naming)
 

include/xrpl/beast/container/aged_map.h

@@ -15,6 +15,6 @@ template <
     class Clock = std::chrono::steady_clock,
     class Compare = std::less<Key>,
     class Allocator = std::allocator<std::pair<Key const, T>>>
-using aged_map = detail::AgedOrderedContainer<false, true, Key, T, Clock, Compare, Allocator>;
+using AgedMap = detail::AgedOrderedContainer<false, true, Key, T, Clock, Compare, Allocator>;
 
 }  // namespace beast

include/xrpl/beast/container/aged_multimap.h

@@ -15,6 +15,6 @@ template <
     class Clock = std::chrono::steady_clock,
     class Compare = std::less<Key>,
     class Allocator = std::allocator<std::pair<Key const, T>>>
-using aged_multimap = detail::AgedOrderedContainer<true, true, Key, T, Clock, Compare, Allocator>;
+using AgedMultimap = detail::AgedOrderedContainer<true, true, Key, T, Clock, Compare, Allocator>;
 
 }  // namespace beast

include/xrpl/beast/container/aged_multiset.h

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

include/xrpl/beast/container/aged_set.h

@@ -13,6 +13,6 @@ template <
     class Clock = std::chrono::steady_clock,
     class Compare = std::less<Key>,
     class Allocator = std::allocator<Key>>
-using aged_set = detail::AgedOrderedContainer<false, false, Key, void, Clock, Compare, Allocator>;
+using AgedSet = detail::AgedOrderedContainer<false, false, Key, void, Clock, Compare, Allocator>;
 
 }  // namespace beast

include/xrpl/beast/container/aged_unordered_map.h

@@ -16,7 +16,7 @@ template <
     class Hash = std::hash<Key>,
     class KeyEqual = std::equal_to<Key>,
     class Allocator = std::allocator<std::pair<Key const, T>>>
-using aged_unordered_map =
+using AgedUnorderedMap =
     detail::AgedUnorderedContainer<false, true, Key, T, Clock, Hash, KeyEqual, Allocator>;
 
 }  // namespace beast

include/xrpl/beast/container/aged_unordered_multimap.h

@@ -16,7 +16,7 @@ template <
     class Hash = std::hash<Key>,
     class KeyEqual = std::equal_to<Key>,
     class Allocator = std::allocator<std::pair<Key const, T>>>
-using aged_unordered_multimap =
+using AgedUnorderedMultimap =
     detail::AgedUnorderedContainer<true, true, Key, T, Clock, Hash, KeyEqual, Allocator>;
 
 }  // namespace beast

include/xrpl/beast/container/aged_unordered_multiset.h

@@ -14,7 +14,7 @@ template <
     class Hash = std::hash<Key>,
     class KeyEqual = std::equal_to<Key>,
     class Allocator = std::allocator<Key>>
-using aged_unordered_multiset =
+using AgedUnorderedMultiset =
     detail::AgedUnorderedContainer<true, false, Key, void, Clock, Hash, KeyEqual, Allocator>;
 
 }  // namespace beast

include/xrpl/beast/container/aged_unordered_set.h

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

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

@@ -4,12 +4,7 @@
 #include <type_traits>
 #include <utility>
 
-namespace beast {
-
-template <bool, bool, class, class, class, class, class>
-class aged_ordered_container;
-
-namespace detail {
+namespace beast::detail {
 
 // If Iterator is SCARY then this iterator will be as well.
 template <bool IsConst, class Iterator>
@@ -144,6 +139,4 @@ private:
     Iterator iter_;
 };
 
-}  // namespace detail
-
-}  // namespace beast
+}  // namespace beast::detail

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

@@ -54,7 +54,7 @@ struct IsBoostReverseIterator<boost::intrusive::reverse_iterator<It>> : std::tru
  * whose items expire after a certain amount of time. The chronological
  * iterators allow for fully customizable expiration strategies.
  *
- * @see aged_set, aged_multiset, aged_map, aged_multimap
+ * @see AgedSet, AgedMultiset, AgedMap, AgedMultimap
  */
 template <
     bool IsMulti,
@@ -67,9 +67,9 @@ template <
 class AgedOrderedContainer
 {
 public:
-    using clock_type = AbstractClock<Clock>;
-    using time_point = clock_type::time_point;
-    using duration = clock_type::duration;
+    using ClockType = AbstractClock<Clock>;
+    using time_point = ClockType::time_point;
+    using duration = ClockType::duration;
     using key_type = Key;
     using mapped_type = T;
     using value_type = std::conditional_t<IsMap, std::pair<Key const, T>, Key>;
@@ -77,9 +77,9 @@ public:
     using difference_type = std::ptrdiff_t;
 
     // Introspection (for unit tests)
-    using is_unordered = std::false_type;
-    using is_multi = std::integral_constant<bool, IsMulti>;
-    using is_map = std::integral_constant<bool, IsMap>;
+    using IsUnorderedType = std::false_type;
+    using IsMultiType = std::integral_constant<bool, IsMulti>;
+    using IsMapType = std::integral_constant<bool, IsMap>;
 
 private:
     static Key const&
@@ -127,8 +127,8 @@ private:
     class PairValueCompare : public Compare
     {
     public:
-        using first_argument = value_type;
-        using second_argument = value_type;
+        using FirstArgument = value_type;
+        using SecondArgument = value_type;
         using result_type = bool;
 
         bool
@@ -156,8 +156,8 @@ private:
     class KeyValueCompare : public Compare
     {
     public:
-        using first_argument = Key;
-        using second_argument = Element;
+        using FirstArgument = Key;
+        using SecondArgument = Element;
         using result_type = bool;
 
         KeyValueCompare() = default;
@@ -197,10 +197,10 @@ private:
         }
     };
 
-    using list_type =
+    using ListType =
         boost::intrusive::make_list<Element, boost::intrusive::constant_time_size<false>>::type;
 
-    using cont_type = std::conditional_t<
+    using ContType = std::conditional_t<
         IsMulti,
         typename boost::intrusive::make_multiset<
             Element,
@@ -219,20 +219,20 @@ private:
                     public beast::detail::EmptyBaseOptimization<ElementAllocator>
     {
     public:
-        explicit ConfigT(clock_type& clock) : clock(clock)
+        explicit ConfigT(ClockType& clock) : clock(clock)
         {
         }
 
-        ConfigT(clock_type& clock, Compare const& comp) : KeyValueCompare(comp), clock(clock)
+        ConfigT(ClockType& clock, Compare const& comp) : KeyValueCompare(comp), clock(clock)
         {
         }
 
-        ConfigT(clock_type& clock, Allocator const& alloc)
+        ConfigT(ClockType& clock, Allocator const& alloc)
             : beast::detail::EmptyBaseOptimization<ElementAllocator>(alloc), clock(clock)
         {
         }
 
-        ConfigT(clock_type& clock, Compare const& comp, Allocator const& alloc)
+        ConfigT(ClockType& clock, Compare const& comp, Allocator const& alloc)
             : KeyValueCompare(comp)
             , beast::detail::EmptyBaseOptimization<ElementAllocator>(alloc)
             , clock(clock)
@@ -328,7 +328,7 @@ private:
             return beast::detail::EmptyBaseOptimization<ElementAllocator>::member();
         }
 
-        std::reference_wrapper<clock_type> clock;
+        std::reference_wrapper<ClockType> clock;
     };
 
     template <class... Args>
@@ -383,12 +383,12 @@ public:
 
     // A set iterator (IsMap==false) is always const
     // because the elements of a set are immutable.
-    using iterator = beast::detail::AgedContainerIterator<!IsMap, typename cont_type::iterator>;
-    using const_iterator = beast::detail::AgedContainerIterator<true, typename cont_type::iterator>;
+    using iterator = beast::detail::AgedContainerIterator<!IsMap, typename ContType::iterator>;
+    using const_iterator = beast::detail::AgedContainerIterator<true, typename ContType::iterator>;
     using reverse_iterator =
-        beast::detail::AgedContainerIterator<!IsMap, typename cont_type::reverse_iterator>;
+        beast::detail::AgedContainerIterator<!IsMap, typename ContType::reverse_iterator>;
     using const_reverse_iterator =
-        beast::detail::AgedContainerIterator<true, typename cont_type::reverse_iterator>;
+        beast::detail::AgedContainerIterator<true, typename ContType::reverse_iterator>;
 
     //--------------------------------------------------------------------------
     //
@@ -406,13 +406,13 @@ public:
     public:
         // A set iterator (IsMap==false) is always const
         // because the elements of a set are immutable.
-        using iterator = beast::detail::AgedContainerIterator<!IsMap, typename list_type::iterator>;
+        using iterator = beast::detail::AgedContainerIterator<!IsMap, typename ListType::iterator>;
         using const_iterator =
-            beast::detail::AgedContainerIterator<true, typename list_type::iterator>;
+            beast::detail::AgedContainerIterator<true, typename ListType::iterator>;
         using reverse_iterator =
-            beast::detail::AgedContainerIterator<!IsMap, typename list_type::reverse_iterator>;
+            beast::detail::AgedContainerIterator<!IsMap, typename ListType::reverse_iterator>;
         using const_reverse_iterator =
-            beast::detail::AgedContainerIterator<true, typename list_type::reverse_iterator>;
+            beast::detail::AgedContainerIterator<true, typename ListType::reverse_iterator>;
 
         iterator
         begin()
@@ -509,7 +509,7 @@ public:
 
     private:
         friend class AgedOrderedContainer;
-        list_type mutable list_;
+        ListType mutable list_;
     } chronological;
 
     //--------------------------------------------------------------------------
@@ -520,28 +520,28 @@ public:
 
     AgedOrderedContainer() = delete;
 
-    explicit AgedOrderedContainer(clock_type& clock);
+    explicit AgedOrderedContainer(ClockType& clock);
 
-    AgedOrderedContainer(clock_type& clock, Compare const& comp);
+    AgedOrderedContainer(ClockType& clock, Compare const& comp);
 
-    AgedOrderedContainer(clock_type& clock, Allocator const& alloc);
+    AgedOrderedContainer(ClockType& clock, Allocator const& alloc);
 
-    AgedOrderedContainer(clock_type& clock, Compare const& comp, Allocator const& alloc);
+    AgedOrderedContainer(ClockType& clock, Compare const& comp, Allocator const& alloc);
 
     template <class InputIt>
-    AgedOrderedContainer(InputIt first, InputIt last, clock_type& clock);
+    AgedOrderedContainer(InputIt first, InputIt last, ClockType& clock);
 
     template <class InputIt>
-    AgedOrderedContainer(InputIt first, InputIt last, clock_type& clock, Compare const& comp);
+    AgedOrderedContainer(InputIt first, InputIt last, ClockType& clock, Compare const& comp);
 
     template <class InputIt>
-    AgedOrderedContainer(InputIt first, InputIt last, clock_type& clock, Allocator const& alloc);
+    AgedOrderedContainer(InputIt first, InputIt last, ClockType& clock, Allocator const& alloc);
 
     template <class InputIt>
     AgedOrderedContainer(
         InputIt first,
         InputIt last,
-        clock_type& clock,
+        ClockType& clock,
         Compare const& comp,
         Allocator const& alloc);
 
@@ -556,21 +556,21 @@ public:
         AgedOrderedContainer&& other,
         Allocator const& alloc);
 
-    AgedOrderedContainer(std::initializer_list<value_type> init, clock_type& clock);
+    AgedOrderedContainer(std::initializer_list<value_type> init, ClockType& clock);
 
     AgedOrderedContainer(
         std::initializer_list<value_type> init,
-        clock_type& clock,
+        ClockType& clock,
         Compare const& comp);
 
     AgedOrderedContainer(
         std::initializer_list<value_type> init,
-        clock_type& clock,
+        ClockType& clock,
         Allocator const& alloc);
 
     AgedOrderedContainer(
         std::initializer_list<value_type> init,
-        clock_type& clock,
+        ClockType& clock,
         Compare const& comp,
         Allocator const& alloc);
 
@@ -591,13 +591,13 @@ public:
         return config_.alloc();
     }
 
-    clock_type&
+    ClockType&
     clock()
     {
         return config_.clock;
     }
 
-    clock_type const&
+    ClockType const&
     clock() const
     {
         return config_.clock;
@@ -820,7 +820,7 @@ public:
     template <class P, bool MaybeMap = IsMap>
     std::conditional_t<IsMulti, iterator, std::pair<iterator, bool>>
     insert(P&& value)
-        requires(MaybeMap && std::is_constructible_v<value_type, P &&>)
+        requires(MaybeMap && std::is_constructible_v<value_type, P&&>)
     {
         return emplace(std::forward<P>(value));
     }
@@ -829,7 +829,7 @@ public:
     template <class P, bool MaybeMap = IsMap>
     std::conditional_t<IsMulti, iterator, std::pair<iterator, bool>>
     insert(const_iterator hint, P&& value)
-        requires(MaybeMap && std::is_constructible_v<value_type, P &&>)
+        requires(MaybeMap && std::is_constructible_v<value_type, P&&>)
     {
         return emplaceHint(hint, std::forward<P>(value));
     }
@@ -1121,7 +1121,7 @@ private:
     void
     touch(
         beast::detail::AgedContainerIterator<IsConst, Iterator> pos,
-        clock_type::time_point const& now)
+        ClockType::time_point const& now)
         requires(!IsBoostReverseIterator<Iterator>::value);
 
     template <
@@ -1138,21 +1138,21 @@ private:
 
 private:
     ConfigT config_;
-    cont_type mutable cont_;
+    ContType mutable cont_;
 };
 
 //------------------------------------------------------------------------------
 
 template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
 AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::AgedOrderedContainer(
-    clock_type& clock)
+    ClockType& clock)
     : config_(clock)
 {
 }
 
 template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
 AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::AgedOrderedContainer(
-    clock_type& clock,
+    ClockType& clock,
     Compare const& comp)
     : config_(clock, comp), cont_(comp)
 {
@@ -1160,7 +1160,7 @@ AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::AgedOrd
 
 template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
 AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::AgedOrderedContainer(
-    clock_type& clock,
+    ClockType& clock,
     Allocator const& alloc)
     : config_(clock, alloc)
 {
@@ -1168,7 +1168,7 @@ AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::AgedOrd
 
 template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
 AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::AgedOrderedContainer(
-    clock_type& clock,
+    ClockType& clock,
     Compare const& comp,
     Allocator const& alloc)
     : config_(clock, comp, alloc), cont_(comp)
@@ -1180,7 +1180,7 @@ template <class InputIt>
 AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::AgedOrderedContainer(
     InputIt first,
     InputIt last,
-    clock_type& clock)
+    ClockType& clock)
     : config_(clock)
 {
     insert(first, last);
@@ -1191,7 +1191,7 @@ template <class InputIt>
 AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::AgedOrderedContainer(
     InputIt first,
     InputIt last,
-    clock_type& clock,
+    ClockType& clock,
     Compare const& comp)
     : config_(clock, comp), cont_(comp)
 {
@@ -1203,7 +1203,7 @@ template <class InputIt>
 AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::AgedOrderedContainer(
     InputIt first,
     InputIt last,
-    clock_type& clock,
+    ClockType& clock,
     Allocator const& alloc)
     : config_(clock, alloc)
 {
@@ -1215,7 +1215,7 @@ template <class InputIt>
 AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::AgedOrderedContainer(
     InputIt first,
     InputIt last,
-    clock_type& clock,
+    ClockType& clock,
     Compare const& comp,
     Allocator const& alloc)
     : config_(clock, comp, alloc), cont_(comp)
@@ -1261,7 +1261,7 @@ AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::AgedOrd
 template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
 AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::AgedOrderedContainer(
     std::initializer_list<value_type> init,
-    clock_type& clock)
+    ClockType& clock)
     : config_(clock)
 {
     insert(init.begin(), init.end());
@@ -1270,7 +1270,7 @@ AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::AgedOrd
 template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
 AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::AgedOrderedContainer(
     std::initializer_list<value_type> init,
-    clock_type& clock,
+    ClockType& clock,
     Compare const& comp)
     : config_(clock, comp), cont_(comp)
 {
@@ -1280,7 +1280,7 @@ AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::AgedOrd
 template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
 AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::AgedOrderedContainer(
     std::initializer_list<value_type> init,
-    clock_type& clock,
+    ClockType& clock,
     Allocator const& alloc)
     : config_(clock, alloc)
 {
@@ -1290,7 +1290,7 @@ AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::AgedOrd
 template <bool IsMulti, bool IsMap, class Key, class T, class Clock, class Compare, class Allocator>
 AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::AgedOrderedContainer(
     std::initializer_list<value_type> init,
-    clock_type& clock,
+    ClockType& clock,
     Compare const& comp,
     Allocator const& alloc)
     : config_(clock, comp, alloc), cont_(comp)
@@ -1372,7 +1372,7 @@ std::conditional_t<IsMap, T, void*>&
 AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::operator[](Key const& key)
     requires(MaybeMap && !MaybeMulti)
 {
-    typename cont_type::insert_commit_data d;
+    typename ContType::insert_commit_data d;
     auto const result(cont_.insert_check(key, std::cref(config_.keyCompare()), d));
     if (result.second)
     {
@@ -1391,7 +1391,7 @@ std::conditional_t<IsMap, T, void*>&
 AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::operator[](Key&& key)
     requires(MaybeMap && !MaybeMulti)
 {
-    typename cont_type::insert_commit_data d;
+    typename ContType::insert_commit_data d;
     auto const result(cont_.insert_check(key, std::cref(config_.keyCompare()), d));
     if (result.second)
     {
@@ -1426,7 +1426,7 @@ AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::insert(
     value_type const& value) -> std::pair<iterator, bool>
     requires(!MaybeMulti)
 {
-    typename cont_type::insert_commit_data d;
+    typename ContType::insert_commit_data d;
     auto const result(cont_.insert_check(extract(value), std::cref(config_.keyCompare()), d));
     if (result.second)
     {
@@ -1461,7 +1461,7 @@ AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::insert(
     -> std::pair<iterator, bool>
     requires(!MaybeMulti && !MaybeMap)
 {
-    typename cont_type::insert_commit_data d;
+    typename ContType::insert_commit_data d;
     auto const result(cont_.insert_check(extract(value), std::cref(config_.keyCompare()), d));
     if (result.second)
     {
@@ -1499,7 +1499,7 @@ AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::insert(
     value_type const& value) -> iterator
     requires(!MaybeMulti)
 {
-    typename cont_type::insert_commit_data d;
+    typename ContType::insert_commit_data d;
     auto const result(
         cont_.insert_check(hint.iterator(), extract(value), std::cref(config_.keyCompare()), d));
     if (result.second)
@@ -1521,7 +1521,7 @@ AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::insert(
     value_type&& value) -> iterator
     requires(!MaybeMulti)
 {
-    typename cont_type::insert_commit_data d;
+    typename ContType::insert_commit_data d;
     auto const result(
         cont_.insert_check(hint.iterator(), extract(value), std::cref(config_.keyCompare()), d));
     if (result.second)
@@ -1545,7 +1545,7 @@ AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::emplace
     // VFALCO NOTE Its unfortunate that we need to
     //             construct element here
     Element* const p(newElement(std::forward<Args>(args)...));
-    typename cont_type::insert_commit_data d;
+    typename ContType::insert_commit_data d;
     auto const result(cont_.insert_check(extract(p->value), std::cref(config_.keyCompare()), d));
     if (result.second)
     {
@@ -1584,7 +1584,7 @@ AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::emplace
     // VFALCO NOTE Its unfortunate that we need to
     //             construct element here
     Element* const p(newElement(std::forward<Args>(args)...));
-    typename cont_type::insert_commit_data d;
+    typename ContType::insert_commit_data d;
     auto const result(
         cont_.insert_check(hint.iterator(), extract(p->value), std::cref(config_.keyCompare()), d));
     if (result.second)
@@ -1721,7 +1721,7 @@ template <bool IsConst, class Iterator>
 void
 AgedOrderedContainer<IsMulti, IsMap, Key, T, Clock, Compare, Allocator>::touch(
     beast::detail::AgedContainerIterator<IsConst, Iterator> pos,
-    clock_type::time_point const& now)
+    ClockType::time_point const& now)
     requires(!IsBoostReverseIterator<Iterator>::value)
 {
     auto& e(*pos.iterator());

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

@@ -59,8 +59,8 @@ namespace detail {
  * whose items expire after a certain amount of time. The chronological
  * iterators allow for fully customizable expiration strategies.
  *
- * @see aged_unordered_set, aged_unordered_multiset
- * @see aged_unordered_map, aged_unordered_multimap
+ * @see AgedUnorderedSet, AgedUnorderedMultiset
+ * @see AgedUnorderedMap, AgedUnorderedMultimap
  */
 template <
     bool IsMulti,
@@ -74,9 +74,9 @@ template <
 class AgedUnorderedContainer
 {
 public:
-    using clock_type = AbstractClock<Clock>;
-    using time_point = clock_type::time_point;
-    using duration = clock_type::duration;
+    using ClockType = AbstractClock<Clock>;
+    using time_point = ClockType::time_point;
+    using duration = ClockType::duration;
     using key_type = Key;
     using mapped_type = T;
     using value_type = std::conditional_t<IsMap, std::pair<Key const, T>, Key>;
@@ -84,9 +84,9 @@ public:
     using difference_type = std::ptrdiff_t;
 
     // Introspection (for unit tests)
-    using is_unordered = std::true_type;
-    using is_multi = std::integral_constant<bool, IsMulti>;
-    using is_map = std::integral_constant<bool, IsMap>;
+    using IsUnorderedType = std::true_type;
+    using IsMultiType = std::integral_constant<bool, IsMulti>;
+    using IsMapType = std::integral_constant<bool, IsMap>;
 
 private:
     static Key const&
@@ -208,10 +208,10 @@ private:
         }
     };
 
-    using list_type =
+    using ListType =
         boost::intrusive::make_list<Element, boost::intrusive::constant_time_size<false>>::type;
 
-    using cont_type = std::conditional_t<
+    using ContType = std::conditional_t<
         IsMulti,
         typename boost::intrusive::make_unordered_multiset<
             Element,
@@ -226,8 +226,8 @@ private:
             boost::intrusive::equal<KeyValueEqual>,
             boost::intrusive::cache_begin<true>>::type>;
 
-    using bucket_type = cont_type::bucket_type;
-    using bucket_traits = cont_type::bucket_traits;
+    using BucketType = ContType::bucket_type;
+    using BucketTraits = ContType::bucket_traits;
 
     using ElementAllocator = std::allocator_traits<Allocator>::template rebind_alloc<Element>;
 
@@ -242,36 +242,36 @@ private:
                     private beast::detail::EmptyBaseOptimization<ElementAllocator>
     {
     public:
-        explicit ConfigT(clock_type& clock) : clock(clock)
+        explicit ConfigT(ClockType& clock) : clock(clock)
         {
         }
 
-        ConfigT(clock_type& clock, Hash const& hash) : ValueHash(hash), clock(clock)
+        ConfigT(ClockType& clock, Hash const& hash) : ValueHash(hash), clock(clock)
         {
         }
 
-        ConfigT(clock_type& clock, KeyEqual const& keyEqual) : KeyValueEqual(keyEqual), clock(clock)
+        ConfigT(ClockType& clock, KeyEqual const& keyEqual) : KeyValueEqual(keyEqual), clock(clock)
         {
         }
 
-        ConfigT(clock_type& clock, Allocator const& alloc)
+        ConfigT(ClockType& clock, Allocator const& alloc)
             : beast::detail::EmptyBaseOptimization<ElementAllocator>(alloc), clock(clock)
         {
         }
 
-        ConfigT(clock_type& clock, Hash const& hash, KeyEqual const& keyEqual)
+        ConfigT(ClockType& clock, Hash const& hash, KeyEqual const& keyEqual)
             : ValueHash(hash), KeyValueEqual(keyEqual), clock(clock)
         {
         }
 
-        ConfigT(clock_type& clock, Hash const& hash, Allocator const& alloc)
+        ConfigT(ClockType& clock, Hash const& hash, Allocator const& alloc)
             : ValueHash(hash)
             , beast::detail::EmptyBaseOptimization<ElementAllocator>(alloc)
             , clock(clock)
         {
         }
 
-        ConfigT(clock_type& clock, KeyEqual const& keyEqual, Allocator const& alloc)
+        ConfigT(ClockType& clock, KeyEqual const& keyEqual, Allocator const& alloc)
             : KeyValueEqual(keyEqual)
             , beast::detail::EmptyBaseOptimization<ElementAllocator>(alloc)
             , clock(clock)
@@ -279,7 +279,7 @@ private:
         }
 
         ConfigT(
-            clock_type& clock,
+            ClockType& clock,
             Hash const& hash,
             KeyEqual const& keyEqual,
             Allocator const& alloc)
@@ -405,29 +405,29 @@ private:
             return beast::detail::EmptyBaseOptimization<ElementAllocator>::member();
         }
 
-        std::reference_wrapper<clock_type> clock;
+        std::reference_wrapper<ClockType> clock;
     };
 
     class Buckets
     {
     public:
-        using vec_type = std::vector<
-            bucket_type,
-            typename std::allocator_traits<Allocator>::template rebind_alloc<bucket_type>>;
+        using VecType = std::vector<
+            BucketType,
+            typename std::allocator_traits<Allocator>::template rebind_alloc<BucketType>>;
 
         Buckets() : maxLoadFactor_(1.f), vec_()
         {
-            vec_.resize(cont_type::suggested_upper_bucket_count(0));
+            vec_.resize(ContType::suggested_upper_bucket_count(0));
         }
 
         Buckets(Allocator const& alloc) : maxLoadFactor_(1.f), vec_(alloc)
         {
-            vec_.resize(cont_type::suggested_upper_bucket_count(0));
+            vec_.resize(ContType::suggested_upper_bucket_count(0));
         }
 
-        operator bucket_traits()
+        operator BucketTraits()
         {
-            return bucket_traits(&vec_[0], vec_.size());
+            return BucketTraits(&vec_[0], vec_.size());
         }
 
         void
@@ -466,10 +466,10 @@ private:
             {
                 // Need two vectors otherwise we
                 // will destroy non-empty buckets.
-                vec_type vec(vec_.get_allocator());
+                VecType vec(vec_.get_allocator());
                 std::swap(vec_, vec);
                 vec_.resize(count);
-                c.rehash(bucket_traits(&vec_[0], vec_.size()));
+                c.rehash(BucketTraits(&vec_[0], vec_.size()));
                 return;
             }
             // Rehash in place.
@@ -478,12 +478,12 @@ private:
                 // This should not reallocate since
                 // we checked capacity earlier.
                 vec_.resize(count);
-                c.rehash(bucket_traits(&vec_[0], count));
+                c.rehash(BucketTraits(&vec_[0], count));
                 return;
             }
             // Resize must happen after rehash otherwise
             // we might destroy non-empty buckets.
-            c.rehash(bucket_traits(&vec_[0], count));
+            c.rehash(BucketTraits(&vec_[0], count));
             vec_.resize(count);
         }
 
@@ -492,13 +492,13 @@ private:
         void
         resize(size_type n, Container& c)
         {
-            size_type const suggested(cont_type::suggested_upper_bucket_count(n));
+            size_type const suggested(ContType::suggested_upper_bucket_count(n));
             rehash(suggested, c);
         }
 
     private:
         float maxLoadFactor_;
-        vec_type vec_;
+        VecType vec_;
     };
 
     template <class... Args>
@@ -553,13 +553,13 @@ public:
 
     // A set iterator (IsMap==false) is always const
     // because the elements of a set are immutable.
-    using iterator = beast::detail::AgedContainerIterator<!IsMap, typename cont_type::iterator>;
-    using const_iterator = beast::detail::AgedContainerIterator<true, typename cont_type::iterator>;
+    using iterator = beast::detail::AgedContainerIterator<!IsMap, typename ContType::iterator>;
+    using const_iterator = beast::detail::AgedContainerIterator<true, typename ContType::iterator>;
 
     using local_iterator =
-        beast::detail::AgedContainerIterator<!IsMap, typename cont_type::local_iterator>;
+        beast::detail::AgedContainerIterator<!IsMap, typename ContType::local_iterator>;
     using const_local_iterator =
-        beast::detail::AgedContainerIterator<true, typename cont_type::local_iterator>;
+        beast::detail::AgedContainerIterator<true, typename ContType::local_iterator>;
 
     //--------------------------------------------------------------------------
     //
@@ -575,13 +575,13 @@ public:
     public:
         // A set iterator (IsMap==false) is always const
         // because the elements of a set are immutable.
-        using iterator = beast::detail::AgedContainerIterator<!IsMap, typename list_type::iterator>;
+        using iterator = beast::detail::AgedContainerIterator<!IsMap, typename ListType::iterator>;
         using const_iterator =
-            beast::detail::AgedContainerIterator<true, typename list_type::iterator>;
+            beast::detail::AgedContainerIterator<true, typename ListType::iterator>;
         using reverse_iterator =
-            beast::detail::AgedContainerIterator<!IsMap, typename list_type::reverse_iterator>;
+            beast::detail::AgedContainerIterator<!IsMap, typename ListType::reverse_iterator>;
         using const_reverse_iterator =
-            beast::detail::AgedContainerIterator<true, typename list_type::reverse_iterator>;
+            beast::detail::AgedContainerIterator<true, typename ListType::reverse_iterator>;
 
         iterator
         begin()
@@ -679,7 +679,7 @@ public:
 
     private:
         friend class AgedUnorderedContainer;
-        list_type mutable list_;
+        ListType mutable list_;
     } chronological;
 
     //--------------------------------------------------------------------------
@@ -690,43 +690,43 @@ public:
 
     AgedUnorderedContainer() = delete;
 
-    explicit AgedUnorderedContainer(clock_type& clock);
+    explicit AgedUnorderedContainer(ClockType& clock);
 
-    AgedUnorderedContainer(clock_type& clock, Hash const& hash);
+    AgedUnorderedContainer(ClockType& clock, Hash const& hash);
 
-    AgedUnorderedContainer(clock_type& clock, KeyEqual const& keyEq);
+    AgedUnorderedContainer(ClockType& clock, KeyEqual const& keyEq);
 
-    AgedUnorderedContainer(clock_type& clock, Allocator const& alloc);
+    AgedUnorderedContainer(ClockType& clock, Allocator const& alloc);
 
-    AgedUnorderedContainer(clock_type& clock, Hash const& hash, KeyEqual const& keyEq);
+    AgedUnorderedContainer(ClockType& clock, Hash const& hash, KeyEqual const& keyEq);
 
-    AgedUnorderedContainer(clock_type& clock, Hash const& hash, Allocator const& alloc);
+    AgedUnorderedContainer(ClockType& clock, Hash const& hash, Allocator const& alloc);
 
-    AgedUnorderedContainer(clock_type& clock, KeyEqual const& keyEq, Allocator const& alloc);
+    AgedUnorderedContainer(ClockType& clock, KeyEqual const& keyEq, Allocator const& alloc);
 
     AgedUnorderedContainer(
-        clock_type& clock,
+        ClockType& clock,
         Hash const& hash,
         KeyEqual const& keyEq,
         Allocator const& alloc);
 
     template <class InputIt>
-    AgedUnorderedContainer(InputIt first, InputIt last, clock_type& clock);
+    AgedUnorderedContainer(InputIt first, InputIt last, ClockType& clock);
 
     template <class InputIt>
-    AgedUnorderedContainer(InputIt first, InputIt last, clock_type& clock, Hash const& hash);
+    AgedUnorderedContainer(InputIt first, InputIt last, ClockType& clock, Hash const& hash);
 
     template <class InputIt>
-    AgedUnorderedContainer(InputIt first, InputIt last, clock_type& clock, KeyEqual const& keyEq);
+    AgedUnorderedContainer(InputIt first, InputIt last, ClockType& clock, KeyEqual const& keyEq);
 
     template <class InputIt>
-    AgedUnorderedContainer(InputIt first, InputIt last, clock_type& clock, Allocator const& alloc);
+    AgedUnorderedContainer(InputIt first, InputIt last, ClockType& clock, Allocator const& alloc);
 
     template <class InputIt>
     AgedUnorderedContainer(
         InputIt first,
         InputIt last,
-        clock_type& clock,
+        ClockType& clock,
         Hash const& hash,
         KeyEqual const& keyEq);
 
@@ -734,7 +734,7 @@ public:
     AgedUnorderedContainer(
         InputIt first,
         InputIt last,
-        clock_type& clock,
+        ClockType& clock,
         Hash const& hash,
         Allocator const& alloc);
 
@@ -742,7 +742,7 @@ public:
     AgedUnorderedContainer(
         InputIt first,
         InputIt last,
-        clock_type& clock,
+        ClockType& clock,
         KeyEqual const& keyEq,
         Allocator const& alloc);
 
@@ -750,7 +750,7 @@ public:
     AgedUnorderedContainer(
         InputIt first,
         InputIt last,
-        clock_type& clock,
+        ClockType& clock,
         Hash const& hash,
         KeyEqual const& keyEq,
         Allocator const& alloc);
@@ -766,44 +766,44 @@ public:
         AgedUnorderedContainer&& other,
         Allocator const& alloc);
 
-    AgedUnorderedContainer(std::initializer_list<value_type> init, clock_type& clock);
+    AgedUnorderedContainer(std::initializer_list<value_type> init, ClockType& clock);
 
     AgedUnorderedContainer(
         std::initializer_list<value_type> init,
-        clock_type& clock,
+        ClockType& clock,
         Hash const& hash);
 
     AgedUnorderedContainer(
         std::initializer_list<value_type> init,
-        clock_type& clock,
+        ClockType& clock,
         KeyEqual const& keyEq);
 
     AgedUnorderedContainer(
         std::initializer_list<value_type> init,
-        clock_type& clock,
+        ClockType& clock,
         Allocator const& alloc);
 
     AgedUnorderedContainer(
         std::initializer_list<value_type> init,
-        clock_type& clock,
+        ClockType& clock,
         Hash const& hash,
         KeyEqual const& keyEq);
 
     AgedUnorderedContainer(
         std::initializer_list<value_type> init,
-        clock_type& clock,
+        ClockType& clock,
         Hash const& hash,
         Allocator const& alloc);
 
     AgedUnorderedContainer(
         std::initializer_list<value_type> init,
-        clock_type& clock,
+        ClockType& clock,
         KeyEqual const& keyEq,
         Allocator const& alloc);
 
     AgedUnorderedContainer(
         std::initializer_list<value_type> init,
-        clock_type& clock,
+        ClockType& clock,
         Hash const& hash,
         KeyEqual const& keyEq,
         Allocator const& alloc);
@@ -825,13 +825,13 @@ public:
         return config_.alloc();
     }
 
-    clock_type&
+    ClockType&
     clock()
     {
         return config_.clock;
     }
 
-    clock_type const&
+    ClockType const&
     clock() const
     {
         return config_.clock;
@@ -1028,7 +1028,7 @@ public:
     template <class P, bool MaybeMap = IsMap>
     std::conditional_t<IsMulti, iterator, std::pair<iterator, bool>>
     insert(P&& value)
-        requires(MaybeMap && std::is_constructible_v<value_type, P &&>)
+        requires(MaybeMap && std::is_constructible_v<value_type, P&&>)
     {
         return emplace(std::forward<P>(value));
     }
@@ -1037,7 +1037,7 @@ public:
     template <class P, bool MaybeMap = IsMap>
     std::conditional_t<IsMulti, iterator, std::pair<iterator, bool>>
     insert(const_iterator hint, P&& value)
-        requires(MaybeMap && std::is_constructible_v<value_type, P &&>)
+        requires(MaybeMap && std::is_constructible_v<value_type, P&&>)
     {
         return emplaceHint(hint, std::forward<P>(value));
     }
@@ -1399,7 +1399,7 @@ private:
     void
     touch(
         beast::detail::AgedContainerIterator<IsConst, Iterator> pos,
-        clock_type::time_point const& now)
+        ClockType::time_point const& now)
     {
         auto& e(*pos.iterator());
         e.when = now;
@@ -1433,7 +1433,7 @@ private:
 private:
     ConfigT config_;
     Buckets buck_;
-    cont_type mutable cont_;
+    ContType mutable cont_;
 };
 
 //------------------------------------------------------------------------------
@@ -1448,7 +1448,7 @@ template <
     class KeyEqual,
     class Allocator>
 AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::
-    AgedUnorderedContainer(clock_type& clock)
+    AgedUnorderedContainer(ClockType& clock)
     : config_(clock)
     , cont_(buck_, std::cref(config_.valueHash()), std::cref(config_.keyValueEqual()))
 {
@@ -1464,7 +1464,7 @@ template <
     class KeyEqual,
     class Allocator>
 AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::
-    AgedUnorderedContainer(clock_type& clock, Hash const& hash)
+    AgedUnorderedContainer(ClockType& clock, Hash const& hash)
     : config_(clock, hash)
     , cont_(buck_, std::cref(config_.valueHash()), std::cref(config_.keyValueEqual()))
 {
@@ -1480,7 +1480,7 @@ template <
     class KeyEqual,
     class Allocator>
 AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::
-    AgedUnorderedContainer(clock_type& clock, KeyEqual const& keyEq)
+    AgedUnorderedContainer(ClockType& clock, KeyEqual const& keyEq)
     : config_(clock, keyEq)
     , cont_(buck_, std::cref(config_.valueHash()), std::cref(config_.keyValueEqual()))
 {
@@ -1496,7 +1496,7 @@ template <
     class KeyEqual,
     class Allocator>
 AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::
-    AgedUnorderedContainer(clock_type& clock, Allocator const& alloc)
+    AgedUnorderedContainer(ClockType& clock, Allocator const& alloc)
     : config_(clock, alloc)
     , buck_(alloc)
     , cont_(buck_, std::cref(config_.valueHash()), std::cref(config_.keyValueEqual()))
@@ -1513,7 +1513,7 @@ template <
     class KeyEqual,
     class Allocator>
 AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::
-    AgedUnorderedContainer(clock_type& clock, Hash const& hash, KeyEqual const& keyEq)
+    AgedUnorderedContainer(ClockType& clock, Hash const& hash, KeyEqual const& keyEq)
     : config_(clock, hash, keyEq)
     , cont_(buck_, std::cref(config_.valueHash()), std::cref(config_.keyValueEqual()))
 {
@@ -1529,7 +1529,7 @@ template <
     class KeyEqual,
     class Allocator>
 AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::
-    AgedUnorderedContainer(clock_type& clock, Hash const& hash, Allocator const& alloc)
+    AgedUnorderedContainer(ClockType& clock, Hash const& hash, Allocator const& alloc)
     : config_(clock, hash, alloc)
     , buck_(alloc)
     , cont_(buck_, std::cref(config_.valueHash()), std::cref(config_.keyValueEqual()))
@@ -1546,7 +1546,7 @@ template <
     class KeyEqual,
     class Allocator>
 AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::
-    AgedUnorderedContainer(clock_type& clock, KeyEqual const& keyEq, Allocator const& alloc)
+    AgedUnorderedContainer(ClockType& clock, KeyEqual const& keyEq, Allocator const& alloc)
     : config_(clock, keyEq, alloc)
     , buck_(alloc)
     , cont_(buck_, std::cref(config_.valueHash()), std::cref(config_.keyValueEqual()))
@@ -1564,7 +1564,7 @@ template <
     class Allocator>
 AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::
     AgedUnorderedContainer(
-        clock_type& clock,
+        ClockType& clock,
         Hash const& hash,
         KeyEqual const& keyEq,
         Allocator const& alloc)
@@ -1585,7 +1585,7 @@ template <
     class Allocator>
 template <class InputIt>
 AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::
-    AgedUnorderedContainer(InputIt first, InputIt last, clock_type& clock)
+    AgedUnorderedContainer(InputIt first, InputIt last, ClockType& clock)
     : config_(clock)
     , cont_(buck_, std::cref(config_.valueHash()), std::cref(config_.keyValueEqual()))
 {
@@ -1603,7 +1603,7 @@ template <
     class Allocator>
 template <class InputIt>
 AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::
-    AgedUnorderedContainer(InputIt first, InputIt last, clock_type& clock, Hash const& hash)
+    AgedUnorderedContainer(InputIt first, InputIt last, ClockType& clock, Hash const& hash)
     : config_(clock, hash)
     , cont_(buck_, std::cref(config_.valueHash()), std::cref(config_.keyValueEqual()))
 {
@@ -1621,7 +1621,7 @@ template <
     class Allocator>
 template <class InputIt>
 AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::
-    AgedUnorderedContainer(InputIt first, InputIt last, clock_type& clock, KeyEqual const& keyEq)
+    AgedUnorderedContainer(InputIt first, InputIt last, ClockType& clock, KeyEqual const& keyEq)
     : config_(clock, keyEq)
     , cont_(buck_, std::cref(config_.valueHash()), std::cref(config_.keyValueEqual()))
 {
@@ -1639,7 +1639,7 @@ template <
     class Allocator>
 template <class InputIt>
 AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::
-    AgedUnorderedContainer(InputIt first, InputIt last, clock_type& clock, Allocator const& alloc)
+    AgedUnorderedContainer(InputIt first, InputIt last, ClockType& clock, Allocator const& alloc)
     : config_(clock, alloc)
     , buck_(alloc)
     , cont_(buck_, std::cref(config_.valueHash()), std::cref(config_.keyValueEqual()))
@@ -1661,7 +1661,7 @@ AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>
     AgedUnorderedContainer(
         InputIt first,
         InputIt last,
-        clock_type& clock,
+        ClockType& clock,
         Hash const& hash,
         KeyEqual const& keyEq)
     : config_(clock, hash, keyEq)
@@ -1684,7 +1684,7 @@ AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>
     AgedUnorderedContainer(
         InputIt first,
         InputIt last,
-        clock_type& clock,
+        ClockType& clock,
         Hash const& hash,
         Allocator const& alloc)
     : config_(clock, hash, alloc)
@@ -1708,7 +1708,7 @@ AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>
     AgedUnorderedContainer(
         InputIt first,
         InputIt last,
-        clock_type& clock,
+        ClockType& clock,
         KeyEqual const& keyEq,
         Allocator const& alloc)
     : config_(clock, keyEq, alloc)
@@ -1732,7 +1732,7 @@ AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>
     AgedUnorderedContainer(
         InputIt first,
         InputIt last,
-        clock_type& clock,
+        ClockType& clock,
         Hash const& hash,
         KeyEqual const& keyEq,
         Allocator const& alloc)
@@ -1829,7 +1829,7 @@ template <
     class KeyEqual,
     class Allocator>
 AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::
-    AgedUnorderedContainer(std::initializer_list<value_type> init, clock_type& clock)
+    AgedUnorderedContainer(std::initializer_list<value_type> init, ClockType& clock)
     : config_(clock)
     , cont_(buck_, std::cref(config_.valueHash()), std::cref(config_.keyValueEqual()))
 {
@@ -1848,7 +1848,7 @@ template <
 AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::
     AgedUnorderedContainer(
         std::initializer_list<value_type> init,
-        clock_type& clock,
+        ClockType& clock,
         Hash const& hash)
     : config_(clock, hash)
     , cont_(buck_, std::cref(config_.valueHash()), std::cref(config_.keyValueEqual()))
@@ -1868,7 +1868,7 @@ template <
 AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::
     AgedUnorderedContainer(
         std::initializer_list<value_type> init,
-        clock_type& clock,
+        ClockType& clock,
         KeyEqual const& keyEq)
     : config_(clock, keyEq)
     , cont_(buck_, std::cref(config_.valueHash()), std::cref(config_.keyValueEqual()))
@@ -1888,7 +1888,7 @@ template <
 AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::
     AgedUnorderedContainer(
         std::initializer_list<value_type> init,
-        clock_type& clock,
+        ClockType& clock,
         Allocator const& alloc)
     : config_(clock, alloc)
     , buck_(alloc)
@@ -1909,7 +1909,7 @@ template <
 AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::
     AgedUnorderedContainer(
         std::initializer_list<value_type> init,
-        clock_type& clock,
+        ClockType& clock,
         Hash const& hash,
         KeyEqual const& keyEq)
     : config_(clock, hash, keyEq)
@@ -1930,7 +1930,7 @@ template <
 AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::
     AgedUnorderedContainer(
         std::initializer_list<value_type> init,
-        clock_type& clock,
+        ClockType& clock,
         Hash const& hash,
         Allocator const& alloc)
     : config_(clock, hash, alloc)
@@ -1952,7 +1952,7 @@ template <
 AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::
     AgedUnorderedContainer(
         std::initializer_list<value_type> init,
-        clock_type& clock,
+        ClockType& clock,
         KeyEqual const& keyEq,
         Allocator const& alloc)
     : config_(clock, keyEq, alloc)
@@ -1974,7 +1974,7 @@ template <
 AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>::
     AgedUnorderedContainer(
         std::initializer_list<value_type> init,
-        clock_type& clock,
+        ClockType& clock,
         Hash const& hash,
         KeyEqual const& keyEq,
         Allocator const& alloc)
@@ -2127,7 +2127,7 @@ AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>
     requires(MaybeMap && !MaybeMulti)
 {
     maybeRehash(1);
-    typename cont_type::insert_commit_data d;
+    typename ContType::insert_commit_data d;
     auto const result(cont_.insert_check(
         key, std::cref(config_.hashFunction()), std::cref(config_.keyValueEqual()), d));
     if (result.second)
@@ -2157,7 +2157,7 @@ AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>
     requires(MaybeMap && !MaybeMulti)
 {
     maybeRehash(1);
-    typename cont_type::insert_commit_data d;
+    typename ContType::insert_commit_data d;
     auto const result(cont_.insert_check(
         key, std::cref(config_.hashFunction()), std::cref(config_.keyValueEqual()), d));
     if (result.second)
@@ -2211,7 +2211,7 @@ AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>
     requires(!MaybeMulti)
 {
     maybeRehash(1);
-    typename cont_type::insert_commit_data d;
+    typename ContType::insert_commit_data d;
     auto const result(cont_.insert_check(
         extract(value), std::cref(config_.hashFunction()), std::cref(config_.keyValueEqual()), d));
     if (result.second)
@@ -2264,7 +2264,7 @@ AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>
     requires(!MaybeMulti && !MaybeMap)
 {
     maybeRehash(1);
-    typename cont_type::insert_commit_data d;
+    typename ContType::insert_commit_data d;
     auto const result(cont_.insert_check(
         extract(value), std::cref(config_.hashFunction()), std::cref(config_.keyValueEqual()), d));
     if (result.second)
@@ -2374,7 +2374,7 @@ AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>
     // VFALCO NOTE Its unfortunate that we need to
     //             construct element here
     Element* const p(newElement(std::forward<Args>(args)...));
-    typename cont_type::insert_commit_data d;
+    typename ContType::insert_commit_data d;
     auto const result(cont_.insert_check(
         extract(p->value),
         std::cref(config_.hashFunction()),
@@ -2611,7 +2611,7 @@ AgedUnorderedContainer<IsMulti, IsMap, Key, T, Clock, Hash, KeyEqual, Allocator>
     value_type const& value) -> std::pair<iterator, bool>
     requires(!MaybeMulti)
 {
-    typename cont_type::insert_commit_data d;
+    typename ContType::insert_commit_data d;
     auto const result(cont_.insert_check(
         extract(value), std::cref(config_.hashFunction()), std::cref(config_.keyValueEqual()), d));
     if (result.second)

include/xrpl/beast/insight/Collector.h

@@ -26,7 +26,7 @@ namespace beast::insight {
 class Collector
 {
 public:
-    using ptr = std::shared_ptr<Collector>;
+    using Ptr = std::shared_ptr<Collector>;
 
     virtual ~Collector() = 0;
 

include/xrpl/beast/insight/Group.h

@@ -13,7 +13,7 @@ namespace beast::insight {
 class Group : public Collector
 {
 public:
-    using ptr = std::shared_ptr<Group>;
+    using Ptr = std::shared_ptr<Group>;
 
     /**
      * Returns the name of this group, for diagnostics.

include/xrpl/beast/insight/Groups.h

@@ -20,10 +20,10 @@ public:
      * Find or create a new collector with a given name.
      */
     /** @{ */
-    virtual Group::ptr const&
+    virtual Group::Ptr const&
     get(std::string const& name) = 0;
 
-    Group::ptr const&
+    Group::Ptr const&
     operator[](std::string const& name)
     {
         return get(name);
@@ -35,6 +35,6 @@ public:
  * Create a group container that uses the specified collector.
  */
 std::unique_ptr<Groups>
-makeGroups(Collector::ptr const& collector);
+makeGroups(Collector::Ptr const& collector);
 
 }  // namespace beast::insight

include/xrpl/beast/rfc2616.h

@@ -108,12 +108,12 @@ Result
 split(FwdIt first, FwdIt last, Char delim)
 {
     using namespace detail;
-    using string = Result::value_type;
+    using String = Result::value_type;
 
     Result result;
 
     FwdIt iter = first;
-    string e;
+    String e;
     while (iter != last)
     {
         if (*iter == '"')
@@ -205,10 +205,10 @@ splitCommas(std::string_view s)
  */
 class ListIterator
 {
-    using iter_type = boost::string_ref::const_iterator;
+    using IterType = boost::string_ref::const_iterator;
 
-    iter_type it_;
-    iter_type end_;
+    IterType it_;
+    IterType end_;
     boost::string_ref value_;
 
 public:
@@ -218,7 +218,7 @@ public:
     using difference_type = std::ptrdiff_t;
     using iterator_category = std::forward_iterator_tag;
 
-    ListIterator(iter_type begin, iter_type end) : it_(begin), end_(end)
+    ListIterator(IterType begin, IterType end) : it_(begin), end_(end)
     {
         if (it_ != end_)
             increment();

include/xrpl/beast/test/yield_to.h

@@ -42,7 +42,7 @@ public:
     /**
      * The type of yield context passed to functions.
      */
-    using yield_context = boost::asio::yield_context;
+    using YieldContext = boost::asio::yield_context;
 
     explicit EnableYieldTo(std::size_t concurrency = 1) : work_(boost::asio::make_work_guard(ios_))
     {
@@ -120,7 +120,7 @@ EnableYieldTo::spawn(F0&& f, FN&&... fn)
         ios_,
         boost::allocator_arg,
         boost::context::fixedsize_stack(2 * 1024 * 1024),
-        [&](yield_context yield) {
+        [&](YieldContext yield) {
             f(yield);
             std::scoped_lock const lock{m_};
             if (--running_ == 0)

include/xrpl/beast/unit_test/detail/const_container.h

@@ -15,29 +15,29 @@ template <class Container>
 class ConstContainer
 {
 private:
-    using cont_type = Container;
+    using ContType = Container;
 
-    cont_type cont_;
+    ContType cont_;
 
 protected:
-    cont_type&
+    ContType&
     cont()
     {
         return cont_;
     }
 
-    [[nodiscard]] cont_type const&
+    [[nodiscard]] ContType const&
     cont() const
     {
         return cont_;
     }
 
 public:
-    using value_type = cont_type::value_type;
-    using size_type = cont_type::size_type;
-    using difference_type = cont_type::difference_type;
-    using iterator = cont_type::const_iterator;
-    using const_iterator = cont_type::const_iterator;
+    using value_type = ContType::value_type;
+    using size_type = ContType::size_type;
+    using difference_type = ContType::difference_type;
+    using iterator = ContType::const_iterator;
+    using const_iterator = ContType::const_iterator;
 
     /**
      * Returns `true` if the container is empty.

include/xrpl/beast/unit_test/reporter.h

@@ -32,7 +32,7 @@ template <class = void>
 class Reporter : public Runner
 {
 private:
-    using clock_type = std::chrono::steady_clock;
+    using ClockType = std::chrono::steady_clock;
 
     struct CaseResults
     {
@@ -51,7 +51,7 @@ private:
         std::size_t cases = 0;
         std::size_t total = 0;
         std::size_t failed = 0;
-        clock_type::time_point start = clock_type::now();
+        ClockType::time_point start = ClockType::now();
 
         explicit SuiteResults(std::string name = "") : name(std::move(name))
         {
@@ -63,7 +63,7 @@ private:
 
     struct Results
     {
-        using run_time = std::pair<std::string, clock_type::duration>;
+        using RunTime = std::pair<std::string, ClockType::duration>;
 
         static constexpr auto kMaxTop = 10;
 
@@ -71,8 +71,8 @@ private:
         std::size_t cases = 0;
         std::size_t total = 0;
         std::size_t failed = 0;
-        std::vector<run_time> top;
-        clock_type::time_point start = clock_type::now();
+        std::vector<RunTime> top;
+        ClockType::time_point start = ClockType::now();
 
         void
         add(SuiteResults const& r);
@@ -94,7 +94,7 @@ public:
 
 private:
     static std::string
-    fmtdur(clock_type::duration const& d);
+    fmtdur(ClockType::duration const& d);
 
     void
     onSuiteBegin(SuiteInfo const& info) override;
@@ -137,14 +137,13 @@ Reporter<Unused>::Results::add(SuiteResults const& r)
     total += r.total;
     cases += r.cases;
     failed += r.failed;
-    auto const elapsed = clock_type::now() - r.start;
+    auto const elapsed = ClockType::now() - r.start;
     if (elapsed >= std::chrono::seconds{1})
     {
         auto const iter = std::lower_bound(
-            top.begin(),
-            top.end(),
-            elapsed,
-            [](run_time const& t1, clock_type::duration const& t2) { return t1.second > t2; });
+            top.begin(), top.end(), elapsed, [](RunTime const& t1, ClockType::duration const& t2) {
+                return t1.second > t2;
+            });
         if (iter != top.end())
         {
             if (top.size() == kMaxTop)
@@ -174,7 +173,7 @@ Reporter<Unused>::~Reporter()
         for (auto const& i : results_.top)
             os_ << std::setw(8) << fmtdur(i.second) << " " << i.first << '\n';
     }
-    auto const elapsed = clock_type::now() - results_.start;
+    auto const elapsed = ClockType::now() - results_.start;
     os_ << fmtdur(elapsed) << ", " << Amount{results_.suites, "suite"} << ", "
         << Amount{results_.cases, "case"} << ", " << Amount{results_.total, "test"} << " total, "
         << Amount{results_.failed, "failure"} << std::endl;
@@ -182,7 +181,7 @@ Reporter<Unused>::~Reporter()
 
 template <class Unused>
 std::string
-Reporter<Unused>::fmtdur(clock_type::duration const& d)
+Reporter<Unused>::fmtdur(ClockType::duration const& d)
 {
     using namespace std::chrono;
     auto const ms = duration_cast<milliseconds>(d);
@@ -249,6 +248,10 @@ Reporter<Unused>::onLog(std::string const& s)
 
 }  // namespace detail
 
-using reporter = detail::Reporter<>;
+using Reporter = detail::Reporter<>;
+
+// TODO [#8340]: Legacy name still used by external consumers of libxrpl (e.g. validator-keys-tool).
+// Do not use in new code; remove once those consumers have migrated.
+using reporter = Reporter;  // NOLINT(readability-identifier-naming)
 
 }  // namespace beast::unit_test

include/xrpl/beast/unit_test/suite.h

@@ -643,12 +643,12 @@ Suite::run(Runner& r)
  * Library   Identifies the library.
  *
  * The declaration for the class implementing the test should be the same
- * as Class ## _test. For example, if Class is aged_ordered_container, the
+ * as Class ## _test. For example, if Class is AgedOrderedContainer, the
  * test class must be declared as:
  *
  * @code
  *
- * struct aged_ordered_container_test : beast::unit_test::suite
+ * struct AgedOrderedContainer_test : beast::unit_test::suite
  * {
  *     //...
  * };

include/xrpl/beast/unit_test/suite_info.h

@@ -18,14 +18,14 @@ class Runner;
  */
 class SuiteInfo
 {
-    using run_type = std::function<void(Runner&)>;
+    using RunType = std::function<void(Runner&)>;
 
     std::string name_;
     std::string module_;
     std::string library_;
     bool manual_;
     int priority_;
-    run_type run_;
+    RunType run_;
 
 public:
     SuiteInfo(
@@ -34,7 +34,7 @@ public:
         std::string library,
         bool manual,
         int priority,
-        run_type run)
+        RunType run)
         : name_(std::move(name))
         , module_(std::move(module))
         , library_(std::move(library))

include/xrpl/beast/unit_test/thread.h

@@ -24,7 +24,7 @@ private:
     std::thread t_;
 
 public:
-    using id = std::thread::id;
+    using Id = std::thread::id;
     using native_handle_type = std::thread::native_handle_type;
 
     Thread() = default;

include/xrpl/beast/utility/Journal.h

@@ -471,7 +471,7 @@ public:
     }
 };
 
-using logstream = BasicLogstream<char>;
-using logwstream = BasicLogstream<wchar_t>;
+using LogStream = BasicLogstream<char>;
+using LogWStream = BasicLogstream<wchar_t>;
 
 }  // namespace beast

include/xrpl/beast/utility/maybe_const.h

@@ -19,6 +19,6 @@ struct MaybeConst
  * Alias for omitting `typename`.
  */
 template <bool IsConst, class T>
-using maybe_const_t = MaybeConst<IsConst, T>::type;
+using MaybeConstT = MaybeConst<IsConst, T>::type;
 
 }  // namespace beast

include/xrpl/beast/xor_shift_engine.h

@@ -94,6 +94,6 @@ XorShiftEngine<Unused>::murmurhash3(result_type x) -> result_type
  * http://xorshift.di.unimi.it/xorshift128plus.c
  * does not accept seed==0
  */
-using xor_shift_engine = detail::XorShiftEngine<>;
+using XorShiftEngine = detail::XorShiftEngine<>;
 
 }  // namespace beast

include/xrpl/conditions/detail/PreimageSha256.h

@@ -105,9 +105,9 @@ public:
     [[nodiscard]] Buffer
     fingerprint() const override
     {
-        sha256_hasher h;
+        Sha256Hasher h;
         h(payload_.data(), payload_.size());
-        auto const d = static_cast<sha256_hasher::result_type>(h);
+        auto const d = static_cast<Sha256Hasher::result_type>(h);
         return {d.data(), d.size()};
     }
 

include/xrpl/consensus/Consensus.h

@@ -288,12 +288,12 @@ checkConsensus(
 template <class Adaptor>
 class Consensus
 {
-    using Ledger_t = Adaptor::Ledger_t;
-    using TxSet_t = Adaptor::TxSet_t;
-    using NodeID_t = Adaptor::NodeID_t;
-    using Tx_t = TxSet_t::Tx;
-    using PeerPosition_t = Adaptor::PeerPosition_t;
-    using Proposal_t = ConsensusProposal<NodeID_t, typename Ledger_t::ID, typename TxSet_t::ID>;
+    using LedgerT = Adaptor::LedgerT;
+    using TxSetT = Adaptor::TxSetT;
+    using NodeIDT = Adaptor::NodeIDT;
+    using TxT = TxSetT::Tx;
+    using PeerPositionT = Adaptor::PeerPositionT;
+    using ProposalT = ConsensusProposal<NodeIDT, typename LedgerT::ID, typename TxSetT::ID>;
 
     using Result = ConsensusResult<Adaptor>;
 
@@ -325,7 +325,7 @@ public:
     /**
      * Clock type for measuring time within the consensus code
      */
-    using clock_type = beast::AbstractClock<std::chrono::steady_clock>;
+    using ClockType = beast::AbstractClock<std::chrono::steady_clock>;
 
     Consensus(Consensus&&) noexcept = default;
 
@@ -336,7 +336,7 @@ public:
      * @param adaptor The instance of the adaptor class
      * @param j The journal to log debug output
      */
-    Consensus(clock_type const& clock, Adaptor& adaptor, beast::Journal j);
+    Consensus(ClockType const& clock, Adaptor& adaptor, beast::Journal j);
 
     /**
      * Kick-off the next round of consensus.
@@ -357,9 +357,9 @@ public:
     void
     startRound(
         NetClock::time_point const& now,
-        Ledger_t::ID const& prevLedgerID,
-        Ledger_t prevLedger,
-        hash_set<NodeID_t> const& nowUntrusted,
+        LedgerT::ID const& prevLedgerID,
+        LedgerT prevLedger,
+        HashSet<NodeIDT> const& nowUntrusted,
         bool proposing,
         std::unique_ptr<std::stringstream> const& clog = {});
 
@@ -371,7 +371,7 @@ public:
      * @return Whether we should do delayed relay of this proposal.
      */
     bool
-    peerProposal(NetClock::time_point const& now, PeerPosition_t const& newProposal);
+    peerProposal(NetClock::time_point const& now, PeerPositionT const& newProposal);
 
     /**
      * Call periodically to drive consensus forward.
@@ -391,7 +391,7 @@ public:
      * @param txSet the transaction set
      */
     void
-    gotTxSet(NetClock::time_point const& now, TxSet_t const& txSet);
+    gotTxSet(NetClock::time_point const& now, TxSetT const& txSet);
 
     /**
      * Simulate the consensus process without any network traffic.
@@ -423,7 +423,7 @@ public:
      *
      * @return ID of previous ledger
      */
-    Ledger_t::ID
+    LedgerT::ID
     prevLedgerID() const
     {
         return prevLedgerID_;
@@ -450,14 +450,14 @@ private:
     void
     startRoundInternal(
         NetClock::time_point const& now,
-        Ledger_t::ID const& prevLedgerID,
-        Ledger_t const& prevLedger,
+        LedgerT::ID const& prevLedgerID,
+        LedgerT const& prevLedger,
         ConsensusMode mode,
         std::unique_ptr<std::stringstream> const& clog);
 
     // Change our view of the previous ledger
     void
-    handleWrongLedger(Ledger_t::ID const& lgrId, std::unique_ptr<std::stringstream> const& clog);
+    handleWrongLedger(LedgerT::ID const& lgrId, std::unique_ptr<std::stringstream> const& clog);
 
     /**
      * Check if our previous ledger matches the network's.
@@ -479,7 +479,7 @@ private:
      * Handle a replayed or a new peer proposal.
      */
     bool
-    peerProposalInternal(NetClock::time_point const& now, PeerPosition_t const& newProposal);
+    peerProposalInternal(NetClock::time_point const& now, PeerPositionT const& newProposal);
 
     /**
      * Handle pre-close phase.
@@ -542,12 +542,12 @@ private:
 
     // Create disputes between our position and the provided one.
     void
-    createDisputes(TxSet_t const& o, std::unique_ptr<std::stringstream> const& clog = {});
+    createDisputes(TxSetT const& o, std::unique_ptr<std::stringstream> const& clog = {});
 
     // Update our disputes given that this node has adopted a new position.
     // Will call createDisputes as needed.
     void
-    updateDisputes(NodeID_t const& node, TxSet_t const& other);
+    updateDisputes(NodeIDT const& node, TxSetT const& other);
 
     // Revoke our outstanding proposal, if any, and cease proposing
     // until this round ends.
@@ -566,7 +566,7 @@ private:
     bool firstRound_ = true;
     bool haveCloseTimeConsensus_ = false;
 
-    clock_type const& clock_;
+    ClockType const& clock_;
 
     // How long the consensus convergence has taken, expressed as
     // a percentage of the time that we expected it to take.
@@ -594,12 +594,12 @@ private:
     // Non-peer (self) consensus data
 
     // Last validated ledger ID provided to consensus
-    Ledger_t::ID prevLedgerID_;
+    LedgerT::ID prevLedgerID_;
     // Last validated ledger seen by consensus
-    Ledger_t previousLedger_;
+    LedgerT previousLedger_;
 
     // Transaction Sets, indexed by hash of transaction tree
-    hash_map<typename TxSet_t::ID, TxSet_t const> acquired_;
+    HashMap<typename TxSetT::ID, TxSetT const> acquired_;
 
     std::optional<Result> result_;
     ConsensusCloseTimes rawCloseTimes_;
@@ -615,24 +615,24 @@ private:
     // Peer related consensus data
 
     // Peer proposed positions for the current round
-    hash_map<NodeID_t, PeerPosition_t> currPeerPositions_;
+    HashMap<NodeIDT, PeerPositionT> currPeerPositions_;
 
     // Recently received peer positions, available when transitioning between
     // ledgers or rounds
-    hash_map<NodeID_t, std::deque<PeerPosition_t>> recentPeerPositions_;
+    HashMap<NodeIDT, std::deque<PeerPositionT>> recentPeerPositions_;
 
     // The number of proposers who participated in the last consensus round
     std::size_t prevProposers_ = 0;
 
     // nodes that have bowed out of this consensus process
-    hash_set<NodeID_t> deadNodes_;
+    HashSet<NodeIDT> deadNodes_;
 
     // Journal for debugging
     beast::Journal const j_;
 };
 
 template <class Adaptor>
-Consensus<Adaptor>::Consensus(clock_type const& clock, Adaptor& adaptor, beast::Journal journal)
+Consensus<Adaptor>::Consensus(ClockType const& clock, Adaptor& adaptor, beast::Journal journal)
     : adaptor_(adaptor), clock_(clock), j_{journal}
 {
     JLOG(j_.debug()) << "Creating consensus object";
@@ -642,9 +642,9 @@ template <class Adaptor>
 void
 Consensus<Adaptor>::startRound(
     NetClock::time_point const& now,
-    Ledger_t::ID const& prevLedgerID,
-    Ledger_t prevLedger,
-    hash_set<NodeID_t> const& nowUntrusted,
+    LedgerT::ID const& prevLedgerID,
+    LedgerT prevLedger,
+    HashSet<NodeIDT> const& nowUntrusted,
     bool proposing,
     std::unique_ptr<std::stringstream> const& clog)
 {
@@ -660,7 +660,7 @@ Consensus<Adaptor>::startRound(
         prevCloseTime_ = rawCloseTimes_.self;
     }
 
-    for (NodeID_t const& n : nowUntrusted)
+    for (NodeIDT const& n : nowUntrusted)
         recentPeerPositions_.erase(n);
 
     ConsensusMode startMode = proposing ? ConsensusMode::Proposing : ConsensusMode::Observing;
@@ -687,8 +687,8 @@ template <class Adaptor>
 void
 Consensus<Adaptor>::startRoundInternal(
     NetClock::time_point const& now,
-    Ledger_t::ID const& prevLedgerID,
-    Ledger_t const& prevLedger,
+    LedgerT::ID const& prevLedgerID,
+    LedgerT const& prevLedger,
     ConsensusMode mode,
     std::unique_ptr<std::stringstream> const& clog)
 {
@@ -715,7 +715,7 @@ Consensus<Adaptor>::startRoundInternal(
     closeResolution_ = getNextLedgerTimeResolution(
         previousLedger_.closeTimeResolution(),
         previousLedger_.closeAgree(),
-        previousLedger_.seq() + typename Ledger_t::Seq{1});
+        previousLedger_.seq() + typename LedgerT::Seq{1});
 
     playbackProposals();
     CLOG(clog) << "number of peer proposals,previous proposers: " << currPeerPositions_.size()
@@ -731,7 +731,7 @@ Consensus<Adaptor>::startRoundInternal(
 
 template <class Adaptor>
 bool
-Consensus<Adaptor>::peerProposal(NetClock::time_point const& now, PeerPosition_t const& newPeerPos)
+Consensus<Adaptor>::peerProposal(NetClock::time_point const& now, PeerPositionT const& newPeerPos)
 {
     JLOG(j_.debug()) << "PROPOSAL " << newPeerPos.render();
     auto const& peerID = newPeerPos.proposal().nodeID();
@@ -752,7 +752,7 @@ template <class Adaptor>
 bool
 Consensus<Adaptor>::peerProposalInternal(
     NetClock::time_point const& now,
-    PeerPosition_t const& newPeerPos)
+    PeerPositionT const& newPeerPos)
 {
     // Nothing to do for now if we are currently working on a ledger
     if (phase_ == ConsensusPhase::Accepted)
@@ -889,7 +889,7 @@ Consensus<Adaptor>::timerEntry(
 
 template <class Adaptor>
 void
-Consensus<Adaptor>::gotTxSet(NetClock::time_point const& now, TxSet_t const& txSet)
+Consensus<Adaptor>::gotTxSet(NetClock::time_point const& now, TxSetT const& txSet)
 {
     // Nothing to do if we've finished work on a ledger
     if (phase_ == ConsensusPhase::Accepted)
@@ -1053,7 +1053,7 @@ Consensus<Adaptor>::getJson(bool full) const
 template <class Adaptor>
 void
 Consensus<Adaptor>::handleWrongLedger(
-    Ledger_t::ID const& lgrId,
+    LedgerT::ID const& lgrId,
     std::unique_ptr<std::stringstream> const& clog)
 {
     CLOG(clog) << "handleWrongLedger. ";
@@ -1491,11 +1491,11 @@ Consensus<Adaptor>::updateOurPositions(std::unique_ptr<std::stringstream> const&
         auto it = currPeerPositions_.begin();
         while (it != currPeerPositions_.end())
         {
-            Proposal_t const& peerProp = it->second.proposal();
+            ProposalT const& peerProp = it->second.proposal();
             if (peerProp.isStale(peerCutoff))
             {
                 // peer's proposal is stale, so remove it
-                NodeID_t const& peerID = peerProp.nodeID();
+                NodeIDT const& peerID = peerProp.nodeID();
                 JLOG(j_.warn()) << "Removing stale proposal from " << peerID;
                 for (auto& dt : result_->disputes)
                     dt.second.unVote(peerID);
@@ -1511,11 +1511,11 @@ Consensus<Adaptor>::updateOurPositions(std::unique_ptr<std::stringstream> const&
     }
 
     // This will stay unseated unless there are any changes
-    std::optional<TxSet_t> ourNewSet;
+    std::optional<TxSetT> ourNewSet;
 
     // Update votes on disputed transactions
     {
-        std::optional<typename TxSet_t::MutableTxSet> mutableSet;
+        std::optional<typename TxSetT::MutableTxSet> mutableSet;
         for (auto& [txId, dispute] : result_->disputes)
         {
             // Because the threshold for inclusion increases,
@@ -1645,7 +1645,7 @@ Consensus<Adaptor>::updateOurPositions(std::unique_ptr<std::stringstream> const&
 
             for (auto const& [nodeId, peerPos] : currPeerPositions_)
             {
-                Proposal_t const& p = peerPos.proposal();
+                ProposalT const& p = peerPos.proposal();
                 if (p.position() == newID)
                     updateDisputes(nodeId, result_->txns);
             }
@@ -1674,7 +1674,7 @@ Consensus<Adaptor>::haveConsensus(std::unique_ptr<std::stringstream> const& clog
     // Count number of agreements/disagreements with our position
     for (auto const& [nodeId, peerPos] : currPeerPositions_)
     {
-        Proposal_t const& peerProp = peerPos.proposal();
+        ProposalT const& peerProp = peerPos.proposal();
         if (peerProp.position() == ourPosition)
         {
             ++agree;
@@ -1789,7 +1789,7 @@ Consensus<Adaptor>::leaveConsensus(std::unique_ptr<std::stringstream> const& clo
 
 template <class Adaptor>
 void
-Consensus<Adaptor>::createDisputes(TxSet_t const& o, std::unique_ptr<std::stringstream> const& clog)
+Consensus<Adaptor>::createDisputes(TxSetT const& o, std::unique_ptr<std::stringstream> const& clog)
 {
     // Cannot create disputes without our stance
     XRPL_ASSERT(result_, "xrpl::Consensus::createDisputes : result is set");
@@ -1825,7 +1825,7 @@ Consensus<Adaptor>::createDisputes(TxSet_t const& o, std::unique_ptr<std::string
                 (!inThisSet && !result_->txns.find(txId) && o.find(txId)),
             "xrpl::Consensus::createDisputes : has disputed transactions");
 
-        Tx_t const tx = inThisSet ? result_->txns.find(txId) : o.find(txId);
+        TxT const tx = inThisSet ? result_->txns.find(txId) : o.find(txId);
         auto txID = tx.id();
 
         if (result_->disputes.find(txID) != result_->disputes.end())
@@ -1833,7 +1833,7 @@ Consensus<Adaptor>::createDisputes(TxSet_t const& o, std::unique_ptr<std::string
 
         JLOG(j_.debug()) << "Transaction " << txID << " is disputed";
 
-        typename Result::Dispute_t dtx{
+        typename Result::DisputeT dtx{
             tx,
             result_->txns.exists(txID),
             std::max(prevProposers_, currPeerPositions_.size()),
@@ -1842,7 +1842,7 @@ Consensus<Adaptor>::createDisputes(TxSet_t const& o, std::unique_ptr<std::string
         // Update all of the available peer's votes on the disputed transaction
         for (auto const& [nodeId, peerPos] : currPeerPositions_)
         {
-            Proposal_t const& peerProp = peerPos.proposal();
+            ProposalT const& peerProp = peerPos.proposal();
             auto const cit = acquired_.find(peerProp.position());
             if (cit != acquired_.end() && dtx.setVote(nodeId, cit->second.exists(txID)))
                 peerUnchangedCounter_ = 0;
@@ -1858,7 +1858,7 @@ Consensus<Adaptor>::createDisputes(TxSet_t const& o, std::unique_ptr<std::string
 
 template <class Adaptor>
 void
-Consensus<Adaptor>::updateDisputes(NodeID_t const& node, TxSet_t const& other)
+Consensus<Adaptor>::updateDisputes(NodeIDT const& node, TxSetT const& other)
 {
     // Cannot updateDisputes without our stance
     XRPL_ASSERT(result_, "xrpl::Consensus::updateDisputes : result is set");

include/xrpl/consensus/ConsensusProposal.h

@@ -235,7 +235,7 @@ public:
     /**
      * The digest for this proposal, used for signing purposes.
      */
-    uint256 const&
+    UInt256 const&
     signingHash() const
     {
         if (!signingHash_)
@@ -283,7 +283,7 @@ private:
     /**
      * The signing hash for this proposal
      */
-    mutable std::optional<uint256> signingHash_;
+    mutable std::optional<UInt256> signingHash_;
 };
 
 template <class NodeId, class LedgerId, class Position>

include/xrpl/consensus/ConsensusTypes.h

@@ -282,15 +282,15 @@ enum class ConsensusState {
 template <class Traits>
 struct ConsensusResult
 {
-    using Ledger_t = Traits::Ledger_t;
-    using TxSet_t = Traits::TxSet_t;
-    using NodeID_t = Traits::NodeID_t;
+    using LedgerT = Traits::LedgerT;
+    using TxSetT = Traits::TxSetT;
+    using NodeIDT = Traits::NodeIDT;
 
-    using Tx_t = TxSet_t::Tx;
-    using Proposal_t = ConsensusProposal<NodeID_t, typename Ledger_t::ID, typename TxSet_t::ID>;
-    using Dispute_t = DisputedTx<Tx_t, NodeID_t>;
+    using TxT = TxSetT::Tx;
+    using ProposalT = ConsensusProposal<NodeIDT, typename LedgerT::ID, typename TxSetT::ID>;
+    using DisputeT = DisputedTx<TxT, NodeIDT>;
 
-    ConsensusResult(TxSet_t&& s, Proposal_t&& p) : txns{std::move(s)}, position{std::move(p)}
+    ConsensusResult(TxSetT&& s, ProposalT&& p) : txns{std::move(s)}, position{std::move(p)}
     {
         XRPL_ASSERT(txns.id() == position.position(), "xrpl::ConsensusResult : valid inputs");
     }
@@ -298,20 +298,20 @@ struct ConsensusResult
     /**
      * The set of transactions consensus agrees go in the ledger
      */
-    TxSet_t txns;
+    TxSetT txns;
 
     /**
      * Our proposed position on transactions/close time
      */
-    Proposal_t position;
+    ProposalT position;
 
     /**
      * Transactions which are under dispute with our peers
      */
-    hash_map<typename Tx_t::ID, Dispute_t> disputes;
+    HashMap<typename TxT::ID, DisputeT> disputes;
 
     // Set of TxSet ids we have already compared/created disputes
-    hash_set<typename TxSet_t::ID> compares;
+    HashSet<typename TxSetT::ID> compares;
 
     // Measures the duration of the establish phase for this consensus round
     ConsensusTimer roundTime;

include/xrpl/consensus/DisputedTx.h

@@ -34,8 +34,8 @@ namespace xrpl {
 template <class Tx, class NodeId>
 class DisputedTx
 {
-    using TxID_t = Tx::ID;
-    using Map_t = boost::container::flat_map<NodeId, bool>;
+    using TxIDT = Tx::ID;
+    using MapT = boost::container::flat_map<NodeId, bool>;
 
 public:
     /**
@@ -55,7 +55,7 @@ public:
     /**
      * The unique id/hash of the disputed transaction.
      */
-    [[nodiscard]] TxID_t const&
+    [[nodiscard]] TxIDT const&
     id() const
     {
         return tx_.id();
@@ -202,7 +202,7 @@ private:
     int nays_{0};   //< Number of no votes
     bool ourVote_;  //< Our vote (true is yes)
     Tx tx_;         //< Transaction under dispute
-    Map_t votes_;   //< Map from NodeID to vote
+    MapT votes_;    //< Map from NodeID to vote
     /**
      * The number of rounds we've gone without changing our vote
      */

include/xrpl/consensus/Validations.h

@@ -312,28 +312,25 @@ class Validations
     mutable Mutex mutex_;
 
     // Validations from currently listed and trusted nodes (partial and full)
-    hash_map<NodeID, Validation> current_;
+    HashMap<NodeID, Validation> current_;
 
     // Used to enforce the largest validation invariant for the local node
     SeqEnforcer<Seq> localSeqEnforcer_;
 
     // Sequence of the largest validation received from each node
-    hash_map<NodeID, SeqEnforcer<Seq>> seqEnforcers_;
+    HashMap<NodeID, SeqEnforcer<Seq>> seqEnforcers_;
 
     /**
      * Validations from listed nodes, indexed by ledger id (partial and full)
      */
-    beast::aged_unordered_map<
-        ID,
-        hash_map<NodeID, Validation>,
-        std::chrono::steady_clock,
-        beast::Uhash<>>
-        byLedger_;
+    beast::
+        AgedUnorderedMap<ID, HashMap<NodeID, Validation>, std::chrono::steady_clock, beast::Uhash<>>
+            byLedger_;
 
     // Partial and full validations indexed by sequence
-    beast::aged_unordered_map<
+    beast::AgedUnorderedMap<
         Seq,
-        hash_map<NodeID, Validation>,
+        HashMap<NodeID, Validation>,
         std::chrono::steady_clock,
         beast::Uhash<>>
         bySequence_;
@@ -351,10 +348,10 @@ class Validations
 
     // Last (validated) ledger successfully acquired. If in this map, it is
     // accounted for in the trie.
-    hash_map<NodeID, Ledger> lastLedger_;
+    HashMap<NodeID, Ledger> lastLedger_;
 
     // Set of ledgers being acquired from the network
-    hash_map<std::pair<Seq, ID>, hash_set<NodeID>> acquiring_;
+    HashMap<std::pair<Seq, ID>, HashSet<NodeID>> acquiring_;
 
     // Parameters to determine validation staleness
     ValidationParms const parms_;
@@ -794,7 +791,7 @@ public:
      * @param removed Identifiers of nodes that are no longer trusted
      */
     void
-    trustChanged(hash_set<NodeID> const& added, hash_set<NodeID> const& removed)
+    trustChanged(HashSet<NodeID> const& added, HashSet<NodeID> const& removed)
     {
         std::scoped_lock const lock{mutex_};
 
@@ -862,9 +859,9 @@ public:
             // fall back to majority over acquiring ledgers
             auto it = std::ranges::max_element(acquiring_, [](auto const& a, auto const& b) {
                 std::pair<Seq, ID> const& aKey = a.first;
-                typename hash_set<NodeID>::size_type const& aSize = a.second.size();
+                typename HashSet<NodeID>::size_type const& aSize = a.second.size();
                 std::pair<Seq, ID> const& bKey = b.first;
-                typename hash_set<NodeID>::size_type const& bSize = b.second.size();
+                typename HashSet<NodeID>::size_type const& bSize = b.second.size();
                 // order by number of trusted peers validating that ledger
                 // break ties with ledger ID
                 return std::tie(aSize, aKey.second) < std::tie(bSize, bKey.second);
@@ -930,7 +927,7 @@ public:
      *       does not know their sequence number
      */
     ID
-    getPreferredLCL(Ledger const& lcl, Seq minSeq, hash_map<ID, std::uint32_t> const& peerCounts)
+    getPreferredLCL(Ledger const& lcl, Seq minSeq, HashMap<ID, std::uint32_t> const& peerCounts)
     {
         std::optional<std::pair<Seq, ID>> preferred = getPreferred(lcl);
 
@@ -1009,9 +1006,9 @@ public:
      * @return The set of node ids for active, listed validators
      */
     auto
-    getCurrentNodeIDs() -> hash_set<NodeID>
+    getCurrentNodeIDs() -> HashSet<NodeID>
     {
-        hash_set<NodeID> ret;
+        HashSet<NodeID> ret;
         std::scoped_lock const lock{mutex_};
         current(
             lock,
@@ -1127,7 +1124,7 @@ public:
      * @return Quantity of laggards.
      */
     std::size_t
-    laggards(Seq const seq, hash_set<NodeKey>& trustedKeys)
+    laggards(Seq const seq, HashSet<NodeKey>& trustedKeys)
     {
         std::size_t laggards = 0;
 

include/xrpl/core/HashRouter.h

@@ -88,7 +88,7 @@ class Config;
 class HashRouter
 {
 public:
-    // The type here *MUST* match the type of Peer::id_t
+    // The type here *MUST* match the type of Peer::ID
     using PeerShortID = std::uint32_t;
 
     /**
@@ -107,17 +107,17 @@ public:
          */
         explicit Setup() = default;
 
-        using seconds = std::chrono::seconds;
+        using Seconds = std::chrono::seconds;
 
         /**
          * Expiration time for a hash entry
          */
-        seconds holdTime{300};
+        Seconds holdTime{300};
 
         /**
          * Amount of time required before a relayed item will be relayed again.
          */
-        seconds relayTime{30};
+        Seconds relayTime{30};
     };
 
 private:
@@ -213,10 +213,10 @@ public:
     // VFALCO TODO Replace "Suppression" terminology with something more
     // semantically meaningful.
     void
-    addSuppression(uint256 const& key);
+    addSuppression(UInt256 const& key);
 
     bool
-    addSuppressionPeer(uint256 const& key, PeerShortID peer);
+    addSuppressionPeer(UInt256 const& key, PeerShortID peer);
 
     /**
      * Add a suppression peer and get message's relay status.
@@ -226,15 +226,15 @@ public:
      * is unseated if has not relayed yet.
      */
     std::pair<bool, std::optional<Stopwatch::time_point>>
-    addSuppressionPeerWithStatus(uint256 const& key, PeerShortID peer);
+    addSuppressionPeerWithStatus(UInt256 const& key, PeerShortID peer);
 
     bool
-    addSuppressionPeer(uint256 const& key, PeerShortID peer, HashRouterFlags& flags);
+    addSuppressionPeer(UInt256 const& key, PeerShortID peer, HashRouterFlags& flags);
 
     // Add a peer suppression and return whether the entry should be processed
     bool
     shouldProcess(
-        uint256 const& key,
+        UInt256 const& key,
         PeerShortID peer,
         HashRouterFlags& flags,
         std::chrono::seconds txInterval);
@@ -245,10 +245,10 @@ public:
      * @return `true` if the flags were changed. `false` if unchanged.
      */
     bool
-    setFlags(uint256 const& key, HashRouterFlags flags);
+    setFlags(UInt256 const& key, HashRouterFlags flags);
 
     HashRouterFlags
-    getFlags(uint256 const& key);
+    getFlags(UInt256 const& key);
 
     /**
      * Determines whether the hashed item should be relayed.
@@ -264,12 +264,12 @@ public:
      *     _not_ be relayed.
      */
     std::optional<std::set<PeerShortID>>
-    shouldRelay(uint256 const& key);
+    shouldRelay(UInt256 const& key);
 
 private:
     // pair.second indicates whether the entry was created
     std::pair<Entry&, bool>
-    emplace(uint256 const&);
+    emplace(UInt256 const&);
 
     std::mutex mutable mutex_;
 
@@ -277,7 +277,7 @@ private:
     Setup const setup_;
 
     // Stores all suppressed hashes and their expiration time
-    beast::aged_unordered_map<uint256, Entry, Stopwatch::clock_type, HardenedHash<strong_hash>>
+    beast::AgedUnorderedMap<UInt256, Entry, Stopwatch::ClockType, HardenedHash<StrongHash>>
         suppressionMap_;
 };
 

include/xrpl/core/Job.h

@@ -81,7 +81,7 @@ enum JobType {
 class Job : public CountedObject<Job>
 {
 public:
-    using clock_type = std::chrono::steady_clock;
+    using ClockType = std::chrono::steady_clock;
 
     /**
      * Default constructor.
@@ -112,7 +112,7 @@ public:
     /**
      * Returns the time when the job was queued.
      */
-    [[nodiscard]] clock_type::time_point const&
+    [[nodiscard]] ClockType::time_point const&
     queueTime() const;
 
     void
@@ -135,7 +135,7 @@ private:
     std::function<void()> job_;
     std::shared_ptr<LoadEvent> loadEvent_;
     std::string name_;
-    clock_type::time_point queueTime_;
+    ClockType::time_point queueTime_;
 };
 
 using JobCounter = ClosureCounter<void>;

include/xrpl/core/JobQueue.h

@@ -156,7 +156,7 @@ public:
 
     JobQueue(
         int threadCount,
-        beast::insight::Collector::ptr const& collector,
+        beast::insight::Collector::Ptr const& collector,
         beast::Journal journal,
         Logs& logs,
         perf::PerfLog& perfLog);
@@ -280,7 +280,7 @@ private:
 
     // Statistics tracking
     perf::PerfLog& perfLog_;
-    beast::insight::Collector::ptr collector_;
+    beast::insight::Collector::Ptr collector_;
     beast::insight::Gauge jobCount_;
     beast::insight::Hook hook_;
 

include/xrpl/core/JobTypeData.h

@@ -17,7 +17,7 @@ private:
     LoadMonitor load_;
 
     /* Support for insight */
-    beast::insight::Collector::ptr collector_;
+    beast::insight::Collector::Ptr collector_;
 
 public:
     /* The job category which we represent */
@@ -38,7 +38,7 @@ public:
 
     JobTypeData(
         JobTypeInfo const& info,
-        beast::insight::Collector::ptr collector,
+        beast::insight::Collector::Ptr collector,
         Logs& logs) noexcept
         : load_(logs.journal("LoadMonitor")), collector_(std::move(collector)), info(info)
 

include/xrpl/core/PeerReservationTable.h

@@ -95,6 +95,10 @@ public:
 private:
     beast::Journal mutable journal_;
     std::mutex mutable mutex_;
+    // Initialized to nullptr for safety. Set by load() during the second
+    // phase of ApplicationImp initialization. Methods that dereference
+    // this pointer must validate it first, since two-phase init means
+    // load() may not have been called yet.
     DatabaseCon* connection_{};
     std::unordered_set<PeerReservation, beast::Uhash<>, KeyEqual> table_;
 };

include/xrpl/core/PerfLog.h

@@ -32,13 +32,13 @@ namespace perf {
 class PerfLog
 {
 public:
-    using steady_clock = std::chrono::steady_clock;
-    using system_clock = std::chrono::system_clock;
-    using steady_time_point = std::chrono::time_point<steady_clock>;
-    using system_time_point = std::chrono::time_point<system_clock>;
-    using seconds = std::chrono::seconds;
-    using milliseconds = std::chrono::milliseconds;
-    using microseconds = std::chrono::microseconds;
+    using SteadyClock = std::chrono::steady_clock;
+    using SystemClock = std::chrono::system_clock;
+    using SteadyTimePoint = std::chrono::time_point<SteadyClock>;
+    using SystemTimePoint = std::chrono::time_point<SystemClock>;
+    using Seconds = std::chrono::seconds;
+    using Milliseconds = std::chrono::milliseconds;
+    using Microseconds = std::chrono::microseconds;
 
     /**
      * Configuration from [perf] section of xrpld.cfg.
@@ -47,7 +47,7 @@ public:
     {
         std::filesystem::path perfLog;
         // log_interval is in milliseconds to support faster testing.
-        milliseconds logInterval{seconds(1)};
+        Milliseconds logInterval{Seconds(1)};
     };
 
     virtual ~PerfLog() = default;
@@ -106,7 +106,7 @@ public:
      * @param instance JobQueue worker thread instance
      */
     virtual void
-    jobStart(JobType const type, microseconds dur, steady_time_point startTime, int instance) = 0;
+    jobStart(JobType const type, Microseconds dur, SteadyTimePoint startTime, int instance) = 0;
 
     /**
      * Log job finishing
@@ -116,7 +116,7 @@ public:
      * @param instance Jobqueue worker thread instance
      */
     virtual void
-    jobFinish(JobType const type, microseconds dur, int instance) = 0;
+    jobFinish(JobType const type, Microseconds dur, int instance) = 0;
 
     /**
      * Render performance counters in Json

include/xrpl/core/ServiceRegistry.h

@@ -40,7 +40,7 @@ template <
 class TaggedCache;
 class STLedgerEntry;
 using SLE = STLedgerEntry;
-using CachedSLEs = TaggedCache<uint256, SLE const>;
+using CachedSLEs = TaggedCache<UInt256, SLE const>;
 
 // Forward declarations
 class AcceptedLedger;
@@ -180,7 +180,7 @@ public:
     virtual InboundTransactions&
     getInboundTransactions() = 0;
 
-    virtual TaggedCache<uint256, AcceptedLedger>&
+    virtual TaggedCache<UInt256, AcceptedLedger>&
     getAcceptedLedgerCache() = 0;
 
     virtual LedgerMaster&
@@ -237,7 +237,7 @@ public:
     virtual Logs&
     getLogs() = 0;
 
-    [[nodiscard]] virtual std::optional<uint256> const&
+    [[nodiscard]] virtual std::optional<UInt256> const&
     getTrapTxID() const = 0;
 
     /**

include/xrpl/core/detail/Workers.h

@@ -207,7 +207,7 @@ private:
     std::condition_variable cv_;  // signaled when all threads paused
     std::mutex mut_;
     bool allPaused_{true};
-    semaphore semaphore_;                             // each pending task is 1 resource
+    Semaphore semaphore_;                             // each pending task is 1 resource
     int numberOfThreads_{0};                          // how many we want active now
     std::atomic<int> activeCount_;                    // to know when all are paused
     std::atomic<int> pauseCount_;                     // how many threads need to pause now

include/xrpl/core/detail/semaphore.h

@@ -91,6 +91,6 @@ public:
     }
 };
 
-using semaphore = BasicSemaphore<std::mutex, std::condition_variable>;
+using Semaphore = BasicSemaphore<std::mutex, std::condition_variable>;
 
 }  // namespace xrpl

include/xrpl/json/json_value.h

@@ -526,7 +526,7 @@ class ValueIteratorBase
 {
 public:
     using iterator_category = std::bidirectional_iterator_tag;
-    using size_t = unsigned int;
+    using SizeT = unsigned int;
     using difference_type = int;
     using SelfType = ValueIteratorBase;
 
@@ -593,7 +593,7 @@ class ValueConstIterator : public ValueIteratorBase
     friend class Value;
 
 public:
-    using size_t = unsigned int;
+    using SizeT = unsigned int;
     using difference_type = int;
     using value_type = Value const;
     using reference = Value const&;
@@ -658,7 +658,7 @@ class ValueIterator : public ValueIteratorBase
     friend class Value;
 
 public:
-    using size_t = unsigned int;
+    using SizeT = unsigned int;
     using difference_type = int;
     using value_type = Value;
     using reference = Value&;

include/xrpl/ledger/AmendmentTable.h

@@ -48,33 +48,33 @@ public:
     struct FeatureInfo
     {
         FeatureInfo() = delete;
-        FeatureInfo(std::string n, uint256 const& f, VoteBehavior v)
+        FeatureInfo(std::string n, UInt256 const& f, VoteBehavior v)
             : name(std::move(n)), feature(f), vote(v)
         {
         }
 
         std::string const name;
-        uint256 const feature;
+        UInt256 const feature;
         VoteBehavior const vote;
     };
 
     virtual ~AmendmentTable() = default;
 
-    [[nodiscard]] virtual uint256
+    [[nodiscard]] virtual UInt256
     find(std::string const& name) const = 0;
 
     virtual bool
-    veto(uint256 const& amendment) = 0;
+    veto(UInt256 const& amendment) = 0;
     virtual bool
-    unVeto(uint256 const& amendment) = 0;
+    unVeto(UInt256 const& amendment) = 0;
 
     virtual bool
-    enable(uint256 const& amendment) = 0;
+    enable(UInt256 const& amendment) = 0;
 
     [[nodiscard]] virtual bool
-    isEnabled(uint256 const& amendment) const = 0;
+    isEnabled(UInt256 const& amendment) const = 0;
     [[nodiscard]] virtual bool
-    isSupported(uint256 const& amendment) const = 0;
+    isSupported(UInt256 const& amendment) const = 0;
 
     /**
      * @brief returns true if one or more amendments on the network
@@ -95,7 +95,7 @@ public:
      * Returns a json::ValueType::Object.
      */
     [[nodiscard]] virtual json::Value
-    getJson(uint256 const& amendment, bool isAdmin) const = 0;
+    getJson(UInt256 const& amendment, bool isAdmin) const = 0;
 
     /**
      * Called when a new fully-validated ledger is accepted.
@@ -122,33 +122,33 @@ public:
     virtual void
     doValidatedLedger(
         LedgerIndex ledgerSeq,
-        std::set<uint256> const& enabled,
-        majorityAmendments_t const& majority) = 0;
+        std::set<UInt256> const& enabled,
+        MajorityAmendmentsT const& majority) = 0;
 
     // Called when the set of trusted validators changes.
     virtual void
-    trustChanged(hash_set<PublicKey> const& allTrusted) = 0;
+    trustChanged(HashSet<PublicKey> const& allTrusted) = 0;
 
     // Called by the consensus code when we need to
     // inject pseudo-transactions
-    virtual std::map<uint256, std::uint32_t>
+    virtual std::map<UInt256, std::uint32_t>
     doVoting(
         Rules const& rules,
         NetClock::time_point closeTime,
-        std::set<uint256> const& enabledAmendments,
-        majorityAmendments_t const& majorityAmendments,
+        std::set<UInt256> const& enabledAmendments,
+        MajorityAmendmentsT const& majorityAmendments,
         std::vector<std::shared_ptr<STValidation>> const& valSet) = 0;
 
     // Called by the consensus code when we need to
     // add feature entries to a validation
-    [[nodiscard]] virtual std::vector<uint256>
-    doValidation(std::set<uint256> const& enabled) const = 0;
+    [[nodiscard]] virtual std::vector<UInt256>
+    doValidation(std::set<UInt256> const& enabled) const = 0;
 
     // The set of amendments to enable in the genesis ledger
     // This will return all known, non-vetoed amendments.
     // If we ever have two amendments that should not both be
     // enabled at the same time, we should ensure one is vetoed.
-    [[nodiscard]] virtual std::vector<uint256>
+    [[nodiscard]] virtual std::vector<UInt256>
     getDesired() const = 0;
 
     // The function below adapts the API callers expect to the

include/xrpl/ledger/ApplyView.h

@@ -43,7 +43,14 @@ enum ApplyFlags : std::uint32_t {
 
     // Transaction shouldn't be applied
     // Signatures shouldn't be checked
-    TapDryRun = 0x1000
+    TapDryRun = 0x1000,
+
+    // Transaction is being preflighted as the payload of a
+    // TransactionProposalCreate. Its signatures are collected on-ledger
+    // afterward, so signature-presence checks (e.g. Batch signer matching)
+    // are skipped at proposal-creation time (On-Chain Cosigner spec
+    // §5.3.1.2).
+    TapProposal = 0x2000
 };
 
 constexpr ApplyFlags
@@ -140,8 +147,8 @@ private:
     dirAdd(
         bool preserveOrder,
         Keylet const& directory,
-        uint256 const& key,
-        std::function<void(SLE::ref)> const& describe);
+        UInt256 const& key,
+        std::function<void(SLE::Ref)> const& describe);
 
 public:
     ApplyView() = default;
@@ -189,7 +196,7 @@ public:
      *     The key is no longer associated with the SLE.
      */
     virtual void
-    erase(SLE::ref sle) = 0;
+    erase(SLE::Ref sle) = 0;
 
     /**
      * Insert a new state SLE
@@ -211,7 +218,7 @@ public:
      * @note The key is taken from the SLE
      */
     virtual void
-    insert(SLE::ref sle) = 0;
+    insert(SLE::Ref sle) = 0;
 
     /**
      * Indicate changes to a peeked SLE
@@ -231,7 +238,7 @@ public:
      */
     /** @{ */
     virtual void
-    update(SLE::ref sle) = 0;
+    update(SLE::Ref sle) = 0;
 
     //--------------------------------------------------------------------------
 
@@ -326,7 +333,7 @@ public:
     dirAppend(
         Keylet const& directory,
         Keylet const& key,
-        std::function<void(SLE::ref)> const& describe)
+        std::function<void(SLE::Ref)> const& describe)
     {
         if (key.type != ltOFFER)
         {
@@ -365,8 +372,8 @@ public:
     std::optional<std::uint64_t>
     dirInsert(
         Keylet const& directory,
-        uint256 const& key,
-        std::function<void(SLE::ref)> const& describe)
+        UInt256 const& key,
+        std::function<void(SLE::Ref)> const& describe)
     {
         return dirAdd(false, directory, key, describe);
     }
@@ -375,7 +382,7 @@ public:
     dirInsert(
         Keylet const& directory,
         Keylet const& key,
-        std::function<void(SLE::ref)> const& describe)
+        std::function<void(SLE::Ref)> const& describe)
     {
         return dirAdd(false, directory, key.key, describe);
     }
@@ -399,7 +406,7 @@ public:
      */
     /** @{ */
     bool
-    dirRemove(Keylet const& directory, std::uint64_t page, uint256 const& key, bool keepRoot);
+    dirRemove(Keylet const& directory, std::uint64_t page, UInt256 const& key, bool keepRoot);
 
     bool
     dirRemove(Keylet const& directory, std::uint64_t page, Keylet const& key, bool keepRoot)
@@ -412,7 +419,7 @@ public:
      * Remove the specified directory, invoking the callback for every node.
      */
     bool
-    dirDelete(Keylet const& directory, std::function<void(uint256 const&)> const&);
+    dirDelete(Keylet const& directory, std::function<void(UInt256 const&)> const&);
 
     /**
      * Remove the specified directory, if it is empty.
@@ -459,20 +466,20 @@ std::uint64_t
 createRoot(
     ApplyView& view,
     Keylet const& directory,
-    uint256 const& key,
-    std::function<void(SLE::ref)> const& describe);
+    UInt256 const& key,
+    std::function<void(SLE::Ref)> const& describe);
 
 auto
-findPreviousPage(ApplyView& view, Keylet const& directory, SLE::ref start);
+findPreviousPage(ApplyView& view, Keylet const& directory, SLE::Ref start);
 
 std::uint64_t
 insertKey(
     ApplyView& view,
-    SLE::ref node,
+    SLE::Ref node,
     std::uint64_t page,
     bool preserveOrder,
     STVector256& indexes,
-    uint256 const& key);
+    UInt256 const& key);
 
 std::optional<std::uint64_t>
 insertPage(
@@ -480,10 +487,10 @@ insertPage(
     std::uint64_t page,
     SLE::pointer node,
     std::uint64_t nextPage,
-    SLE::ref next,
-    uint256 const& key,
+    SLE::Ref next,
+    UInt256 const& key,
     Keylet const& directory,
-    std::function<void(SLE::ref)> const& describe);
+    std::function<void(SLE::Ref)> const& describe);
 
 }  // namespace directory
 }  // namespace xrpl

include/xrpl/ledger/ApplyViewImpl.h

@@ -50,7 +50,7 @@ public:
         OpenView& to,
         STTx const& tx,
         TER ter,
-        std::optional<uint256> parentBatchId,
+        std::optional<UInt256> parentBatchId,
         bool isDryRun,
         beast::Journal j);
 
@@ -81,10 +81,10 @@ public:
     visit(
         OpenView& target,
         std::function<void(
-            uint256 const& key,
+            UInt256 const& key,
             bool isDelete,
-            SLE::const_ref before,
-            SLE::const_ref after)> const& func);
+            SLE::ConstRef before,
+            SLE::ConstRef after)> const& func);
 
 private:
     std::optional<STAmount> deliver_;

include/xrpl/ledger/BookDirs.h

@@ -15,12 +15,12 @@ class BookDirs
 {
 private:
     ReadView const* view_ = nullptr;
-    uint256 const root_;
-    uint256 const nextQuality_;
-    uint256 const key_;
+    UInt256 const root_;
+    UInt256 const nextQuality_;
+    UInt256 const key_;
     SLE::const_pointer sle_ = nullptr;
     unsigned int entry_ = 0;
-    uint256 index_;
+    UInt256 index_;
 
 public:
     class const_iterator;  // NOLINT(readability-identifier-naming)
@@ -67,19 +67,19 @@ public:
 private:
     friend class BookDirs;
 
-    const_iterator(ReadView const& view, uint256 const& root, uint256 const& dirKey)
+    const_iterator(ReadView const& view, UInt256 const& root, UInt256 const& dirKey)
         : view_(&view), root_(root), key_(dirKey), curKey_(dirKey)
     {
     }
 
     ReadView const* view_ = nullptr;
-    uint256 root_;
-    uint256 nextQuality_;
-    uint256 key_;
-    uint256 curKey_;
+    UInt256 root_;
+    UInt256 nextQuality_;
+    UInt256 key_;
+    UInt256 curKey_;
     SLE::const_pointer sle_;
     unsigned int entry_ = 0;
-    uint256 index_;
+    UInt256 index_;
     std::optional<value_type> mutable cache_;
 };
 

include/xrpl/ledger/CachedSLEs.h

@@ -5,5 +5,5 @@
 #include <xrpl/protocol/STLedgerEntry.h>
 
 namespace xrpl {
-using CachedSLEs = TaggedCache<uint256, SLE const>;
+using CachedSLEs = TaggedCache<UInt256, SLE const>;
 }  // namespace xrpl