fix: refuse a key file on a filesystem without hard links and check appended blobs fully

fix: make the show_manifest encoding optional
fix: sync the key file's directory best effort and end line comments at CR
2026-10-22 03:27:08 +00:00 · 2026-10-06 21:38:34 -04:00 · 2026-10-06 21:09:28 -04:00 · 2026-10-06 20:52:23 -04:00 · 2026-10-06 20:14:32 -04:00 · 2026-10-06 19:58:39 -04:00
1002 changed files with 13999 additions and 7431 deletions
@@ -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
@@ -121,6 +128,6 @@ CheckOptions:
  readability-identifier-naming.PublicMemberSuffix: ""
  readability-identifier-naming.GlobalFunctionIgnoredRegexp: "^(to_string|hash_append|tuple_hash)$"

-HeaderFilterRegex: '^.*/(tests?|xrpl|xrpld)/.*\.(h|hpp|ipp)$'
-ExcludeHeaderFilterRegex: '^.*/protocol_autogen/.*\.(h|hpp)$'
+HeaderFilterRegex: '^.*/(tests?|tools|xrpl|xrpld)/.*\.(h|hpp|ipp)$'
+ExcludeHeaderFilterRegex: '^.*/protocol_autogen/.*\.(h|hpp)$|^.*\.pb\.h$'
 WarningsAsErrors: "*"
@@ -68,9 +68,10 @@ words:
  - Britto
  - Btrfs
  - Buildx
-  - canonicality
  - canonicalised
+  - canonicality
  - cctools
+  - CGNAT
  - changespq
  - checkme
  - choco
@@ -138,9 +139,11 @@ words:
  - gpgkey
  - Hinnant
  - hotwallet
+  - hvssbqmgz
  - hwaddress
  - hwrap
  - ifndef
+  - Iiwib
  - inequation
  - Injectivity
  - insuf
@@ -154,6 +157,7 @@ words:
  - jemalloc
  - jlog
  - jtnofill
+  - keyfile
  - keylet
  - keylets
  - keyvadb
@@ -179,11 +183,10 @@ words:
  - mathbunnyru
  - mcmodel
  - MEMORYSTATUSEX
-  - MPTAMM
-  - MPTDEX
  - Merkle
  - misprediction
  - missingok
+  - MPTAMM
  - mptbalance
  - MPTDEX
  - mptflags
@@ -258,8 +261,8 @@ words:
  - replayer
  - repodata
  - repomd
-  - rerandomize
  - rerandomization
+  - rerandomize
  - rerandomized
  - rerandomizes
  - rerere
@@ -282,8 +285,8 @@ words:
  - rustup
  - sahyadri
  - Satoshi
-  - scons
  - Schnorr
+  - scons
  - secp
  - sendq
  - seqit
@@ -313,6 +316,7 @@ words:
  - stobject
  - stpath
  - stpathset
+  - STRINGIZE
  - sttx
  - stvar
  - stvector
@@ -348,6 +352,7 @@ words:
  - unfindable
  - unflatten
  - unfund
+  - ungated
  - unimpair
  - unroutable
  - unscalable
@@ -387,5 +392,3 @@ words:
  - xxhash
  - xxhasher
  - zstdio
-  - CGNAT
-  - ungated
@@ -15,26 +15,21 @@ 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}"
@@ -194,9 +194,18 @@ tests.libxrpl > xrpl.resource
 tests.libxrpl > xrpl.server
 tests.libxrpl > xrpl.shamap
 tests.libxrpl > xrpl.tx
+tests.tools > tools.validator-keys
+tests.tools > xrpl.basics
+tests.tools > xrpl.json
+tests.tools > xrpl.protocol
+tests.tools > xrpl.server
 tests.xrpld > xrpld.rpc
 tests.xrpld > xrpl.json
 tests.xrpld > xrpl.protocol
+tools.validator-keys > xrpl.basics
+tools.validator-keys > xrpl.json
+tools.validator-keys > xrpl.protocol
+tools.validator-keys > xrpl.server
 xrpl.conditions > xrpl.basics
 xrpl.conditions > xrpl.protocol
 xrpl.config > xrpl.basics
@@ -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
@@ -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."
@@ -61,9 +61,6 @@ ${SED_COMMAND} -i 's/ripple.pb.h/xrpl.pb.h/' include/xrpl/protocol/messages.h
 ${SED_COMMAND} -i 's/ripple.pb.h/xrpl.pb.h/' BUILD.md
 ${SED_COMMAND} -i 's/ripple.pb.h/xrpl.pb.h/' BUILD.md

-# Restore the name of the validator keys repository.
-${SED_COMMAND} -i 's@xrpl/validator-keys-tool@ripple/validator-keys-tool@' cmake/XrplValidatorKeys.cmake
-
 # Ensure the name of the binary and config remain 'rippled' for now.
 ${SED_COMMAND} -i -E 's/xrpld(-example)?\.cfg/rippled\1.cfg/g' cmake/XrplInstall.cmake
 if grep -q '"xrpld"' cmake/XrplCore.cmake; then
@@ -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
@@ -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."
@@ -13,7 +13,6 @@ on:
      - ready_for_review
    branches:
      - develop
-      - "release-*"
      - "release/*"
      - "staging/*"

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

@@ -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"
@@ -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
@@ -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 }}
@@ -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' }}' \
@@ -278,18 +291,16 @@ jobs:
          if-no-files-found: error

      - name: Run the validator-keys tests
-        if: ${{ env.VALIDATOR_KEYS_ENABLED == 'true' }}
+        if: ${{ env.VALIDATOR_KEYS_ENABLED == 'true' && !inputs.build_only }}
        working-directory: ${{ env.BUILD_DIR }}
-        run: ./validator-keys --unittest
+        run: ./validator_keys_tests

      - name: Upload the validator-keys binary
        if: ${{ env.PACKAGING_ARTIFACTS_ENABLED == 'true' && env.VALIDATOR_KEYS_ENABLED == 'true' }}
        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
        with:
          name: validator-keys-${{ inputs.config_name }}
-          path: |
-            ${{ env.BUILD_DIR }}/validator-keys
-            ${{ env.BUILD_DIR }}/validator-keys-LICENSE
+          path: ${{ env.BUILD_DIR }}/validator-keys
          retention-days: 3
          if-no-files-found: error

@@ -85,6 +85,7 @@ jobs:
              -Dtests=ON \
              -Dwerr=ON \
              -Dxrpld=ON \
+              -Dvalidator_keys=ON \
              -Dverify_headers=ON \
              -Drust=ON \
              ..
@@ -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
@@ -38,5 +38,6 @@ Paths below reflect the current layout; update this section if modularization mo
 - `include/xrpl/` + `src/libxrpl/` — the core protocol library: ledger, shamap, consensus, crypto, json, resource, nodestore, rdb, peerfinder, and `tx/` (transaction application: `Transactor.cpp`, `applySteps.cpp`, invariants, payment paths). `tx/transactors/` has one file per transaction type, grouped by subsystem: `escrow/`, `vault/`, `lending/`, `sponsor/`, `nft/`, `token/` (MPT), `payment_channel/`, `permissioned_domain/`, `dex/`, `oracle/`, `did/`, `credentials/`, `bridge/`, `check/`, `delegate/`, `account/`, `system/`. Any change to transaction-processing behavior must be gated behind an Amendment.
 - `src/xrpld/` — the server application built on top of `libxrpl`: `app`, `core`, `overlay` (P2P networking), `peerfinder`, `perflog`, `rpc`, `shamap`. `main` builds an `ApplicationImp` implementing `Application`; most components hold a reference to it (`app_`), giving broad cross-component access — expect to trace call chains through `Application&`.
 - `src/test/` — unit tests mirroring the subsystems above, plus `jtx/` (the transaction-building test DSL — e.g. `jtx/escrow.h`, `jtx/vault.h`, `jtx/sponsor.h`, `jtx/permissioned_dex.h`) and `unit_test/` (the custom test framework itself, derived from Beast).
- `src/tests/` — unit tests for `libxrpl` written in `gtest`, gradually replacing the `src/test` equivalents.
+- `src/tests/` — unit tests for `libxrpl` written in `gtest`, gradually replacing the `src/test` equivalents; `src/tests/tools/` holds the `gtest` suites of the tools below.
+- `src/tools/` — standalone binaries built on `libxrpl` behind their own CMake option: `validator-keys` (`-Dvalidator_keys=ON`), the validator and publisher key tool, whose library `xrpl.validator-keys` is what its tests link.
 - `crates/` — a Rust workspace (only built with `-Dxrpld -Drust=ON`) bridged into C++ via `cxxbridge`/the `cxx` crate; currently just a `hello_world` interop scaffold. Requires the Rust toolchain pinned in `rust-toolchain.toml` (the Nix devshell provides it automatically).
@@ -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
@@ -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)
@@ -177,6 +176,9 @@ if(tests)
    include(CTest)
    add_subdirectory(src/tests/libxrpl)
    add_subdirectory(src/tests/xrpld)
+    if(validator_keys)
+        add_subdirectory(src/tests/tools/validator-keys)
+    endif()
 endif()

 if(benchmark)
@@ -92,7 +92,8 @@ If you create new source files, they must be organized as follows:
 - If the files are in any of the `libxrpl` modules, the headers (`.h`) must go
  under `include/xrpl`, and source (`.cpp`) files must go under
  `src/libxrpl`.
- All other non-test files must go under `src/xrpld`.
+- All other non-test files must go under `src/xrpld`, except a standalone tool
+  built as its own binary on top of `libxrpl`, which goes under `src/tools`.
 - New test source files should use `gtest` and go under `src/tests`, unless that isn't possible, in which case they should use our legacy test framework and go under `src/test`.
 - All benchmark source files must go under `src/benchmarks`.

@@ -479,8 +480,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.

@@ -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
@@ -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}")
@@ -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)
@@ -1,43 +1,15 @@
 option(
    validator_keys
-    "Enables building of validator-keys tool as a separate target (imported via FetchContent)"
+    "Enables building of the validator-keys tool as a separate target"
    OFF
 )

 if(validator_keys)
-    # Own the install destination below rather than relying on another module
-    # having pulled this in first.
-    include(GNUInstallDirs)
-
-    # Pinned to an exact commit, not a branch: the tool ships inside our
-    # packages, so the same xrpld version must always package the same
-    # validator-keys. Bump this deliberately.
-    set(validator_keys_commit "4c0fb75eec9601c711645998c904507e87e910ae")
-    message(STATUS "Using ValidatorKeys commit: ${validator_keys_commit}")
-
-    FetchContent_Declare(
-        validator_keys
-        GIT_REPOSITORY https://github.com/ripple/validator-keys-tool.git
-        GIT_TAG "${validator_keys_commit}"
-    )
-    FetchContent_MakeAvailable(validator_keys)
-    # The tool's own CMakeLists excludes the target from 'all' when it is built
-    # as a subproject. Undo that, so validator_keys=ON really does build it.
-    set_target_properties(
-        validator-keys
-        PROPERTIES
-            RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}"
-            EXCLUDE_FROM_ALL OFF
-            EXCLUDE_FROM_DEFAULT_BUILD OFF
-    )
-    # We ship this binary, so like xrpld it must not keep the Nix store's ELF
-    # loader, or it cannot run on the target distro at all.
-    patch_nix_binary(validator-keys)
-
-    configure_file(
-        "${validator_keys_SOURCE_DIR}/LICENSE"
-        "${CMAKE_BINARY_DIR}/validator-keys-LICENSE"
-        COPYONLY
-    )
-    install(TARGETS validator-keys RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
+    if(WIN32)
+        message(
+            FATAL_ERROR
+            "validator_keys is not supported on Windows: key files are written with POSIX mkstemp and rename"
+        )
+    endif()
+    add_subdirectory(src/tools/validator-keys)
 endif()
@@ -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}")
@@ -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",
 }

@@ -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)};
    }
@@ -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)};
@@ -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"
@@ -120,13 +124,7 @@ class Xrpl(ConanFile):
    }

    def set_version(self):
-        if self.version is None:
-            path = f"{self.recipe_folder}/src/libxrpl/protocol/BuildInfo.cpp"
-            regex = r"versionString\s?=\s?\"(.*)\""
-            with open(path, 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":
@@ -169,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
@@ -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)$"
@@ -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;
@@ -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;
    }
@@ -5,6 +5,6 @@

 namespace xrpl {

-using KeyCache = TaggedCache<uint256, int, true>;
+using KeyCache = TaggedCache<UInt256, int, true>;

 }  // namespace xrpl
@@ -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>)
@@ -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.
@@ -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_;
@@ -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};
 };
@@ -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&)
@@ -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
@@ -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
@@ -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.
@@ -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;
@@ -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
@@ -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()));
@@ -40,7 +40,7 @@ private:

 public:
    using value_type = Int;
-    using tag_type = Tag;
+    using TagType = Tag;

    TaggedInteger() = default;

@@ -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)$"
@@ -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)

@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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());
@@ -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)
@@ -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;

@@ -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.
@@ -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
@@ -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();
@@ -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)
@@ -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.
@@ -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
@@ -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
 * {
 *     //...
 * };
@@ -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))
@@ -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;
@@ -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
@@ -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
@@ -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
@@ -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()};
    }

@@ -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");
@@ -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>
@@ -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;
@@ -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
     */
@@ -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;

@@ -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_;
 };

@@ -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>;
@@ -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_;

@@ -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)

@@ -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
@@ -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;

    /**
@@ -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
@@ -91,6 +91,6 @@ public:
    }
 };

-using semaphore = BasicSemaphore<std::mutex, std::condition_variable>;
+using Semaphore = BasicSemaphore<std::mutex, std::condition_variable>;

 }  // namespace xrpl
@@ -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&;
@@ -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
@@ -147,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;
@@ -196,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
@@ -218,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
@@ -238,7 +238,7 @@ public:
     */
    /** @{ */
    virtual void
-    update(SLE::ref sle) = 0;
+    update(SLE::Ref sle) = 0;

    //--------------------------------------------------------------------------

@@ -333,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)
        {
@@ -372,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);
    }
@@ -382,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);
    }
@@ -406,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)
@@ -419,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.
@@ -466,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(
@@ -487,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
@@ -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_;
@@ -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_;
 };

@@ -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
@@ -26,7 +26,7 @@ private:
    DigestAwareReadView const& base_;
    CachedSLEs& cache_;
    std::mutex mutable mutex_;
-    std::unordered_map<key_type, uint256, HardenedHash<>> mutable map_;
+    std::unordered_map<key_type, UInt256, HardenedHash<>> mutable map_;

 public:
    CachedViewImpl() = delete;
@@ -78,31 +78,31 @@ public:
        return base_.succ(key, last);
    }

-    std::unique_ptr<SlesType::iter_base>
+    std::unique_ptr<SlesType::IterBase>
    slesBegin() const override
    {
        return base_.slesBegin();
    }

-    std::unique_ptr<SlesType::iter_base>
+    std::unique_ptr<SlesType::IterBase>
    slesEnd() const override
    {
        return base_.slesEnd();
    }

-    std::unique_ptr<SlesType::iter_base>
-    slesUpperBound(uint256 const& key) const override
+    std::unique_ptr<SlesType::IterBase>
+    slesUpperBound(UInt256 const& key) const override
    {
        return base_.slesUpperBound(key);
    }

-    std::unique_ptr<TxsType::iter_base>
+    std::unique_ptr<TxsType::IterBase>
    txsBegin() const override
    {
        return base_.txsBegin();
    }

-    std::unique_ptr<TxsType::iter_base>
+    std::unique_ptr<TxsType::IterBase>
    txsEnd() const override
    {
        return base_.txsEnd();
@@ -114,7 +114,7 @@ public:
        return base_.txExists(key);
    }

-    tx_type
+    TxType
    txRead(key_type const& key) const override
    {
        return base_.txRead(key);
@@ -124,7 +124,7 @@ public:
    // DigestAwareReadView
    //

-    std::optional<digest_type>
+    std::optional<DigestType>
    digest(key_type const& key) const override
    {
        return base_.digest(key);
@@ -147,7 +147,7 @@ private:
    std::shared_ptr<Base const> sp_;

 public:
-    using base_type = Base;
+    using BaseType = Base;

    CachedView() = delete;
    CachedView(CachedView const&) = delete;
@@ -27,7 +27,7 @@ private:
    class Key
    {
    public:
-        Key(uint256 const& account, SeqProxy seqProx, uint256 const& id)
+        Key(UInt256 const& account, SeqProxy seqProx, UInt256 const& id)
            : account_(account), txId_(id), seqProxy_(seqProx)
        {
        }
@@ -59,21 +59,21 @@ private:
            return lhs.txId_ == rhs.txId_;
        }

-        [[nodiscard]] uint256 const&
+        [[nodiscard]] UInt256 const&
        getAccount() const
        {
            return account_;
        }

-        [[nodiscard]] uint256 const&
+        [[nodiscard]] UInt256 const&
        getTXID() const
        {
            return txId_;
        }

    private:
-        uint256 account_;
-        uint256 txId_;
+        UInt256 account_;
+        UInt256 txId_;
        SeqProxy seqProxy_;
    };

@@ -81,7 +81,7 @@ private:
    operator<(Key const& lhs, Key const& rhs);

    // Calculate the salted key for the given account
-    uint256
+    UInt256
    accountKey(AccountID const& account);

 public:
@@ -141,7 +141,7 @@ public:
        return map_.empty();
    }

-    [[nodiscard]] uint256 const&
+    [[nodiscard]] UInt256 const&
    key() const
    {
        return salt_;
@@ -151,7 +151,7 @@ private:
    std::map<Key, std::shared_ptr<STTx const>> map_;

    // Used to salt the accounts so people can't mine for low account numbers
-    uint256 salt_;
+    UInt256 salt_;
 };

 }  // namespace xrpl
@@ -17,7 +17,7 @@ namespace xrpl {
 * A class that simplifies iterating ledger directory pages
 *
 * The Dir class provides a forward iterator for walking through
- * the uint256 values contained in ledger directories.
+ * the UInt256 values contained in ledger directories.
 *
 * The Dir class also allows accelerated directory walking by
 * stepping directly from one page to the next using the next_page()
@@ -86,7 +86,7 @@ public:
        return page_;
    }

-    uint256
+    UInt256
    index() const
    {
        return index_;
@@ -103,11 +103,11 @@ private:
    ReadView const* view_ = nullptr;
    Keylet root_;
    Keylet page_;
-    uint256 index_;
+    UInt256 index_;
    std::optional<value_type> mutable cache_;
    SLE::const_pointer sle_;
    STVector256 const* indexes_ = nullptr;
-    std::vector<uint256>::const_iterator it_;
+    std::vector<UInt256>::const_iterator it_;
 };

 }  // namespace xrpl
@@ -102,7 +102,7 @@ public:
        CreateGenesisT,
        Rules rules,
        Fees const& fees,
-        std::vector<uint256> const& amendments,
+        std::vector<UInt256> const& amendments,
        Family& family);

    Ledger(LedgerHeader const& info, Rules rules, Family& family);
@@ -181,40 +181,40 @@ public:
    exists(Keylet const& k) const override;

    bool
-    exists(uint256 const& key) const;
+    exists(UInt256 const& key) const;

-    std::optional<uint256>
-    succ(uint256 const& key, std::optional<uint256> const& last = std::nullopt) const override;
+    std::optional<UInt256>
+    succ(UInt256 const& key, std::optional<UInt256> const& last = std::nullopt) const override;

    SLE::const_pointer
    read(Keylet const& k) const override;

-    std::unique_ptr<SlesType::iter_base>
+    std::unique_ptr<SlesType::IterBase>
    slesBegin() const override;

-    std::unique_ptr<SlesType::iter_base>
+    std::unique_ptr<SlesType::IterBase>
    slesEnd() const override;

-    std::unique_ptr<SlesType::iter_base>
-    slesUpperBound(uint256 const& key) const override;
+    std::unique_ptr<SlesType::IterBase>
+    slesUpperBound(UInt256 const& key) const override;

-    std::unique_ptr<TxsType::iter_base>
+    std::unique_ptr<TxsType::IterBase>
    txsBegin() const override;

-    std::unique_ptr<TxsType::iter_base>
+    std::unique_ptr<TxsType::IterBase>
    txsEnd() const override;

    bool
-    txExists(uint256 const& key) const override;
+    txExists(UInt256 const& key) const override;

-    tx_type
+    TxType
    txRead(key_type const& key) const override;

    //
    // DigestAwareReadView
    //

-    std::optional<digest_type>
+    std::optional<DigestType>
    digest(key_type const& key) const override;

    //
@@ -222,16 +222,16 @@ public:
    //

    void
-    rawErase(SLE::ref sle) override;
+    rawErase(SLE::Ref sle) override;

    void
-    rawInsert(SLE::ref sle) override;
+    rawInsert(SLE::Ref sle) override;

    void
-    rawErase(uint256 const& key);
+    rawErase(UInt256 const& key);

    void
-    rawReplace(SLE::ref sle) override;
+    rawReplace(SLE::Ref sle) override;

    void
    rawDestroyXRP(XRPAmount const& fee) override
@@ -245,7 +245,7 @@ public:

    void
    rawTxInsert(
-        uint256 const& key,
+        UInt256 const& key,
        std::shared_ptr<Serializer const> const& txn,
        std::shared_ptr<Serializer const> const& metaData) override;

@@ -346,7 +346,7 @@ public:
     *
     * @return the public keys
     */
-    hash_set<PublicKey>
+    HashSet<PublicKey>
    negativeUNL() const;

    /**
@@ -82,7 +82,7 @@ private:
    // List of tx, key order
    // Use boost::pmr functionality instead of std::pmr
    // functions b/c clang does not support pmr yet (as-of 9/2020)
-    using txs_map = std::map<
+    using TxsMap = std::map<
        key_type,
        TxData,
        std::less<>,
@@ -91,7 +91,7 @@ private:
    // monotonic_resource_ must outlive `items_`. Make a pointer so it may be
    // easily moved.
    std::unique_ptr<boost::container::pmr::monotonic_buffer_resource> monotonicResource_;
-    txs_map txs_;
+    TxsMap txs_;
    Rules rules_;
    LedgerHeader header_;
    ReadView const* base_;
@@ -224,37 +224,37 @@ public:
    SLE::const_pointer
    read(Keylet const& k) const override;

-    std::unique_ptr<SlesType::iter_base>
+    std::unique_ptr<SlesType::IterBase>
    slesBegin() const override;

-    std::unique_ptr<SlesType::iter_base>
+    std::unique_ptr<SlesType::IterBase>
    slesEnd() const override;

-    std::unique_ptr<SlesType::iter_base>
-    slesUpperBound(uint256 const& key) const override;
+    std::unique_ptr<SlesType::IterBase>
+    slesUpperBound(UInt256 const& key) const override;

-    std::unique_ptr<TxsType::iter_base>
+    std::unique_ptr<TxsType::IterBase>
    txsBegin() const override;

-    std::unique_ptr<TxsType::iter_base>
+    std::unique_ptr<TxsType::IterBase>
    txsEnd() const override;

    bool
    txExists(key_type const& key) const override;

-    tx_type
+    TxType
    txRead(key_type const& key) const override;

    // RawView

    void
-    rawErase(SLE::ref sle) override;
+    rawErase(SLE::Ref sle) override;

    void
-    rawInsert(SLE::ref sle) override;
+    rawInsert(SLE::Ref sle) override;

    void
-    rawReplace(SLE::ref sle) override;
+    rawReplace(SLE::Ref sle) override;

    void
    rawDestroyXRP(XRPAmount const& fee) override;
@@ -101,7 +101,7 @@ public:
 * @return The set of books whose offers were created, modified, or
 *         deleted. May be empty for non-offer transactions.
 */
-hash_set<Book>
+HashSet<Book>
 affectedBooks(AcceptedLedgerTx const& alTx, beast::Journal const& j);

 }  // namespace xrpl
@@ -18,7 +18,7 @@ struct OwnerCounts
    std::uint32_t sponsoring = 0;

    OwnerCounts() = default;
-    OwnerCounts(SLE::const_ref sle)
+    OwnerCounts(SLE::ConstRef sle)
        : owner(sle->at(sfOwnerCount))
        , sponsored(sle->at(sfSponsoredOwnerCount))
        , sponsoring(sle->at(sfSponsoringOwnerCount))
@@ -30,7 +30,7 @@ public:
     * can calculate metadata.
     */
    virtual void
-    rawErase(SLE::ref sle) = 0;
+    rawErase(SLE::Ref sle) = 0;

    /**
     * Unconditionally insert a state item.
@@ -45,7 +45,7 @@ public:
     * @note The key is taken from the SLE
     */
    virtual void
-    rawInsert(SLE::ref sle) = 0;
+    rawInsert(SLE::Ref sle) = 0;

    /**
     * Unconditionally replace a state item.
@@ -61,7 +61,7 @@ public:
     * @note The key is taken from the SLE
     */
    virtual void
-    rawReplace(SLE::ref sle) = 0;
+    rawReplace(SLE::Ref sle) = 0;

    /**
     * Destroy XRP.
Author	SHA1	Message	Date
Denis Angell	ead061fadb	fix: refuse a key file on a filesystem without hard links and check appended blobs fully	2026-10-06 21:38:34 -04:00
Denis Angell	22334aa7c9	fix: make the show_manifest encoding optional	2026-10-06 21:09:28 -04:00
Denis Angell	8cd344b56c	fix: sync the key file's directory best effort and end line comments at CR	2026-10-06 20:52:23 -04:00
Denis Angell	d1498b1849	fix: require the token's manifest to verify for the list's master key	2026-10-06 20:14:32 -04:00
Denis Angell	fa8be41369	fix: list the no-hard-link errors instead of comparing equal ones	2026-10-06 19:58:39 -04:00
Denis Angell	b89ec84283	fix: refuse create_token while a token is pending	2026-10-06 19:53:27 -04:00
Denis Angell	910b25db47	fix: address the validator-keys AI review on key files, list output and signing keys	2026-10-06 19:36:19 -04:00
Denis Angell	b093cb5912	fix: verify appended blobs, keep a pending token, and register tool tests with CTest	2026-10-06 15:07:36 -04:00
Denis Angell	40b299652e	test: release the held directory when its lock fails	2026-10-06 13:21:26 -04:00
Denis Angell	bcd5b64659	fix: reject merged list values and serialize key file updates	2026-10-06 13:05:57 -04:00
Denis Angell	c11a71349e	fix: make every directory created for a key file owner-only	2026-10-06 11:56:43 -04:00
Denis Angell	7a84f1c0d0	fix: reject text after the list object and honour --out for revocations	2026-10-06 11:31:51 -04:00
Denis Angell	59cb0adb37	fix: require canonical base64 for a public key argument	2026-10-06 10:59:31 -04:00
Denis Angell	1103fefdf8	fix: create key files without replacing one a concurrent run wrote	2026-10-06 10:21:27 -04:00
Denis Angell	38a0899a71	style: name the legacy config file without the old binary name	2026-10-05 20:07:32 -04:00
Denis Angell	51cf1b8fc8	fix: address the validator-keys review on output, key path, appends and packaging	2026-10-05 19:37:42 -04:00
Denis Angell	610b6e6555	fix: make STObject a complete type in Manifest.h	2026-10-03 13:08:42 +00:00
Denis Angell	1c55353bda	fix: create OwnerOnlyFile's temporary atomically with mkstemp	2026-10-03 13:08:38 +00:00
Denis Angell	f616b1b763	Local merge develop into dangell7/validator-keys	2026-10-02 12:05:44 +00:00
Ayaz Salikhov	97fbea23cc	build: Determine version based on tags only (#8457 )	2026-10-01 20:52:53 +00:00
Ayaz Salikhov	e6055ddbe1	build: Push docker image for antithesis with voidstar (#8341 )	2026-10-01 19:12:36 +00:00
Ayaz Salikhov	a5c76fde2d	ci: Add guardrails for release backporting (#8449 )	2026-10-01 13:35:58 +00:00
Ayaz Salikhov	eed6527946	style: Update pre-commit hooks (#8456 )	2026-10-01 13:35:37 +00:00
Alex KremerandValentin Balaschenko	ddbc5f1a24	fix: Resolve IntrusivePointer leak (#8328 ) Co-authored-by: Valentin Balaschenko <[email protected]>	2026-09-30 15:51:25 +00:00
Alex Kremer	97a1824537	chore: CamelCase for typedef/using in `clang-tidy` (#8177 )	2026-09-30 15:17:18 +00:00
Ayaz Salikhov	b44c87613c	release: Merge release/3.4.x into develop Content was already merged via #8239 (rebased); this records the merge so future release/3.4.x merges don't replay it.	2026-09-30 14:08:23 +01:00
BartandBart	b3bbf50d40	refactor: Make the config name constants constexpr string views (#8332 ) Co-authored-by: Bart <[email protected]>	2026-09-30 10:50:18 +00:00
BartandBart	53246e5b15	fix: Count cluster traffic only from cluster members (#8319 ) Co-authored-by: Bart <[email protected]>	2026-09-30 10:32:25 +00:00
Bart	7e82b0660f	fix: Queue a transaction hash only for peers that asked for it (#8309 )	2026-09-30 10:31:21 +00:00
Bart	4a4fded2eb	chore: Bump version to 3.4.0	2026-09-16 18:23:54 +02:00
yinyiqian1	c8e767afa4	fix: Reject PaymentBurn payments that cross zero balance	2026-09-16 18:23:28 +02:00
Pratik Mankawde	00eeb0a005	fix: Reject variable-length prefixes the encoder cannot write	2026-09-16 18:23:28 +02:00
Vito Tumas	a18839d92d	fix: Relax MPT authorize cap for LoanSet and VaultWithdraw	2026-09-16 18:23:28 +02:00
Gregory Tsipenyuk	8c594c7ed9	fix: Skip CheckCash limit waiver for the issuer	2026-09-16 18:22:39 +02:00
Ayaz Salikhov	ebd810b184	build: Add missing script to conan package	2026-09-16 18:22:26 +02:00
Jingchen	3e4e56d6bb	fix: Make calculateBaseFee exception-safe	2026-09-16 18:22:26 +02:00
Ayaz Salikhov	76da5d4475	build: Fix test installation on debian:11 due to EOL	2026-09-16 18:22:26 +02:00
Ayaz Salikhov	c0d0fd0d97	build: Add assert-enabled builds and packages	2026-09-16 18:22:26 +02:00
Timothy Banks	9aebb5ebea	fix: Cap TMTransactions list size and charge fee for undeserializable transactions	2026-09-16 18:22:26 +02:00
Vito Tumas	796f2f8f1e	fix: Relax Loan Invariants to allow zero-principal LoanPay transaction	2026-09-16 18:22:26 +02:00
Timothy Banks	b190f2b14f	test: Add ProtocolMessage harness for testing TMPing	2026-09-16 18:22:25 +02:00
Denis Angell	fa789d95fd	style: drop includes the test publisher server no longer uses	2026-09-14 18:31:58 -04:00
Denis Angell	3dc27ca77d	fix: replace output files whole and refuse an output that names an input	2026-09-14 17:32:39 -04:00
Denis Angell	5cda41fad0	refactor: sign manifests and revocations in libxrpl	2026-09-14 17:14:23 -04:00
Denis Angell	88a9bc76bc	fix: name xrp-ledger.toml correctly in the attest_domain hint	2026-09-14 14:52:49 -04:00
Denis Angell	5e7da075fa	fix: refuse symlinked key file temporaries and keep secrets out of errors	2026-09-14 14:35:34 -04:00
Denis Angell	b51d8c1140	refactor: satisfy clang-tidy in validator-keys	2026-09-14 13:46:16 -04:00
Denis Angell	82f95502ac	docs: article the rename check expects in the validator-keys guide	2026-09-14 13:03:36 -04:00
Denis Angell	0467fd7144	fix: reject duplicate validators and a zero expiration; restrict output files before writing	2026-09-14 12:51:59 -04:00
Denis Angell	3ffba1678e	refactor: one manifest pipeline, server-faithful list checks, gtest suites for validator-keys	2026-09-14 12:47:53 -04:00
Denis Angell	9d2428967d	test: cover the tool's sources; appended blobs verify under their own manifest	2026-09-13 20:39:36 -04:00
Denis Angell	7bd7ea79dd	ci: lint validator-keys in the clang-tidy job	2026-09-13 19:56:36 -04:00
Denis Angell	728db41016	test: manifest sequence continues from a migrated token_sequence	2026-09-13 19:56:34 -04:00
Denis Angell	ff5aa537e1	feat: vendor validator-keys with external signing and validator-list signing	2026-09-13 19:52:40 -04:00
Timothy Banks	6099940c2c	fix: Unbounded Database Seek via TMGetLedger	2026-09-04 15:32:36 +01:00
Ed Hennis	0db7b766e6	fix: Trim unknown fields when parsing incoming peer protobuf messages	2026-09-04 10:32:08 +00:00
Mayukha Vadari	ea6226b8b9	fix: Prevent `simulate` from updating the orderbook db	2026-09-04 06:17:43 -04:00
Timothy Banks	eae0a35415	fix: Use a hardened hash on the STPathElement	2026-09-03 17:06:27 -04:00