diff --git a/.cspell.config.yaml b/.cspell.config.yaml
index 8929973e8a..48afdc2b7a 100644
--- a/.cspell.config.yaml
+++ b/.cspell.config.yaml
@@ -64,6 +64,7 @@ words:
   - blindings
   - bookdir
   - Bougalis
+  - bthomee
   - Britto
   - Btrfs
   - Buildx
@@ -141,6 +142,7 @@ words:
   - hwrap
   - ifndef
   - inequation
+  - Injectivity
   - insuf
   - insuff
   - invasively
@@ -366,7 +368,6 @@ words:
   - venv
   - vfalco
   - vinnie
-  - vkeylet
   - wasmi
   - wextra
   - wptr
diff --git a/.github/actions/setup-nix-env/action.yml b/.github/actions/setup-nix-env/action.yml
index a95053e536..38b8365649 100644
--- a/.github/actions/setup-nix-env/action.yml
+++ b/.github/actions/setup-nix-env/action.yml
@@ -40,10 +40,11 @@ runs:
         # Unlike the Linux nix images, macOS needs no SSL_CERT_FILE: it has its
         # own trust store, and pinning would break TLS to hosts relying on it.
 
-        # Workspace-local, so `cleanup-workspace` clears it, but not the
-        # `.conan2` prepare-runner hands the system toolchain: that Conan is a
-        # different version, and the two would migrate each other's cache.
-        echo "CONAN_HOME=${{ github.workspace }}/.conan2-nix" >>"${GITHUB_ENV}"
+        # In RUNNER_TEMP, which the runner empties per job, like the `.conan2`
+        # prepare-runner hands the system toolchain - but under its own name:
+        # that Conan is a different version, and the two would migrate each
+        # other's cache.
+        echo "CONAN_HOME=${RUNNER_TEMP}/.conan2-nix" >>"${GITHUB_ENV}"
 
     # Config, profiles and remote, exactly as the dev shell sets them up on
     # entry; the `setup-conan` action is skipped for this toolchain.
diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md
index 95d75c04b4..e0d511c467 100644
--- a/.github/pull_request_template.md
+++ b/.github/pull_request_template.md
@@ -18,7 +18,7 @@ If too broad, please consider splitting into multiple PRs.
 If there is a relevant task or issue, please link it here.
 -->
 
-### Context of Change
+## Context of Change
 
 <!--
 Please include the context of a change.
@@ -29,7 +29,7 @@ If a refactor, how is this better than the previous implementation?
 If there is a spec or design document for this feature, please link it here.
 -->
 
-### API Impact
+## API Impact
 
 <!--
 Please check [x] relevant options, delete irrelevant ones.
diff --git a/.github/scripts/levelization/results/ordering.txt b/.github/scripts/levelization/results/ordering.txt
index 5577c363fd..284fc9cdb7 100644
--- a/.github/scripts/levelization/results/ordering.txt
+++ b/.github/scripts/levelization/results/ordering.txt
@@ -82,7 +82,6 @@ test.app > xrpl.tx
 test.basics > test.jtx
 test.basics > xrpl.basics
 test.basics > xrpl.core
-test.basics > xrpld.rpc
 test.basics > xrpl.json
 test.basics > xrpl.protocol
 test.beast > xrpl.basics
@@ -113,6 +112,7 @@ test.jtx > xrpl.config
 test.jtx > xrpl.core
 test.jtx > xrpld.app
 test.jtx > xrpld.core
+test.jtx > xrpld.overlay
 test.jtx > xrpld.rpc
 test.jtx > xrpl.json
 test.jtx > xrpl.ledger
@@ -286,10 +286,10 @@ xrpld.perflog > xrpl.basics
 xrpld.perflog > xrpl.config
 xrpld.perflog > xrpl.core
 xrpld.perflog > xrpld.app
-xrpld.perflog > xrpld.rpc
 xrpld.perflog > xrpl.json
 xrpld.perflog > xrpl.nodestore
 xrpld.perflog > xrpl.protocol
+xrpld.perflog > xrpl.server
 xrpld.rpc > xrpl.basics
 xrpld.rpc > xrpl.config
 xrpld.rpc > xrpl.core
diff --git a/.github/scripts/strategy-matrix/generate.py b/.github/scripts/strategy-matrix/generate.py
index 65671dbd11..5528d6442e 100755
--- a/.github/scripts/strategy-matrix/generate.py
+++ b/.github/scripts/strategy-matrix/generate.py
@@ -15,6 +15,14 @@ _BASE_CMAKE_ARGS = [
     "-Drust=ON",
 ]
 
+# The package formats a config can be packaged as, each with its own
+# install-test job in reusable-package.yml.
+PACKAGE_TYPES = ("deb", "rpm")
+
+# The package name a variant suffixes, as build_pkg.py's BASE_NAME spells it:
+# the two have to agree, or the artifact globs miss what was built.
+BASE_NAME = "xrpld"
+
 # Maps sanitizer names (as used in cmake) to short config-name suffixes.
 _SANITIZER_SUFFIX: dict[str, str] = {
     "address": "asan",
@@ -62,10 +70,20 @@ def get_cmake_args(build_type: str, extra_args: str) -> str:
 class PackageConfig:
     """The 'package' map of a config whose binaries are also packaged."""
 
-    type: str  # "deb" or "rpm"; has to match what the image provides
+    type: str  # has to match what the image provides
     # The packaging container image: a vanilla distro image, not the nix image
     # the config itself builds in.
     image: str
+    # A flavour of the package, named xrpld-<variant>, for a config whose
+    # binaries are not the plain release build. A variant needs no counterpart
+    # in the other format.
+    variant: str = ""
+
+    def __post_init__(self) -> None:
+        assert self.type in PACKAGE_TYPES, (
+            f"unsupported package type {self.type!r}: "
+            f"use one of {', '.join(PACKAGE_TYPES)}."
+        )
 
 
 @dataclasses.dataclass
@@ -178,6 +196,8 @@ class PackagingEntry:
     validator_keys_artifact_name: str
     image: str
     package_type: str  # "deb" or "rpm"; drives the format-specific steps
+    package_variant: str  # passed to build_pkg.py --variant; empty for xrpld
+    package_name: str  # the name it builds under, which the artifact globs use
 
 
 # ---------------------------------------------------------------------------
@@ -267,12 +287,32 @@ def expand_linux_packaging(linux: LinuxFile) -> list[PackagingEntry]:
                         validator_keys_artifact_name=f"validator-keys-{name}",
                         image=cfg.package.image,
                         package_type=cfg.package.type,
+                        package_variant=cfg.package.variant,
+                        package_name=(
+                            f"{BASE_NAME}-{cfg.package.variant}"
+                            if cfg.package.variant
+                            else BASE_NAME
+                        ),
                     )
                 )
 
     return entries
 
 
+def package_names_by_type(entries: list[PackagingEntry]) -> dict[str, list[str]]:
+    """The names of the packages in 'entries', keyed by format.
+
+    Derived from the packaging matrix rather than listed again, so the packages
+    the install-test jobs look for are the packages that were built.
+    """
+    return {
+        package_type: sorted(
+            {e.package_name for e in entries if e.package_type == package_type}
+        )
+        for package_type in PACKAGE_TYPES
+    }
+
+
 def expand_platform_matrix(pf: PlatformFile, minimal: bool) -> list[MatrixEntry]:
     """Expand a PlatformFile (macOS or Windows) into matrix entries.
 
@@ -341,6 +381,10 @@ if __name__ == "__main__":
 
     if args.packaging:
         matrix = expand_linux_packaging(LinuxFile.load(THIS_DIR / "linux.json"))
+        # One list per format, so each install-test job installs the packages its
+        # own format produced.
+        for package_type, names in package_names_by_type(matrix).items():
+            print(f"{package_type}_package_names={json.dumps(names)}")
     else:
         if args.config in ("linux", None):
             matrix += expand_linux_matrix(
diff --git a/.github/scripts/strategy-matrix/linux.json b/.github/scripts/strategy-matrix/linux.json
index d8cdbdfa52..9b069f0ce3 100644
--- a/.github/scripts/strategy-matrix/linux.json
+++ b/.github/scripts/strategy-matrix/linux.json
@@ -1,5 +1,5 @@
 {
-  "image_tag": "sha-473fe44",
+  "image_tag": "sha-060957e",
   "configs": {
     "ubuntu": [
       {
@@ -74,7 +74,20 @@
         "extra_cmake_args": "-Dvalidator_keys=ON",
         "package": {
           "type": "deb",
-          "image": "ghcr.io/xrplf/xrpld/packaging-debian:sha-b6a8995"
+          "image": "ghcr.io/xrplf/xrpld/packaging-debian:sha-49cdc10"
+        }
+      },
+      {
+        "compiler": ["gcc"],
+        "build_type": ["Release"],
+        "arch": ["amd64"],
+        "minimal": false,
+        "suffix": "assert",
+        "extra_cmake_args": "-Dvalidator_keys=ON -Dassert=ON",
+        "package": {
+          "type": "deb",
+          "image": "ghcr.io/xrplf/xrpld/packaging-debian:sha-49cdc10",
+          "variant": "assert"
         }
       }
     ],
@@ -88,7 +101,7 @@
         "extra_cmake_args": "-Dvalidator_keys=ON",
         "package": {
           "type": "rpm",
-          "image": "ghcr.io/xrplf/xrpld/packaging-rhel:sha-b6a8995"
+          "image": "ghcr.io/xrplf/xrpld/packaging-rhel:sha-49cdc10"
         }
       }
     ]
diff --git a/.github/workflows/build-nix-images.yml b/.github/workflows/build-nix-images.yml
index a528786dd4..8ecf4912f5 100644
--- a/.github/workflows/build-nix-images.yml
+++ b/.github/workflows/build-nix-images.yml
@@ -5,15 +5,13 @@ on:
     branches:
       - develop
     paths:
-      - ".github/workflows/build-nix-images.yml"
       - "flake.nix"
       - "flake.lock"
       - "rust-toolchain.toml"
       - "nix/**"
       - "!nix/docker/README.md"
       - "!nix/devshell.nix"
-      - "!nix/check-tools/*.txt"
-      - "bin/check-tools.sh"
+      - "!nix/check-tools/**"
       - "bin/default-loader-path.sh"
       - "bin/install-sanitizer-libs.sh"
   pull_request:
@@ -25,7 +23,7 @@ on:
       - "nix/**"
       - "!nix/docker/README.md"
       - "!nix/devshell.nix"
-      - "!nix/check-tools/*.txt"
+      - "!nix/check-tools/**"
       - "bin/check-tools.sh"
       - "bin/default-loader-path.sh"
       - "bin/install-sanitizer-libs.sh"
@@ -60,7 +58,7 @@ jobs:
             base_image: debian:bookworm
           - name: rhel
             base_image: registry.access.redhat.com/ubi9/ubi:latest
-    uses: XRPLF/actions/.github/workflows/build-multiarch-image.yml@65d5a0bd72be4ecea95cff0673a6e0672ab5243a
+    uses: XRPLF/actions/.github/workflows/build-multiarch-image.yml@034e87065fcd0100214cf0672923bd38d193cf78
     with:
       image_name: xrpld/nix-${{ matrix.distro.name }}
       dockerfile: nix/docker/Dockerfile
diff --git a/.github/workflows/build-packaging-images.yml b/.github/workflows/build-packaging-images.yml
index e099decc12..45fe338097 100644
--- a/.github/workflows/build-packaging-images.yml
+++ b/.github/workflows/build-packaging-images.yml
@@ -41,7 +41,7 @@ jobs:
           # AlmaLinux rather than UBI, which does not ship rpm-sign.
           - name: rhel
             base_image: almalinux:10
-    uses: XRPLF/actions/.github/workflows/build-multiarch-image.yml@65d5a0bd72be4ecea95cff0673a6e0672ab5243a
+    uses: XRPLF/actions/.github/workflows/build-multiarch-image.yml@034e87065fcd0100214cf0672923bd38d193cf78
     with:
       image_name: xrpld/packaging-${{ matrix.distro.name }}
       dockerfile: package/docker/Dockerfile
diff --git a/.github/workflows/build-pre-commit-image.yml b/.github/workflows/build-pre-commit-image.yml
index 71f083b686..fc2d3f2ab2 100644
--- a/.github/workflows/build-pre-commit-image.yml
+++ b/.github/workflows/build-pre-commit-image.yml
@@ -30,7 +30,7 @@ jobs:
     permissions:
       contents: read
       packages: write
-    uses: XRPLF/actions/.github/workflows/build-multiarch-image.yml@65d5a0bd72be4ecea95cff0673a6e0672ab5243a
+    uses: XRPLF/actions/.github/workflows/build-multiarch-image.yml@034e87065fcd0100214cf0672923bd38d193cf78
     with:
       image_name: xrpld/pre-commit
       dockerfile: bin/pre-commit/Dockerfile
diff --git a/.github/workflows/cargo-audit.yml b/.github/workflows/cargo-audit.yml
index 6ddc6cdac9..6e613b822a 100644
--- a/.github/workflows/cargo-audit.yml
+++ b/.github/workflows/cargo-audit.yml
@@ -34,7 +34,7 @@ permissions:
 jobs:
   audit:
     runs-on: ubuntu-latest
-    container: ghcr.io/xrplf/xrpld/nix-ubuntu:sha-473fe44
+    container: ghcr.io/xrplf/xrpld/nix-ubuntu:sha-060957e
     permissions:
       contents: read
       # Needed to open an issue on scheduled failures.
diff --git a/.github/workflows/check-tools.yml b/.github/workflows/check-tools.yml
index 1169140481..4b1a81de17 100644
--- a/.github/workflows/check-tools.yml
+++ b/.github/workflows/check-tools.yml
@@ -79,7 +79,7 @@ jobs:
         uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
 
       - name: Prepare runner
-        uses: XRPLF/actions/prepare-runner@7bf7ceca5932114abdd0d43493c3c30c5a654e13
+        uses: XRPLF/actions/prepare-runner@b3e255d74d785d053e4903da8ac90983cd7d9e82
         with:
           enable_ccache: false
 
diff --git a/.github/workflows/on-pr.yml b/.github/workflows/on-pr.yml
index 933c7b8a54..62a995d864 100644
--- a/.github/workflows/on-pr.yml
+++ b/.github/workflows/on-pr.yml
@@ -85,6 +85,7 @@ jobs:
             .github/workflows/reusable-build-test.yml
             .github/workflows/reusable-check-autogen.yml
             .github/workflows/reusable-clang-tidy.yml
+            .github/workflows/reusable-package-test-install.yml
             .github/workflows/reusable-package.yml
             .github/workflows/reusable-rust.yml
             .github/workflows/reusable-strategy-matrix.yml
@@ -189,6 +190,12 @@ jobs:
     # matrix (i.e. not yet labeled "Ready to merge" or "Full CI build").
     if: ${{ needs.should-run.outputs.go == 'true' && (github.event_name != 'pull_request' || contains(github.event.pull_request.labels.*.name, 'Ready to merge') || contains(github.event.pull_request.labels.*.name, 'Full CI build')) }}
     uses: ./.github/workflows/reusable-package.yml
+    with:
+      # A pull request builds packages to prove they still build, and publishes
+      # nothing. Stated rather than left to the input's default, so that changing
+      # that default cannot start publishing from pull requests. No secrets are
+      # passed either, which is the second reason a publish here cannot succeed.
+      publish: false
 
   upload-recipe:
     needs:
diff --git a/.github/workflows/on-trigger.yml b/.github/workflows/on-trigger.yml
index 2099f5f739..2bf73332d2 100644
--- a/.github/workflows/on-trigger.yml
+++ b/.github/workflows/on-trigger.yml
@@ -23,6 +23,7 @@ on:
       - ".github/workflows/reusable-build-test.yml"
       - ".github/workflows/reusable-check-autogen.yml"
       - ".github/workflows/reusable-clang-tidy.yml"
+      - ".github/workflows/reusable-package-test-install.yml"
       - ".github/workflows/reusable-package.yml"
       - ".github/workflows/reusable-rust.yml"
       - ".github/workflows/reusable-strategy-matrix.yml"
diff --git a/.github/workflows/pre-commit.yml b/.github/workflows/pre-commit.yml
index 1f6b69f087..25063b9dfa 100644
--- a/.github/workflows/pre-commit.yml
+++ b/.github/workflows/pre-commit.yml
@@ -14,7 +14,7 @@ on:
 jobs:
   # Call the workflow in the XRPLF/actions repo that runs the pre-commit hooks.
   run-hooks:
-    uses: XRPLF/actions/.github/workflows/pre-commit.yml@f1952595d212e86169935135efc66294b4574131
+    uses: XRPLF/actions/.github/workflows/pre-commit.yml@279ec358f4a1be4088be3e024b07916fa97c75b6
     with:
       runs_on: ubuntu-latest
       container: '{ "image": "ghcr.io/xrplf/xrpld/pre-commit:sha-473fe44" }'
diff --git a/.github/workflows/publish-docs.yml b/.github/workflows/publish-docs.yml
index 8c5d10929c..735ddfc906 100644
--- a/.github/workflows/publish-docs.yml
+++ b/.github/workflows/publish-docs.yml
@@ -41,13 +41,13 @@ env:
 jobs:
   build:
     runs-on: ubuntu-latest
-    container: ghcr.io/xrplf/xrpld/nix-ubuntu:sha-473fe44
+    container: ghcr.io/xrplf/xrpld/nix-ubuntu:sha-060957e
     steps:
       - name: Checkout repository
         uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
 
       - name: Prepare runner
-        uses: XRPLF/actions/prepare-runner@7bf7ceca5932114abdd0d43493c3c30c5a654e13
+        uses: XRPLF/actions/prepare-runner@b3e255d74d785d053e4903da8ac90983cd7d9e82
         with:
           enable_ccache: false
 
@@ -91,4 +91,4 @@ jobs:
     steps:
       - name: Deploy to GitHub Pages
         id: deploy
-        uses: actions/deploy-pages@cd2ce8fcbc39b97be8ca5fce6e763baed58fa128 # v5.0.0
+        uses: actions/deploy-pages@368f82528645a54fb793d4d04e342629a3f51346 # v5.0.1
diff --git a/.github/workflows/reusable-build-test-config.yml b/.github/workflows/reusable-build-test-config.yml
index 2846c3fb85..2a0c9332f3 100644
--- a/.github/workflows/reusable-build-test-config.yml
+++ b/.github/workflows/reusable-build-test-config.yml
@@ -129,7 +129,7 @@ jobs:
         uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
 
       - name: Prepare runner
-        uses: XRPLF/actions/prepare-runner@7bf7ceca5932114abdd0d43493c3c30c5a654e13
+        uses: XRPLF/actions/prepare-runner@b3e255d74d785d053e4903da8ac90983cd7d9e82
         with:
           enable_ccache: ${{ inputs.ccache_enabled }}
 
@@ -439,7 +439,7 @@ jobs:
 
       - name: Upload coverage report
         if: ${{ github.repository_owner == 'XRPLF' && !inputs.build_only && env.COVERAGE_ENABLED == 'true' }}
-        uses: codecov/codecov-action@fb8b3582c8e4def4969c97caa2f19720cb33a72f # v7.0.0
+        uses: codecov/codecov-action@303a32d7a59b442fa8d48b6a1cc6825c09c847a5 # v7.1.1
         with:
           disable_search: true
           disable_telem: true
diff --git a/.github/workflows/reusable-clang-tidy.yml b/.github/workflows/reusable-clang-tidy.yml
index 045d384181..8e3b80e318 100644
--- a/.github/workflows/reusable-clang-tidy.yml
+++ b/.github/workflows/reusable-clang-tidy.yml
@@ -34,7 +34,7 @@ jobs:
     needs: [determine-files]
     if: ${{ needs.determine-files.outputs.cpp_changed_files != '' || needs.determine-files.outputs.need_full_run == 'true' }}
     runs-on: ["self-hosted", "Linux", "X64", "heavy"]
-    container: "ghcr.io/xrplf/xrpld/nix-debian:sha-473fe44"
+    container: "ghcr.io/xrplf/xrpld/nix-debian:sha-060957e"
     permissions:
       contents: read
       issues: write
@@ -43,7 +43,7 @@ jobs:
         uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
 
       - name: Prepare runner
-        uses: XRPLF/actions/prepare-runner@7bf7ceca5932114abdd0d43493c3c30c5a654e13
+        uses: XRPLF/actions/prepare-runner@b3e255d74d785d053e4903da8ac90983cd7d9e82
         with:
           enable_ccache: false
 
diff --git a/.github/workflows/reusable-package-test-install.yml b/.github/workflows/reusable-package-test-install.yml
new file mode 100644
index 0000000000..4f1b6d7cb5
--- /dev/null
+++ b/.github/workflows/reusable-package-test-install.yml
@@ -0,0 +1,120 @@
+# Install one package format on every distro family it targets, one job per
+# package name and image, and run the binaries there. Called once per format by
+# reusable-package.yml, which owns the names and the image lists.
+name: Install packages
+
+on:
+  workflow_call:
+    inputs:
+      package_type:
+        description: 'The package format to install ("deb" or "rpm").'
+        required: true
+        type: string
+      package_names:
+        description: "JSON array of package names built for this format."
+        required: true
+        type: string
+      images:
+        description: "JSON array of container images to install in."
+        required: true
+        type: string
+
+defaults:
+  run:
+    shell: bash
+
+env:
+  PACKAGE_DIR: packages
+
+jobs:
+  install:
+    strategy:
+      fail-fast: false
+      matrix:
+        package_name: ${{ fromJson(inputs.package_names) }}
+        image: ${{ fromJson(inputs.images) }}
+    name: "${{ matrix.package_name }} on ${{ matrix.image }}"
+    permissions:
+      contents: read
+    runs-on: ubuntu-latest
+    container: ${{ matrix.image }}
+    timeout-minutes: 5
+
+    steps:
+      # Every package lands in one directory; the step below picks its own,
+      # which keeps this independent of the artifact names.
+      - name: Download package artifacts
+        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
+        with:
+          pattern: "*-pkg"
+          merge-multiple: true
+          path: ${{ env.PACKAGE_DIR }}
+
+      - name: Find the package
+        id: find
+        env:
+          PACKAGE_NAME: ${{ matrix.package_name }}
+          PACKAGE_TYPE: ${{ inputs.package_type }}
+        run: |
+          # The version follows the name, separated by '_' in a DEB and '-' in an
+          # RPM. Requiring a digit after it is what keeps 'xrpld' from picking up
+          # another package, such as 'xrpld-assert'.
+          pattern="${PACKAGE_NAME}[_-][0-9]*.${PACKAGE_TYPE}"
+          package="$(find "${PACKAGE_DIR}" -type f -name "${pattern}" -print -quit)"
+          test -n "${package}" || {
+              echo "no ${pattern} found in ${PACKAGE_DIR}" >&2
+              exit 1
+          }
+          echo "package=${package}" >>"${GITHUB_OUTPUT}"
+
+      # Debian 11 went end-of-life on 2026-08-31
+      # (https://www.debian.org/News/2026/20260831) and its packages are
+      # already partly gone from deb.debian.org, so switch to the
+      # snapshot.debian.org entries the image ships commented out in its
+      # sources.list: they are pinned to the snapshot the image was built
+      # from, so they serve every version it needs and never go away.
+      # Snapshots keep their original, long-passed Valid-Until, hence the
+      # disabled check; the retries absorb snapshot.debian.org's throttling.
+      - name: Switch Debian 11 to snapshot.debian.org
+        if: ${{ matrix.image == 'debian:11' }}
+        run: |
+          sed -i 's|^deb |# deb |; s|^# deb http://snapshot|deb http://snapshot|' /etc/apt/sources.list
+          printf '%s\n' \
+              'Acquire::Check-Valid-Until "false";' \
+              'Acquire::Retries "3";' \
+              >/etc/apt/apt.conf.d/99snapshot
+
+      - name: Install the DEB
+        if: ${{ inputs.package_type == 'deb' }}
+        env:
+          DEBIAN_FRONTEND: noninteractive
+          PACKAGE: ${{ steps.find.outputs.package }}
+        run: |
+          # Stock Debian and Ubuntu images carry no package lists, so apt has
+          # nothing to resolve the systemd dependency from until it fetches them.
+          apt-get update -qq
+          apt-get install -y "./${PACKAGE}"
+
+      - name: Install the RPM
+        if: ${{ inputs.package_type == 'rpm' }}
+        env:
+          PACKAGE: ${{ steps.find.outputs.package }}
+        run: dnf install -y "./${PACKAGE}"
+
+      - name: Run xrpld
+        run: xrpld --version
+
+      - name: Run validator-keys
+        run: validator-keys --version
+
+      - name: Run rippled, the legacy compatibility symlink
+        run: rippled --version
+
+      - name: Check the service account
+        run: id xrpld
+
+      - name: Check the state directory
+        run: test -d /var/lib/xrpld
+
+      - name: Check the log directory
+        run: test -d /var/log/xrpld
diff --git a/.github/workflows/reusable-package.yml b/.github/workflows/reusable-package.yml
index 2a5e6a8c04..700ec9180b 100644
--- a/.github/workflows/reusable-package.yml
+++ b/.github/workflows/reusable-package.yml
@@ -1,11 +1,16 @@
-# Build Linux packages from the pre-built xrpld and validator-keys artifacts:
+# Build, verify and publish Linux packages from the pre-built xrpld and
+# validator-keys artifacts, in three stages:
 #
-#   - one job per config that carries a "package" map in linux.json
-#   - that map names the container image and the format it builds there
-#   - every job ends with the image's publish_pkg.py, uploading what it built
-#     with 'publish: true' and doing a --dry-run otherwise
+#   - 'package' builds and signs one format per config that carries a "package"
+#     map in linux.json; that map names the container image and the format
+#   - 'test-install-deb' and 'test-install-rpm' call
+#     reusable-package-test-install.yml to install what was built on a range of
+#     distros and run the binaries there, so a package that cannot be installed
+#     never reaches Nexus
+#   - 'publish' uploads with the image's publish_pkg.py, doing a --dry-run
+#     unless 'publish: true'
 #
-# Only linux/amd64 is supported; the runner is hardcoded in the job below.
+# Only linux/amd64 is supported; the runner is hardcoded in the jobs below.
 name: Package
 
 on:
@@ -20,7 +25,7 @@ on:
         description: "The base URL of the Nexus instance hosting the deb and rpm repositories."
         required: false
         type: string
-        default: https://packages.xrplf.org
+        default: https://packages-upload.xrplf.org
 
     secrets:
       remote_username:
@@ -39,12 +44,15 @@ defaults:
 
 env:
   BUILD_DIR: build
+  PACKAGE_DIR: packages
 
 jobs:
   generate-matrix:
     runs-on: ubuntu-latest
     outputs:
       matrix: ${{ steps.generate.outputs.matrix }}
+      deb_package_names: ${{ steps.generate.outputs.deb_package_names }}
+      rpm_package_names: ${{ steps.generate.outputs.rpm_package_names }}
     steps:
       - name: Checkout repository
         uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
@@ -70,14 +78,14 @@ jobs:
       contents: read
     runs-on: ["self-hosted", "Linux", "X64", "heavy"]
     container: ${{ matrix.image }}
-    timeout-minutes: 30
+    timeout-minutes: 10
 
     steps:
       - name: Checkout repository
         uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
 
       - name: Prepare runner
-        uses: XRPLF/actions/prepare-runner@7bf7ceca5932114abdd0d43493c3c30c5a654e13
+        uses: XRPLF/actions/prepare-runner@b3e255d74d785d053e4903da8ac90983cd7d9e82
         with:
           enable_ccache: false
 
@@ -103,6 +111,7 @@ jobs:
       - name: Build package
         env:
           PACKAGE_TYPE: ${{ matrix.package_type }}
+          PACKAGE_VARIANT: ${{ matrix.package_variant }}
           PKG_RELEASE: ${{ steps.release_info.outputs.pkg_release }}
           CHANNEL: ${{ steps.release_info.outputs.channel }}
         run: |
@@ -110,26 +119,116 @@ jobs:
               --package-type "${PACKAGE_TYPE}" \
               --build-dir "${BUILD_DIR}" \
               --pkg-release "${PKG_RELEASE}" \
+              --variant "${PACKAGE_VARIANT}" \
               --channel "${CHANNEL}"
 
-      # Before the upload, so the artifact and the published package are the
-      # same bytes. DEBs are not signed, so the key is never set on that job.
+      # Before the upload, so the artifact, the tested package and the published
+      # package are the same bytes.
       - name: Sign RPM
         if: ${{ inputs.publish && matrix.package_type == 'rpm' }}
         env:
           PKG_SIGNING_KEY: ${{ secrets.signing_key }}
         run: ./package/sign_rpm.py --package-dir "${BUILD_DIR}"
 
+      # Split from the debug symbols, which are an order of magnitude larger, so
+      # that test-install downloads only what it installs. In the globs below the
+      # version follows the name, separated by '_' in a DEB and '-' in an RPM. A
+      # version starts with a digit and a longer name does not, so that one digit
+      # is what tells 'xrpld-3.4.1-...' from 'xrpld-assert-3.4.1-...'.
       - name: Upload package artifact
         uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
         with:
           name: ${{ matrix.xrpld_artifact_name }}-pkg
           path: |
-            ${{ env.BUILD_DIR }}/debbuild/*.deb
-            ${{ env.BUILD_DIR }}/debbuild/*.ddeb
-            ${{ env.BUILD_DIR }}/rpmbuild/RPMS/**/*.rpm
+            ${{ env.BUILD_DIR }}/debbuild/${{ matrix.package_name }}_[0-9]*.deb
+            ${{ env.BUILD_DIR }}/rpmbuild/RPMS/**/${{ matrix.package_name }}-[0-9]*.rpm
           if-no-files-found: error
 
+      - name: Upload debug symbol artifact
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        with:
+          name: ${{ matrix.xrpld_artifact_name }}-pkg-debug
+          path: |
+            ${{ env.BUILD_DIR }}/debbuild/${{ matrix.package_name }}-dbgsym_[0-9]*.deb
+            ${{ env.BUILD_DIR }}/debbuild/${{ matrix.package_name }}-dbgsym_[0-9]*.ddeb
+            ${{ env.BUILD_DIR }}/rpmbuild/RPMS/**/${{ matrix.package_name }}-debuginfo-[0-9]*.rpm
+          if-no-files-found: error
+
+  # One call per format, so a variant packaged for one format is installed for
+  # that format alone. The images are every distro family that format targets,
+  # oldest release first, so both ends of the dependency range the packages
+  # declare are exercised.
+  test-install-deb:
+    needs: [generate-matrix, package]
+    name: install deb
+    uses: ./.github/workflows/reusable-package-test-install.yml
+    with:
+      package_type: deb
+      package_names: ${{ needs.generate-matrix.outputs.deb_package_names }}
+      images: |
+        [
+          "debian:11",
+          "debian:12",
+          "debian:13",
+          "ubuntu:20.04",
+          "ubuntu:22.04",
+          "ubuntu:24.04",
+          "ubuntu:26.04"
+        ]
+
+  test-install-rpm:
+    needs: [generate-matrix, package]
+    name: install rpm
+    uses: ./.github/workflows/reusable-package-test-install.yml
+    with:
+      package_type: rpm
+      package_names: ${{ needs.generate-matrix.outputs.rpm_package_names }}
+      images: |
+        [
+          "almalinux:9",
+          "almalinux:10",
+          "rockylinux/rockylinux:9",
+          "rockylinux/rockylinux:10",
+          "registry.access.redhat.com/ubi9/ubi",
+          "registry.access.redhat.com/ubi10/ubi"
+        ]
+
+  publish:
+    needs: [generate-matrix, package, test-install-deb, test-install-rpm]
+    strategy:
+      fail-fast: false
+      matrix: ${{ fromJson(needs.generate-matrix.outputs.matrix) }}
+    # The name says which of the two this is, because the job runs either way:
+    # with publish false it passes --dry-run and uploads nothing, and a job
+    # called "publish ..." succeeding on a pull request reads like a release.
+    name: "publish ${{ matrix.xrpld_artifact_name }}${{ !inputs.publish && ' (dry run)' || '' }}"
+    permissions:
+      contents: read
+    runs-on: ["self-hosted", "Linux", "X64", "heavy"]
+    container: ${{ matrix.image }}
+    timeout-minutes: 30
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+
+      - name: Prepare runner
+        uses: XRPLF/actions/prepare-runner@b3e255d74d785d053e4903da8ac90983cd7d9e82
+        with:
+          enable_ccache: false
+
+      # Both artifacts, so the debug symbols are published alongside the package.
+      - name: Download package artifacts
+        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
+        with:
+          pattern: ${{ matrix.xrpld_artifact_name }}-pkg*
+          merge-multiple: true
+          path: ${{ env.PACKAGE_DIR }}
+
+      - name: Determine release info
+        id: release_info
+        uses: ./.github/actions/release-info
+
       - name: Publish package
         env:
           CHANNEL: ${{ steps.release_info.outputs.channel }}
@@ -140,6 +239,6 @@ jobs:
         run: |
           publish_pkg.py \
               --channel "${CHANNEL}" \
-              --package-dir "${BUILD_DIR}" \
+              --package-dir "${PACKAGE_DIR}" \
               --nexus-url "${NEXUS_URL}" \
               ${DRY_RUN_OPTION}
diff --git a/.github/workflows/reusable-rust.yml b/.github/workflows/reusable-rust.yml
index a0199f0129..bdd5f75ca6 100644
--- a/.github/workflows/reusable-rust.yml
+++ b/.github/workflows/reusable-rust.yml
@@ -1,8 +1,9 @@
 # Clippy, coverage and documentation for the Rust crates in crates/. Each runs
 # as an independent job on a GitHub-hosted runner, but inside the same container
 # image used to build the crates in the C++/Corrosion path, so the toolchain
-# (and therefore the lints, coverage instrumentation and the cargo cache) matches
-# what production builds use.
+# (and therefore the lints and the cargo cache) matches what production builds
+# use. Coverage is the exception: it needs the nightly rustc that honours
+# #[coverage(off)], which the image carries alongside the pinned stable.
 #
 # Rust unit tests are deliberately NOT run here. They run as part of the C++
 # build (reusable-build-test-config.yml), which already compiles the crates on a
@@ -27,7 +28,7 @@ permissions:
 jobs:
   clippy:
     runs-on: ubuntu-latest
-    container: ghcr.io/xrplf/xrpld/nix-ubuntu:sha-473fe44
+    container: ghcr.io/xrplf/xrpld/nix-ubuntu:sha-060957e
     steps:
       - name: Checkout repository
         uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
@@ -40,11 +41,14 @@ jobs:
 
   coverage:
     runs-on: ubuntu-latest
-    container: ghcr.io/xrplf/xrpld/nix-ubuntu:sha-473fe44
+    container: ghcr.io/xrplf/xrpld/nix-ubuntu:sha-060957e
     steps:
       - name: Checkout repository
         uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
 
+      - name: Use the nightly Rust toolchain
+        run: rust-nightly path >>"${GITHUB_PATH}"
+
       - name: Use cargo artifacts cache
         uses: ./.github/actions/cargo-cache
 
@@ -53,7 +57,7 @@ jobs:
 
       - name: Upload coverage report
         if: ${{ github.repository == 'XRPLF/rippled' }}
-        uses: codecov/codecov-action@fb8b3582c8e4def4969c97caa2f19720cb33a72f # v7.0.0
+        uses: codecov/codecov-action@303a32d7a59b442fa8d48b6a1cc6825c09c847a5 # v7.1.1
         with:
           disable_search: true
           disable_telem: true
@@ -66,7 +70,7 @@ jobs:
 
   doc:
     runs-on: ubuntu-latest
-    container: ghcr.io/xrplf/xrpld/nix-ubuntu:sha-473fe44
+    container: ghcr.io/xrplf/xrpld/nix-ubuntu:sha-060957e
     steps:
       - name: Checkout repository
         uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
diff --git a/.github/workflows/reusable-upload-recipe.yml b/.github/workflows/reusable-upload-recipe.yml
index 6fa289665a..0511458e7f 100644
--- a/.github/workflows/reusable-upload-recipe.yml
+++ b/.github/workflows/reusable-upload-recipe.yml
@@ -40,7 +40,7 @@ defaults:
 jobs:
   upload:
     runs-on: ubuntu-latest
-    container: ghcr.io/xrplf/xrpld/nix-ubuntu:sha-473fe44
+    container: ghcr.io/xrplf/xrpld/nix-ubuntu:sha-060957e
     env:
       REMOTE_NAME: ${{ inputs.remote_name }}
       CONAN_LOGIN_USERNAME_XRPLF: ${{ secrets.remote_username }}
@@ -50,7 +50,7 @@ jobs:
         uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
 
       - name: Prepare runner
-        uses: XRPLF/actions/prepare-runner@7bf7ceca5932114abdd0d43493c3c30c5a654e13
+        uses: XRPLF/actions/prepare-runner@b3e255d74d785d053e4903da8ac90983cd7d9e82
         with:
           enable_ccache: false
 
diff --git a/.github/workflows/upload-conan-deps.yml b/.github/workflows/upload-conan-deps.yml
index 184f13cc5e..526b647429 100644
--- a/.github/workflows/upload-conan-deps.yml
+++ b/.github/workflows/upload-conan-deps.yml
@@ -68,7 +68,7 @@ jobs:
         uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
 
       - name: Prepare runner
-        uses: XRPLF/actions/prepare-runner@7bf7ceca5932114abdd0d43493c3c30c5a654e13
+        uses: XRPLF/actions/prepare-runner@b3e255d74d785d053e4903da8ac90983cd7d9e82
         with:
           enable_ccache: false
 
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index f223ab1684..7212214f01 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -53,6 +53,11 @@ repos:
         entry: ./bin/pre-commit/check_doxygen_style.py
         language: python
         types_or: [c++, c]
+      - id: fix-gtest-names
+        name: "fix gtest names: CamelCase suite, snake_case test case"
+        entry: ./bin/pre-commit/fix_gtest_names.py
+        language: python
+        types_or: [c++, c]
 
   - repo: https://github.com/pre-commit/mirrors-clang-format
     rev: f4d7745e17a28aad7eed2f4874ca8d1568c11c4c # frozen: v22.1.8
@@ -70,6 +75,11 @@ repos:
         language: system
         types: [rust]
         pass_filenames: false # rustfmt formats the whole workspace
+      - id: check-coverage-attrs
+        name: check Rust coverage attributes
+        entry: ./bin/pre-commit/check_rust_coverage_attrs.py
+        language: python
+        files: ^crates/.*\.rs$
 
   - repo: https://github.com/BlankSpruce/gersemi-pre-commit
     rev: e98930bdc210d3387007f9252d8c1694ea7e410f # frozen: 0.27.7
diff --git a/API-CHANGELOG.md b/API-CHANGELOG.md
index df58282f76..192aa7272e 100644
--- a/API-CHANGELOG.md
+++ b/API-CHANGELOG.md
@@ -22,14 +22,47 @@ API version 2 is available in `xrpld` version 2.0.0 and later. See [API-VERSION-
 
 This version is supported by all `xrpld` versions. For WebSocket and HTTP JSON-RPC requests, it is currently the default API version used when no `api_version` is specified.
 
-## Unreleased
+## XRP Ledger server version 3.4.0
 
-This section contains changes targeting a future version.
+Version 3.4.0 is not yet released. These changes are available in the 3.4.0 beta releases.
 
-### Additions
+### Additions in 3.4.0
+
+- `ledger`: `nftoken_id`, `nftoken_ids`, and `offer_id` are now included in transaction metadata when transactions are expanded (`expand`, or admin-only `full`), matching the `tx`, `account_tx`, and `subscribe` (`transactions` stream) responses. ([#5706](https://github.com/XRPLF/rippled/pull/5706))
+
+### Bugfixes in 3.4.0
+
+- `sign`, `sign_for`, `submit`: `signature_target` now returns `invalidParams` unless it names `CounterpartySignature` or `SponsorSignature`. It previously accepted any inner object field, such as `Book` or `NFToken`, and signed into it.
+- `sign`, `sign_for`, `submit`, `submit_multisigned`: With `fixCleanup3_4_0` enabled, a signature in `CounterpartySignature` or `SponsorSignature` covers a different prefix than the transaction's own signature, so a signature can no longer be moved from one of those roles into another. Clients that build these signatures themselves must use the new prefixes: `CPT` and `CPM` (single- and multi-signing) for `CounterpartySignature`, and `SPN` and `SPM` for `SponsorSignature`.
+- `get_aggregate_price`: Duplicate entries in the `oracles` request array are now ignored. [#6586](https://github.com/XRPLF/rippled/pull/6586)
+- `vault_info`: Errors now identify what the request got wrong instead of reporting every failure as the unregistered token `malformedRequest`, and the `error`, `error_code` and `error_message` fields now agree with each other. An invalid `vault_id` or `seq` returns `invalidParams`, an invalid `owner` returns `actMalformed`, and a request that mixes `vault_id` with `owner`/`seq` or supplies neither returns `invalidParams` with a message naming the accepted combinations. [#8015](https://github.com/XRPLF/rippled/pull/8015)
+- `vault_info`: A well-formed all-zero `vault_id` now returns `entryNotFound` instead of being rejected as malformed, and `entryNotFound` responses now include `error_code` and `error_message`. Clients that request `ripplerpc` 3.0 or above therefore receive HTTP 400 with that error rather than HTTP 200. [#8015](https://github.com/XRPLF/rippled/pull/8015)
+- `vault_info`: `vault_id` and `owner` must now be strings, matching how `ledger_entry` reads the same fields. An object or an array in either field previously produced an internal error, and a number was silently converted to its decimal text; `vault_id` now returns `invalidParams` and `owner` returns `actMalformed`. [#8015](https://github.com/XRPLF/rippled/pull/8015)
+- `gateway_balances`: The `account` and `ident` fields now return an `invalidParams` error if the value is not a string, instead of an `internal` error. [#7655](https://github.com/XRPLF/rippled/pull/7655)
+- `account_lines`: The `peer` field now returns an error if the value is not a string. [#7728](https://github.com/XRPLF/rippled/pull/7728)
+- `ledger`: `delivered_amount` is now included in the metadata of successful `AccountDelete` transactions when transactions are expanded (`expand`, or admin-only `full`). Previously it was only added for `Payment` and `CheckCash`, which made `ledger` inconsistent with `tx` and `account_tx`. [#5706](https://github.com/XRPLF/rippled/pull/5706)
+- `noripple_check`: The `transactions` field is no longer included in error responses; it is still returned (possibly as an empty array) whenever `transactions` is `true` and the request succeeds. A malformed `account` is now rejected before the ledger is looked up, so that error response no longer carries the `ledger_hash`, `ledger_index`, and `validated` fields ([#6303](https://github.com/XRPLF/rippled/pull/6303)).
+
+## XRP Ledger server version 3.3.0
+
+[Version 3.3.0](https://github.com/XRPLF/rippled/releases/tag/3.3.0) was released on Aug 6, 2026.
+
+### Additions in 3.3.0
+
+- `account_tx`: Added an optional `delegate` request object to filter delegated transactions. The object requires `delegate_filter`, which must be either `actor` for transactions owned by the requested account but signed by another account, or `authorizer` for transactions signed by the requested account on behalf of another account. The optional `counter_party` account narrows the results to a specific signer/delegate for `actor` or a specific owner/delegator for `authorizer`. Malformed `delegate`, `delegate_filter`, and `counter_party` values return standard invalid field errors, and invalid account IDs return `actMalformed`. When paginating delegate-filtered queries, a marker from a delegate-filtered query includes a `delegate` flag and is only valid for follow-up requests that also supply `delegate` (mixing marker conventions returns `invalidParams`). Because filtering is applied after the ledger scan, a page may contain fewer results than `limit` (possibly zero) while still returning a marker, so callers must continue until no marker is present. ([#6126](https://github.com/XRPLF/rippled/pull/6126))
+
+## XRP Ledger server version 3.2.1
+
+[Version 3.2.1](https://github.com/XRPLF/rippled/releases/tag/3.2.1) was released on Aug 1, 2026.
+
+This release contains bug fixes only and no API changes.
+
+## XRP Ledger server version 3.2.0
+
+[Version 3.2.0](https://github.com/XRPLF/rippled/releases/tag/3.2.0) was released on Jun 16, 2026.
+
+### Additions in 3.2.0
 
-- `account_tx`: Added an optional `delegate` request object to filter delegated transactions. The object requires `delegate_filter`, which must be either `actor` for transactions owned by the requested account but signed by another account, or `authorizer` for transactions signed by the requested account on behalf of another account. The optional `counter_party` account narrows the results to a specific signer/delegate for `actor` or a specific owner/delegator for `authorizer`. Malformed `delegate`, `delegate_filter`, and `counter_party` values return standard invalid field errors, and invalid account IDs return `actMalformed`.
-  When paginating delegate-filtered queries, a marker from a delegate-filtered query includes a `delegate` flag and is only valid for follow-up requests that also supply `delegate` (mixing marker conventions returns `invalidParams`). Because filtering is applied after the ledger scan, a page may contain fewer results than `limit` (possibly zero) while still returning a marker, so callers must continue until no marker is present.
 - `ledger_entry`, `account_objects`: The `Delegate` ledger entry now includes an optional `DestinationNode` field, which stores the index into the authorized account's owner directory. This field is present on entries created after bidirectional directory tracking was introduced and may appear in RPC responses for those entries. ([#6681](https://github.com/XRPLF/rippled/pull/6681))
 - `server_definitions`: Added the following new sections to the response ([#6321](https://github.com/XRPLF/rippled/pull/6321)):
   - `TRANSACTION_FORMATS`: Describes the fields and their optionality for each transaction type, including common fields shared across all transactions.
@@ -37,11 +70,9 @@ This section contains changes targeting a future version.
   - `TRANSACTION_FLAGS`: Maps transaction type names to their supported flags and flag values.
   - `LEDGER_ENTRY_FLAGS`: Maps ledger entry type names to their flags and flag values.
   - `ACCOUNT_SET_FLAGS`: Maps AccountSet flag names (asf flags) to their numeric values.
-- `ledger`: `nftoken_id`, `nftoken_ids`, and `offer_id` are now included in transaction metadata when transactions are expanded (`expand`, or admin-only `full`), matching the `tx`, `account_tx`, and `subscribe` (`transactions` stream) responses. ([#5706](https://github.com/XRPLF/rippled/pull/5706))
 
-### Bugfixes
+### Bugfixes in 3.2.0
 
-- `get_aggregate_price`: Duplicate entries in the `oracles` request array are now ignored. [#6586](https://github.com/XRPLF/rippled/pull/6586)
 - Peer Crawler: The `port` field in `overlay.active[]` now consistently returns an integer instead of a string for outbound peers. [#6318](https://github.com/XRPLF/rippled/pull/6318)
 - `ping`: The `ip` field is no longer returned as an empty string for proxied connections without a forwarded-for header. It is now omitted, consistent with the behavior for identified connections. [#6730](https://github.com/XRPLF/rippled/pull/6730)
 - gRPC `GetLedgerDiff`: Fixed error message that incorrectly said "base ledger not validated" when the desired ledger was not validated. [#6730](https://github.com/XRPLF/rippled/pull/6730)
@@ -53,12 +84,24 @@ This section contains changes targeting a future version.
 - `submit`: The `fail_hard` field now returns an error if the value is not a boolean. [#6529](https://github.com/XRPLF/rippled/pull/6529)
 - `subscribe`: The `taker` field in the `books` array now returns `actMalformed` instead of `badIssuer` if the value is not a valid account. [#6529](https://github.com/XRPLF/rippled/pull/6529)
 - Fixed a bug in `Forwarded` HTTP header parsing where the extracted IP address could be incorrect when no comma or semicolon delimiter follows the address. This could cause the server to misidentify a client's IP address when operating behind a reverse proxy. [#6529](https://github.com/XRPLF/rippled/pull/6529)
-- `vault_info`: Errors now identify what the request got wrong instead of reporting every failure as the unregistered token `malformedRequest`, and the `error`, `error_code` and `error_message` fields now agree with each other. An invalid `vault_id` or `seq` returns `invalidParams`, an invalid `owner` returns `actMalformed`, and a request that mixes `vault_id` with `owner`/`seq` or supplies neither returns `invalidParams` with a message naming the accepted combinations. [#8015](https://github.com/XRPLF/rippled/pull/8015)
-- `vault_info`: A well-formed all-zero `vault_id` now returns `entryNotFound` instead of being rejected as malformed, and `entryNotFound` responses now include `error_code` and `error_message`. Clients that request `ripplerpc` 3.0 or above therefore receive HTTP 400 with that error rather than HTTP 200. [#8015](https://github.com/XRPLF/rippled/pull/8015)
-- `vault_info`: `vault_id` and `owner` must now be strings, matching how `ledger_entry` reads the same fields. An object or an array in either field previously produced an internal error, and a number was silently converted to its decimal text; `vault_id` now returns `invalidParams` and `owner` returns `actMalformed`. [#8015](https://github.com/XRPLF/rippled/pull/8015)
-- `gateway_balances`: The `account` and `ident` fields now return an `invalidParams` error if the value is not a string, instead of an `internal` error. [#7655](https://github.com/XRPLF/rippled/pull/7655)
-- `account_lines`: The `peer` field now returns an error if the value is not a string. [#7728](https://github.com/XRPLF/rippled/pull/7728)
-- `ledger`: `delivered_amount` is now included in the metadata of successful `AccountDelete` transactions when transactions are expanded (`expand`, or admin-only `full`). Previously it was only added for `Payment` and `CheckCash`, which made `ledger` inconsistent with `tx` and `account_tx`. [#5706](https://github.com/XRPLF/rippled/pull/5706)
+
+## XRP Ledger server version 3.1.3
+
+[Version 3.1.3](https://github.com/XRPLF/rippled/releases/tag/3.1.3) was released on May 8, 2026.
+
+This release contains bug fixes only and no API changes.
+
+## XRP Ledger server version 3.1.2
+
+[Version 3.1.2](https://github.com/XRPLF/rippled/releases/tag/3.1.2) was released on Mar 12, 2026.
+
+This release contains bug fixes only and no API changes.
+
+## XRP Ledger server version 3.1.1
+
+[Version 3.1.1](https://github.com/XRPLF/rippled/releases/tag/3.1.1) was released on Feb 23, 2026.
+
+This release contains bug fixes only and no API changes.
 
 ## XRP Ledger server version 3.1.0
 
diff --git a/bin/check-tools.sh b/bin/check-tools.sh
index 8273375428..ed76861aa4 100755
--- a/bin/check-tools.sh
+++ b/bin/check-tools.sh
@@ -158,6 +158,7 @@ if [ "${os}" = "linux" ] || [ "${os}" = "macos" ]; then
     check cargo-nextest cargo nextest --version
     check clippy-driver
     check rust-analyzer
+    check rust-nightly rust-nightly run rustc --version
     check rustc
     check rustfmt
 fi
diff --git a/bin/install-packaging-tools.sh b/bin/install-packaging-tools.sh
index 36557364ae..0d1fce3055 100755
--- a/bin/install-packaging-tools.sh
+++ b/bin/install-packaging-tools.sh
@@ -25,7 +25,9 @@ esac
 # Packaging runs in a vanilla distro image, so the tooling comes from the distro's
 # archive rather than from nixpkgs:
 #
-#   - debhelper and dpkg-dev build the DEB
+#   - debhelper and dpkg-dev build the DEB, and lintian checks it
+#   - binutils gives debian/rules the readelf its glibc-floor check runs; it
+#     already arrives via dpkg-dev, but that tool is called directly
 #   - rpm-build builds the RPM, with systemd-rpm-macros and redhat-rpm-config
 #     supplying the systemd and find-debuginfo macros the spec uses
 #   - rpm-sign and gnupg2 sign the built RPM
@@ -37,11 +39,13 @@ function install() {
         debian | ubuntu)
             apt-get update -y
             apt-get install -y --no-install-recommends \
+                binutils \
                 ca-certificates \
                 debhelper \
                 debhelper-compat \
                 dpkg-dev \
                 git \
+                lintian \
                 python3
             ;;
 
diff --git a/bin/pre-commit/check_rust_coverage_attrs.py b/bin/pre-commit/check_rust_coverage_attrs.py
new file mode 100755
index 0000000000..dba56d5756
--- /dev/null
+++ b/bin/pre-commit/check_rust_coverage_attrs.py
@@ -0,0 +1,149 @@
+#!/usr/bin/env python3
+"""
+Check that Rust unit tests stay out of the coverage report.
+
+cargo-llvm-cov instruments the test code along with everything else, so a test
+module that is not excluded counts its own body as covered and inflates the
+reported number. Excluding it takes two attributes:
+
+  * every `#[cfg(test)]` module carries
+    `#[cfg_attr(coverage_nightly, coverage(off))]`;
+  * every crate root (lib.rs, main.rs) carries
+    `#![cfg_attr(coverage_nightly, feature(coverage_attribute))]`, which the
+    attribute above needs in order to compile.
+
+Both are inert outside the coverage job: cargo-llvm-cov defines
+`coverage_nightly` only when it runs on a nightly toolchain.
+
+The crate-root gate is checked even in a crate that has no tests yet, because
+that is what lets the first test module added later carry the attribute without
+a build failure. Missing it is a hard error, so it cannot go unnoticed; a
+missing `coverage(off)` fails open, which is why this check exists.
+
+Matching is on exact attribute text, which works because `cargo fmt` runs over
+the whole workspace in the hook ahead of this one: rustfmt puts every attribute
+on its own line and normalizes what is inside it, turning `#[cfg( test )]`
+and `#[cfg(test,)]` alike into `#[cfg(test)]`. So there is nothing here that
+parses Rust. The price is that a cfg this file does not spell out literally --
+`all(test, ...)`, `any(test, ...)`, `not(test)` -- is reported rather than
+classified, on the grounds that guessing at coverage semantics is how a check
+like this ends up quietly wrong.
+
+Usage: ./bin/pre-commit/check_rust_coverage_attrs.py <file1> <file2> ...
+
+Exit status is non-zero if any violation is found.
+"""
+
+import re
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+
+CRATE_ROOTS = {"lib.rs", "main.rs"}
+
+FEATURE_ATTR = "#![cfg_attr(coverage_nightly, feature(coverage_attribute))]"
+COVERAGE_OFF_ATTR = "#[cfg_attr(coverage_nightly, coverage(off))]"
+CFG_TEST_ATTR = "#[cfg(test)]"
+
+# Any other cfg that mentions `test`. String literals are blanked before this
+# runs, so `feature = "test"` does not read as the `test` cfg.
+RE_CFG_MENTIONS_TEST = re.compile(r"^#\[cfg\(.*\btest\b.*\)\]$")
+RE_STRING = re.compile(r'"(?:[^"\\]|\\.)*"')
+RE_MOD = re.compile(r"^(?:pub(?:\([^)]*\))?\s+)?mod\s+([A-Za-z_]\w*)")
+
+
+@dataclass(frozen=True)
+class Finding:
+    line: int
+    label: str
+    message: str
+
+
+def _check_module(attrs: list[str], line: int, name: str) -> list[Finding]:
+    """Findings for one module, given the attributes attached to it."""
+    if COVERAGE_OFF_ATTR in attrs:
+        return []  # excluded from coverage; which cfg gates it does not matter
+    if CFG_TEST_ATTR in attrs:
+        return [
+            Finding(
+                line,
+                "missing-coverage-off",
+                f"`mod {name}` is #[cfg(test)] but not excluded from coverage; "
+                f"add {COVERAGE_OFF_ATTR}",
+            )
+        ]
+    unclassified = [
+        attr for attr in attrs if RE_CFG_MENTIONS_TEST.match(RE_STRING.sub('""', attr))
+    ]
+    if unclassified:
+        return [
+            Finding(
+                line,
+                "unclassified-cfg",
+                f"`mod {name}` is gated on {unclassified[0]}, which this check "
+                f"cannot tell apart from a module that ships in the library; "
+                f"add {COVERAGE_OFF_ATTR} if it is test-only, or teach this "
+                f"check the cfg if it is not",
+            )
+        ]
+    return []
+
+
+def _check_test_modules(lines: list[str]) -> list[Finding]:
+    """Findings for every test module that is not excluded from coverage."""
+    findings: list[Finding] = []
+    attrs: list[str] = []
+    attrs_line = 0
+    for number, raw in enumerate(lines, start=1):
+        stripped = raw.strip()
+        # Blank lines and comments are allowed between an attribute and its item.
+        if not stripped or stripped.startswith("//"):
+            continue
+        if stripped.startswith("#["):
+            if not attrs:
+                attrs_line = number
+            attrs.append(stripped)
+            continue
+        module = RE_MOD.match(stripped)
+        if module is not None and attrs:
+            findings += _check_module(attrs, attrs_line, module.group(1))
+        attrs = []
+    return findings
+
+
+def _check_crate_root(name: str, lines: list[str]) -> list[Finding]:
+    """A finding if a crate root is missing the coverage_attribute feature gate."""
+    if name not in CRATE_ROOTS:
+        return []
+    if any(line.strip() == FEATURE_ATTR for line in lines):
+        return []
+    return [
+        Finding(
+            1,
+            "missing-feature-gate",
+            f"crate root is missing {FEATURE_ATTR}",
+        )
+    ]
+
+
+def check_source(name: str, text: str) -> list[Finding]:
+    """Findings for one file's contents; `name` is its base name (lib.rs, ...)."""
+    lines = text.splitlines()
+    return _check_crate_root(name, lines) + _check_test_modules(lines)
+
+
+def check_file(path: Path) -> list[Finding]:
+    return check_source(path.name, path.read_text(encoding="utf-8"))
+
+
+def main() -> int:
+    total = 0
+    for path in (Path(name) for name in sys.argv[1:]):
+        for finding in check_file(path):
+            total += 1
+            print(f"{path}:{finding.line}: {finding.label}: {finding.message}")
+    return 1 if total else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/bin/pre-commit/fix_gtest_names.py b/bin/pre-commit/fix_gtest_names.py
new file mode 100755
index 0000000000..7dbbdf63ba
--- /dev/null
+++ b/bin/pre-commit/fix_gtest_names.py
@@ -0,0 +1,144 @@
+#!/usr/bin/env python3
+
+"""
+Rewrites gtest names to the required style in this project: the suite name is
+CamelCase, the test-case name is snake_case.
+
+    TEST(SuiteName, test_case_name)
+
+The gtest `DISABLED_` prefix is kept verbatim on either name.
+
+Both conversions fold acronyms the way a reader expects:
+`SetAndResetAccountTxnID` -> `set_and_reset_account_txn_id`, not
+`set_and_reset_account_txn_i_d`.
+
+The first argument of `TEST_F`, `TEST_P`, `TYPED_TEST` and `TYPED_TEST_P` is a
+fixture class rather than a free identifier, so rewriting it here would leave
+the class it names behind. Those are reported for a human to rename (clang-tidy
+checks the class declaration itself, via readability-identifier-naming).
+
+Usage: ./bin/pre-commit/fix_gtest_names.py <file1> <file2> ...
+"""
+
+import re
+import sys
+from collections import Counter
+from pathlib import Path
+
+# A test-case definition, `MACRO(SuiteOrFixture, TestName)`, anchored at the
+# start of a line so that commented-out definitions and project macros that
+# merely look similar (`TEST_EXPECT(...)`) are left alone. The `\s*` between
+# arguments allows for a definition clang-format wrapped over several lines.
+PATTERN = re.compile(
+    r"(?P<head>^[ \t]*(?P<macro>TYPED_TEST_P|TYPED_TEST|TEST_F|TEST_P|TEST)\s*\(\s*)"
+    r"(?P<suite>\w+)(?P<mid>\s*,\s*)(?P<name>\w+)(?P<tail>\s*\))",
+    re.MULTILINE,
+)
+
+# The macros whose first argument names a fixture class, not a free identifier.
+FIXTURE_MACROS = ("TEST_F", "TEST_P", "TYPED_TEST", "TYPED_TEST_P")
+
+DISABLED = "DISABLED_"
+
+ACRONYM_BOUNDARY = re.compile(r"([A-Z]+)([A-Z][a-z])")
+WORD_BOUNDARY = re.compile(r"([a-z\d])([A-Z])")
+
+
+def _split_disabled(name: str) -> tuple[str, str]:
+    """Splits off gtest's `DISABLED_` prefix, which is kept verbatim."""
+    if name.startswith(DISABLED):
+        return DISABLED, name[len(DISABLED) :]
+    return "", name
+
+
+def snake_case(name: str) -> str:
+    """Returns the name in snake_case, leaving acronyms whole.
+
+    `SetAndResetAccountTxnID` -> `set_and_reset_account_txn_id`,
+    `parseStatRSSkB` -> `parse_stat_rs_sk_b`.
+    """
+    prefix, core = _split_disabled(name)
+    core = ACRONYM_BOUNDARY.sub(r"\1_\2", core)
+    return prefix + WORD_BOUNDARY.sub(r"\1_\2", core).lower()
+
+
+def camel_case(name: str) -> str:
+    """Returns the name in CamelCase, capitalizing each underscored word.
+
+    Only the letters that have to change are touched, so acronyms survive: a
+    conversion that went via snake_case would turn `SHAMapTest` into
+    `ShaMapTest`, whereas here it is already CamelCase and stays put.
+    `json_value` -> `JsonValue`, `parseStatRSSkB` -> `ParseStatRSSkB`.
+    """
+    prefix, core = _split_disabled(name)
+    return prefix + "".join(w[:1].upper() + w[1:] for w in core.split("_") if w)
+
+
+def _corrected(match: re.Match) -> tuple[str, str]:
+    """Returns the suite and test-case names this definition should end up with."""
+    suite = match["suite"]
+    return (
+        suite if match["macro"] in FIXTURE_MACROS else camel_case(suite),
+        snake_case(match["name"]),
+    )
+
+
+def fix_source(text: str) -> tuple[str, list[str]]:
+    """Returns the corrected text and one `line: message` report per bad name."""
+    # gtest joins the suite and test names into one class name, so two test
+    # cases whose joined names agree cannot coexist: `TEST(a, b_c)` and
+    # `TEST(a_b, c)` both define `a_b_c_Test`. A rename that would introduce
+    # such a clash is reported for a human instead of applied.
+    joined = Counter("_".join(_corrected(m)) for m in PATTERN.finditer(text))
+    reports = []
+
+    def rewrite(match: re.Match) -> str:
+        suite, name = match["suite"], match["name"]
+        new_suite, new_name = _corrected(match)
+        line = text.count("\n", 0, match.start()) + 1
+
+        if match["macro"] in FIXTURE_MACROS and camel_case(suite) != suite:
+            reports.append(
+                f"{line}: fixture '{suite}' is not CamelCase: rename the class "
+                f"to '{camel_case(suite)}' by hand"
+            )
+        if (new_suite, new_name) == (suite, name):
+            return match[0]
+        if joined[f"{new_suite}_{new_name}"] > 1:
+            reports.append(
+                f"{line}: cannot rename '{suite}, {name}' to '{new_suite}, "
+                f"{new_name}': another test case already generates that name"
+            )
+            return match[0]
+        if new_suite != suite:
+            reports.append(f"{line}: renamed suite '{suite}' to '{new_suite}'")
+        if new_name != name:
+            reports.append(f"{line}: renamed test case '{name}' to '{new_name}'")
+        return match["head"] + new_suite + match["mid"] + new_name + match["tail"]
+
+    return PATTERN.sub(rewrite, text), reports
+
+
+def fix_names(path: Path) -> bool:
+    """Corrects one file's gtest names, reporting each on stdout."""
+    original = path.read_text(encoding="utf-8")
+    fixed, reports = fix_source(original)
+    for report in reports:
+        print(f"{path}:{report}")
+    if fixed != original:
+        path.write_text(fixed, encoding="utf-8")
+    return not reports
+
+
+def main() -> int:
+    files = [Path(f) for f in sys.argv[1:]]
+    success = True
+
+    for path in files:
+        success &= fix_names(path)
+
+    return 0 if success else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/bin/pre-commit/test_fix_gtest_names.py b/bin/pre-commit/test_fix_gtest_names.py
new file mode 100755
index 0000000000..aa0481f795
--- /dev/null
+++ b/bin/pre-commit/test_fix_gtest_names.py
@@ -0,0 +1,259 @@
+#!/usr/bin/env python3
+"""
+Tests for fix_gtest_names.py.
+
+Run directly (no test framework needed):
+    ./bin/pre-commit/test_fix_gtest_names.py
+or under pytest:
+    pytest bin/pre-commit/test_fix_gtest_names.py
+"""
+
+import sys
+import textwrap
+
+from fix_gtest_names import camel_case, fix_source, snake_case
+
+
+def dedent(text: str) -> str:
+    """Removes a fixture's common indentation and its leading newline.
+
+    Lets fixtures be written as indented triple-quoted here-docs while keeping
+    honest 1-based line numbers.
+    """
+    return textwrap.dedent(text).lstrip("\n")
+
+
+def fixed(text: str) -> str:
+    return fix_source(dedent(text))[0]
+
+
+def reports(text: str) -> list[str]:
+    return fix_source(dedent(text))[1]
+
+
+# --- conversion --------------------------------------------------------------
+
+
+def test_snake_case_conversion() -> None:
+    assert snake_case("BadInputs") == "bad_inputs"
+    assert snake_case("mulDiv") == "mul_div"
+    assert snake_case("already_snake") == "already_snake"
+    assert snake_case("base64") == "base64"
+
+
+def test_snake_case_keeps_acronyms_whole() -> None:
+    assert snake_case("SetAndResetAccountTxnID") == "set_and_reset_account_txn_id"
+    assert snake_case("XRPToIOU") == "xrp_to_iou"
+    assert snake_case("STAmountMath") == "st_amount_math"
+
+
+def test_camel_case_conversion() -> None:
+    assert camel_case("json_value") == "JsonValue"
+    assert camel_case("mulDiv") == "MulDiv"
+    assert camel_case("scope") == "Scope"
+    assert camel_case("base64") == "Base64"
+
+
+def test_camel_case_leaves_acronyms_alone() -> None:
+    # A snake_case round-trip would give `ShaMapTest` / `ParseStatmRsSkB` here.
+    assert camel_case("SHAMapTest") == "SHAMapTest"
+    assert camel_case("parseStatmRSSkB") == "ParseStatmRSSkB"
+    assert camel_case("XRPAmount") == "XRPAmount"
+    assert camel_case("CSPRNG") == "CSPRNG"
+
+
+def test_disabled_prefix_preserved() -> None:
+    assert snake_case("DISABLED_FooBar") == "DISABLED_foo_bar"
+    assert snake_case("DISABLED_foo_bar") == "DISABLED_foo_bar"
+    assert snake_case("DISABLED_") == "DISABLED_"
+    assert camel_case("DISABLED_foo_bar") == "DISABLED_FooBar"
+    assert camel_case("DISABLED_") == "DISABLED_"
+
+
+# --- what counts as a test definition ---------------------------------------
+
+
+def test_all_macros_recognized() -> None:
+    code = """
+    TEST(Suite, oneName)
+    TEST_F(Fixture, twoName)
+    TEST_P(Fixture, threeName)
+    TYPED_TEST(Fixture, fourName)
+    TYPED_TEST_P(Fixture, fiveName)
+    """
+    assert fixed(code) == dedent("""
+        TEST(Suite, one_name)
+        TEST_F(Fixture, two_name)
+        TEST_P(Fixture, three_name)
+        TYPED_TEST(Fixture, four_name)
+        TYPED_TEST_P(Fixture, five_name)
+        """)
+
+
+def test_conforming_definitions_untouched() -> None:
+    code = """
+    TEST(AccountSet, bad_inputs)
+    TEST_F(MutexMakeTest, default_constructor)
+    TEST(SHAMap, DISABLED_slow_path)
+    """
+    assert reports(code) == []
+    assert fixed(code) == dedent(code)
+
+
+def test_lookalikes_ignored() -> None:
+    code = """
+    // TEST(Suite, notATest)
+    TEST_EXPECT(someCall())
+    TEST_EXPECTS(amount == value, amount.getText())
+    INSTANTIATE_TEST_SUITE_P(Prefix, Fixture, testValues());
+    auto x = TEST(Suite, notATest);
+    TYPED_TEST_SUITE(Fixture, MyTypes);
+    """
+    assert reports(code) == []
+    assert fixed(code) == dedent(code)
+
+
+def test_indented_and_wrapped_definitions() -> None:
+    code = """
+    namespace ripple {
+        TEST(Suite, indentedName)
+    }
+    TEST_F(
+        SomeVeryLongFixtureName,
+        wrappedName)
+    """
+    assert fixed(code) == dedent("""
+        namespace ripple {
+            TEST(Suite, indented_name)
+        }
+        TEST_F(
+            SomeVeryLongFixtureName,
+            wrapped_name)
+        """)
+
+
+# --- rewriting --------------------------------------------------------------
+
+
+def test_only_the_two_names_are_rewritten() -> None:
+    code = """
+    TEST(mulDiv, mulDiv)
+    {
+        auto const mulDiv = 1;  // mulDiv stays
+    }
+    """
+    assert fixed(code) == dedent("""
+        TEST(MulDiv, mul_div)
+        {
+            auto const mulDiv = 1;  // mulDiv stays
+        }
+        """)
+
+
+def test_suite_name_camel_cased() -> None:
+    code = """
+    TEST(json_value, limits)
+    TEST(scope, ScopeExit)
+    """
+    assert reports(code) == [
+        "1: renamed suite 'json_value' to 'JsonValue'",
+        "2: renamed suite 'scope' to 'Scope'",
+        "2: renamed test case 'ScopeExit' to 'scope_exit'",
+    ]
+    assert fixed(code) == dedent("""
+        TEST(JsonValue, limits)
+        TEST(Scope, scope_exit)
+        """)
+
+
+def test_fixture_reported_but_not_renamed() -> None:
+    # The first argument names a class, so only a human (or clang-tidy) can
+    # rename it; the test-case name is still fixed.
+    code = """
+    TEST_F(my_fixture, someTest)
+    """
+    assert reports(code) == [
+        "1: fixture 'my_fixture' is not CamelCase: rename the class to "
+        "'MyFixture' by hand",
+        "1: renamed test case 'someTest' to 'some_test'",
+    ]
+    assert fixed(code) == dedent("""
+        TEST_F(my_fixture, some_test)
+        """)
+
+
+def test_reports_carry_line_numbers() -> None:
+    code = """
+    #include <foo.h>
+
+    TEST(Suite, firstName)
+
+    TEST(Suite, secondName)
+    """
+    assert reports(code) == [
+        "3: renamed test case 'firstName' to 'first_name'",
+        "5: renamed test case 'secondName' to 'second_name'",
+    ]
+
+
+# --- collisions -------------------------------------------------------------
+
+
+def test_collision_reported_and_not_applied() -> None:
+    # Both would define `Suite_mul_div_Test`.
+    code = """
+    TEST(Suite, mulDiv)
+    TEST(Suite, mul_div)
+    """
+    assert reports(code) == [
+        "1: cannot rename 'Suite, mulDiv' to 'Suite, mul_div': another test "
+        "case already generates that name"
+    ]
+    assert fixed(code) == dedent(code)
+
+
+def test_collision_between_converging_suites() -> None:
+    # Both suites camel-case to `SuiteA`, so both would define
+    # `SuiteA_one_test_Test`.
+    code = """
+    TEST(SuiteA, oneTest)
+    TEST(Suite_a, one_test)
+    """
+    assert [r.split(":")[1].strip() for r in reports(code)] == [
+        "cannot rename 'SuiteA, oneTest' to 'SuiteA, one_test'",
+        "cannot rename 'Suite_a, one_test' to 'SuiteA, one_test'",
+    ]
+    assert fixed(code) == dedent(code)
+
+
+def test_same_name_in_different_suites_is_not_a_collision() -> None:
+    code = """
+    TEST(SuiteOne, mulDiv)
+    TEST(SuiteTwo, mulDiv)
+    """
+    assert fixed(code) == dedent("""
+        TEST(SuiteOne, mul_div)
+        TEST(SuiteTwo, mul_div)
+        """)
+
+
+def main() -> int:
+    tests = sorted(
+        (name, fn)
+        for name, fn in globals().items()
+        if name.startswith("test_") and callable(fn)
+    )
+    failed = 0
+    for name, fn in tests:
+        try:
+            fn()
+            print(f"PASS {name}")
+        except AssertionError as exc:
+            failed += 1
+            print(f"FAIL {name}: {exc!r}")
+    print(f"\n{len(tests) - failed}/{len(tests)} passed")
+    return 1 if failed else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/cmake/XrplPackaging.cmake b/cmake/XrplPackaging.cmake
index e2f7029ad2..0fdeae0d0d 100644
--- a/cmake/XrplPackaging.cmake
+++ b/cmake/XrplPackaging.cmake
@@ -44,12 +44,18 @@ else()
     set(pkg_type rpm)
 endif()
 
+# Unquoted below, so an empty value adds no argument at all.
+set(pkg_variant_option "")
+if(assert)
+    set(pkg_variant_option --variant=assert)
+endif()
+
 add_custom_target(
     package
     COMMAND
         ${CMAKE_SOURCE_DIR}/package/build_pkg.py --package-type=${pkg_type}
         --build-dir=${CMAKE_BINARY_DIR} --pkg-release=${pkg_release}
-        --channel=UNRELEASED
+        ${pkg_variant_option} --channel=UNRELEASED
     WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
     DEPENDS xrpld validator-keys
     COMMENT "Building Linux ${pkg_type} package"
diff --git a/conanfile.py b/conanfile.py
index 0683a3779f..52d4da4286 100644
--- a/conanfile.py
+++ b/conanfile.py
@@ -149,6 +149,7 @@ class Xrpl(ConanFile):
         self.requires("xxhash/0.8.3", transitive_headers=True)
 
     exports_sources = (
+        "bin/default-loader-path.sh",
         "CMakeLists.txt",
         "cfg/*",
         "cmake/*",
diff --git a/crates/Cargo.toml b/crates/Cargo.toml
index 0bb0e9c550..36c79f1752 100644
--- a/crates/Cargo.toml
+++ b/crates/Cargo.toml
@@ -8,6 +8,9 @@ cxx = { version = "1.0.198", features = ["c++20"] }
 [workspace.package]
 edition = "2024"
 
+[workspace.lints.rust]
+unexpected_cfgs = { level = "warn", check-cfg = [ 'cfg(coverage)', 'cfg(coverage_nightly)' ] }
+
 [profile.release]
 opt-level = 3
 overflow-checks = true
diff --git a/crates/hello_world/Cargo.toml b/crates/hello_world/Cargo.toml
index 2e5a329c9a..50f02cc95f 100644
--- a/crates/hello_world/Cargo.toml
+++ b/crates/hello_world/Cargo.toml
@@ -8,3 +8,6 @@ crate-type = ["staticlib"]
 
 [dependencies]
 cxx.workspace = true
+
+[lints]
+workspace = true
diff --git a/crates/hello_world/src/lib.rs b/crates/hello_world/src/lib.rs
index b1cb121fa0..6f69801a1d 100644
--- a/crates/hello_world/src/lib.rs
+++ b/crates/hello_world/src/lib.rs
@@ -1,3 +1,5 @@
+#![cfg_attr(coverage_nightly, feature(coverage_attribute))]
+
 #[cxx::bridge(namespace = "rs::hello_world")]
 mod ffi {
     extern "Rust" {
@@ -8,3 +10,14 @@ mod ffi {
 pub fn hello_world() -> String {
     "hello_world".to_string()
 }
+
+#[cfg(test)]
+#[cfg_attr(coverage_nightly, coverage(off))]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn hello_world_returns_hello_world() {
+        assert_eq!(hello_world(), "hello_world")
+    }
+}
diff --git a/docs/install.md b/docs/install.md
index 4c52b587b6..34606fbe11 100644
--- a/docs/install.md
+++ b/docs/install.md
@@ -6,7 +6,8 @@
 
 `xrpld` is published as DEB and RPM packages for 64-bit x86 Linux.
 Use APT on Debian-based distributions such as Debian and Ubuntu,
-and YUM on Red Hat-based distributions such as RHEL, AlmaLinux, and Rocky Linux.
+and DNF on Red Hat-based distributions such as RHEL, AlmaLinux, and Rocky Linux,
+where `yum` is a symlink to `dnf`.
 To build from source instead, see [BUILD.md](../BUILD.md).
 
 ## Release channels
@@ -81,7 +82,7 @@ wherever it appears in the repository configuration.
     sudo apt -y install xrpld
     ```
 
-### With the YUM package manager
+### With the DNF package manager
 
 1.  Add the XRPL Foundation package-signing key:
 
@@ -109,9 +110,23 @@ wherever it appears in the repository configuration.
 3.  Install the `xrpld` package:
 
     ```bash
-    sudo yum install -y xrpld
+    sudo dnf install -y xrpld
     ```
 
+### Optional: the assert-enabled build
+
+Every channel also carries `xrpld-assert` as a DEB, the same build with assertions
+enabled, for diagnosing a problem on a non-production server.
+It installs the same files as `xrpld` and replaces it, so install one or the other:
+
+```bash
+sudo apt -y install xrpld-assert # APT removes xrpld itself
+```
+
+Switching stops the service, since it is a removal and an installation rather than an upgrade,
+and APT starts it again.
+Install `xrpld` the same way to switch back.
+
 ## The xrpld service
 
 Both package managers install a systemd unit and enable it, so `xrpld` starts on boot.
@@ -121,7 +136,7 @@ Check whether it is already running:
 systemctl status xrpld.service
 ```
 
-The APT packages start it immediately as well; the YUM packages do not, so start it yourself:
+The DEB packages start it immediately as well; the RPM packages do not, so start it yourself:
 
 ```bash
 sudo systemctl start xrpld.service
diff --git a/include/xrpl/basics/StringUtilities.h b/include/xrpl/basics/StringUtilities.h
index e3b91c2f25..7cb67cb15b 100644
--- a/include/xrpl/basics/StringUtilities.h
+++ b/include/xrpl/basics/StringUtilities.h
@@ -162,4 +162,89 @@ toUInt64(std::string const& s);
 bool
 isProperlyFormedTomlDomain(std::string_view domain);
 
+/**
+ * Whether a view can be passed on as a C string.
+ *
+ * A reader given only data() stops at the first null, so the view must reach the
+ * terminating null. The test rebuilds the view from data() and compares: a view
+ * that stops earlier rebuilds longer, and so compares unequal.
+ *
+ * consteval because reading the byte after the view is only defined when @p str
+ * points into storage holding a null at or after its end, such as a string
+ * literal. An unterminated view is then a compile error, not an out-of-bounds
+ * read.
+ *
+ * @param str The view to test.
+ * @return Whether @p str is null-terminated. A view with no data is not.
+ */
+consteval bool
+isNullTerminated(std::string_view str)
+{
+    if (str.data() == nullptr)
+        return false;
+
+    // Reading past the view is the point, so the usual data() warning does not
+    // apply.
+    // NOLINTNEXTLINE(bugprone-suspicious-stringview-data-usage)
+    return std::string_view{str.data()} == str;
+}
+
+/**
+ * A string that is known to reach its terminating null.
+ *
+ * Converts to std::string_view, so it compares and hashes as one. Unlike a
+ * view, asCString() may be handed to a reader that expects a C string, such
+ * as json::StaticString.
+ *
+ * The only constructor is consteval and rejects a view that stops before the
+ * null, so the property holds by construction and no caller asserts it.
+ */
+class NullTerminatedView
+{
+public:
+    /**
+     * Build a view from one that reaches its terminating null.
+     *
+     * Explicit, so that a plain view cannot become a proof of termination by
+     * accident. The conversion the other way stays implicit.
+     *
+     * @param view The string to hold. Rejected at compile time if it stops
+     *        before its terminating null, or has no data.
+     */
+    explicit consteval NullTerminatedView(std::string_view view)
+        : data_(view.data()), size_(view.size())
+    {
+        if (!isNullTerminated(view))
+            throw "xrpl::NullTerminatedView : view does not reach a null";
+    }
+
+    constexpr
+    operator std::string_view() const noexcept
+    {
+        return view();
+    }
+
+    /**
+     * @return The string as a view.
+     */
+    [[nodiscard]] constexpr std::string_view
+    view() const noexcept
+    {
+        return {data_, size_};
+    }
+
+    /**
+     * @return The string as a C string. Never null.
+     */
+    [[nodiscard]] constexpr char const*
+    asCString() const noexcept
+    {
+        return data_;
+    }
+
+private:
+    char const* data_;
+    std::size_t size_;
+};
+
 }  // namespace xrpl
diff --git a/include/xrpl/basics/base_uint.h b/include/xrpl/basics/base_uint.h
index bee8b8b945..3786f28c6a 100644
--- a/include/xrpl/basics/base_uint.h
+++ b/include/xrpl/basics/base_uint.h
@@ -518,7 +518,7 @@ public:
      * The input must be precisely `2 * bytes` hexadecimal characters
      * long, with one exception: the value '0'.
      *
-     * @param sv A null-terminated string of hexadecimal characters
+     * @param sv A string of hexadecimal characters
      * @return true if the input was parsed properly; false otherwise.
      */
     [[nodiscard]] constexpr bool
diff --git a/include/xrpl/core/HashRouter.h b/include/xrpl/core/HashRouter.h
index 20aafecc5f..25e4df3d0d 100644
--- a/include/xrpl/core/HashRouter.h
+++ b/include/xrpl/core/HashRouter.h
@@ -34,7 +34,10 @@ enum class HashRouterFlags : std::uint16_t {
     PRIVATE4 = 0x0800,
     // Used in EscrowFinish.cpp
     PRIVATE5 = 0x1000,
-    PRIVATE6 = 0x2000
+    PRIVATE6 = 0x2000,
+    // Used in apply.cpp
+    PRIVATE7 = 0x4000,
+    PRIVATE8 = 0x8000
 };
 
 constexpr HashRouterFlags
diff --git a/include/xrpl/core/PerfLog.h b/include/xrpl/core/PerfLog.h
index dd78a8f9a6..0c544c9aa5 100644
--- a/include/xrpl/core/PerfLog.h
+++ b/include/xrpl/core/PerfLog.h
@@ -1,6 +1,7 @@
 #pragma once
 
 #include <xrpl/basics/Log.h>
+#include <xrpl/basics/StringUtilities.h>
 #include <xrpl/core/Job.h>
 #include <xrpl/json/json_value.h>
 
@@ -9,7 +10,8 @@
 #include <filesystem>
 #include <functional>
 #include <memory>
-#include <string>
+#include <span>
+#include <string_view>
 
 namespace beast {
 class Journal;
@@ -67,7 +69,7 @@ public:
      * @param requestId Unique identifier to track command
      */
     virtual void
-    rpcStart(std::string const& method, std::uint64_t requestId) = 0;
+    rpcStart(std::string_view method, std::uint64_t requestId) = 0;
 
     /**
      * Log successful finish of RPC call
@@ -76,7 +78,7 @@ public:
      * @param requestId Unique identifier to track command
      */
     virtual void
-    rpcFinish(std::string const& method, std::uint64_t requestId) = 0;
+    rpcFinish(std::string_view method, std::uint64_t requestId) = 0;
 
     /**
      * Log errored RPC call
@@ -85,7 +87,7 @@ public:
      * @param requestId Unique identifier to track command
      */
     virtual void
-    rpcError(std::string const& method, std::uint64_t requestId) = 0;
+    rpcError(std::string_view method, std::uint64_t requestId) = 0;
 
     /**
      * Log queued job
@@ -150,10 +152,20 @@ public:
 PerfLog::Setup
 setupPerfLog(Section const& section, std::filesystem::path const& configDir);
 
+/**
+ * @param methodNames The RPC methods to count, one counter per name. Reported
+ *        as JSON keys that borrow each name and read it as a C string, which is
+ *        why the parameter type requires one that reaches its terminating null.
+ *        The names must outlive the returned object, which holds views of them.
+ *        The range itself need not: it is copied.
+ *        Passed in rather than looked up here, so that this layer needs no
+ *        knowledge of the dispatch table.
+ */
 std::unique_ptr<PerfLog>
 makePerfLog(
     PerfLog::Setup const& setup,
     Application& app,
+    std::span<NullTerminatedView const> methodNames,
     beast::Journal journal,
     std::function<void()>&& signalStop);
 
@@ -161,7 +173,7 @@ template <typename Func, class Rep, class Period>
 auto
 measureDurationAndLog(
     Func&& func,
-    std::string const& actionDescription,
+    std::string_view actionDescription,
     std::chrono::duration<Rep, Period> maxDelay,
     beast::Journal const& journal)
 {
diff --git a/include/xrpl/ledger/entries/AMMEntry.h b/include/xrpl/ledger/entries/AMMEntry.h
new file mode 100644
index 0000000000..0c1c0fe629
--- /dev/null
+++ b/include/xrpl/ledger/entries/AMMEntry.h
@@ -0,0 +1,45 @@
+#pragma once
+
+#include <xrpl/basics/base_uint.h>
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/ledger/entries/SLEBase.h>
+#include <xrpl/protocol/Asset.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/LedgerFormats.h>
+
+namespace xrpl {
+
+template <typename ViewT>
+class AMMEntry : public SLEBase<ViewT, ltAMM>
+{
+public:
+    using Base = SLEBase<ViewT, ltAMM>;
+
+    // Inherit base constructors: adopt an existing SLE, or resolve one from a
+    // Keylet against the view.
+    using Base::Base;
+
+    explicit AMMEntry(
+        Asset const& issue1,
+        Asset const& issue2,
+        Base::ViewRefType view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::amm(issue1, issue2), view, j)
+    {
+    }
+
+    explicit AMMEntry(
+        uint256 const& ammID,
+        Base::ViewRefType view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::amm(ammID), view, j)
+    {
+    }
+};
+
+using AMMEntryR = AMMEntry<ReadView>;
+using AMMEntryW = AMMEntry<ApplyView>;
+
+}  // namespace xrpl
diff --git a/include/xrpl/ledger/entries/AccountRootEntry.h b/include/xrpl/ledger/entries/AccountRootEntry.h
new file mode 100644
index 0000000000..5555ea8c50
--- /dev/null
+++ b/include/xrpl/ledger/entries/AccountRootEntry.h
@@ -0,0 +1,35 @@
+#pragma once
+
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/ledger/entries/SLEBase.h>
+#include <xrpl/protocol/AccountID.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/LedgerFormats.h>
+
+namespace xrpl {
+
+template <typename ViewT>
+class AccountRootEntry : public SLEBase<ViewT, ltACCOUNT_ROOT>
+{
+public:
+    using Base = SLEBase<ViewT, ltACCOUNT_ROOT>;
+
+    // Inherit base constructors: adopt an existing SLE, or resolve one from a
+    // Keylet against the view.
+    using Base::Base;
+
+    explicit AccountRootEntry(
+        AccountID const& id,
+        Base::ViewRefType view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::account(id), view, j)
+    {
+    }
+};
+
+using AccountRootEntryR = AccountRootEntry<ReadView>;
+using AccountRootEntryW = AccountRootEntry<ApplyView>;
+
+}  // namespace xrpl
diff --git a/include/xrpl/ledger/entries/AmendmentsEntry.h b/include/xrpl/ledger/entries/AmendmentsEntry.h
new file mode 100644
index 0000000000..ce4dca7e80
--- /dev/null
+++ b/include/xrpl/ledger/entries/AmendmentsEntry.h
@@ -0,0 +1,33 @@
+#pragma once
+
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/ledger/entries/SLEBase.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/LedgerFormats.h>
+
+namespace xrpl {
+
+template <typename ViewT>
+class AmendmentsEntry : public SLEBase<ViewT, ltAMENDMENTS>
+{
+public:
+    using Base = SLEBase<ViewT, ltAMENDMENTS>;
+
+    // Inherit base constructors: adopt an existing SLE, or resolve one from a
+    // Keylet against the view.
+    using Base::Base;
+
+    explicit AmendmentsEntry(
+        Base::ViewRefType view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::amendments(), view, j)
+    {
+    }
+};
+
+using AmendmentsEntryR = AmendmentsEntry<ReadView>;
+using AmendmentsEntryW = AmendmentsEntry<ApplyView>;
+
+}  // namespace xrpl
diff --git a/include/xrpl/ledger/entries/BridgeEntry.h b/include/xrpl/ledger/entries/BridgeEntry.h
new file mode 100644
index 0000000000..a51fbe0c12
--- /dev/null
+++ b/include/xrpl/ledger/entries/BridgeEntry.h
@@ -0,0 +1,36 @@
+#pragma once
+
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/ledger/entries/SLEBase.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/LedgerFormats.h>
+#include <xrpl/protocol/STXChainBridge.h>
+
+namespace xrpl {
+
+template <typename ViewT>
+class BridgeEntry : public SLEBase<ViewT, ltBRIDGE>
+{
+public:
+    using Base = SLEBase<ViewT, ltBRIDGE>;
+
+    // Inherit base constructors: adopt an existing SLE, or resolve one from a
+    // Keylet against the view.
+    using Base::Base;
+
+    explicit BridgeEntry(
+        STXChainBridge const& bridge,
+        STXChainBridge::ChainType chainType,
+        Base::ViewRefType view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::bridge(bridge, chainType), view, j)
+    {
+    }
+};
+
+using BridgeEntryR = BridgeEntry<ReadView>;
+using BridgeEntryW = BridgeEntry<ApplyView>;
+
+}  // namespace xrpl
diff --git a/include/xrpl/ledger/entries/CheckEntry.h b/include/xrpl/ledger/entries/CheckEntry.h
new file mode 100644
index 0000000000..bf6a188ff5
--- /dev/null
+++ b/include/xrpl/ledger/entries/CheckEntry.h
@@ -0,0 +1,46 @@
+#pragma once
+
+#include <xrpl/basics/base_uint.h>
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/ledger/entries/SLEBase.h>
+#include <xrpl/protocol/AccountID.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/LedgerFormats.h>
+#include <xrpl/protocol/SeqProxy.h>
+
+namespace xrpl {
+
+template <typename ViewT>
+class CheckEntry : public SLEBase<ViewT, ltCHECK>
+{
+public:
+    using Base = SLEBase<ViewT, ltCHECK>;
+
+    // Inherit base constructors: adopt an existing SLE, or resolve one from a
+    // Keylet against the view.
+    using Base::Base;
+
+    explicit CheckEntry(
+        AccountID const& id,
+        SeqProxy const& seq,
+        Base::ViewRefType view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::check(id, seq), view, j)
+    {
+    }
+
+    explicit CheckEntry(
+        uint256 const& checkID,
+        Base::ViewRefType view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::check(checkID), view, j)
+    {
+    }
+};
+
+using CheckEntryR = CheckEntry<ReadView>;
+using CheckEntryW = CheckEntry<ApplyView>;
+
+}  // namespace xrpl
diff --git a/include/xrpl/ledger/entries/CredentialEntry.h b/include/xrpl/ledger/entries/CredentialEntry.h
new file mode 100644
index 0000000000..4b6a3386a1
--- /dev/null
+++ b/include/xrpl/ledger/entries/CredentialEntry.h
@@ -0,0 +1,47 @@
+#pragma once
+
+#include <xrpl/basics/Slice.h>
+#include <xrpl/basics/base_uint.h>
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/ledger/entries/SLEBase.h>
+#include <xrpl/protocol/AccountID.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/LedgerFormats.h>
+
+namespace xrpl {
+
+template <typename ViewT>
+class CredentialEntry : public SLEBase<ViewT, ltCREDENTIAL>
+{
+public:
+    using Base = SLEBase<ViewT, ltCREDENTIAL>;
+
+    // Inherit base constructors: adopt an existing SLE, or resolve one from a
+    // Keylet against the view.
+    using Base::Base;
+
+    explicit CredentialEntry(
+        AccountID const& subject,
+        AccountID const& issuer,
+        Slice const& credType,
+        Base::ViewRefType view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::credential(subject, issuer, credType), view, j)
+    {
+    }
+
+    explicit CredentialEntry(
+        uint256 const& credentialID,
+        Base::ViewRefType view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::credential(credentialID), view, j)
+    {
+    }
+};
+
+using CredentialEntryR = CredentialEntry<ReadView>;
+using CredentialEntryW = CredentialEntry<ApplyView>;
+
+}  // namespace xrpl
diff --git a/include/xrpl/ledger/entries/DIDEntry.h b/include/xrpl/ledger/entries/DIDEntry.h
new file mode 100644
index 0000000000..ee3eaf8153
--- /dev/null
+++ b/include/xrpl/ledger/entries/DIDEntry.h
@@ -0,0 +1,35 @@
+#pragma once
+
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/ledger/entries/SLEBase.h>
+#include <xrpl/protocol/AccountID.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/LedgerFormats.h>
+
+namespace xrpl {
+
+template <typename ViewT>
+class DIDEntry : public SLEBase<ViewT, ltDID>
+{
+public:
+    using Base = SLEBase<ViewT, ltDID>;
+
+    // Inherit base constructors: adopt an existing SLE, or resolve one from a
+    // Keylet against the view.
+    using Base::Base;
+
+    explicit DIDEntry(
+        AccountID const& account,
+        Base::ViewRefType view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::did(account), view, j)
+    {
+    }
+};
+
+using DIDEntryR = DIDEntry<ReadView>;
+using DIDEntryW = DIDEntry<ApplyView>;
+
+}  // namespace xrpl
diff --git a/include/xrpl/ledger/entries/DelegateEntry.h b/include/xrpl/ledger/entries/DelegateEntry.h
new file mode 100644
index 0000000000..de908d4dcd
--- /dev/null
+++ b/include/xrpl/ledger/entries/DelegateEntry.h
@@ -0,0 +1,36 @@
+#pragma once
+
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/ledger/entries/SLEBase.h>
+#include <xrpl/protocol/AccountID.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/LedgerFormats.h>
+
+namespace xrpl {
+
+template <typename ViewT>
+class DelegateEntry : public SLEBase<ViewT, ltDELEGATE>
+{
+public:
+    using Base = SLEBase<ViewT, ltDELEGATE>;
+
+    // Inherit base constructors: adopt an existing SLE, or resolve one from a
+    // Keylet against the view.
+    using Base::Base;
+
+    explicit DelegateEntry(
+        AccountID const& account,
+        AccountID const& authorizedAccount,
+        Base::ViewRefType view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::delegate(account, authorizedAccount), view, j)
+    {
+    }
+};
+
+using DelegateEntryR = DelegateEntry<ReadView>;
+using DelegateEntryW = DelegateEntry<ApplyView>;
+
+}  // namespace xrpl
diff --git a/include/xrpl/ledger/entries/DepositPreauthEntry.h b/include/xrpl/ledger/entries/DepositPreauthEntry.h
new file mode 100644
index 0000000000..783363084d
--- /dev/null
+++ b/include/xrpl/ledger/entries/DepositPreauthEntry.h
@@ -0,0 +1,58 @@
+#pragma once
+
+#include <xrpl/basics/Slice.h>
+#include <xrpl/basics/base_uint.h>
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/ledger/entries/SLEBase.h>
+#include <xrpl/protocol/AccountID.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/LedgerFormats.h>
+
+#include <set>
+#include <utility>
+
+namespace xrpl {
+
+template <typename ViewT>
+class DepositPreauthEntry : public SLEBase<ViewT, ltDEPOSIT_PREAUTH>
+{
+public:
+    using Base = SLEBase<ViewT, ltDEPOSIT_PREAUTH>;
+
+    // Inherit base constructors: adopt an existing SLE, or resolve one from a
+    // Keylet against the view.
+    using Base::Base;
+
+    explicit DepositPreauthEntry(
+        AccountID const& owner,
+        AccountID const& preauthorized,
+        Base::ViewRefType view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::depositPreauth(owner, preauthorized), view, j)
+    {
+    }
+
+    explicit DepositPreauthEntry(
+        AccountID const& owner,
+        std::set<std::pair<AccountID, Slice>> const& authCreds,
+        Base::ViewRefType view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::depositPreauth(owner, authCreds), view, j)
+    {
+    }
+
+    explicit DepositPreauthEntry(
+        uint256 const& preauthID,
+        Base::ViewRefType view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::depositPreauth(preauthID), view, j)
+    {
+    }
+};
+
+using DepositPreauthEntryR = DepositPreauthEntry<ReadView>;
+using DepositPreauthEntryW = DepositPreauthEntry<ApplyView>;
+
+}  // namespace xrpl
diff --git a/include/xrpl/ledger/entries/DirectoryNodeEntry.h b/include/xrpl/ledger/entries/DirectoryNodeEntry.h
new file mode 100644
index 0000000000..b57bec7348
--- /dev/null
+++ b/include/xrpl/ledger/entries/DirectoryNodeEntry.h
@@ -0,0 +1,50 @@
+#pragma once
+
+#include <xrpl/basics/base_uint.h>
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/ledger/entries/SLEBase.h>
+#include <xrpl/protocol/AccountID.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/LedgerFormats.h>
+
+#include <cstdint>
+
+namespace xrpl {
+
+template <typename ViewT>
+class DirectoryNodeEntry : public SLEBase<ViewT, ltDIR_NODE>
+{
+public:
+    using Base = SLEBase<ViewT, ltDIR_NODE>;
+
+    // Inherit base constructors: adopt an existing SLE, or resolve one from a
+    // Keylet against the view.
+    using Base::Base;
+
+    explicit DirectoryNodeEntry(
+        AccountID const& id,
+        Base::ViewRefType view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::ownerDir(id), view, j)
+    {
+    }
+
+    /**
+     * Resolve a specific page of the directory rooted at @p root.
+     */
+    explicit DirectoryNodeEntry(
+        uint256 const& root,
+        std::uint64_t index,
+        Base::ViewRefType view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::page(root, index), view, j)
+    {
+    }
+};
+
+using DirectoryNodeEntryR = DirectoryNodeEntry<ReadView>;
+using DirectoryNodeEntryW = DirectoryNodeEntry<ApplyView>;
+
+}  // namespace xrpl
diff --git a/include/xrpl/ledger/entries/EscrowEntry.h b/include/xrpl/ledger/entries/EscrowEntry.h
new file mode 100644
index 0000000000..9eb1418a4c
--- /dev/null
+++ b/include/xrpl/ledger/entries/EscrowEntry.h
@@ -0,0 +1,37 @@
+#pragma once
+
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/ledger/entries/SLEBase.h>
+#include <xrpl/protocol/AccountID.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/LedgerFormats.h>
+#include <xrpl/protocol/SeqProxy.h>
+
+namespace xrpl {
+
+template <typename ViewT>
+class EscrowEntry : public SLEBase<ViewT, ltESCROW>
+{
+public:
+    using Base = SLEBase<ViewT, ltESCROW>;
+
+    // Inherit base constructors: adopt an existing SLE, or resolve one from a
+    // Keylet against the view.
+    using Base::Base;
+
+    explicit EscrowEntry(
+        AccountID const& src,
+        SeqProxy const& seq,
+        Base::ViewRefType view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::escrow(src, seq), view, j)
+    {
+    }
+};
+
+using EscrowEntryR = EscrowEntry<ReadView>;
+using EscrowEntryW = EscrowEntry<ApplyView>;
+
+}  // namespace xrpl
diff --git a/include/xrpl/ledger/entries/FeeSettingsEntry.h b/include/xrpl/ledger/entries/FeeSettingsEntry.h
new file mode 100644
index 0000000000..66d61892e5
--- /dev/null
+++ b/include/xrpl/ledger/entries/FeeSettingsEntry.h
@@ -0,0 +1,33 @@
+#pragma once
+
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/ledger/entries/SLEBase.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/LedgerFormats.h>
+
+namespace xrpl {
+
+template <typename ViewT>
+class FeeSettingsEntry : public SLEBase<ViewT, ltFEE_SETTINGS>
+{
+public:
+    using Base = SLEBase<ViewT, ltFEE_SETTINGS>;
+
+    // Inherit base constructors: adopt an existing SLE, or resolve one from a
+    // Keylet against the view.
+    using Base::Base;
+
+    explicit FeeSettingsEntry(
+        Base::ViewRefType view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::feeSettings(), view, j)
+    {
+    }
+};
+
+using FeeSettingsEntryR = FeeSettingsEntry<ReadView>;
+using FeeSettingsEntryW = FeeSettingsEntry<ApplyView>;
+
+}  // namespace xrpl
diff --git a/include/xrpl/ledger/entries/LedgerHashesEntry.h b/include/xrpl/ledger/entries/LedgerHashesEntry.h
new file mode 100644
index 0000000000..ab54d820a1
--- /dev/null
+++ b/include/xrpl/ledger/entries/LedgerHashesEntry.h
@@ -0,0 +1,33 @@
+#pragma once
+
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/ledger/entries/SLEBase.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/LedgerFormats.h>
+
+namespace xrpl {
+
+template <typename ViewT>
+class LedgerHashesEntry : public SLEBase<ViewT, ltLEDGER_HASHES>
+{
+public:
+    using Base = SLEBase<ViewT, ltLEDGER_HASHES>;
+
+    // Inherit base constructors: adopt an existing SLE, or resolve one from a
+    // Keylet against the view.
+    using Base::Base;
+
+    explicit LedgerHashesEntry(
+        Base::ViewRefType view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::skip(), view, j)
+    {
+    }
+};
+
+using LedgerHashesEntryR = LedgerHashesEntry<ReadView>;
+using LedgerHashesEntryW = LedgerHashesEntry<ApplyView>;
+
+}  // namespace xrpl
diff --git a/include/xrpl/ledger/entries/LoanBrokerEntry.h b/include/xrpl/ledger/entries/LoanBrokerEntry.h
new file mode 100644
index 0000000000..77e6b660ed
--- /dev/null
+++ b/include/xrpl/ledger/entries/LoanBrokerEntry.h
@@ -0,0 +1,46 @@
+#pragma once
+
+#include <xrpl/basics/base_uint.h>
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/ledger/entries/SLEBase.h>
+#include <xrpl/protocol/AccountID.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/LedgerFormats.h>
+#include <xrpl/protocol/SeqProxy.h>
+
+namespace xrpl {
+
+template <typename ViewT>
+class LoanBrokerEntry : public SLEBase<ViewT, ltLOAN_BROKER>
+{
+public:
+    using Base = SLEBase<ViewT, ltLOAN_BROKER>;
+
+    // Inherit base constructors: adopt an existing SLE, or resolve one from a
+    // Keylet against the view.
+    using Base::Base;
+
+    explicit LoanBrokerEntry(
+        AccountID const& owner,
+        SeqProxy const& seq,
+        Base::ViewRefType view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::loanBroker(owner, seq), view, j)
+    {
+    }
+
+    explicit LoanBrokerEntry(
+        uint256 const& loanBrokerID,
+        Base::ViewRefType view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::loanBroker(loanBrokerID), view, j)
+    {
+    }
+};
+
+using LoanBrokerEntryR = LoanBrokerEntry<ReadView>;
+using LoanBrokerEntryW = LoanBrokerEntry<ApplyView>;
+
+}  // namespace xrpl
diff --git a/include/xrpl/ledger/entries/LoanEntry.h b/include/xrpl/ledger/entries/LoanEntry.h
new file mode 100644
index 0000000000..124c5915fc
--- /dev/null
+++ b/include/xrpl/ledger/entries/LoanEntry.h
@@ -0,0 +1,45 @@
+#pragma once
+
+#include <xrpl/basics/base_uint.h>
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/ledger/entries/SLEBase.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/LedgerFormats.h>
+#include <xrpl/protocol/SeqProxy.h>
+
+namespace xrpl {
+
+template <typename ViewT>
+class LoanEntry : public SLEBase<ViewT, ltLOAN>
+{
+public:
+    using Base = SLEBase<ViewT, ltLOAN>;
+
+    // Inherit base constructors: adopt an existing SLE, or resolve one from a
+    // Keylet against the view.
+    using Base::Base;
+
+    explicit LoanEntry(
+        uint256 const& loanBrokerID,
+        SeqProxy const& loanSeq,
+        Base::ViewRefType view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::loan(loanBrokerID, loanSeq), view, j)
+    {
+    }
+
+    explicit LoanEntry(
+        uint256 const& loanID,
+        Base::ViewRefType view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::loan(loanID), view, j)
+    {
+    }
+};
+
+using LoanEntryR = LoanEntry<ReadView>;
+using LoanEntryW = LoanEntry<ApplyView>;
+
+}  // namespace xrpl
diff --git a/include/xrpl/ledger/entries/MPTokenEntry.h b/include/xrpl/ledger/entries/MPTokenEntry.h
new file mode 100644
index 0000000000..dcd6c5adb1
--- /dev/null
+++ b/include/xrpl/ledger/entries/MPTokenEntry.h
@@ -0,0 +1,55 @@
+#pragma once
+
+#include <xrpl/basics/base_uint.h>
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/ledger/entries/SLEBase.h>
+#include <xrpl/protocol/AccountID.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/LedgerFormats.h>
+#include <xrpl/protocol/UintTypes.h>
+
+namespace xrpl {
+
+template <typename ViewT>
+class MPTokenEntry : public SLEBase<ViewT, ltMPTOKEN>
+{
+public:
+    using Base = SLEBase<ViewT, ltMPTOKEN>;
+
+    // Inherit base constructors: adopt an existing SLE, or resolve one from a
+    // Keylet against the view.
+    using Base::Base;
+
+    explicit MPTokenEntry(
+        MPTID const& issuanceID,
+        AccountID const& holder,
+        Base::ViewRefType view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::mptoken(issuanceID, holder), view, j)
+    {
+    }
+
+    explicit MPTokenEntry(
+        uint256 const& issuanceKey,
+        AccountID const& holder,
+        Base::ViewRefType view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::mptoken(issuanceKey, holder), view, j)
+    {
+    }
+
+    explicit MPTokenEntry(
+        uint256 const& mptokenKey,
+        Base::ViewRefType view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::mptoken(mptokenKey), view, j)
+    {
+    }
+};
+
+using MPTokenEntryR = MPTokenEntry<ReadView>;
+using MPTokenEntryW = MPTokenEntry<ApplyView>;
+
+}  // namespace xrpl
diff --git a/include/xrpl/ledger/entries/MPTokenIssuanceEntry.h b/include/xrpl/ledger/entries/MPTokenIssuanceEntry.h
new file mode 100644
index 0000000000..52dac53217
--- /dev/null
+++ b/include/xrpl/ledger/entries/MPTokenIssuanceEntry.h
@@ -0,0 +1,56 @@
+#pragma once
+
+#include <xrpl/basics/base_uint.h>
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/ledger/entries/SLEBase.h>
+#include <xrpl/protocol/AccountID.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/LedgerFormats.h>
+#include <xrpl/protocol/UintTypes.h>
+
+#include <cstdint>
+
+namespace xrpl {
+
+template <typename ViewT>
+class MPTokenIssuanceEntry : public SLEBase<ViewT, ltMPTOKEN_ISSUANCE>
+{
+public:
+    using Base = SLEBase<ViewT, ltMPTOKEN_ISSUANCE>;
+
+    // Inherit base constructors: adopt an existing SLE, or resolve one from a
+    // Keylet against the view.
+    using Base::Base;
+
+    explicit MPTokenIssuanceEntry(
+        std::uint32_t seq,
+        AccountID const& issuer,
+        Base::ViewRefType view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::mptokenIssuance(makeMptID(seq, issuer)), view, j)
+    {
+    }
+
+    explicit MPTokenIssuanceEntry(
+        MPTID const& issuanceID,
+        Base::ViewRefType view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::mptokenIssuance(issuanceID), view, j)
+    {
+    }
+
+    explicit MPTokenIssuanceEntry(
+        uint256 const& issuanceKey,
+        Base::ViewRefType view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::mptokenIssuance(issuanceKey), view, j)
+    {
+    }
+};
+
+using MPTokenIssuanceEntryR = MPTokenIssuanceEntry<ReadView>;
+using MPTokenIssuanceEntryW = MPTokenIssuanceEntry<ApplyView>;
+
+}  // namespace xrpl
diff --git a/include/xrpl/ledger/entries/NFTokenOfferEntry.h b/include/xrpl/ledger/entries/NFTokenOfferEntry.h
new file mode 100644
index 0000000000..a2e71652cd
--- /dev/null
+++ b/include/xrpl/ledger/entries/NFTokenOfferEntry.h
@@ -0,0 +1,46 @@
+#pragma once
+
+#include <xrpl/basics/base_uint.h>
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/ledger/entries/SLEBase.h>
+#include <xrpl/protocol/AccountID.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/LedgerFormats.h>
+#include <xrpl/protocol/SeqProxy.h>
+
+namespace xrpl {
+
+template <typename ViewT>
+class NFTokenOfferEntry : public SLEBase<ViewT, ltNFTOKEN_OFFER>
+{
+public:
+    using Base = SLEBase<ViewT, ltNFTOKEN_OFFER>;
+
+    // Inherit base constructors: adopt an existing SLE, or resolve one from a
+    // Keylet against the view.
+    using Base::Base;
+
+    explicit NFTokenOfferEntry(
+        AccountID const& owner,
+        SeqProxy const& seq,
+        Base::ViewRefType view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::nftokenOffer(owner, seq), view, j)
+    {
+    }
+
+    explicit NFTokenOfferEntry(
+        uint256 const& offerID,
+        Base::ViewRefType view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::nftokenOffer(offerID), view, j)
+    {
+    }
+};
+
+using NFTokenOfferEntryR = NFTokenOfferEntry<ReadView>;
+using NFTokenOfferEntryW = NFTokenOfferEntry<ApplyView>;
+
+}  // namespace xrpl
diff --git a/include/xrpl/ledger/entries/NFTokenPageEntry.h b/include/xrpl/ledger/entries/NFTokenPageEntry.h
new file mode 100644
index 0000000000..11701f17ea
--- /dev/null
+++ b/include/xrpl/ledger/entries/NFTokenPageEntry.h
@@ -0,0 +1,37 @@
+#pragma once
+
+#include <xrpl/basics/base_uint.h>
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/ledger/entries/SLEBase.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/Keylet.h>
+#include <xrpl/protocol/LedgerFormats.h>
+
+namespace xrpl {
+
+template <typename ViewT>
+class NFTokenPageEntry : public SLEBase<ViewT, ltNFTOKEN_PAGE>
+{
+public:
+    using Base = SLEBase<ViewT, ltNFTOKEN_PAGE>;
+
+    // Inherit base constructors: adopt an existing SLE, or resolve one from a
+    // Keylet against the view.
+    using Base::Base;
+
+    explicit NFTokenPageEntry(
+        Keylet const& page,
+        uint256 const& token,
+        Base::ViewRefType view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::nftokenPage(page, token), view, j)
+    {
+    }
+};
+
+using NFTokenPageEntryR = NFTokenPageEntry<ReadView>;
+using NFTokenPageEntryW = NFTokenPageEntry<ApplyView>;
+
+}  // namespace xrpl
diff --git a/include/xrpl/ledger/entries/NegativeUNLEntry.h b/include/xrpl/ledger/entries/NegativeUNLEntry.h
new file mode 100644
index 0000000000..9c61058622
--- /dev/null
+++ b/include/xrpl/ledger/entries/NegativeUNLEntry.h
@@ -0,0 +1,33 @@
+#pragma once
+
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/ledger/entries/SLEBase.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/LedgerFormats.h>
+
+namespace xrpl {
+
+template <typename ViewT>
+class NegativeUNLEntry : public SLEBase<ViewT, ltNEGATIVE_UNL>
+{
+public:
+    using Base = SLEBase<ViewT, ltNEGATIVE_UNL>;
+
+    // Inherit base constructors: adopt an existing SLE, or resolve one from a
+    // Keylet against the view.
+    using Base::Base;
+
+    explicit NegativeUNLEntry(
+        Base::ViewRefType view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::negativeUNL(), view, j)
+    {
+    }
+};
+
+using NegativeUNLEntryR = NegativeUNLEntry<ReadView>;
+using NegativeUNLEntryW = NegativeUNLEntry<ApplyView>;
+
+}  // namespace xrpl
diff --git a/include/xrpl/ledger/entries/OfferEntry.h b/include/xrpl/ledger/entries/OfferEntry.h
new file mode 100644
index 0000000000..2180d3c89c
--- /dev/null
+++ b/include/xrpl/ledger/entries/OfferEntry.h
@@ -0,0 +1,46 @@
+#pragma once
+
+#include <xrpl/basics/base_uint.h>
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/ledger/entries/SLEBase.h>
+#include <xrpl/protocol/AccountID.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/LedgerFormats.h>
+#include <xrpl/protocol/SeqProxy.h>
+
+namespace xrpl {
+
+template <typename ViewT>
+class OfferEntry : public SLEBase<ViewT, ltOFFER>
+{
+public:
+    using Base = SLEBase<ViewT, ltOFFER>;
+
+    // Inherit base constructors: adopt an existing SLE, or resolve one from a
+    // Keylet against the view.
+    using Base::Base;
+
+    explicit OfferEntry(
+        AccountID const& id,
+        SeqProxy const& seq,
+        Base::ViewRefType view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::offer(id, seq), view, j)
+    {
+    }
+
+    explicit OfferEntry(
+        uint256 const& offerID,
+        Base::ViewRefType view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::offer(offerID), view, j)
+    {
+    }
+};
+
+using OfferEntryR = OfferEntry<ReadView>;
+using OfferEntryW = OfferEntry<ApplyView>;
+
+}  // namespace xrpl
diff --git a/include/xrpl/ledger/entries/OracleEntry.h b/include/xrpl/ledger/entries/OracleEntry.h
new file mode 100644
index 0000000000..69013a2745
--- /dev/null
+++ b/include/xrpl/ledger/entries/OracleEntry.h
@@ -0,0 +1,38 @@
+#pragma once
+
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/ledger/entries/SLEBase.h>
+#include <xrpl/protocol/AccountID.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/LedgerFormats.h>
+
+#include <cstdint>
+
+namespace xrpl {
+
+template <typename ViewT>
+class OracleEntry : public SLEBase<ViewT, ltORACLE>
+{
+public:
+    using Base = SLEBase<ViewT, ltORACLE>;
+
+    // Inherit base constructors: adopt an existing SLE, or resolve one from a
+    // Keylet against the view.
+    using Base::Base;
+
+    explicit OracleEntry(
+        AccountID const& account,
+        std::uint32_t documentID,
+        Base::ViewRefType view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::oracle(account, documentID), view, j)
+    {
+    }
+};
+
+using OracleEntryR = OracleEntry<ReadView>;
+using OracleEntryW = OracleEntry<ApplyView>;
+
+}  // namespace xrpl
diff --git a/include/xrpl/ledger/entries/PayChannelEntry.h b/include/xrpl/ledger/entries/PayChannelEntry.h
new file mode 100644
index 0000000000..3540474633
--- /dev/null
+++ b/include/xrpl/ledger/entries/PayChannelEntry.h
@@ -0,0 +1,38 @@
+#pragma once
+
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/ledger/entries/SLEBase.h>
+#include <xrpl/protocol/AccountID.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/LedgerFormats.h>
+#include <xrpl/protocol/SeqProxy.h>
+
+namespace xrpl {
+
+template <typename ViewT>
+class PayChannelEntry : public SLEBase<ViewT, ltPAYCHAN>
+{
+public:
+    using Base = SLEBase<ViewT, ltPAYCHAN>;
+
+    // Inherit base constructors: adopt an existing SLE, or resolve one from a
+    // Keylet against the view.
+    using Base::Base;
+
+    explicit PayChannelEntry(
+        AccountID const& src,
+        AccountID const& dst,
+        SeqProxy const& seq,
+        Base::ViewRefType view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::payChannel(src, dst, seq), view, j)
+    {
+    }
+};
+
+using PayChannelEntryR = PayChannelEntry<ReadView>;
+using PayChannelEntryW = PayChannelEntry<ApplyView>;
+
+}  // namespace xrpl
diff --git a/include/xrpl/ledger/entries/PermissionedDomainEntry.h b/include/xrpl/ledger/entries/PermissionedDomainEntry.h
new file mode 100644
index 0000000000..0668a8f8b6
--- /dev/null
+++ b/include/xrpl/ledger/entries/PermissionedDomainEntry.h
@@ -0,0 +1,46 @@
+#pragma once
+
+#include <xrpl/basics/base_uint.h>
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/ledger/entries/SLEBase.h>
+#include <xrpl/protocol/AccountID.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/LedgerFormats.h>
+#include <xrpl/protocol/SeqProxy.h>
+
+namespace xrpl {
+
+template <typename ViewT>
+class PermissionedDomainEntry : public SLEBase<ViewT, ltPERMISSIONED_DOMAIN>
+{
+public:
+    using Base = SLEBase<ViewT, ltPERMISSIONED_DOMAIN>;
+
+    // Inherit base constructors: adopt an existing SLE, or resolve one from a
+    // Keylet against the view.
+    using Base::Base;
+
+    explicit PermissionedDomainEntry(
+        AccountID const& account,
+        SeqProxy const& seq,
+        Base::ViewRefType view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::permissionedDomain(account, seq), view, j)
+    {
+    }
+
+    explicit PermissionedDomainEntry(
+        uint256 const& domainID,
+        Base::ViewRefType view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::permissionedDomain(domainID), view, j)
+    {
+    }
+};
+
+using PermissionedDomainEntryR = PermissionedDomainEntry<ReadView>;
+using PermissionedDomainEntryW = PermissionedDomainEntry<ApplyView>;
+
+}  // namespace xrpl
diff --git a/include/xrpl/ledger/entries/RippleStateEntry.h b/include/xrpl/ledger/entries/RippleStateEntry.h
new file mode 100644
index 0000000000..f9bd8aa703
--- /dev/null
+++ b/include/xrpl/ledger/entries/RippleStateEntry.h
@@ -0,0 +1,48 @@
+#pragma once
+
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/ledger/entries/SLEBase.h>
+#include <xrpl/protocol/AccountID.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/Issue.h>
+#include <xrpl/protocol/LedgerFormats.h>
+#include <xrpl/protocol/UintTypes.h>
+
+namespace xrpl {
+
+template <typename ViewT>
+class RippleStateEntry : public SLEBase<ViewT, ltRIPPLE_STATE>
+{
+public:
+    using Base = SLEBase<ViewT, ltRIPPLE_STATE>;
+
+    // Inherit base constructors: adopt an existing SLE, or resolve one from a
+    // Keylet against the view.
+    using Base::Base;
+
+    explicit RippleStateEntry(
+        AccountID const& id0,
+        AccountID const& id1,
+        Currency const& currency,
+        Base::ViewRefType view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::trustLine(id0, id1, currency), view, j)
+    {
+    }
+
+    explicit RippleStateEntry(
+        AccountID const& id,
+        Issue const& issue,
+        Base::ViewRefType view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::trustLine(id, issue), view, j)
+    {
+    }
+};
+
+using RippleStateEntryR = RippleStateEntry<ReadView>;
+using RippleStateEntryW = RippleStateEntry<ApplyView>;
+
+}  // namespace xrpl
diff --git a/include/xrpl/ledger/entries/SLEBase.h b/include/xrpl/ledger/entries/SLEBase.h
new file mode 100644
index 0000000000..182e03b55d
--- /dev/null
+++ b/include/xrpl/ledger/entries/SLEBase.h
@@ -0,0 +1,503 @@
+#pragma once
+
+#include <xrpl/basics/base_uint.h>
+#include <xrpl/basics/contract.h>
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/beast/utility/instrumentation.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/protocol/Keylet.h>
+#include <xrpl/protocol/LedgerFormats.h>
+#include <xrpl/protocol/STLedgerEntry.h>
+
+#include <concepts>
+#include <memory>
+#include <stdexcept>
+#include <type_traits>
+#include <utility>
+
+namespace xrpl {
+
+// Concept to distinguish read-only vs writable view types
+template <typename V>
+concept IsWritableView = std::derived_from<V, ApplyView>;
+
+namespace detail {
+
+/**
+ * Resolves a keylet for a read-only entry.
+ *
+ * ReadView::read() on an ApplyView returns the underlying ledger's entry
+ * whenever the view is not already tracking one, while peek() installs the
+ * view's own copy and returns that. A read-only entry built with read()
+ * would therefore hold an SLE that goes stale the moment anything peeks the
+ * same key and modifies it. Resolve through peek() whenever the view really is
+ * an ApplyView, so every entry over that view shares one SLE.
+ *
+ * @note The const_cast is what makes reaching ApplyView::peek() possible, and
+ *       it is defined behavior only when the view really is a non-const
+ *       object that the caller merely observes through a const reference.
+ *       That holds for every production view today, but it is not a
+ *       guarantee the codebase makes: the unit tests already build
+ *       genuinely const ApplyView-derived objects (`Sandbox const` in
+ *       Directory_test.cpp and View_test.cpp, `PaymentSandbox const` in
+ *       TheoreticalQuality_test.cpp and View_test.cpp). Constructing a
+ *       read-only entry over one of those would be undefined behavior, so
+ *       do not, until #8069 removes the cast -- by giving ApplyView a
+ *       const-qualified peek(), which needs no amendment because
+ *       Action::Cache is invisible to apply(), visit() and metadata.
+ *
+ * @note Consequently a "read-only" entry over an ApplyView is not free of
+ *       side effects: peek() installs an Action::Cache entry in the apply
+ *       state table. That is benign for transaction metadata -- Cache entries
+ *       are skipped in ApplyStateTable::apply(), ::visit() and in metadata
+ *       generation -- but it does cost one deep SLE copy on first touch.
+ */
+inline SLE::const_pointer
+resolveEntry(ReadView const& view, Keylet const& key)
+{
+    // Safe only for a view that is not itself a const object -- see the
+    // note above. The entry holds a const reference because it does not
+    // modify the view, not because the view is const.
+    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-const-cast)
+    if (auto const applyView = dynamic_cast<ApplyView*>(const_cast<ReadView*>(&view)))
+        return applyView->peek(key);
+    return view.read(key);
+}
+
+}  // namespace detail
+
+/**
+ * View-parameterized base class for all ledger entries.
+ *
+ * SLEBase<ReadView>  — read-only:  holds shared_ptr<SLE const> + ReadView const&
+ * SLEBase<ApplyView> — writable:   holds shared_ptr<SLE> + ApplyView& + Keylet,
+ *                                   plus insert/update/erase operations
+ *
+ * Write-only members are gated by `requires` clauses, providing compile-time
+ * guarantees that read-only entries cannot mutate state.
+ *
+ * @tparam EntryType the ledger entry type this entry is statically bound to.
+ * Derived per-type entries pass their own type (e.g. ltACCOUNT_ROOT); the
+ * generic ReadOnlySLE / WritableSLE aliases leave it at ltANY, which opts out
+ * of the static type check. Binding the type here is what keeps an entry for
+ * one entry type from being constructed or converted from another -- see the
+ * converting constructor below.
+ *
+ * Derived classes should provide domain-specific accessors that hide
+ * implementation details of the underlying ledger entry format.
+ */
+template <typename ViewT, LedgerEntryType EntryType = ltANY>
+class SLEBase
+{
+public:
+    static constexpr bool kIsWritable = IsWritableView<ViewT>;
+
+    // The ledger entry type this entry is bound to, and whether that binding
+    // is meaningful (ltANY means "any type", i.e. no static check).
+    static constexpr LedgerEntryType kEntryType = EntryType;
+    static constexpr bool kIsTyped = (EntryType != ltANY);
+
+    // SLE pointer type: mutable for writable views, const for read-only
+    using SlePtrType = std::conditional_t<kIsWritable, SLE::pointer, SLE::const_pointer>;
+
+    // View reference type: ApplyView& for writable, ReadView const& for
+    // read-only
+    using ViewRefType = std::conditional_t<kIsWritable, ApplyView&, ReadView const&>;
+
+    // Non-virtual by design: these entries are parameterized on the view and
+    // entry type, never used polymorphically through a base pointer. A vptr
+    // would be 8 bytes of pure overhead on a type meant to be as cheap as the
+    // shared_ptr it wraps. See the static_assert below the class.
+    //
+    // The destructor is public because the ReadOnlySLE / WritableSLE aliases
+    // name this class directly and are used as value types. Since it is not
+    // virtual, never delete a derived entry through an SLEBase*.
+    ~SLEBase() = default;
+
+    SLEBase(SLEBase const&)
+        requires(!kIsWritable)
+    = default;
+    SLEBase(SLEBase&&) = default;
+    SLEBase&
+    operator=(SLEBase const&) = delete;
+    SLEBase&
+    operator=(SLEBase&&) = delete;
+    SLEBase() = delete;
+
+    // --- Constructors that adopt/resolve an SLE (public so the ReadOnlySLE /
+    //     WritableSLE aliases and the per-type entries can be built directly
+    //     from a keylet, or -- read-only only -- from an already-fetched
+    //     SLE). ---
+
+    /**
+     * Constructor for read-only context (adopt an already-fetched SLE).
+     *
+     * There is deliberately no writable equivalent: a writable entry needs
+     * a Keylet so that newSLE() can still build an entry when none exists,
+     * and that cannot be recovered from a null SLE.
+     */
+    explicit SLEBase(
+        SLE::const_pointer sle,
+        ViewRefType view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        requires(!kIsWritable)
+        : view_(view), sle_(std::move(sle)), j_(j)
+    {
+        XRPL_ASSERT(
+            !kIsTyped || !sle_ || sle_->getType() == kEntryType,
+            "xrpl::SLEBase::SLEBase : adopted SLE matches bound entry type");
+    }
+
+    /**
+     * Constructor for read-only context (read from view by keylet)
+     */
+    explicit SLEBase(
+        Keylet const& key,
+        ViewRefType view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        requires(!kIsWritable)
+        : view_(view), sle_(detail::resolveEntry(view, key)), j_(j)
+    {
+        XRPL_ASSERT(
+            !kIsTyped || key.type == kEntryType,
+            "xrpl::SLEBase::SLEBase : keylet matches bound entry type");
+    }
+
+    /**
+     * Converting constructor: writable → read-only.
+     *
+     * Enables implicit conversion from SLEBase<ApplyView> to
+     * SLEBase<ReadView>, so functions taking ReadOnlySLE const& can accept
+     * WritableSLE.
+     *
+     * Constrained to the same entry type (or to a ltANY target, i.e. widening
+     * a typed entry to a generic ReadOnlySLE). The constraint is load-bearing:
+     * this constructor is inherited into every per-type entry, and unconstrained
+     * it would bind any writable entry that slices to SLEBase, so an OfferEntryW
+     * would convert to an AccountRootEntryR with no cast at the call site.
+     */
+    template <typename OtherViewT, LedgerEntryType OtherType>
+    SLEBase(SLEBase<OtherViewT, OtherType> const& other)
+        requires(!kIsWritable && IsWritableView<OtherViewT> &&
+                 (OtherType == EntryType || EntryType == ltANY))
+        : view_(other.readView()), sle_(other.rawSle()), j_(other.journal())
+    {
+    }
+
+    /**
+     * Constructor for writable context (peek from view by keylet)
+     */
+    explicit SLEBase(
+        Keylet const& key,
+        ApplyView& view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        requires kIsWritable
+        : view_(view), key_(key), sle_(view_.peek(key)), j_(j)
+    {
+        XRPL_ASSERT(
+            !kIsTyped || key.type == kEntryType,
+            "xrpl::SLEBase::SLEBase : keylet matches bound entry type");
+    }
+
+    /**
+     * Constructor for writable context, for call sites that hold an
+     * ApplyViewContext (peek from ctx.view by keylet).
+     *
+     * ctx.tx is not retained: this exists purely so transactors can pass the
+     * context they already have instead of spelling out ctx.view. If an entry
+     * ever needs the applying transaction, store it here rather than adding
+     * another overload.
+     */
+    explicit SLEBase(
+        Keylet const& key,
+        ApplyViewContext const& ctx,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        requires kIsWritable
+        : SLEBase(key, ctx.view, j)
+    {
+    }
+
+    // --- Common interface (always available) ---
+
+    /**
+     * Returns true if the ledger entry exists
+     */
+    [[nodiscard]] bool
+    exists() const
+    {
+        return sle_ != nullptr;
+    }
+
+    /**
+     * Explicit conversion to bool for convenient existence checking
+     */
+    explicit
+    operator bool() const
+    {
+        return exists();
+    }
+
+    /**
+     * Returns the underlying SLE for read access.
+     *
+     * Prefer operator-> / operator* for field access; this is for the call
+     * sites that need the shared_ptr itself.
+     */
+    [[nodiscard]] SLE::const_pointer
+    rawSle() const
+    {
+        return sle_;
+    }
+
+    /**
+     * Returns the ledger entry type of this entry.
+     *
+     * For a per-type entry this is kEntryType, known at compile time and
+     * valid whether or not the entry exists. Only the generic ReadOnlySLE /
+     * WritableSLE aliases have to read it back out of the SLE.
+     *
+     * @throws std::logic_error for a generic (ltANY) entry if exists() is
+     *         false.
+     */
+    [[nodiscard]] LedgerEntryType
+    type() const
+    {
+        if constexpr (kIsTyped)
+        {
+            return kEntryType;
+        }
+        else
+        {
+            if (!exists())
+                Throw<std::logic_error>("xrpl::SLEBase::type : entry does not exist");
+            return sle_->getType();
+        }
+    }
+
+    /**
+     * Returns the keylet identifying this entry.
+     *
+     * Writable entries keep the keylet they were built from, so it is valid
+     * even before newSLE(). Read-only entries derive it from the SLE, which
+     * must therefore exist.
+     *
+     * @throws std::logic_error for a read-only entry if exists() is false.
+     */
+    [[nodiscard]] Keylet
+    keylet() const
+    {
+        if constexpr (kIsWritable)
+        {
+            return key_;
+        }
+        else
+        {
+            if (!exists())
+                Throw<std::logic_error>("xrpl::SLEBase::keylet : entry does not exist");
+            // Take the type from the SLE, not from kEntryType: the adopt-SLE
+            // constructor's type check is assert-only, so a Release build can
+            // be holding an SLE whose type disagrees with the binding, and the
+            // SLE is the one telling the truth.
+            return Keylet(sle_->getType(), sle_->key());
+        }
+    }
+
+    /**
+     * Returns the ledger key of this entry.
+     *
+     * @throws std::logic_error same as keylet(): for read-only entries,
+     *         if exists() is false.
+     */
+    [[nodiscard]] uint256
+    key() const
+    {
+        return keylet().key;
+    }
+
+    /**
+     * Returns the read view (always available; ApplyView inherits ReadView)
+     */
+    [[nodiscard]] ReadView const&
+    readView() const
+    {
+        return view_;
+    }
+
+    /**
+     * Const dereference operators (always available)
+     *
+     * @throws std::logic_error if exists() is false.
+     */
+    STLedgerEntry const*
+    operator->() const
+    {
+        if (!exists())
+            Throw<std::logic_error>("xrpl::SLEBase::operator-> : entry does not exist");
+        return sle_.get();
+    }
+
+    STLedgerEntry const&
+    operator*() const
+    {
+        if (!exists())
+            Throw<std::logic_error>("xrpl::SLEBase::operator* : entry does not exist");
+        return *sle_;
+    }
+
+    // --- Writable interface (compile-time gated) ---
+    //
+    // Everything that hands out mutable access (or mutates) is non-const, so
+    // that a `FooEntryW const&` is as inert as a `FooEntryR`. Use readView()
+    // when a const entry only needs to inspect the view.
+
+    /**
+     * Returns the underlying SLE for write access.
+     *
+     * Prefer operator-> / operator* for field access; this is for the call
+     * sites that need the shared_ptr itself.
+     */
+    [[nodiscard]] SlePtrType const&
+    mutableRawSle()
+        requires kIsWritable
+    {
+        return sle_;
+    }
+
+    /**
+     * Returns the apply view for write operations
+     */
+    [[nodiscard]] ApplyView&
+    applyView()
+        requires kIsWritable
+    {
+        return view_;
+    }
+
+    /**
+     * Mutable dereference operators
+     *
+     * @throws std::logic_error if exists() is false.
+     */
+    STLedgerEntry*
+    operator->()
+        requires kIsWritable
+    {
+        if (!exists())
+            Throw<std::logic_error>("xrpl::SLEBase::operator-> : entry does not exist");
+        return sle_.get();
+    }
+
+    STLedgerEntry&
+    operator*()
+        requires kIsWritable
+    {
+        if (!exists())
+            Throw<std::logic_error>("xrpl::SLEBase::operator* : entry does not exist");
+        return *sle_;
+    }
+
+    /**
+     * Inserts the entry into the view.
+     *
+     * @throws std::logic_error if exists() is false.
+     */
+    void
+    insert()
+        requires kIsWritable
+    {
+        if (!exists())
+            Throw<std::logic_error>("xrpl::SLEBase::insert : entry does not exist");
+        view_.insert(sle_);
+    }
+
+    /**
+     * Erases the entry from the view.
+     *
+     * Drops the SLE afterwards, so the entry reports !exists() and any
+     * further use throws here rather than either throwing from deep inside
+     * ApplyStateTable or -- worse -- silently succeeding. For an
+     * entry that already existed, ApplyStateTable::erase keeps holding this
+     * exact SLE and builds the DeletedNode's FinalFields from it, so a write
+     * through the entry after erase() would land in transaction metadata
+     * with no diagnostic at all.
+     *
+     * @throws std::logic_error if exists() is false.
+     */
+    void
+    erase()
+        requires kIsWritable
+    {
+        if (!exists())
+            Throw<std::logic_error>("xrpl::SLEBase::erase : entry does not exist");
+        view_.erase(sle_);
+        sle_ = nullptr;
+    }
+
+    /**
+     * @throws std::logic_error if exists() is false.
+     */
+    void
+    update()
+        requires kIsWritable
+    {
+        if (!exists())
+            Throw<std::logic_error>("xrpl::SLEBase::update : entry does not exist");
+        view_.update(sle_);
+    }
+
+    /**
+     * @throws std::logic_error if exists() is true: newSLE() would otherwise
+     *         silently discard the SLE already held.
+     */
+    void
+    newSLE()
+        requires kIsWritable
+    {
+        if (exists())
+            Throw<std::logic_error>("xrpl::SLEBase::newSLE : entry already exists");
+        sle_ = std::make_shared<SLE>(key_);
+    }
+
+    [[nodiscard]] beast::Journal
+    journal() const
+    {
+        return j_;
+    }
+
+protected:
+    ViewRefType view_;
+
+    // Keylet is only meaningful for writable views, which need it to build an
+    // SLE that does not exist yet; read-only entries derive it from the SLE.
+    struct Empty
+    {
+    };
+
+    // No default member initializer: Keylet is not default-constructible, so
+    // every writable constructor must initialize key_ explicitly.
+    [[no_unique_address]]
+    std::conditional_t<kIsWritable, Keylet, Empty> key_;
+
+    SlePtrType sle_{};
+    beast::Journal j_;
+};
+
+/**
+ * Generic (any-entry-type) SLE entries.
+ *
+ * Use these when the concrete ledger entry type is not known at a given site;
+ * otherwise prefer the per-type entries (e.g. AccountRootEntry.h), which
+ * additionally enforce the entry type at compile time.
+ *
+ *   SLE::const_pointer / SLE::const_ref  ->  ReadOnlySLE
+ *   SLE::pointer       / SLE::ref        ->  WritableSLE
+ */
+using ReadOnlySLE = SLEBase<ReadView>;
+using WritableSLE = SLEBase<ApplyView>;
+
+static_assert(
+    !std::is_polymorphic_v<ReadOnlySLE> && !std::is_polymorphic_v<WritableSLE>,
+    "SLEBase must stay a thin value type; it must not acquire a vtable");
+
+}  // namespace xrpl
diff --git a/include/xrpl/ledger/entries/SignerListEntry.h b/include/xrpl/ledger/entries/SignerListEntry.h
new file mode 100644
index 0000000000..f6f881cd69
--- /dev/null
+++ b/include/xrpl/ledger/entries/SignerListEntry.h
@@ -0,0 +1,35 @@
+#pragma once
+
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/ledger/entries/SLEBase.h>
+#include <xrpl/protocol/AccountID.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/LedgerFormats.h>
+
+namespace xrpl {
+
+template <typename ViewT>
+class SignerListEntry : public SLEBase<ViewT, ltSIGNER_LIST>
+{
+public:
+    using Base = SLEBase<ViewT, ltSIGNER_LIST>;
+
+    // Inherit base constructors: adopt an existing SLE, or resolve one from a
+    // Keylet against the view.
+    using Base::Base;
+
+    explicit SignerListEntry(
+        AccountID const& account,
+        Base::ViewRefType view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::signerList(account), view, j)
+    {
+    }
+};
+
+using SignerListEntryR = SignerListEntry<ReadView>;
+using SignerListEntryW = SignerListEntry<ApplyView>;
+
+}  // namespace xrpl
diff --git a/include/xrpl/ledger/entries/SponsorshipEntry.h b/include/xrpl/ledger/entries/SponsorshipEntry.h
new file mode 100644
index 0000000000..98445479d9
--- /dev/null
+++ b/include/xrpl/ledger/entries/SponsorshipEntry.h
@@ -0,0 +1,36 @@
+#pragma once
+
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/ledger/entries/SLEBase.h>
+#include <xrpl/protocol/AccountID.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/LedgerFormats.h>
+
+namespace xrpl {
+
+template <typename ViewT>
+class SponsorshipEntry : public SLEBase<ViewT, ltSPONSORSHIP>
+{
+public:
+    using Base = SLEBase<ViewT, ltSPONSORSHIP>;
+
+    // Inherit base constructors: adopt an existing SLE, or resolve one from a
+    // Keylet against the view.
+    using Base::Base;
+
+    explicit SponsorshipEntry(
+        AccountID const& sponsor,
+        AccountID const& sponsee,
+        Base::ViewRefType view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::sponsorship(sponsor, sponsee), view, j)
+    {
+    }
+};
+
+using SponsorshipEntryR = SponsorshipEntry<ReadView>;
+using SponsorshipEntryW = SponsorshipEntry<ApplyView>;
+
+}  // namespace xrpl
diff --git a/include/xrpl/ledger/entries/TicketEntry.h b/include/xrpl/ledger/entries/TicketEntry.h
new file mode 100644
index 0000000000..16d9a9f3d9
--- /dev/null
+++ b/include/xrpl/ledger/entries/TicketEntry.h
@@ -0,0 +1,46 @@
+#pragma once
+
+#include <xrpl/basics/base_uint.h>
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/ledger/entries/SLEBase.h>
+#include <xrpl/protocol/AccountID.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/LedgerFormats.h>
+#include <xrpl/protocol/SeqProxy.h>
+
+namespace xrpl {
+
+template <typename ViewT>
+class TicketEntry : public SLEBase<ViewT, ltTICKET>
+{
+public:
+    using Base = SLEBase<ViewT, ltTICKET>;
+
+    // Inherit base constructors: adopt an existing SLE, or resolve one from a
+    // Keylet against the view.
+    using Base::Base;
+
+    explicit TicketEntry(
+        AccountID const& id,
+        SeqProxy const& ticketSeq,
+        Base::ViewRefType view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::ticket(id, ticketSeq), view, j)
+    {
+    }
+
+    explicit TicketEntry(
+        uint256 const& ticketID,
+        Base::ViewRefType view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::ticket(ticketID), view, j)
+    {
+    }
+};
+
+using TicketEntryR = TicketEntry<ReadView>;
+using TicketEntryW = TicketEntry<ApplyView>;
+
+}  // namespace xrpl
diff --git a/include/xrpl/ledger/entries/VaultEntry.h b/include/xrpl/ledger/entries/VaultEntry.h
new file mode 100644
index 0000000000..897a9117b1
--- /dev/null
+++ b/include/xrpl/ledger/entries/VaultEntry.h
@@ -0,0 +1,46 @@
+#pragma once
+
+#include <xrpl/basics/base_uint.h>
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/ledger/entries/SLEBase.h>
+#include <xrpl/protocol/AccountID.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/LedgerFormats.h>
+#include <xrpl/protocol/SeqProxy.h>
+
+namespace xrpl {
+
+template <typename ViewT>
+class VaultEntry : public SLEBase<ViewT, ltVAULT>
+{
+public:
+    using Base = SLEBase<ViewT, ltVAULT>;
+
+    // Inherit base constructors: adopt an existing SLE, or resolve one from a
+    // Keylet against the view.
+    using Base::Base;
+
+    explicit VaultEntry(
+        AccountID const& owner,
+        SeqProxy const& seq,
+        Base::ViewRefType view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::vault(owner, seq), view, j)
+    {
+    }
+
+    explicit VaultEntry(
+        uint256 const& vaultID,
+        Base::ViewRefType view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::vault(vaultID), view, j)
+    {
+    }
+};
+
+using VaultEntryR = VaultEntry<ReadView>;
+using VaultEntryW = VaultEntry<ApplyView>;
+
+}  // namespace xrpl
diff --git a/include/xrpl/ledger/entries/XChainOwnedClaimIDEntry.h b/include/xrpl/ledger/entries/XChainOwnedClaimIDEntry.h
new file mode 100644
index 0000000000..9cec1fcec9
--- /dev/null
+++ b/include/xrpl/ledger/entries/XChainOwnedClaimIDEntry.h
@@ -0,0 +1,38 @@
+#pragma once
+
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/ledger/entries/SLEBase.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/LedgerFormats.h>
+#include <xrpl/protocol/STXChainBridge.h>
+
+#include <cstdint>
+
+namespace xrpl {
+
+template <typename ViewT>
+class XChainOwnedClaimIDEntry : public SLEBase<ViewT, ltXCHAIN_OWNED_CLAIM_ID>
+{
+public:
+    using Base = SLEBase<ViewT, ltXCHAIN_OWNED_CLAIM_ID>;
+
+    // Inherit base constructors: adopt an existing SLE, or resolve one from a
+    // Keylet against the view.
+    using Base::Base;
+
+    explicit XChainOwnedClaimIDEntry(
+        STXChainBridge const& bridge,
+        std::uint64_t seq,
+        Base::ViewRefType view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::xChainClaimID(bridge, seq), view, j)
+    {
+    }
+};
+
+using XChainOwnedClaimIDEntryR = XChainOwnedClaimIDEntry<ReadView>;
+using XChainOwnedClaimIDEntryW = XChainOwnedClaimIDEntry<ApplyView>;
+
+}  // namespace xrpl
diff --git a/include/xrpl/ledger/entries/XChainOwnedCreateAccountClaimIDEntry.h b/include/xrpl/ledger/entries/XChainOwnedCreateAccountClaimIDEntry.h
new file mode 100644
index 0000000000..e9494e702f
--- /dev/null
+++ b/include/xrpl/ledger/entries/XChainOwnedCreateAccountClaimIDEntry.h
@@ -0,0 +1,39 @@
+#pragma once
+
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/ledger/entries/SLEBase.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/LedgerFormats.h>
+#include <xrpl/protocol/STXChainBridge.h>
+
+#include <cstdint>
+
+namespace xrpl {
+
+template <typename ViewT>
+class XChainOwnedCreateAccountClaimIDEntry
+    : public SLEBase<ViewT, ltXCHAIN_OWNED_CREATE_ACCOUNT_CLAIM_ID>
+{
+public:
+    using Base = SLEBase<ViewT, ltXCHAIN_OWNED_CREATE_ACCOUNT_CLAIM_ID>;
+
+    // Inherit base constructors: adopt an existing SLE, or resolve one from a
+    // Keylet against the view.
+    using Base::Base;
+
+    explicit XChainOwnedCreateAccountClaimIDEntry(
+        STXChainBridge const& bridge,
+        std::uint64_t seq,
+        Base::ViewRefType view,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : Base(keylet::xChainCreateAccountClaimID(bridge, seq), view, j)
+    {
+    }
+};
+
+using XChainOwnedCreateAccountClaimIDEntryR = XChainOwnedCreateAccountClaimIDEntry<ReadView>;
+using XChainOwnedCreateAccountClaimIDEntryW = XChainOwnedCreateAccountClaimIDEntry<ApplyView>;
+
+}  // namespace xrpl
diff --git a/include/xrpl/ledger/helpers/CredentialHelpers.h b/include/xrpl/ledger/helpers/CredentialHelpers.h
index 6d235b4316..8b1c819bf4 100644
--- a/include/xrpl/ledger/helpers/CredentialHelpers.h
+++ b/include/xrpl/ledger/helpers/CredentialHelpers.h
@@ -14,7 +14,6 @@
 #include <xrpl/protocol/STVector256.h>
 #include <xrpl/protocol/TER.h>
 
-#include <cstdint>
 #include <memory>
 #include <set>
 #include <utility>
@@ -34,32 +33,6 @@ checkExpired(SLE const& sleCredential, NetClock::time_point const& closed);
 [[nodiscard]] TER
 deleteSLE(ApplyView& view, SLE::ref sleCredential, beast::Journal j);
 
-/**
- * @brief Remove credentials pinned to a pseudo-account's owner directory.
- *
- * Cleans up credentials that were linked to a pseudo-account (Vault, LoanBroker,
- * AMM), which such an account can neither accept nor delete. Only credentials
- * are removed; every other object is left in place. The walk visits at most
- * @p maxNodesToDelete directory entries and charges the ones it leaves alone
- * against that budget too, so a directory holding other objects yields fewer
- * than @p maxNodesToDelete deletions. On reaching the bound the result is
- * `tecINCOMPLETE` and the caller must propagate it so a later transaction
- * resumes.
- *
- * @param view Mutable ledger view.
- * @param pseudoAcct The pseudo-account whose directory is cleaned.
- * @param maxNodesToDelete Upper bound on directory entries processed in one call.
- * @param j Journal for diagnostics.
- * @return tesSUCCESS once no credentials remain, tecINCOMPLETE if the bound was
- *         reached, or a deletion error.
- */
-[[nodiscard]] TER
-deletePseudoAccountCredentials(
-    ApplyView& view,
-    AccountID const& pseudoAcct,
-    std::uint16_t maxNodesToDelete,
-    beast::Journal j);
-
 // Amendment and parameters checks for sfCredentialIDs field
 NotTEC
 checkFields(STTx const& tx, Rules const& rules, beast::Journal j);
diff --git a/include/xrpl/ledger/helpers/LendingHelpers.h b/include/xrpl/ledger/helpers/LendingHelpers.h
index f3fc82eacb..3887b10120 100644
--- a/include/xrpl/ledger/helpers/LendingHelpers.h
+++ b/include/xrpl/ledger/helpers/LendingHelpers.h
@@ -338,9 +338,9 @@ struct AccountingDeltas
     Number debtTotalDelta;
 };
 
-// Whole-life (pre-LendingProtocolV1_1) recognition model: interest is
-// recognized into AssetsTotal/DebtTotal up front, at origination.
-namespace accrual {
+// Instant interest recognition (pre-LendingProtocolV1_1): interest is
+// recognized into AssetsTotal/DebtTotal immediately, at origination.
+namespace instant_recognition {
 
 // LoanSet origination: what's added to Vault.AssetsTotal and LoanBroker.DebtTotal
 AccountingDeltas
@@ -362,7 +362,7 @@ loanVaultExposure(SLE::const_ref loanSle);
 AccountingDeltas
 loanPaymentDeltas(LoanPaymentParts const& parts);
 
-}  // namespace accrual
+}  // namespace instant_recognition
 
 // Cash-basis (LendingProtocolV1_1) recognition model: AssetsTotal/DebtTotal
 // are principal-only, interest is recognized only as it's actually paid.
@@ -381,7 +381,7 @@ loanPaymentDeltas(LoanPaymentParts const& parts);
 
 // Public dispatchers: pick cash_basis:: if featureLendingProtocolV1_1 is
 // enabled AND the Vault's LEVersion (VaultHelpers::getVaultVersion) is
-// VaultVersion::CashBasis, else accrual::. These are the only entry points
+// VaultVersion::CashBasis, else instant_recognition::. These are the only entry points
 // transactors call.
 AccountingDeltas
 loanOriginationDeltas(
diff --git a/include/xrpl/ledger/helpers/TokenHelpers.h b/include/xrpl/ledger/helpers/TokenHelpers.h
index 2a2f1b568e..12fa8a105e 100644
--- a/include/xrpl/ledger/helpers/TokenHelpers.h
+++ b/include/xrpl/ledger/helpers/TokenHelpers.h
@@ -38,6 +38,12 @@ enum class FreezeHandling { IgnoreFreeze, ZeroIfFrozen };
  */
 enum class AuthHandling { IgnoreAuth, ZeroIfUnauthorized };
 
+/**
+ * Controls whether the recipient owner-reserve check is enforced when
+ * auto-creating a trustline or MPToken during AMMWithdraw or AMMClawback.
+ */
+enum class ReserveHandling : bool { EnforceReserve, IgnoreReserve };
+
 /**
  * Controls whether to include the account's full spendable balance
  */
diff --git a/include/xrpl/ledger/helpers/VaultHelpers.h b/include/xrpl/ledger/helpers/VaultHelpers.h
index b42f349b95..acbcb8ec04 100644
--- a/include/xrpl/ledger/helpers/VaultHelpers.h
+++ b/include/xrpl/ledger/helpers/VaultHelpers.h
@@ -172,8 +172,8 @@ isSoleShareholder(ReadView const& view, AccountID const& account, SLE::const_ref
 
 /**
  * Resolves a Vault's LEVersion, the single point every accounting touch
- * point should call to determine which recognition model (accrual vs.
- * cash-basis) a Vault uses. Vaults created before featureLendingProtocolV1_1
+ * point should call to determine which recognition model (instant interest
+ * recognition vs. cash-basis) a Vault uses. Vaults created before featureLendingProtocolV1_1
  * activated never have sfLEVersion set, which resolves here to
  * VaultVersion::Legacy.
  *
diff --git a/include/xrpl/nodestore/detail/DatabaseNodeImp.h b/include/xrpl/nodestore/detail/DatabaseNodeImp.h
index 33a2e27939..9ba81a7323 100644
--- a/include/xrpl/nodestore/detail/DatabaseNodeImp.h
+++ b/include/xrpl/nodestore/detail/DatabaseNodeImp.h
@@ -92,7 +92,7 @@ public:
     void
     importDatabase(Database& source) override
     {
-        importInternal(*backend_.get(), source);
+        importInternal(*backend_, source);
     }
 
     void
diff --git a/include/xrpl/peerfinder/Config.h b/include/xrpl/peerfinder/Config.h
index 3326ae8a97..fa2d2d78e8 100644
--- a/include/xrpl/peerfinder/Config.h
+++ b/include/xrpl/peerfinder/Config.h
@@ -26,7 +26,8 @@ struct Config
     /**
      * The largest number of public peer slots to allow.
      * This includes both inbound and outbound, but does not include
-     * fixed peers.
+     * fixed peers. A configuration built by `makeConfig` always holds
+     * `maxPeers == inPeers + outPeers`.
      */
     std::size_t maxPeers{tuning::kDefaultMaxPeers};
 
diff --git a/include/xrpl/protocol/ConfidentialTransfer.h b/include/xrpl/protocol/ConfidentialTransfer.h
index ecf7970aba..5c52fb0ba3 100644
--- a/include/xrpl/protocol/ConfidentialTransfer.h
+++ b/include/xrpl/protocol/ConfidentialTransfer.h
@@ -6,6 +6,7 @@
 #include <xrpl/protocol/AccountID.h>
 #include <xrpl/protocol/SField.h>
 #include <xrpl/protocol/STInteger.h>  // IWYU pragma: keep
+#include <xrpl/protocol/STLedgerEntry.h>
 #include <xrpl/protocol/STObject.h>
 #include <xrpl/protocol/TER.h>
 #include <xrpl/protocol/UintTypes.h>
@@ -301,6 +302,87 @@ verifySchnorrProof(Slice const& pubKeySlice, Slice const& proofSlice, uint256 co
 NotTEC
 checkEncryptedAmountFormat(STObject const& object);
 
+/**
+ * @brief Checks whether a holder's issuer mirror is encrypted under the
+ * issuance's currently registered issuer key.
+ *
+ * Verifies that the holder's issuer mirror epoch matches the active issuer key
+ * epoch on the issuance. An absent mirror epoch defaults to epoch 0. A holder without an issuer
+ * mirror is considered stale, as there is no key anchor for future re-encryptions.
+ *
+ * @param issuance The MPTokenIssuance ledger object.
+ * @param mptoken  The holder's MPToken ledger object.
+ * @return true if the MPToken's issuer mirror is current. false if stale.
+ */
+[[nodiscard]] bool
+isIssuerMirrorCurrent(SLE const& issuance, SLE const& mptoken);
+
+/**
+ * @brief Checks whether a holder's auditor mirror is encrypted under the
+ * issuance's currently registered auditor key.
+ *
+ * Verifies that the holder's auditor mirror epoch matches the active auditor key
+ * epoch on the issuance. An absent mirror epoch defaults to epoch 0. An issuance
+ * without an auditor key requires no auditor mirror and is considered current.
+ *
+ * @param issuance The MPTokenIssuance ledger object.
+ * @param mptoken  The holder's MPToken ledger object.
+ * @return true if the auditor mirror is current or not required.
+ */
+[[nodiscard]] bool
+isAuditorMirrorCurrent(SLE const& issuance, SLE const& mptoken);
+
+/**
+ * @brief Checks whether each mirror a holder is required to have is encrypted
+ * under the issuance's currently registered ElGamal keys.
+ *
+ * Verifies that both the issuer mirror and the auditor mirror (if required)
+ * are current. This serves as a combined check, ensuring all necessary
+ * holder mirror epochs match the active key epochs on the issuance.
+ *
+ * @param issuance The MPTokenIssuance ledger object.
+ * @param mptoken  The holder's MPToken ledger object.
+ * @return true if the required mirrors are current.
+ */
+[[nodiscard]] bool
+areMirrorsCurrent(SLE const& issuance, SLE const& mptoken);
+
+/**
+ * @brief Set the holder's issuer mirror epoch to match the issuance's current issuer key epoch.
+ *
+ * Call this after writing the issuer mirror ciphertext under the issuance's
+ * currently registered issuer key, so that the mirror reads as current afterwards.
+ *
+ * @param issuance The MPTokenIssuance ledger object.
+ * @param mptoken  The holder's MPToken ledger entry to update.
+ */
+void
+setIssuerMirrorEpoch(SLE const& issuance, SLE& mptoken);
+
+/**
+ * @brief Set the holder's auditor mirror epoch to match the issuance's current auditor key epoch.
+ *
+ * Call this after writing the auditor mirror ciphertext under the issuance's
+ * currently registered auditor key. Does nothing when the holder has no auditor mirror.
+ *
+ * @param issuance The MPTokenIssuance ledger object.
+ * @param mptoken  The holder's MPToken ledger entry to update.
+ */
+void
+setAuditorMirrorEpoch(SLE const& issuance, SLE& mptoken);
+
+/**
+ * @brief Set the holder's MPToken mirror epochs to match the issuance's current key epochs.
+ *
+ * Call this after writing mirror ciphertexts under the issuance's currently
+ * registered keys, so that the mirrors read as current afterwards.
+ *
+ * @param issuance The MPTokenIssuance ledger object.
+ * @param mptoken  The holder's MPToken ledger entry to update.
+ */
+void
+setMirrorEpochs(SLE const& issuance, SLE& mptoken);
+
 /**
  * @brief Verifies revealed amount encryptions for all recipients.
  *
diff --git a/include/xrpl/protocol/HashPrefix.h b/include/xrpl/protocol/HashPrefix.h
index 9d4471d05c..e77e891b04 100644
--- a/include/xrpl/protocol/HashPrefix.h
+++ b/include/xrpl/protocol/HashPrefix.h
@@ -92,6 +92,26 @@ enum class HashPrefix : std::uint32_t {
      * Batch
      */
     Batch = detail::makeHashPrefix('B', 'C', 'H'),
+
+    /**
+     * inner transaction to sign as the counterparty
+     */
+    CounterpartyTxSign = detail::makeHashPrefix('C', 'P', 'T'),
+
+    /**
+     * inner transaction to multi-sign as the counterparty
+     */
+    CounterpartyTxMultiSign = detail::makeHashPrefix('C', 'P', 'M'),
+
+    /**
+     * inner transaction to sign as the sponsor
+     */
+    SponsorTxSign = detail::makeHashPrefix('S', 'P', 'N'),
+
+    /**
+     * inner transaction to multi-sign as the sponsor
+     */
+    SponsorTxMultiSign = detail::makeHashPrefix('S', 'P', 'M'),
 };
 
 template <class Hasher>
diff --git a/include/xrpl/protocol/PathAsset.h b/include/xrpl/protocol/PathAsset.h
index ebf6fb68a4..02de9aa7df 100644
--- a/include/xrpl/protocol/PathAsset.h
+++ b/include/xrpl/protocol/PathAsset.h
@@ -5,9 +5,11 @@
 #include <xrpl/protocol/Concepts.h>
 #include <xrpl/protocol/UintTypes.h>
 
+#include <cstdint>
 #include <ostream>
 #include <stdexcept>
 #include <string>
+#include <type_traits>
 #include <variant>
 
 namespace xrpl {
@@ -121,9 +123,32 @@ operator==(PathAsset const& lhs, PathAsset const& rhs)
 
 template <typename Hasher>
 void
-hash_append(Hasher& h, PathAsset const& pathAsset)
+hash_append(Hasher& h, PathAsset const& pathAsset) noexcept
 {
-    std::visit([&]<ValidPathAsset T>(T const& e) { hash_append(h, e); }, pathAsset.value());
+    using beast::hash_append;
+    using Variant = std::remove_cvref_t<decltype(pathAsset.value())>;
+
+    static_assert(
+        std::variant_size_v<Variant> < 0xFFu,
+        "PathAsset's discriminant must fit in a byte, leaving 0xFF reserved.");
+
+    // std::visit is not noexcept: it throws bad_variant_access when the variant
+    // is valueless_by_exception.
+    if (pathAsset.value().valueless_by_exception()) [[unlikely]]
+    {
+        hash_append(h, static_cast<std::uint8_t>(0xFFu));
+        return;
+    }
+
+    hash_append(h, static_cast<std::uint8_t>(pathAsset.value().index()));
+    std::visit(
+        [&]<ValidPathAsset T>(T const& e) noexcept {
+            static_assert(
+                noexcept(hash_append(h, e)),
+                "Every PathAsset alternative must be nothrow-hashable.");
+            hash_append(h, e);
+        },
+        pathAsset.value());
 }
 
 inline bool
diff --git a/include/xrpl/protocol/Protocol.h b/include/xrpl/protocol/Protocol.h
index 8edd4bf4fd..61f246c752 100644
--- a/include/xrpl/protocol/Protocol.h
+++ b/include/xrpl/protocol/Protocol.h
@@ -12,6 +12,7 @@
 #include <chrono>
 #include <cstddef>
 #include <cstdint>
+#include <limits>
 
 namespace xrpl {
 
@@ -321,7 +322,7 @@ constexpr std::uint8_t kVaultMaximumIouScale = 18;
  * Vault ledger-entry schema versions. Assigned to newly created
  * Vaults once featureLendingProtocolV1_1 is enabled. Vaults created before
  * activation are left without LEVersion (implicit legacy version 0,
- * accrual-basis accounting).
+ * instant interest recognition).
  */
 enum class VaultVersion : uint8_t {
     Legacy = 0,
@@ -407,16 +408,6 @@ using TxID = uint256;
  */
 constexpr std::uint16_t kMaxDeletableAmmTrustLines = 512;
 
-/**
- * The maximum number of owner-directory entries to walk when clearing
- * credentials pinned to a pseudo-account, in a single transaction.
- *
- * The walk stops after this many entries whether or not each one turns out to
- * be a credential, so a directory that also holds other objects yields fewer
- * deletions per transaction.
- */
-constexpr std::uint16_t kMaxDeletablePseudoAccountCredentials = 512;
-
 /**
  * The maximum length of a URI inside an Oracle
  */
@@ -549,11 +540,21 @@ constexpr std::size_t kEcConvertBackProofLength =
  */
 constexpr std::size_t kEcClawbackProofLength = SECP256K1_COMPACT_CLAWBACK_PROOF_SIZE;
 
+/**
+ * Length of compact equality proof.
+ */
+constexpr std::size_t kEcEqualityProofLength = 128;
+
 /**
  * Extra base fee multiplier charged to confidential MPT transactions.
  */
 constexpr std::uint32_t kConfidentialFeeMultiplier = 9;
 
+/**
+ * Maximum value a confidential MPT key epoch may reach.
+ */
+constexpr std::uint32_t kMaxKeyEpoch = std::numeric_limits<std::uint32_t>::max();
+
 /**
  * Compressed EC point prefix for even y-coordinate
  */
diff --git a/include/xrpl/protocol/STPathSet.h b/include/xrpl/protocol/STPathSet.h
index 5768721111..b91d899071 100644
--- a/include/xrpl/protocol/STPathSet.h
+++ b/include/xrpl/protocol/STPathSet.h
@@ -12,6 +12,8 @@
 #include <xrpl/protocol/UintTypes.h>
 
 #include <cstddef>
+#include <cstdint>
+#include <memory>
 #include <optional>
 #include <utility>
 #include <vector>
@@ -65,7 +67,7 @@ public:
         PathAsset const& asset,
         AccountID const& issuer);
 
-    [[nodiscard]] auto
+    [[nodiscard]] std::uint32_t
     getNodeType() const;
 
     [[nodiscard]] bool
@@ -109,9 +111,6 @@ public:
     [[nodiscard]] bool
     isType(Type const& pe) const;
 
-    [[nodiscard]] size_t
-    getHash() const;
-
     bool
     operator==(STPathElement const& t) const;
 
@@ -120,6 +119,17 @@ private:
     getHash(STPathElement const& element);
 };
 
+template <class Hasher>
+void
+hash_append(Hasher& h, STPathElement const& e) noexcept
+{
+    using beast::hash_append;
+    hash_append(h, (e.getNodeType() & STPathElement::TypeAccount) != 0u);
+    hash_append(h, e.getAccountID());
+    hash_append(h, e.getPathAsset());
+    hash_append(h, e.getIssuerID());
+}
+
 class STPath final : public CountedObject<STPath>
 {
     std::vector<STPathElement> path_;
@@ -176,9 +186,10 @@ template <class Hasher>
 void
 hash_append(Hasher& h, STPath const& p) noexcept
 {
+    using beast::hash_append;
     for (auto const& e : p)
     {
-        beast::hash_append(h, e.getHash());
+        hash_append(h, e);
     }
 }
 
@@ -188,13 +199,39 @@ hash_append(Hasher& h, STPath const& p) noexcept
 class STPathSet final : public STBase, public CountedObject<STPathSet>
 {
     std::vector<STPath> value_;
-    xrpl::hardened_hash_set<STPath> seenHashes_;
+
+    /**
+     * Deduplication index over `value_`, for pathfinding.
+     * The use of a std::unique_ptr is intentional as it
+     * only requires 8 additional bytes of storage for the pointer
+     * as opposed to 64 bytes with an optional.  This keeps the size
+     * of the STPathSet to within the `STVar::kMaxSize` limit of 72 bytes.
+     */
+    std::unique_ptr<hardened_hash_set<STPath>> seen_;
 
 public:
+    struct DeduplicationTag
+    {
+    };
+
     STPathSet() = default;
+    /**
+     * Deduplication tagged constructor.
+     * Use when you want to ensure that the STPathSet does not contain duplicate paths.
+     */
+    explicit STPathSet(DeduplicationTag);
 
     STPathSet(SField const& n);
     STPathSet(SerialIter& sit, SField const& name);
+    STPathSet(STPathSet const& other);
+    STPathSet(STPathSet&&) = default;
+
+    STPathSet&
+    operator=(STPathSet const& other);
+    STPathSet&
+    operator=(STPathSet&&) = default;
+
+    ~STPathSet() override = default;
 
     void
     add(Serializer& s) const override;
@@ -204,6 +241,16 @@ public:
     [[nodiscard]] SerializedTypeID
     getSType() const override;
 
+    /**
+     * @brief assembleAdd adds a path to the set by combining a base path and a tail element.
+     *
+     * @param base The base path.
+     * @param tail The tail element.
+     * @return true if the path was added, false if it was a duplicate and not added.
+     * @remarks Requires the STPathSet to be constructed with the DeduplicationTag. The return value
+     * indicates whether the combined path was inserted (true) or rejected as a duplicate (false).
+     * It is fine for callers to ignore the return value.
+     */
     bool
     assembleAdd(STPath const& base, STPathElement const& tail);
 
@@ -229,22 +276,61 @@ public:
     [[nodiscard]] bool
     empty() const;
 
-    void
+    /**
+     * @brief pushBack adds a path to the set.
+     *
+     * @param e The path to add.
+     * @return true if the path was added, false if it was a duplicate and not added.
+     * @remarks If the STPathSet was constructed with the DeduplicationTag, then this method will
+     *          check for duplicates and only add the path if it is not already present in the
+     *          set. If the STPathSet was constructed without the DeduplicationTag,
+     *          then this method will always add the path to the set, regardless of duplicates.
+     *          It is fine for callers to ignore the return value.
+     */
+    bool
     pushBack(STPath const& e);
 
+    /**
+     * @brief emplaceBack adds a path to the set.
+     *
+     * @param args The arguments to construct the path with.
+     * @return true if the path was added, false if it was a duplicate and not added.
+     * @remarks If the STPathSet was constructed with the DeduplicationTag, then this method will
+     *          check for duplicates and only add the path if it is not already present in the
+     *          set. If the STPathSet was constructed without the DeduplicationTag,
+     *          then this method will always add the path to the set, regardless of duplicates.
+     *          It is fine for callers to ignore the return value.
+     * @note The path is constructed before the duplicate check, so on a false
+     *       return the constructed path is discarded and any argument
+     *       forwarded as an rvalue is left in a moved-from state.  Use
+     *       pushBack when the caller needs to keep its path on rejection.
+     */
     template <typename... Args>
-    void
+    bool
     emplaceBack(Args&&... args);
 
-    [[nodiscard]] bool
-    contains(STPath const& path) const;
-
 private:
     STBase*
     copy(std::size_t n, void* buf) const override;
     STBase*
     move(std::size_t n, void* buf) override;
 
+    /**
+     * @brief Append a path via `append`, then register it in the deduplication index.
+     *
+     * @param append Invoked with `value_`; must append exactly one path to it.
+     * @return true if the path was kept, false if it was a duplicate and was rolled back.
+     * @remarks Appends to the vector before touching the index, so that a failed allocation
+     *          there leaves both containers untouched rather than leaving the index holding
+     *          a path the vector does not.  If the index insert reports a duplicate, or
+     *          throws, the append is rolled back so the two containers stay consistent; in
+     *          the throwing case the exception propagates.  With no index (constructed
+     *          without the DeduplicationTag) the append is unconditional.
+     */
+    template <typename Append>
+    bool
+    appendUnique(Append&& append);
+
     friend class detail::STVar;
 };
 
@@ -336,7 +422,7 @@ inline STPathElement::STPathElement(
     hashValue_ = getHash(*this);
 }
 
-inline auto
+inline std::uint32_t
 STPathElement::getNodeType() const
 {
     return type_;
@@ -545,25 +631,50 @@ STPathSet::empty() const
     return value_.empty();
 }
 
-inline void
-STPathSet::pushBack(STPath const& e)
+template <typename Append>
+inline bool
+STPathSet::appendUnique(Append&& append)
 {
-    value_.push_back(e);
-    seenHashes_.emplace(value_.back());
-}
+    // Append to the vector first, so that a failed allocation there leaves both
+    // containers untouched rather than leaving the index holding a path the
+    // vector does not.
+    append(value_);
 
-template <typename... Args>
-inline void
-STPathSet::emplaceBack(Args&&... args)
-{
-    value_.emplace_back(std::forward<Args>(args)...);
-    seenHashes_.emplace(value_.back());
+    if (seen_ == nullptr)
+    {
+        return true;
+    }
+
+    try
+    {
+        if (!seen_->insert(value_.back()).second)
+        {
+            // Already present: roll back the append.
+            value_.pop_back();
+            return false;
+        }
+    }
+    catch (...)
+    {
+        // The index insert failed, so roll back the append to keep the vector
+        // and the index consistent.
+        value_.pop_back();
+        throw;
+    }
+    return true;
 }
 
 inline bool
-STPathSet::contains(STPath const& path) const
+STPathSet::pushBack(STPath const& e)
 {
-    return seenHashes_.contains(path);
+    return appendUnique([&](auto& value) { value.push_back(e); });
+}
+
+template <typename... Args>
+inline bool
+STPathSet::emplaceBack(Args&&... args)
+{
+    return appendUnique([&](auto& value) { value.emplace_back(std::forward<Args>(args)...); });
 }
 
 }  // namespace xrpl
diff --git a/include/xrpl/protocol/STTx.h b/include/xrpl/protocol/STTx.h
index e213d4e0b7..e6291ae950 100644
--- a/include/xrpl/protocol/STTx.h
+++ b/include/xrpl/protocol/STTx.h
@@ -5,6 +5,7 @@
 #include <xrpl/basics/base_uint.h>
 #include <xrpl/json/json_value.h>
 #include <xrpl/protocol/AccountID.h>
+#include <xrpl/protocol/HashPrefix.h>
 #include <xrpl/protocol/PublicKey.h>
 #include <xrpl/protocol/Rules.h>
 #include <xrpl/protocol/SField.h>
@@ -13,6 +14,7 @@
 #include <xrpl/protocol/SecretKey.h>
 #include <xrpl/protocol/SeqProxy.h>
 #include <xrpl/protocol/Serializer.h>
+#include <xrpl/protocol/Sign.h>
 #include <xrpl/protocol/TxFormats.h>
 
 #include <boost/container/flat_set.hpp>
@@ -105,14 +107,36 @@ public:
     [[nodiscard]] json::Value
     getJson(JsonOptions options, bool binary) const;
 
+    /**
+     * Sign the transaction as its account.
+     *
+     * @param publicKey The public key for signing.
+     * @param secretKey The secret key for signing.
+     */
+    void
+    sign(PublicKey const& publicKey, SecretKey const& secretKey);
+
+    /**
+     * Sign the transaction in one of its signature fields.
+     *
+     * The signature is bound to the role that made it, so it cannot be moved
+     * into another role.
+     *
+     * @param publicKey The public key for signing.
+     * @param secretKey The secret key for signing.
+     * @param role The role signing the transaction.
+     * @param rules The current ledger rules.
+     */
     void
     sign(
         PublicKey const& publicKey,
         SecretKey const& secretKey,
-        std::optional<std::reference_wrapper<SField const>> signatureTarget = {});
+        SignatureRole role,
+        Rules const& rules);
 
     /**
      * Check the signature.
+     *
      * @param rules The current ledger rules.
      * @return `true` if valid signature. If invalid, the error message string.
      */
@@ -120,7 +144,7 @@ public:
     checkSign(Rules const& rules) const;
 
     [[nodiscard]] std::expected<void, std::string>
-    checkBatchSign(Rules const& rules) const;
+    checkBatchSign() const;
 
     // SQL Functions with metadata.
     static std::string const&
@@ -162,28 +186,28 @@ public:
 private:
     /**
      * Check the signature.
+     *
      * @param rules The current ledger rules.
      * @param sigObject Reference to object that contains the signature fields.
      *     Will be *this more often than not.
+     * @param role The role that made the signature in sigObject. Determines
+     *     the signing prefix, which binds the signature to that role.
      * @return `true` if valid signature. If invalid, the error message string.
      */
     [[nodiscard]] std::expected<void, std::string>
-    checkSign(Rules const& rules, STObject const& sigObject) const;
+    checkSign(Rules const& rules, STObject const& sigObject, SignatureRole role) const;
 
     [[nodiscard]] std::expected<void, std::string>
-    checkSingleSign(STObject const& sigObject) const;
+    checkSingleSign(STObject const& sigObject, HashPrefix prefix) const;
 
     [[nodiscard]] std::expected<void, std::string>
-    checkMultiSign(Rules const& rules, STObject const& sigObject) const;
+    checkMultiSign(STObject const& sigObject, HashPrefix prefix) const;
 
     [[nodiscard]] std::expected<void, std::string>
     checkBatchSingleSign(STObject const& batchSigner, std::vector<uint256> const& txIds) const;
 
     [[nodiscard]] std::expected<void, std::string>
-    checkBatchMultiSign(
-        STObject const& batchSigner,
-        Rules const& rules,
-        std::vector<uint256> const& txIds) const;
+    checkBatchMultiSign(STObject const& batchSigner, std::vector<uint256> const& txIds) const;
 
     void
     buildBatchTxns();
diff --git a/include/xrpl/protocol/STValidation.h b/include/xrpl/protocol/STValidation.h
index 8101b27341..f70e971f87 100644
--- a/include/xrpl/protocol/STValidation.h
+++ b/include/xrpl/protocol/STValidation.h
@@ -124,6 +124,13 @@ public:
     [[nodiscard]] NodeID const&
     getNodeID() const noexcept;
 
+    /**
+     * Whether this validation carries a good signature.
+     *
+     * Reports false if the signature cannot be checked at all, so a caller
+     * cannot tell that apart from a bad signature. Either way the validation is
+     * unusable, and the reason is logged. Only a computed answer is remembered.
+     */
     [[nodiscard]] bool
     isValid() const noexcept;
 
diff --git a/include/xrpl/protocol/Serializer.h b/include/xrpl/protocol/Serializer.h
index c1ea5c16ba..997199629a 100644
--- a/include/xrpl/protocol/Serializer.h
+++ b/include/xrpl/protocol/Serializer.h
@@ -10,6 +10,7 @@
 #include <xrpl/protocol/HashPrefix.h>
 #include <xrpl/protocol/SField.h>
 
+#include <cstddef>
 #include <cstdint>
 #include <cstring>
 #include <stdexcept>
@@ -25,6 +26,101 @@ private:
     Blob data_;
 
 public:
+    /**
+     * A header is never longer than this. The encoder fills a buffer of this
+     * size and writes only the bytes it used.
+     */
+    static constexpr int kMaxNumberOfBytesInHeader = 3;
+
+    // A field whose size varies is stored as a header holding its length, then
+    // the field data. The header is 1, 2 or 3 bytes long. Nothing outside it says
+    // which, so the decoder reads the first byte and its value says how long the
+    // header is:
+    //
+    //     0 ... 192   kMin/kMaxValueOfFirstByteFor1ByteHeader
+    //   193 ... 240   kMin/kMaxValueOfFirstByteFor2ByteHeader
+    //   241 ... 254   kMin/kMaxValueOfFirstByteFor3ByteHeader
+    //         255     belongs to no header
+    //
+    // Each range starts one past the end of the range before it.
+
+    static constexpr int kMinValueOfFirstByteFor1ByteHeader = 0;
+    static constexpr int kMaxValueOfFirstByteFor1ByteHeader = 192;
+
+    static constexpr int kMinValueOfFirstByteFor2ByteHeader =
+        kMaxValueOfFirstByteFor1ByteHeader + 1;
+    static constexpr int kMaxValueOfFirstByteFor2ByteHeader = 240;
+
+    static constexpr int kMinValueOfFirstByteFor3ByteHeader =
+        kMaxValueOfFirstByteFor2ByteHeader + 1;
+
+    static constexpr int kMaxValueOfFirstByteFor3ByteHeader = 254;
+
+    // A length x too big for one byte is split across the header. For 2 bytes:
+    //
+    //     first byte  = 193 + (x - 193) / 256
+    //     second byte = (x - 193) % 256
+    //
+    // so 300 is stored as 193, 107. For 3 bytes it is the same, from 241, with
+    // the remainder split across two bytes: 20,000 is stored as 241, 29, 95.
+
+    static constexpr int kNumberOfValuesInOneByte = 256;
+    static constexpr int kNumberOfValuesInTwoBytes =
+        kNumberOfValuesInOneByte * kNumberOfValuesInOneByte;
+
+    // Each header length therefore covers a range of field lengths:
+    //
+    //        0 ...     192   kMin/kMaxValueOfLengthFor1ByteHeader
+    //      193 ...  12,480   kMin/kMaxValueOfLengthFor2ByteHeader
+    //   12,481 ... 918,744   kMin/kMaxValueOfLengthFor3ByteHeader
+    //
+    // The encoder always uses the shortest header that fits.
+
+    /**
+     * A 1 byte header holds the length in the byte itself, so both ends of
+     * this range are the same numbers as the first byte's own range.
+     */
+    static constexpr int kMinValueOfLengthFor1ByteHeader = kMinValueOfFirstByteFor1ByteHeader;
+    static constexpr int kMaxValueOfLengthFor1ByteHeader = kMaxValueOfFirstByteFor1ByteHeader;
+
+    static constexpr int kMinValueOfLengthFor2ByteHeader = kMaxValueOfLengthFor1ByteHeader + 1;
+
+    /**
+     * 48 values of the first byte mean a 2 byte header, and each of them covers
+     * 256 lengths. The 48 is worked out from the two range ends above, so it
+     * stays right if either of them changes.
+     */
+    static constexpr int kMaxValueOfLengthFor2ByteHeader = kMinValueOfLengthFor2ByteHeader +
+        ((kMaxValueOfFirstByteFor2ByteHeader - kMaxValueOfFirstByteFor1ByteHeader) *
+         kNumberOfValuesInOneByte) -
+        1;
+
+    static constexpr int kMinValueOfLengthFor3ByteHeader = kMaxValueOfLengthFor2ByteHeader + 1;
+
+    /**
+     * 14 values of the first byte mean a 3 byte header, and each of them covers
+     * 65,536 lengths. Counted the same way, that gives the largest length any
+     * header can state.
+     *
+     * Nothing is accepted or rejected against this. The assertion below uses it
+     * to check that every length the encoder writes is one a header can state.
+     */
+    static constexpr int kMaxRepresentableLength = kMinValueOfLengthFor3ByteHeader +
+        ((kMaxValueOfFirstByteFor3ByteHeader - kMaxValueOfFirstByteFor2ByteHeader) *
+         kNumberOfValuesInTwoBytes) -
+        1;
+
+    /**
+     * The largest length the encoder will write. This is the one number here
+     * that is picked rather than worked out. The decoder accepts nothing above
+     * it, so both sides agree on the same set of lengths.
+     */
+    static constexpr int kMaxValueOfLengthFor3ByteHeader = 918744;
+
+    static_assert(
+        kMaxValueOfLengthFor3ByteHeader <= kMaxRepresentableLength,
+        "a length the encoder writes must be one a header can state");
+
     explicit Serializer(int n = 256)
     {
         data_.reserve(n);
@@ -61,7 +157,7 @@ public:
 
     // assemble functions
     int
-    add8(unsigned char i);
+    add8(unsigned char byteValue);
     int
     add16(std::uint16_t i);
 
@@ -270,18 +366,90 @@ public:
         return v.data_ == data_;
     }
 
+    /**
+     * Works out how long a header is, from its first byte.
+     *
+     * Each overload of decodeVLLength below reads one header length, so call
+     * this first to learn which of them to call.
+     *
+     * @param firstByte First byte of the header, as read from the stream.
+     * @return How many bytes the whole header takes, counting firstByte: 1, 2
+     * or 3.
+     * @throws std::overflow_error if firstByte is the one value that starts no
+     * header.
+     */
     static int
-    decodeLengthLength(int b1);
+    decodeLengthLength(std::byte firstByte);
+
+    /**
+     * Reads the field length out of a 1 byte header.
+     *
+     * @param firstByte The single header byte, which is the length itself.
+     * @return Field length in bytes, from kMinValueOfLengthFor1ByteHeader to
+     * kMaxValueOfLengthFor1ByteHeader.
+     * @throws std::overflow_error if firstByte is big enough to mean a longer
+     * header, in which case it is not a length by itself.
+     */
     static int
-    decodeVLLength(int b1);
+    decodeVLLength(std::byte firstByte);
+
+    /**
+     * Reads the field length out of a 2 byte header.
+     *
+     * @param firstByte First header byte. Its value means a 2 byte header, and
+     * how far it sits into that range gives the top part of the length.
+     * @param secondByte Second header byte, holding the rest of the length.
+     * @return Field length in bytes, from kMinValueOfLengthFor2ByteHeader to
+     * kMaxValueOfLengthFor2ByteHeader.
+     * @throws std::overflow_error if firstByte is outside the range that means
+     * a 2 byte header.
+     */
     static int
-    decodeVLLength(int b1, int b2);
+    decodeVLLength(std::byte firstByte, std::byte secondByte);
+
+    /**
+     * Reads the field length out of a 3 byte header.
+     *
+     * @param firstByte First header byte. Its value means a 3 byte header, and
+     * how far it sits into that range gives the top part of the length.
+     * @param secondByte Second header byte, holding the middle part of the
+     * length.
+     * @param thirdByte Third header byte, holding the low part.
+     * @return Field length in bytes, from kMinValueOfLengthFor3ByteHeader to
+     * kMaxValueOfLengthFor3ByteHeader.
+     * @throws std::overflow_error if firstByte is outside the range that means
+     * a 3 byte header, or if the three bytes together state a length above
+     * kMaxValueOfLengthFor3ByteHeader, which the encoder would not write back.
+     */
     static int
-    decodeVLLength(int b1, int b2, int b3);
+    decodeVLLength(std::byte firstByte, std::byte secondByte, std::byte thirdByte);
 
 private:
+    /**
+     * Works out how many bytes the header needs for the given length.
+     *
+     * This deliberately repeats the width choice addEncoded makes, so that
+     * addVL's assertion can compare the two. It has no other caller; do not
+     * reach for it as a utility.
+     *
+     * @param length Field length in bytes.
+     * @return How many header bytes it needs: 1, 2 or 3.
+     * @throws std::overflow_error if length is negative, or above
+     * kMaxValueOfLengthFor3ByteHeader.
+     */
     static int
-    encodeLengthLength(int length);  // length to encode length
+    encodeLengthLength(int length);
+
+    /**
+     * Appends the length header for a field of the given length.
+     *
+     * The field's own data is not written; the caller appends it next.
+     *
+     * @param length Field length in bytes.
+     * @return Offset within this Serializer at which the header was written.
+     * @throws std::overflow_error if length is negative, or above
+     * kMaxValueOfLengthFor3ByteHeader.
+     */
     int
     addEncoded(int length);
 };
@@ -390,9 +558,15 @@ public:
     void
     getFieldID(int& type, int& name);
 
-    // Returns the size of the VL if the
-    // next object is a VL. Advances the iterator
-    // to the beginning of the VL.
+    /**
+     * Reads the length header at the read position and steps past it.
+     *
+     * @return Field length in bytes. The iterator is left on the first byte of
+     * the field data.
+     * @throws std::overflow_error if the header states a length the encoder could
+     * not have written.
+     * @throws std::runtime_error if the data runs out before the header does.
+     */
     int
     getVLDataLength();
 
diff --git a/include/xrpl/protocol/Sign.h b/include/xrpl/protocol/Sign.h
index fad2c35c9e..b7a318eb35 100644
--- a/include/xrpl/protocol/Sign.h
+++ b/include/xrpl/protocol/Sign.h
@@ -4,13 +4,65 @@
 #include <xrpl/protocol/HashPrefix.h>
 #include <xrpl/protocol/KeyType.h>
 #include <xrpl/protocol/PublicKey.h>
+#include <xrpl/protocol/Rules.h>
 #include <xrpl/protocol/SField.h>
 #include <xrpl/protocol/STObject.h>
 #include <xrpl/protocol/SecretKey.h>
 #include <xrpl/protocol/Serializer.h>
 
+#include <optional>
+
 namespace xrpl {
 
+/**
+ * The signature slots on a transaction.
+ *
+ * Each role signs different bytes, so a signature cannot be moved from the
+ * role that made it into another role. See signingPrefix.
+ */
+enum class SignatureRole {
+    /**
+     * The transaction's own signature, in sfTxnSignature or sfSigners.
+     */
+    Transaction,
+    /**
+     * The counterparty's signature, in sfCounterpartySignature.
+     */
+    Counterparty,
+    /**
+     * The sponsor's signature, in sfSponsorSignature.
+     */
+    Sponsor
+};
+
+/**
+ * The field that holds this role's signature.
+ *
+ * @return The signature field, or nullptr for SignatureRole::Transaction,
+ * whose signature lives at the top level of the transaction.
+ */
+[[nodiscard]] SField const*
+signatureField(SignatureRole role);
+
+/**
+ * The role that signs into the given field.
+ *
+ * @return The role, or an unseated optional if the field does not hold a
+ * transaction signature.
+ */
+[[nodiscard]] std::optional<SignatureRole>
+signatureRole(SField const& sigField);
+
+/**
+ * The hash prefix that binds a transaction signature to the role that made it.
+ *
+ * @param role The role making the signature.
+ * @param multiSigning Whether the signature is a multi-signature.
+ * @param rules The current ledger rules.
+ */
+[[nodiscard]] HashPrefix
+signingPrefix(SignatureRole role, bool multiSigning, Rules const& rules);
+
 /**
  * Sign an STObject
  *
@@ -49,9 +101,12 @@ verify(
 
 /**
  * Return a Serializer suitable for computing a multisigning TxnSignature.
+ *
+ * @param prefix Prefix to insert before the serialized object. Get it from
+ * signingPrefix, so that the signature is bound to the role making it.
  */
 Serializer
-buildMultiSigningData(STObject const& obj, AccountID const& signingID);
+buildMultiSigningData(STObject const& obj, AccountID const& signingID, HashPrefix prefix);
 
 /**
  * Break the multi-signing hash computation into 2 parts for optimization.
@@ -67,7 +122,7 @@ buildMultiSigningData(STObject const& obj, AccountID const& signingID);
  *     signer's unique data.
  */
 Serializer
-startMultiSigningData(STObject const& obj);
+startMultiSigningData(STObject const& obj, HashPrefix prefix);
 
 inline void
 finishMultiSigningData(AccountID const& signingID, Serializer& s)
diff --git a/include/xrpl/protocol/TER.h b/include/xrpl/protocol/TER.h
index 730d021254..5702b01d1d 100644
--- a/include/xrpl/protocol/TER.h
+++ b/include/xrpl/protocol/TER.h
@@ -129,8 +129,11 @@ enum TEMcodes : TERUnderlyingType {
     temARRAY_TOO_LARGE,
     temBAD_TRANSFER_FEE,
     temINVALID_INNER_BATCH,
+
     temBAD_MPT,
     temBAD_CIPHERTEXT,
+    temINVALID_BYTECODE,
+    temTEMP_DISABLED,
 };
 
 //------------------------------------------------------------------------------
@@ -179,6 +182,8 @@ enum TEFcodes : TERUnderlyingType {
     tefINVALID_LEDGER_FIX_TYPE,
     tefNO_DST_PARTIAL,
     tefBAD_PATH_COUNT,
+    tefNO_BYTECODE,
+    tefBYTECODE_NOT_INCLUDED,
 };
 
 //------------------------------------------------------------------------------
@@ -370,6 +375,8 @@ enum TECcodes : TERUnderlyingType {
     tecNO_DELEGATE_PERMISSION = 198,
     tecBAD_PROOF = 199,
     tecNO_SPONSOR_PERMISSION = 200,
+    tecOUT_OF_GAS = 201,
+    tecBYTECODE_REJECTED = 202,
 };
 
 //------------------------------------------------------------------------------
diff --git a/include/xrpl/protocol/detail/STVar.h b/include/xrpl/protocol/detail/STVar.h
index 56f868b665..72a310546e 100644
--- a/include/xrpl/protocol/detail/STVar.h
+++ b/include/xrpl/protocol/detail/STVar.h
@@ -34,10 +34,11 @@ concept ValidConstructSTArgs =
 // and includes a small-object allocation optimization.
 class STVar
 {
-private:
+public:
     // The largest "small object" we can accommodate
     static constexpr std::size_t kMaxSize = 72;
 
+private:
     alignas(std::max_align_t) std::byte d_[kMaxSize] = {};
     STBase* p_ = nullptr;
 
diff --git a/include/xrpl/protocol/detail/features.macro b/include/xrpl/protocol/detail/features.macro
index ae696a4ea4..e63a7f515d 100644
--- a/include/xrpl/protocol/detail/features.macro
+++ b/include/xrpl/protocol/detail/features.macro
@@ -15,6 +15,10 @@
 // Add new amendments to the top of this list.
 // Keep it sorted in reverse chronological order.
 
+XRPL_FEATURE(SmartEscrow,                 Supported::No,  VoteBehavior::DefaultNo)
+XRPL_FEATURE(LendingProtocolV1_2,         Supported::No,  VoteBehavior::DefaultNo)
+XRPL_FIX    (Cleanup3_5_0,                Supported::Yes, VoteBehavior::DefaultNo)
+XRPL_FEATURE(ConfidentialMPTKeyRotation,  Supported::No,  VoteBehavior::DefaultNo)
 XRPL_FIX    (Cleanup3_4_0,                Supported::Yes, VoteBehavior::DefaultNo)
 XRPL_FEATURE(Sponsor,                     Supported::Yes, VoteBehavior::DefaultNo)
 XRPL_FEATURE(BatchV1_1,                   Supported::Yes, VoteBehavior::DefaultNo)
diff --git a/include/xrpl/protocol/detail/ledger_entries.macro b/include/xrpl/protocol/detail/ledger_entries.macro
index f166473d7f..04b390a7a4 100644
--- a/include/xrpl/protocol/detail/ledger_entries.macro
+++ b/include/xrpl/protocol/detail/ledger_entries.macro
@@ -309,6 +309,11 @@ LEDGER_ENTRY(ltFEE_SETTINGS, 0x0073, FeeSettings, fee, ({
     {sfBaseFeeDrops,           SoeOptional},
     {sfReserveBaseDrops,       SoeOptional},
     {sfReserveIncrementDrops,  SoeOptional},
+    // Smart Escrow fields
+    {sfGasLimit,               SoeOptional},
+    {sfBytecodeSizeLimit,      SoeOptional},
+    {sfGasPrice,               SoeOptional},
+
     {sfPreviousTxnID,          SoeOptional},
     {sfPreviousTxnLgrSeq,      SoeOptional},
 }))
@@ -339,6 +344,8 @@ LEDGER_ENTRY(ltESCROW, 0x0075, Escrow, escrow, ({
     {sfCondition,            SoeOptional},
     {sfCancelAfter,          SoeOptional},
     {sfFinishAfter,          SoeOptional},
+    {sfBytecode,             SoeOptional},
+    {sfData,                 SoeOptional},
     {sfSourceTag,            SoeOptional},
     {sfDestinationTag,       SoeOptional},
     {sfOwnerNode,            SoeRequired},
@@ -408,6 +415,8 @@ LEDGER_ENTRY(ltMPTOKEN_ISSUANCE, 0x007e, MPTokenIssuance, mpt_issuance, ({
     {sfReferenceHolding,         SoeOptional},
     {sfIssuerEncryptionKey,      SoeOptional},
     {sfAuditorEncryptionKey,     SoeOptional},
+    {sfIssuerKeyEpoch,           SoeOptional},
+    {sfAuditorKeyEpoch,          SoeOptional},
     {sfConfidentialOutstandingAmount, SoeDefault},
 }))
 
@@ -427,6 +436,8 @@ LEDGER_ENTRY(ltMPTOKEN, 0x007f, MPToken, mptoken, ({
     {sfConfidentialBalanceVersion,  SoeDefault},
     {sfIssuerEncryptedBalance,      SoeOptional},
     {sfAuditorEncryptedBalance,     SoeOptional},
+    {sfIssuerKeyMirrorEpoch,        SoeOptional},
+    {sfAuditorKeyMirrorEpoch,       SoeOptional},
     {sfHolderEncryptionKey,         SoeOptional},
 }))
 
diff --git a/include/xrpl/protocol/detail/sfields.macro b/include/xrpl/protocol/detail/sfields.macro
index ec05804253..2cf35743ae 100644
--- a/include/xrpl/protocol/detail/sfields.macro
+++ b/include/xrpl/protocol/detail/sfields.macro
@@ -119,6 +119,15 @@ TYPED_SFIELD(sfRemainingOwnerCount,      UINT32,    73)
 TYPED_SFIELD(sfSponsorFlags,             UINT32,    74)
 TYPED_SFIELD(sfSubscriptionDate,         UINT32,    75)
 TYPED_SFIELD(sfRedemptionDate,           UINT32,    76)
+TYPED_SFIELD(sfIssuerKeyEpoch,           UINT32,    77)
+TYPED_SFIELD(sfAuditorKeyEpoch,          UINT32,    78)
+TYPED_SFIELD(sfIssuerKeyMirrorEpoch,     UINT32,    79)
+TYPED_SFIELD(sfAuditorKeyMirrorEpoch,    UINT32,    80)
+TYPED_SFIELD(sfGasLimit,                 UINT32,    81)
+TYPED_SFIELD(sfBytecodeSizeLimit,        UINT32,    82)
+TYPED_SFIELD(sfGasPrice,                 UINT32,    83)
+TYPED_SFIELD(sfGas,                      UINT32,    84)
+TYPED_SFIELD(sfGasUsed,                  UINT32,    85)
 
 // 64-bit integers (common)
 TYPED_SFIELD(sfIndexNext,                UINT64,     1)
@@ -234,6 +243,7 @@ TYPED_SFIELD(sfManagementFeeOutstanding, NUMBER,     17, SField::kSmdNeedsAsset
 // 32-bit signed (common)
 TYPED_SFIELD(sfLoanScale,                INT32,      1)
 TYPED_SFIELD(sfRemainingOwnerCountDelta, INT32,      2)
+TYPED_SFIELD(sfVMReturnCode,             INT32,      3)
 
 // currency amount (common)
 TYPED_SFIELD(sfAmount,                   AMOUNT,     1)
@@ -318,6 +328,7 @@ TYPED_SFIELD(sfAuditorEncryptedAmount,      VL,     43)
 TYPED_SFIELD(sfAuditorEncryptionKey,        VL,     44)
 TYPED_SFIELD(sfAmountCommitment,            VL,     45)
 TYPED_SFIELD(sfBalanceCommitment,           VL,     46)
+TYPED_SFIELD(sfBytecode,                    VL,     47)
 
 // account (common)
 TYPED_SFIELD(sfAccount,                  ACCOUNT,    1)
diff --git a/include/xrpl/protocol/detail/transactions.macro b/include/xrpl/protocol/detail/transactions.macro
index dbf9b66ac7..cb3d5fd2b1 100644
--- a/include/xrpl/protocol/detail/transactions.macro
+++ b/include/xrpl/protocol/detail/transactions.macro
@@ -66,11 +66,13 @@ TRANSACTION(ttPAYMENT, 0, Payment,
 #endif
 TRANSACTION(ttESCROW_CREATE, 1, EscrowCreate, ({.delegable = Delegation::Delegable}), ({
     {sfDestination, SoeRequired},
+    {sfDestinationTag, SoeOptional},
     {sfAmount, SoeRequired, SoeMptSupported},
     {sfCondition, SoeOptional},
     {sfCancelAfter, SoeOptional},
     {sfFinishAfter, SoeOptional},
-    {sfDestinationTag, SoeOptional},
+    {sfBytecode, SoeOptional},
+    {sfData, SoeOptional},
 }))
 
 /** This transaction type completes an existing escrow. */
@@ -83,6 +85,7 @@ TRANSACTION(ttESCROW_FINISH, 2, EscrowFinish, ({.delegable = Delegation::Delegab
     {sfFulfillment, SoeOptional},
     {sfCondition, SoeOptional},
     {sfCredentialIDs, SoeOptional},
+    {sfGas, SoeOptional},
 }))
 
 
@@ -1131,6 +1134,19 @@ TRANSACTION(ttSPONSORSHIP_SET, 91, SponsorshipSet,
     {sfRemainingOwnerCountDelta, SoeOptional},
 }))
 
+#if TRANSACTION_INCLUDE
+#   include <xrpl/tx/transactors/token/ConfidentialMPTMirrorUpdate.h>
+#endif
+TRANSACTION(ttCONFIDENTIAL_MPT_MIRROR_UPDATE, 92, ConfidentialMPTMirrorUpdate,
+    ({.delegable = Delegation::Delegable, .amendment = featureConfidentialMPTKeyRotation}),
+    ({
+    {sfMPTokenIssuanceID, SoeRequired},
+    {sfHolder, SoeOptional},
+    {sfIssuerEncryptedAmount, SoeOptional},
+    {sfAuditorEncryptedAmount, SoeOptional},
+    {sfZKProof, SoeRequired},
+}))
+
 /** This system-generated transaction type is used to update the status of the various amendments.
 
     For details, see: https://xrpl.org/amendments.html
@@ -1161,6 +1177,10 @@ TRANSACTION(ttFEE, 101, SetFee,
     {sfBaseFeeDrops, SoeOptional},
     {sfReserveBaseDrops, SoeOptional},
     {sfReserveIncrementDrops, SoeOptional},
+    // Smart Escrow fields
+    {sfGasLimit, SoeOptional},
+    {sfBytecodeSizeLimit, SoeOptional},
+    {sfGasPrice, SoeOptional},
 }))
 
 /** This system-generated transaction type is used to update the network's negative UNL
diff --git a/include/xrpl/protocol/jss.h b/include/xrpl/protocol/jss.h
index 63e877ca31..b294a846da 100644
--- a/include/xrpl/protocol/jss.h
+++ b/include/xrpl/protocol/jss.h
@@ -278,6 +278,7 @@ JSS(frozen_balances);                // out: GatewayBalances
 JSS(full);                           // in: LedgerClearer, handlers/Ledger
 JSS(full_reply);                     // out: PathFind
 JSS(fullbelow_size);                 // out: GetCounts
+JSS(gateway);                        // in: noripple_check
 JSS(git);                            // out: server_info
 JSS(good);                           // out: RPCVersion
 JSS(hash);                           // out: NetworkOPs, InboundLedger, LedgerToJson, STTx; field
@@ -481,6 +482,7 @@ JSS(ports);                       // out: NetworkOPs
 JSS(previous);                    // out: Reservations
 JSS(previous_ledger);             // out: LedgerPropose
 JSS(price);                       // out: amm_info, AuctionSlot
+JSS(problems);                    // out: noripple_check
 JSS(proof);                       // in: BookOffers
 JSS(propose_seq);                 // out: LedgerPropose
 JSS(proposers);                   // out: NetworkOPs, LedgerConsensus
@@ -660,6 +662,7 @@ JSS(url);                         // in/out: Subscribe, Unsubscribe
 JSS(url_password);                // in: Subscribe
 JSS(url_username);                // in: Subscribe
 JSS(urlgravatar);                 //
+JSS(user);                        // in: noripple_check
 JSS(username);                    // in: Subscribe
 JSS(validated);                   // out: NetworkOPs, RPCHelpers, AccountTx*, Tx
 JSS(validator_list_expires);      // out: NetworkOps, ValidatorList
diff --git a/include/xrpl/protocol_autogen/ledger_entries/Escrow.h b/include/xrpl/protocol_autogen/ledger_entries/Escrow.h
index 106d69722f..fc01c8b858 100644
--- a/include/xrpl/protocol_autogen/ledger_entries/Escrow.h
+++ b/include/xrpl/protocol_autogen/ledger_entries/Escrow.h
@@ -174,6 +174,54 @@ public:
         return this->sle_->isFieldPresent(sfFinishAfter);
     }
 
+    /**
+     * @brief Get sfBytecode (SoeOptional)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_VL::type::value_type>
+    getBytecode() const
+    {
+        if (hasBytecode())
+            return this->sle_->at(sfBytecode);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfBytecode is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasBytecode() const
+    {
+        return this->sle_->isFieldPresent(sfBytecode);
+    }
+
+    /**
+     * @brief Get sfData (SoeOptional)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_VL::type::value_type>
+    getData() const
+    {
+        if (hasData())
+            return this->sle_->at(sfData);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfData is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasData() const
+    {
+        return this->sle_->isFieldPresent(sfData);
+    }
+
     /**
      * @brief Get sfSourceTag (SoeOptional)
      * @return The field value, or std::nullopt if not present.
@@ -453,6 +501,28 @@ public:
         return *this;
     }
 
+    /**
+     * @brief Set sfBytecode (SoeOptional)
+     * @return Reference to this builder for method chaining.
+     */
+    EscrowBuilder&
+    setBytecode(std::decay_t<typename SF_VL::type::value_type> const& value)
+    {
+        object_[sfBytecode] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfData (SoeOptional)
+     * @return Reference to this builder for method chaining.
+     */
+    EscrowBuilder&
+    setData(std::decay_t<typename SF_VL::type::value_type> const& value)
+    {
+        object_[sfData] = value;
+        return *this;
+    }
+
     /**
      * @brief Set sfSourceTag (SoeOptional)
      * @return Reference to this builder for method chaining.
diff --git a/include/xrpl/protocol_autogen/ledger_entries/FeeSettings.h b/include/xrpl/protocol_autogen/ledger_entries/FeeSettings.h
index 21478f749d..826ad6983e 100644
--- a/include/xrpl/protocol_autogen/ledger_entries/FeeSettings.h
+++ b/include/xrpl/protocol_autogen/ledger_entries/FeeSettings.h
@@ -213,6 +213,78 @@ public:
         return this->sle_->isFieldPresent(sfReserveIncrementDrops);
     }
 
+    /**
+     * @brief Get sfGasLimit (SoeOptional)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getGasLimit() const
+    {
+        if (hasGasLimit())
+            return this->sle_->at(sfGasLimit);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfGasLimit is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasGasLimit() const
+    {
+        return this->sle_->isFieldPresent(sfGasLimit);
+    }
+
+    /**
+     * @brief Get sfBytecodeSizeLimit (SoeOptional)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getBytecodeSizeLimit() const
+    {
+        if (hasBytecodeSizeLimit())
+            return this->sle_->at(sfBytecodeSizeLimit);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfBytecodeSizeLimit is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasBytecodeSizeLimit() const
+    {
+        return this->sle_->isFieldPresent(sfBytecodeSizeLimit);
+    }
+
+    /**
+     * @brief Get sfGasPrice (SoeOptional)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getGasPrice() const
+    {
+        if (hasGasPrice())
+            return this->sle_->at(sfGasPrice);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfGasPrice is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasGasPrice() const
+    {
+        return this->sle_->isFieldPresent(sfGasPrice);
+    }
+
     /**
      * @brief Get sfPreviousTxnID (SoeOptional)
      * @return The field value, or std::nullopt if not present.
@@ -375,6 +447,39 @@ public:
         return *this;
     }
 
+    /**
+     * @brief Set sfGasLimit (SoeOptional)
+     * @return Reference to this builder for method chaining.
+     */
+    FeeSettingsBuilder&
+    setGasLimit(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfGasLimit] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfBytecodeSizeLimit (SoeOptional)
+     * @return Reference to this builder for method chaining.
+     */
+    FeeSettingsBuilder&
+    setBytecodeSizeLimit(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfBytecodeSizeLimit] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfGasPrice (SoeOptional)
+     * @return Reference to this builder for method chaining.
+     */
+    FeeSettingsBuilder&
+    setGasPrice(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfGasPrice] = value;
+        return *this;
+    }
+
     /**
      * @brief Set sfPreviousTxnID (SoeOptional)
      * @return Reference to this builder for method chaining.
diff --git a/include/xrpl/protocol_autogen/ledger_entries/MPToken.h b/include/xrpl/protocol_autogen/ledger_entries/MPToken.h
index 874d779d09..c1601fc2fa 100644
--- a/include/xrpl/protocol_autogen/ledger_entries/MPToken.h
+++ b/include/xrpl/protocol_autogen/ledger_entries/MPToken.h
@@ -268,6 +268,54 @@ public:
         return this->sle_->isFieldPresent(sfAuditorEncryptedBalance);
     }
 
+    /**
+     * @brief Get sfIssuerKeyMirrorEpoch (SoeOptional)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getIssuerKeyMirrorEpoch() const
+    {
+        if (hasIssuerKeyMirrorEpoch())
+            return this->sle_->at(sfIssuerKeyMirrorEpoch);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfIssuerKeyMirrorEpoch is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasIssuerKeyMirrorEpoch() const
+    {
+        return this->sle_->isFieldPresent(sfIssuerKeyMirrorEpoch);
+    }
+
+    /**
+     * @brief Get sfAuditorKeyMirrorEpoch (SoeOptional)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getAuditorKeyMirrorEpoch() const
+    {
+        if (hasAuditorKeyMirrorEpoch())
+            return this->sle_->at(sfAuditorKeyMirrorEpoch);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfAuditorKeyMirrorEpoch is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasAuditorKeyMirrorEpoch() const
+    {
+        return this->sle_->isFieldPresent(sfAuditorKeyMirrorEpoch);
+    }
+
     /**
      * @brief Get sfHolderEncryptionKey (SoeOptional)
      * @return The field value, or std::nullopt if not present.
@@ -471,6 +519,28 @@ public:
         return *this;
     }
 
+    /**
+     * @brief Set sfIssuerKeyMirrorEpoch (SoeOptional)
+     * @return Reference to this builder for method chaining.
+     */
+    MPTokenBuilder&
+    setIssuerKeyMirrorEpoch(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfIssuerKeyMirrorEpoch] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfAuditorKeyMirrorEpoch (SoeOptional)
+     * @return Reference to this builder for method chaining.
+     */
+    MPTokenBuilder&
+    setAuditorKeyMirrorEpoch(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfAuditorKeyMirrorEpoch] = value;
+        return *this;
+    }
+
     /**
      * @brief Set sfHolderEncryptionKey (SoeOptional)
      * @return Reference to this builder for method chaining.
diff --git a/include/xrpl/protocol_autogen/ledger_entries/MPTokenIssuance.h b/include/xrpl/protocol_autogen/ledger_entries/MPTokenIssuance.h
index 6a2caf52ae..74b5e3c4eb 100644
--- a/include/xrpl/protocol_autogen/ledger_entries/MPTokenIssuance.h
+++ b/include/xrpl/protocol_autogen/ledger_entries/MPTokenIssuance.h
@@ -351,6 +351,54 @@ public:
         return this->sle_->isFieldPresent(sfAuditorEncryptionKey);
     }
 
+    /**
+     * @brief Get sfIssuerKeyEpoch (SoeOptional)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getIssuerKeyEpoch() const
+    {
+        if (hasIssuerKeyEpoch())
+            return this->sle_->at(sfIssuerKeyEpoch);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfIssuerKeyEpoch is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasIssuerKeyEpoch() const
+    {
+        return this->sle_->isFieldPresent(sfIssuerKeyEpoch);
+    }
+
+    /**
+     * @brief Get sfAuditorKeyEpoch (SoeOptional)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getAuditorKeyEpoch() const
+    {
+        if (hasAuditorKeyEpoch())
+            return this->sle_->at(sfAuditorKeyEpoch);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfAuditorKeyEpoch is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasAuditorKeyEpoch() const
+    {
+        return this->sle_->isFieldPresent(sfAuditorKeyEpoch);
+    }
+
     /**
      * @brief Get sfConfidentialOutstandingAmount (SoeDefault)
      * @return The field value, or std::nullopt if not present.
@@ -600,6 +648,28 @@ public:
         return *this;
     }
 
+    /**
+     * @brief Set sfIssuerKeyEpoch (SoeOptional)
+     * @return Reference to this builder for method chaining.
+     */
+    MPTokenIssuanceBuilder&
+    setIssuerKeyEpoch(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfIssuerKeyEpoch] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfAuditorKeyEpoch (SoeOptional)
+     * @return Reference to this builder for method chaining.
+     */
+    MPTokenIssuanceBuilder&
+    setAuditorKeyEpoch(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfAuditorKeyEpoch] = value;
+        return *this;
+    }
+
     /**
      * @brief Set sfConfidentialOutstandingAmount (SoeDefault)
      * @return Reference to this builder for method chaining.
diff --git a/include/xrpl/protocol_autogen/transactions/ConfidentialMPTMirrorUpdate.h b/include/xrpl/protocol_autogen/transactions/ConfidentialMPTMirrorUpdate.h
new file mode 100644
index 0000000000..1fc25bca99
--- /dev/null
+++ b/include/xrpl/protocol_autogen/transactions/ConfidentialMPTMirrorUpdate.h
@@ -0,0 +1,266 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STTx.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/TransactionBase.h>
+#include <xrpl/protocol_autogen/TransactionBuilderBase.h>
+#include <xrpl/json/json_value.h>
+
+#include <stdexcept>
+#include <optional>
+
+namespace xrpl::transactions {
+
+class ConfidentialMPTMirrorUpdateBuilder;
+
+/**
+ * @brief Transaction: ConfidentialMPTMirrorUpdate
+ *
+ * Type: ttCONFIDENTIAL_MPT_MIRROR_UPDATE (92)
+ * Delegable: Delegation::Delegable
+ * Amendment: featureConfidentialMPTKeyRotation
+ * Privileges: Privilege::NoPriv
+ *
+ * Immutable wrapper around STTx providing type-safe field access.
+ * Use ConfidentialMPTMirrorUpdateBuilder to construct new transactions.
+ */
+class ConfidentialMPTMirrorUpdate : public TransactionBase
+{
+public:
+    static constexpr xrpl::TxType txType = ttCONFIDENTIAL_MPT_MIRROR_UPDATE;
+
+    /**
+     * @brief Construct a ConfidentialMPTMirrorUpdate transaction wrapper from an existing STTx object.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    explicit ConfidentialMPTMirrorUpdate(std::shared_ptr<STTx const> tx)
+        : TransactionBase(std::move(tx))
+    {
+        // Verify transaction type
+        if (tx_->getTxnType() != txType)
+        {
+            throw std::runtime_error("Invalid transaction type for ConfidentialMPTMirrorUpdate");
+        }
+    }
+
+    // Transaction-specific field getters
+
+    /**
+     * @brief Get sfMPTokenIssuanceID (SoeRequired)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT192::type::value_type
+    getMPTokenIssuanceID() const
+    {
+        return this->tx_->at(sfMPTokenIssuanceID);
+    }
+
+    /**
+     * @brief Get sfHolder (SoeOptional)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_ACCOUNT::type::value_type>
+    getHolder() const
+    {
+        if (hasHolder())
+        {
+            return this->tx_->at(sfHolder);
+        }
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfHolder is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasHolder() const
+    {
+        return this->tx_->isFieldPresent(sfHolder);
+    }
+
+    /**
+     * @brief Get sfIssuerEncryptedAmount (SoeOptional)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_VL::type::value_type>
+    getIssuerEncryptedAmount() const
+    {
+        if (hasIssuerEncryptedAmount())
+        {
+            return this->tx_->at(sfIssuerEncryptedAmount);
+        }
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfIssuerEncryptedAmount is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasIssuerEncryptedAmount() const
+    {
+        return this->tx_->isFieldPresent(sfIssuerEncryptedAmount);
+    }
+
+    /**
+     * @brief Get sfAuditorEncryptedAmount (SoeOptional)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_VL::type::value_type>
+    getAuditorEncryptedAmount() const
+    {
+        if (hasAuditorEncryptedAmount())
+        {
+            return this->tx_->at(sfAuditorEncryptedAmount);
+        }
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfAuditorEncryptedAmount is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasAuditorEncryptedAmount() const
+    {
+        return this->tx_->isFieldPresent(sfAuditorEncryptedAmount);
+    }
+
+    /**
+     * @brief Get sfZKProof (SoeRequired)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_VL::type::value_type
+    getZKProof() const
+    {
+        return this->tx_->at(sfZKProof);
+    }
+};
+
+/**
+ * @brief Builder for ConfidentialMPTMirrorUpdate transactions.
+ *
+ * Provides a fluent interface for constructing transactions with method chaining.
+ * Uses STObject internally for flexible transaction construction.
+ * Inherits common field setters from TransactionBuilderBase.
+ */
+class ConfidentialMPTMirrorUpdateBuilder : public TransactionBuilderBase<ConfidentialMPTMirrorUpdateBuilder>
+{
+public:
+    /**
+     * @brief Construct a new ConfidentialMPTMirrorUpdateBuilder with required fields.
+     * @param account The account initiating the transaction.
+     * @param mPTokenIssuanceID The sfMPTokenIssuanceID field value.
+     * @param zKProof The sfZKProof field value.
+     * @param sequence Optional sequence number for the transaction.
+     * @param fee Optional fee for the transaction.
+     */
+    ConfidentialMPTMirrorUpdateBuilder(SF_ACCOUNT::type::value_type account,
+                     std::decay_t<typename SF_UINT192::type::value_type> const& mPTokenIssuanceID,                     std::decay_t<typename SF_VL::type::value_type> const& zKProof,                    std::optional<SF_UINT32::type::value_type> sequence = std::nullopt,
+                    std::optional<SF_AMOUNT::type::value_type> fee = std::nullopt
+)
+        : TransactionBuilderBase<ConfidentialMPTMirrorUpdateBuilder>(ttCONFIDENTIAL_MPT_MIRROR_UPDATE, account, sequence, fee)
+    {
+        setMPTokenIssuanceID(mPTokenIssuanceID);
+        setZKProof(zKProof);
+    }
+
+    /**
+     * @brief Construct a ConfidentialMPTMirrorUpdateBuilder from an existing STTx object.
+     * @param tx The existing transaction to copy from.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    ConfidentialMPTMirrorUpdateBuilder(std::shared_ptr<STTx const> tx)
+    {
+        if (tx->getTxnType() != ttCONFIDENTIAL_MPT_MIRROR_UPDATE)
+        {
+            throw std::runtime_error("Invalid transaction type for ConfidentialMPTMirrorUpdateBuilder");
+        }
+        object_ = *tx;
+    }
+
+    /**
+     * @brief Transaction-specific field setters
+     */
+
+    /**
+     * @brief Set sfMPTokenIssuanceID (SoeRequired)
+     * @return Reference to this builder for method chaining.
+     */
+    ConfidentialMPTMirrorUpdateBuilder&
+    setMPTokenIssuanceID(std::decay_t<typename SF_UINT192::type::value_type> const& value)
+    {
+        object_[sfMPTokenIssuanceID] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfHolder (SoeOptional)
+     * @return Reference to this builder for method chaining.
+     */
+    ConfidentialMPTMirrorUpdateBuilder&
+    setHolder(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
+    {
+        object_[sfHolder] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfIssuerEncryptedAmount (SoeOptional)
+     * @return Reference to this builder for method chaining.
+     */
+    ConfidentialMPTMirrorUpdateBuilder&
+    setIssuerEncryptedAmount(std::decay_t<typename SF_VL::type::value_type> const& value)
+    {
+        object_[sfIssuerEncryptedAmount] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfAuditorEncryptedAmount (SoeOptional)
+     * @return Reference to this builder for method chaining.
+     */
+    ConfidentialMPTMirrorUpdateBuilder&
+    setAuditorEncryptedAmount(std::decay_t<typename SF_VL::type::value_type> const& value)
+    {
+        object_[sfAuditorEncryptedAmount] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfZKProof (SoeRequired)
+     * @return Reference to this builder for method chaining.
+     */
+    ConfidentialMPTMirrorUpdateBuilder&
+    setZKProof(std::decay_t<typename SF_VL::type::value_type> const& value)
+    {
+        object_[sfZKProof] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Build and return the ConfidentialMPTMirrorUpdate wrapper.
+     * @param publicKey The public key for signing.
+     * @param secretKey The secret key for signing.
+     * @return The constructed transaction wrapper.
+     */
+    ConfidentialMPTMirrorUpdate
+    build(PublicKey const& publicKey, SecretKey const& secretKey)
+    {
+        sign(publicKey, secretKey);
+        return ConfidentialMPTMirrorUpdate{std::make_shared<STTx>(std::move(object_))};
+    }
+};
+
+}  // namespace xrpl::transactions
diff --git a/include/xrpl/protocol_autogen/transactions/EscrowCreate.h b/include/xrpl/protocol_autogen/transactions/EscrowCreate.h
index 3d28a12cee..78f9f00033 100644
--- a/include/xrpl/protocol_autogen/transactions/EscrowCreate.h
+++ b/include/xrpl/protocol_autogen/transactions/EscrowCreate.h
@@ -58,6 +58,32 @@ public:
         return this->tx_->at(sfDestination);
     }
 
+    /**
+     * @brief Get sfDestinationTag (SoeOptional)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getDestinationTag() const
+    {
+        if (hasDestinationTag())
+        {
+            return this->tx_->at(sfDestinationTag);
+        }
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfDestinationTag is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasDestinationTag() const
+    {
+        return this->tx_->isFieldPresent(sfDestinationTag);
+    }
+
     /**
      * @brief Get sfAmount (SoeRequired)
      * @note This field supports MPT (Multi-Purpose Token) amounts.
@@ -149,29 +175,55 @@ public:
     }
 
     /**
-     * @brief Get sfDestinationTag (SoeOptional)
+     * @brief Get sfBytecode (SoeOptional)
      * @return The field value, or std::nullopt if not present.
      */
     [[nodiscard]]
-    protocol_autogen::Optional<SF_UINT32::type::value_type>
-    getDestinationTag() const
+    protocol_autogen::Optional<SF_VL::type::value_type>
+    getBytecode() const
     {
-        if (hasDestinationTag())
+        if (hasBytecode())
         {
-            return this->tx_->at(sfDestinationTag);
+            return this->tx_->at(sfBytecode);
         }
         return std::nullopt;
     }
 
     /**
-     * @brief Check if sfDestinationTag is present.
+     * @brief Check if sfBytecode is present.
      * @return True if the field is present, false otherwise.
      */
     [[nodiscard]]
     bool
-    hasDestinationTag() const
+    hasBytecode() const
     {
-        return this->tx_->isFieldPresent(sfDestinationTag);
+        return this->tx_->isFieldPresent(sfBytecode);
+    }
+
+    /**
+     * @brief Get sfData (SoeOptional)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_VL::type::value_type>
+    getData() const
+    {
+        if (hasData())
+        {
+            return this->tx_->at(sfData);
+        }
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfData is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasData() const
+    {
+        return this->tx_->isFieldPresent(sfData);
     }
 };
 
@@ -232,6 +284,17 @@ public:
         return *this;
     }
 
+    /**
+     * @brief Set sfDestinationTag (SoeOptional)
+     * @return Reference to this builder for method chaining.
+     */
+    EscrowCreateBuilder&
+    setDestinationTag(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfDestinationTag] = value;
+        return *this;
+    }
+
     /**
      * @brief Set sfAmount (SoeRequired)
      * @note This field supports MPT (Multi-Purpose Token) amounts.
@@ -278,13 +341,24 @@ public:
     }
 
     /**
-     * @brief Set sfDestinationTag (SoeOptional)
+     * @brief Set sfBytecode (SoeOptional)
      * @return Reference to this builder for method chaining.
      */
     EscrowCreateBuilder&
-    setDestinationTag(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    setBytecode(std::decay_t<typename SF_VL::type::value_type> const& value)
     {
-        object_[sfDestinationTag] = value;
+        object_[sfBytecode] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfData (SoeOptional)
+     * @return Reference to this builder for method chaining.
+     */
+    EscrowCreateBuilder&
+    setData(std::decay_t<typename SF_VL::type::value_type> const& value)
+    {
+        object_[sfData] = value;
         return *this;
     }
 
diff --git a/include/xrpl/protocol_autogen/transactions/EscrowFinish.h b/include/xrpl/protocol_autogen/transactions/EscrowFinish.h
index 1cbc60c738..9c24c7671b 100644
--- a/include/xrpl/protocol_autogen/transactions/EscrowFinish.h
+++ b/include/xrpl/protocol_autogen/transactions/EscrowFinish.h
@@ -146,6 +146,32 @@ public:
     {
         return this->tx_->isFieldPresent(sfCredentialIDs);
     }
+
+    /**
+     * @brief Get sfGas (SoeOptional)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getGas() const
+    {
+        if (hasGas())
+        {
+            return this->tx_->at(sfGas);
+        }
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfGas is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasGas() const
+    {
+        return this->tx_->isFieldPresent(sfGas);
+    }
 };
 
 /**
@@ -249,6 +275,17 @@ public:
         return *this;
     }
 
+    /**
+     * @brief Set sfGas (SoeOptional)
+     * @return Reference to this builder for method chaining.
+     */
+    EscrowFinishBuilder&
+    setGas(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfGas] = value;
+        return *this;
+    }
+
     /**
      * @brief Build and return the EscrowFinish wrapper.
      * @param publicKey The public key for signing.
diff --git a/include/xrpl/protocol_autogen/transactions/SetFee.h b/include/xrpl/protocol_autogen/transactions/SetFee.h
index 9513723e94..edcea7b734 100644
--- a/include/xrpl/protocol_autogen/transactions/SetFee.h
+++ b/include/xrpl/protocol_autogen/transactions/SetFee.h
@@ -254,6 +254,84 @@ public:
     {
         return this->tx_->isFieldPresent(sfReserveIncrementDrops);
     }
+
+    /**
+     * @brief Get sfGasLimit (SoeOptional)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getGasLimit() const
+    {
+        if (hasGasLimit())
+        {
+            return this->tx_->at(sfGasLimit);
+        }
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfGasLimit is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasGasLimit() const
+    {
+        return this->tx_->isFieldPresent(sfGasLimit);
+    }
+
+    /**
+     * @brief Get sfBytecodeSizeLimit (SoeOptional)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getBytecodeSizeLimit() const
+    {
+        if (hasBytecodeSizeLimit())
+        {
+            return this->tx_->at(sfBytecodeSizeLimit);
+        }
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfBytecodeSizeLimit is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasBytecodeSizeLimit() const
+    {
+        return this->tx_->isFieldPresent(sfBytecodeSizeLimit);
+    }
+
+    /**
+     * @brief Get sfGasPrice (SoeOptional)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getGasPrice() const
+    {
+        if (hasGasPrice())
+        {
+            return this->tx_->at(sfGasPrice);
+        }
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfGasPrice is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasGasPrice() const
+    {
+        return this->tx_->isFieldPresent(sfGasPrice);
+    }
 };
 
 /**
@@ -386,6 +464,39 @@ public:
         return *this;
     }
 
+    /**
+     * @brief Set sfGasLimit (SoeOptional)
+     * @return Reference to this builder for method chaining.
+     */
+    SetFeeBuilder&
+    setGasLimit(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfGasLimit] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfBytecodeSizeLimit (SoeOptional)
+     * @return Reference to this builder for method chaining.
+     */
+    SetFeeBuilder&
+    setBytecodeSizeLimit(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfBytecodeSizeLimit] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfGasPrice (SoeOptional)
+     * @return Reference to this builder for method chaining.
+     */
+    SetFeeBuilder&
+    setGasPrice(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfGasPrice] = value;
+        return *this;
+    }
+
     /**
      * @brief Build and return the SetFee wrapper.
      * @param publicKey The public key for signing.
diff --git a/include/xrpl/shamap/SHAMap.h b/include/xrpl/shamap/SHAMap.h
index 05de33ddf3..6d4f719b5a 100644
--- a/include/xrpl/shamap/SHAMap.h
+++ b/include/xrpl/shamap/SHAMap.h
@@ -14,6 +14,7 @@
 #include <xrpl/shamap/SHAMapItem.h>
 #include <xrpl/shamap/SHAMapLeafNode.h>
 #include <xrpl/shamap/SHAMapMissingNode.h>
+#include <xrpl/shamap/SHAMapNodeID.h>
 #include <xrpl/shamap/SHAMapTreeNode.h>
 
 #include <condition_variable>
@@ -34,7 +35,6 @@
 
 namespace xrpl {
 
-class SHAMapNodeID;
 class SHAMapSyncFilter;
 
 /**
@@ -420,7 +420,107 @@ public:
     invariants() const;
 
 private:
-    using SharedPtrNodeStack = std::stack<std::pair<SHAMapTreeNodePtr, SHAMapNodeID>>;
+    /**
+     * A path from the root of the map down to some node, pairing each node with the ID naming its
+     * position.
+     *
+     * The two halves of an entry must agree, and the only way to get that wrong is to compute an ID
+     * from the wrong branch. So this type does not accept an ID at all: every push takes the branch
+     * being descended and derives the ID itself, so a node and its ID cannot disagree. Reads are
+     * exposed through the same accessors a std::stack would offer.
+     */
+    class NodePathStack
+    {
+    public:
+        [[nodiscard]] bool
+        empty() const
+        {
+            return stack_.empty();
+        }
+
+        [[nodiscard]] std::size_t
+        size() const
+        {
+            return stack_.size();
+        }
+
+        [[nodiscard]] std::pair<SHAMapTreeNodePtr, SHAMapNodeID> const&
+        top() const
+        {
+            XRPL_ASSERT(!stack_.empty(), "xrpl::SHAMap::NodePathStack::top : non-empty stack");
+            return stack_.top();
+        }
+
+        void
+        pop()
+        {
+            XRPL_ASSERT(!stack_.empty(), "xrpl::SHAMap::NodePathStack::pop : non-empty stack");
+            stack_.pop();
+        }
+
+        void
+        clear()
+        {
+            stack_ = {};
+        }
+
+        /**
+         * Start a path at the root of the map, whose ID is the zero-depth ID by definition.
+         */
+        void
+        pushRoot(SHAMapTreeNodePtr node)
+        {
+            XRPL_ASSERT(stack_.empty(), "xrpl::SHAMap::NodePathStack::pushRoot : empty stack");
+            stack_.emplace(std::move(node), SHAMapNodeID{});
+        }
+
+        /**
+         * Extend the path to the child of the current node reached by `branch`.
+         *
+         * A node keeps the depth it was reached at, never a normalized kLeafDepth. Only a leaf may
+         * sit at kLeafDepth, since an inner node there would have no branch left to select.
+         */
+        void
+        pushChild(SHAMapTreeNodePtr node, unsigned int branch)
+        {
+            XRPL_ASSERT(node, "xrpl::SHAMap::NodePathStack::pushChild : non-null node input");
+            XRPL_ASSERT(
+                !stack_.empty(), "xrpl::SHAMap::NodePathStack::pushChild : non-empty stack");
+            auto childID = stack_.top().second.getChildNodeID(branch);
+            XRPL_ASSERT_IF(
+                node->isInner(),
+                childID.getDepth() < kLeafDepth,
+                "xrpl::SHAMap::NodePathStack::pushChild : inner node above leaf depth");
+            XRPL_ASSERT_IF(
+                node->isLeaf(),
+                childID.isPrefixOf(leafKey(*node)),
+                "xrpl::SHAMap::NodePathStack::pushChild : leaf key below branch");
+            stack_.emplace(std::move(node), std::move(childID));
+        }
+
+        /**
+         * Extend the path to a node lying on the path to `target`.
+         *
+         * For nodes not reached by descending a known branch: the walk tracks only the key it is
+         * heading for, or the node is newly created. Either way `target` selects the branch.
+         */
+        void
+        pushNode(SHAMapTreeNodePtr node, uint256 const& target)
+        {
+            if (stack_.empty())
+            {
+                pushRoot(std::move(node));
+            }
+            else
+            {
+                pushChild(std::move(node), selectBranch(stack_.top().second, target));
+            }
+        }
+
+    private:
+        std::stack<std::pair<SHAMapTreeNodePtr, SHAMapNodeID>> stack_;
+    };
+
     using DeltaRef =
         std::pair<boost::intrusive_ptr<SHAMapItem const>, boost::intrusive_ptr<SHAMapItem const>>;
 
@@ -447,7 +547,7 @@ private:
      * Update hashes up to the root
      */
     void
-    dirtyUp(SharedPtrNodeStack& stack, uint256 const& target, SHAMapTreeNodePtr terminal);
+    dirtyUp(NodePathStack& stack, uint256 const& target, SHAMapTreeNodePtr terminal);
 
     /**
      * Walk towards the specified id, returning the node.  Caller must check
@@ -455,7 +555,7 @@ private:
      * id
      */
     SHAMapLeafNode*
-    walkTowardsKey(uint256 const& id, SharedPtrNodeStack* stack = nullptr) const;
+    walkTowardsKey(uint256 const& id, NodePathStack* stack = nullptr) const;
     /**
      * Return nullptr if key not found
      */
@@ -482,27 +582,29 @@ private:
     SHAMapTreeNodePtr
     writeNode(NodeObjectType t, SHAMapTreeNodePtr node) const;
 
-    // returns the first item at or below this node
-    SHAMapLeafNode*
-    firstBelow(SHAMapTreeNodePtr node, SharedPtrNodeStack& stack, unsigned int branch = 0u) const;
-
-    // returns the last item at or below this node
-    SHAMapLeafNode*
-    lastBelow(
-        SHAMapTreeNodePtr node,
-        SharedPtrNodeStack& stack,
-        unsigned int branch = kBranchFactor) const;
-
-    // direction in which belowHelper scans an inner node's branches
+    // direction in which a scan walks an inner node's branches
     enum class BelowDirection { First, Last };
 
-    // helper function for firstBelow and lastBelow
+    /**
+     * Returns the first or last item at or below the node already on top of `stack`, extending
+     * `stack` with the path walked to reach it.
+     */
     SHAMapLeafNode*
-    belowHelper(
-        SHAMapTreeNodePtr node,
-        SharedPtrNodeStack& stack,
-        unsigned int branch,
-        BelowDirection direction) const;
+    belowHelper(NodePathStack& stack, BelowDirection direction) const;
+
+    /**
+     * Returns the nearest item strictly past `id`, in the given direction.
+     *
+     * Walks back up the path to `id`. At each inner node the branches beyond the one `id` takes
+     * hold the candidates, so the first non-empty one is the closest and the extreme leaf below
+     * it is the answer.
+     *
+     * @param id The key to search from, which need not be in the map.
+     * @param direction First to search upwards from `id`, Last to search downwards.
+     * @return An iterator to the item found, or end() if no item lies on that side of `id`.
+     */
+    ConstIterator
+    boundHelper(uint256 const& id, BelowDirection direction) const;
 
     // Simple descent
     // Get a child of the specified node
@@ -550,9 +652,9 @@ private:
     hasLeafNode(uint256 const& tag, SHAMapHash const& hash) const;
 
     SHAMapLeafNode const*
-    peekFirstItem(SharedPtrNodeStack& stack) const;
+    peekFirstItem(NodePathStack& stack) const;
     SHAMapLeafNode const*
-    peekNextItem(uint256 const& id, SharedPtrNodeStack& stack) const;
+    peekNextItem(uint256 const& id, NodePathStack& stack) const;
     bool
     walkBranch(
         SHAMapTreeNode* node,
@@ -697,7 +799,7 @@ public:
     using pointer = value_type const*;
 
 private:
-    SharedPtrNodeStack stack_;
+    NodePathStack stack_;
     SHAMap const* map_ = nullptr;
     pointer item_ = nullptr;
 
@@ -723,7 +825,7 @@ public:
 private:
     explicit ConstIterator(SHAMap const* map);
     ConstIterator(SHAMap const* map, std::nullptr_t);
-    ConstIterator(SHAMap const* map, pointer item, SharedPtrNodeStack&& stack);
+    ConstIterator(SHAMap const* map, pointer item, NodePathStack&& stack);
 
     friend bool
     operator==(ConstIterator const& x, ConstIterator const& y);
@@ -742,10 +844,7 @@ inline SHAMap::ConstIterator::ConstIterator(SHAMap const* map, std::nullptr_t) :
 {
 }
 
-inline SHAMap::ConstIterator::ConstIterator(
-    SHAMap const* map,
-    pointer item,
-    SharedPtrNodeStack&& stack)
+inline SHAMap::ConstIterator::ConstIterator(SHAMap const* map, pointer item, NodePathStack&& stack)
     : stack_(std::move(stack)), map_(map), item_(item)
 {
 }
diff --git a/include/xrpl/tx/ApplyContext.h b/include/xrpl/tx/ApplyContext.h
index e827e69f01..7be7f34b0b 100644
--- a/include/xrpl/tx/ApplyContext.h
+++ b/include/xrpl/tx/ApplyContext.h
@@ -8,6 +8,7 @@
 #include <xrpl/ledger/ApplyViewImpl.h>
 #include <xrpl/ledger/OpenView.h>
 #include <xrpl/ledger/RawView.h>
+#include <xrpl/protocol/Book.h>
 #include <xrpl/protocol/STAmount.h>
 #include <xrpl/protocol/STTx.h>
 #include <xrpl/protocol/TER.h>
@@ -129,6 +130,14 @@ public:
         view_->rawDestroyXRP(fee);
     }
 
+    /**
+     * Registers a newly-created order book directory with the shared,
+     * process-wide OrderBookDB, unless this transaction is being applied
+     * under TapDryRun.
+     */
+    void
+    addOrderBook(Book const& book);
+
     ApplyViewContext
     getApplyViewContext()
     {
diff --git a/include/xrpl/tx/applySteps.h b/include/xrpl/tx/applySteps.h
index bd495481f2..0a1ae9fa3a 100644
--- a/include/xrpl/tx/applySteps.h
+++ b/include/xrpl/tx/applySteps.h
@@ -12,6 +12,7 @@
 #include <xrpl/protocol/XRPAmount.h>
 
 #include <cstdint>
+#include <expected>
 #include <optional>
 #include <utility>
 
@@ -393,16 +394,21 @@ preclaim(PreflightResult const& preflightResult, ServiceRegistry& registry, Open
  *
  * No validation is done or implied by this function.
  *
- * Caller is responsible for handling any exceptions.
- * Since none should be thrown, that will usually
- * mean terminating.
- *
+ * Callers do not expect this function to throw; exceptions from a transactor's
+ * `calculateBaseFee` are caught and reported as an error instead.
  * @param view The current open ledger.
  * @param tx The transaction to be checked.
  *
- * @return The base fee.
+ * @return The base fee on success. Returns `std::unexpected(temUNKNOWN)` if the transaction
+ * type is not recognized, and `std::unexpected(tefEXCEPTION)` if the transactor's
+ * `calculateBaseFee` threw.
+ *
+ * @note Failure is reported as an error rather than a fee of zero because a
+ * zero (or default) fee would pass checkFee and let the transaction be
+ * applied for less than it owes. Callers that only need a fee hint may fall
+ * back to a default; callers deciding whether to apply should reject.
  */
-XRPAmount
+[[nodiscard]] std::expected<XRPAmount, TER>
 calculateBaseFee(ReadView const& view, STTx const& tx);
 
 /**
diff --git a/include/xrpl/tx/invariants/LoanInvariant.h b/include/xrpl/tx/invariants/LoanInvariant.h
index 34ce1a4dc2..8cbdefc911 100644
--- a/include/xrpl/tx/invariants/LoanInvariant.h
+++ b/include/xrpl/tx/invariants/LoanInvariant.h
@@ -38,9 +38,11 @@ namespace xrpl {
  *    f. A Loan must reference a live `ltLOAN_BROKER`, and that broker must
  *       reference a live `ltVAULT`.
  *    g. Post-conditions for the Loan paid down by a successful `ttLOAN_PAY`:
- *       `PaymentRemaining > 0` after: `PrincipalOutstanding` and
- *          `PaymentRemaining` strictly decrease; `NextPaymentDueDate`
- *          advances by N * `PaymentInterval`, N > 0.
+ *       `PaymentRemaining > 0` after: neither `PrincipalOutstanding` nor
+ *          `TotalValueOutstanding` increases, and at least one of them
+ *          strictly decreases;
+ *          `PaymentRemaining` strictly decreases;
+ *          `NextPaymentDueDate` advances by N * `PaymentInterval`, N > 0.
  *       `PaymentRemaining == 0` after: pinned by checks 1 and 5b.
  *
  */
diff --git a/include/xrpl/tx/transactors/dex/AMMWithdraw.h b/include/xrpl/tx/transactors/dex/AMMWithdraw.h
index 6861fa7bc4..ea0ad3b253 100644
--- a/include/xrpl/tx/transactors/dex/AMMWithdraw.h
+++ b/include/xrpl/tx/transactors/dex/AMMWithdraw.h
@@ -109,6 +109,11 @@ public:
      * @param lpTokens current LPT balance
      * @param lpTokensWithdraw amount of tokens to withdraw
      * @param tfee trading fee in basis points
+     * @param freezeHandling whether a frozen balance is reported as zero
+     * @param authHandling whether an unauthorized MPT balance is reported as
+     *        zero
+     * @param reserveHandling whether the recipient owner-reserve check is
+     *        enforced when a trustline or MPToken has to be auto-created
      * @param withdrawAll if withdrawing all lptokens
      * @param priorBalance balance before fees
      * @return
@@ -128,6 +133,7 @@ public:
         std::uint16_t tfee,
         FreezeHandling freezeHandling,
         AuthHandling authHandling,
+        ReserveHandling reserveHandling,
         WithdrawAll withdrawAll,
         XRPAmount const& priorBalance,
         beast::Journal const& journal);
@@ -150,6 +156,11 @@ public:
      * @param lpTokensAMMBalance current AMM LPT balance
      * @param lpTokensWithdraw amount of lptokens to withdraw
      * @param tfee trading fee in basis points
+     * @param freezeHandling whether a frozen balance is reported as zero
+     * @param authHandling whether an unauthorized MPT balance is reported as
+     *        zero
+     * @param reserveHandling whether the recipient owner-reserve check is
+     *        enforced when a trustline or MPToken has to be auto-created
      * @param withdrawAll if withdraw all lptokens
      * @param priorBalance balance before fees
      * @return
@@ -169,6 +180,7 @@ public:
         std::uint16_t tfee,
         FreezeHandling freezeHandling,
         AuthHandling authHandling,
+        ReserveHandling reserveHandling,
         WithdrawAll withdrawAll,
         XRPAmount const& priorBalance,
         beast::Journal const& journal);
diff --git a/include/xrpl/tx/transactors/token/ConfidentialMPTMirrorUpdate.h b/include/xrpl/tx/transactors/token/ConfidentialMPTMirrorUpdate.h
new file mode 100644
index 0000000000..12ad5c8f28
--- /dev/null
+++ b/include/xrpl/tx/transactors/token/ConfidentialMPTMirrorUpdate.h
@@ -0,0 +1,98 @@
+#pragma once
+
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/core/ServiceRegistry.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/protocol/STTx.h>
+#include <xrpl/protocol/TER.h>
+#include <xrpl/protocol/XRPAmount.h>
+#include <xrpl/tx/ApplyContext.h>
+#include <xrpl/tx/Transactor.h>
+
+namespace xrpl {
+
+/**
+ * @brief Updates the encrypted mirror balances of a Confidential MPToken.
+ *
+ * @details
+ * This transaction updates a single holder's mirrored confidential balances
+ * (`sfIssuerEncryptedBalance` and/or `sfAuditorEncryptedBalance`) with the latest
+ * ElGamal public keys defined on the `MPTokenIssuance`.
+ *
+ * It supports both issuer and holder self-migration modes, each mode supports multiple flows:
+ * - Issuer mode: Submitted by the issuer.
+ * 1. Issuer Key Rotation Migration: Re-encrypts the
+ *   holder's `sfIssuerEncryptedBalance` under the issuer's new ElGamal public key.
+ *
+ * 2. Auditor Key Rotation Migration: Re-encrypts the
+ *   holder's `sfAuditorEncryptedBalance` under the auditor's new ElGamal public key.
+ *
+ * 3. Simultaneous Rotation Migration: Updates both the issuer
+ *   and auditor encrypted balances in a single transaction to optimize network throughput.
+ *
+ * 4. Auditor Late-Registration Migration: When the issuer ElGamal
+ *   public key is already registered on the `MPTokenIssuance` object, the issuer can
+ *   register an auditor key at a later time through `MPTokenIssuanceSet`. Then the issuer uses this
+ *   flow to set the holder's initial `sfAuditorEncryptedBalance` on `MPToken` object.
+ *
+ * - Holder self-migration mode: Submitted by the holder. The holder decrypts their own
+ *   `sfConfidentialBalanceSpending` with holder's private key to recover the balance and
+ *   re-encrypts it under the relevant new ElGamal public key(s). This mode is always
+ *   available to the holder and is not conditioned on the issuer being unable to migrate
+ *   them: the ledger cannot verify whether an issuer has really lost its private key. That
+ *   loss is only the expected motivation, since an issuer that still holds its key can
+ *   migrate holders itself in issuer mode.
+ * @note All holder migration flows strictly require the holder's
+ *       `sfConfidentialBalanceInbox` to be canonically zero; the holder must run
+ *       `ConfidentialMPTMergeInbox` first so the spending balance reflects the
+ *       full balance.
+ *
+ * 5. Holder Issuer-Mirror Migration: Re-encrypts the holder's
+ *    `sfIssuerEncryptedBalance` under the issuer's new ElGamal public key.
+ *
+ * 6. Holder Auditor-Mirror Migration: Re-encrypts the holder's
+ *    `sfAuditorEncryptedBalance` under the auditor's new ElGamal public key, or
+ *    sets it for the first time when the auditor key was late-registered. This is the
+ *    holder-driven counterpart to flows 2 and 4, for when the issuer does not migrate
+ *    the holder itself.
+ *
+ * 7. Simultaneous Holder Self-Migration: Updates both the issuer and auditor
+ *    encrypted balances in a single transaction (both keys have rotated).
+ */
+class ConfidentialMPTMirrorUpdate : public Transactor
+{
+public:
+    static constexpr auto kConsequencesFactory = ConsequencesFactoryType::Normal;
+
+    explicit ConfidentialMPTMirrorUpdate(ApplyContext& ctx) : Transactor(ctx)
+    {
+    }
+
+    static bool
+    checkExtraFeatures(PreflightContext const& ctx);
+
+    static NotTEC
+    preflight(PreflightContext const& ctx);
+
+    static XRPAmount
+    calculateBaseFee(ReadView const& view, STTx const& tx);
+
+    static TER
+    preclaim(PreclaimContext const& ctx);
+
+    TER
+    doApply() override;
+
+    void
+    visitInvariantEntry(bool isDelete, SLE::const_ref before, SLE::const_ref after) override;
+
+    [[nodiscard]] bool
+    finalizeInvariants(
+        STTx const& tx,
+        TER result,
+        XRPAmount fee,
+        ReadView const& view,
+        beast::Journal const& j) override;
+};
+
+}  // namespace xrpl
diff --git a/nix/check-tools/macos.txt b/nix/check-tools/macos.txt
index 8edfeef311..d2dee651f1 100644
--- a/nix/check-tools/macos.txt
+++ b/nix/check-tools/macos.txt
@@ -131,6 +131,9 @@ Rust toolchain:
   ✅ rust-analyzer
      rust-analyzer 1.97.1 (8bab26f4 2026-07-14)
      /nix/store/j6apc5pmd0giy15da9p650r8zklslmvi-rust-analyzer-preview-1.97.1-aarch64-apple-darwin/bin/rust-analyzer
+  ✅ rust-nightly
+     rustc 1.99.0-nightly (87e5904f5 2026-07-20)
+     /nix/store/fqpjz4l0nsnji8b2pz57mnj0akbp6hcl-rust-nightly/bin/rust-nightly
   ✅ rustc
      rustc 1.97.1 (8bab26f4f 2026-07-14)
      /nix/store/bnfk1sl4s9angb0vj1cj9a5y5zvqinwy-rust-minimal-1.97.1/bin/rustc
@@ -140,4 +143,4 @@ Rust toolchain:
 
 Skipping git-over-HTTPS check (CHECK_TOOLS_SKIP_CLONE is set).
 
-✅ All 44 checked tools are present and runnable.
+✅ All 45 checked tools are present and runnable.
diff --git a/nix/check-tools/nix-ubuntu-amd64.txt b/nix/check-tools/nix-ubuntu-amd64.txt
index 28b6c38014..ba5d5e65b1 100644
--- a/nix/check-tools/nix-ubuntu-amd64.txt
+++ b/nix/check-tools/nix-ubuntu-amd64.txt
@@ -131,6 +131,9 @@ Rust toolchain:
   ✅ rust-analyzer
      rust-analyzer 1.97.1 (8bab26f 2026-07-14)
      /nix/store/lr3m97p3hx1k22a7c44pb0wa7rbayhfi-rust-analyzer-preview-1.97.1-x86_64-unknown-linux-gnu/bin/rust-analyzer
+  ✅ rust-nightly
+     rustc 1.99.0-nightly (87e5904f5 2026-07-20)
+     /nix/store/j7kf7a5h4xypzp6x1skg4dsdx2k4fwb3-rust-nightly/bin/rust-nightly
   ✅ rustc
      rustc 1.97.1 (8bab26f4f 2026-07-14)
      /nix/store/40d3mzka7r1ps71l0yv2fs6616nbw85m-rust-minimal-1.97.1/bin/rustc
@@ -168,4 +171,4 @@ Mold:
 
 Skipping git-over-HTTPS check (CHECK_TOOLS_SKIP_CLONE is set).
 
-✅ All 52 checked tools are present and runnable.
+✅ All 53 checked tools are present and runnable.
diff --git a/nix/check-tools/nix-ubuntu-arm64.txt b/nix/check-tools/nix-ubuntu-arm64.txt
index b3b5885a7f..2b45230327 100644
--- a/nix/check-tools/nix-ubuntu-arm64.txt
+++ b/nix/check-tools/nix-ubuntu-arm64.txt
@@ -131,6 +131,9 @@ Rust toolchain:
   ✅ rust-analyzer
      rust-analyzer 1.97.1 (8bab26f 2026-07-14)
      /nix/store/262830dlw2517lnagfx7i7agqgl4fmsd-rust-analyzer-preview-1.97.1-aarch64-unknown-linux-gnu/bin/rust-analyzer
+  ✅ rust-nightly
+     rustc 1.99.0-nightly (87e5904f5 2026-07-20)
+     /nix/store/c59pxk1yikdlf129qwyg4fplmxcrha0k-rust-nightly/bin/rust-nightly
   ✅ rustc
      rustc 1.97.1 (8bab26f4f 2026-07-14)
      /nix/store/a6p27cg6b8szfixfyvkssx6l0c345zw8-rust-minimal-1.97.1/bin/rustc
@@ -168,4 +171,4 @@ Mold:
 
 Skipping git-over-HTTPS check (CHECK_TOOLS_SKIP_CLONE is set).
 
-✅ All 52 checked tools are present and runnable.
+✅ All 53 checked tools are present and runnable.
diff --git a/nix/docker/Dockerfile b/nix/docker/Dockerfile
index 5506bc3c77..7eae693ad2 100644
--- a/nix/docker/Dockerfile
+++ b/nix/docker/Dockerfile
@@ -10,6 +10,8 @@ RUN mkdir -p ~/.config/nix && \
 COPY nix/ci-env.nix /tmp/build/nix/ci-env.nix
 COPY nix/linux.nix /tmp/build/nix/linux.nix
 COPY nix/packages.nix /tmp/build/nix/packages.nix
+COPY nix/rust-nightly.sh /tmp/build/nix/rust-nightly.sh
+COPY nix/rust.nix /tmp/build/nix/rust.nix
 COPY nix/utils.nix /tmp/build/nix/utils.nix
 COPY flake.nix /tmp/build/
 COPY flake.lock /tmp/build/
diff --git a/nix/packages.nix b/nix/packages.nix
index c7972c9843..9af230097d 100644
--- a/nix/packages.nix
+++ b/nix/packages.nix
@@ -16,23 +16,7 @@ let
     exec ${pkgs.python3}/bin/python3 ${llvmPackages.clang-unwrapped}/bin/run-clang-tidy "$@"
   '';
 
-  # rust-overlay's toolchain propagates the *default* stdenv.cc onto the PATH (so
-  # cargo has a linker). That default may be different from the clang we pin here,
-  # so it shadows our clang and the build can silently use a different compiler
-  # version. Drop that cc from every propagation channel instead of pinning a
-  # replacement: the toolchain then carries no compiler and cargo just uses the
-  # active shell's stdenv cc. Must cover all channels — rust-overlay uses both
-  # propagatedBuildInputs and depsHostHostPropagated.
-  rustToolchainBase = pkgs.rust-bin.fromRustupToolchainFile ../rust-toolchain.toml;
-  rustToolchain =
-    let
-      defaultCc = pkgs.stdenv.cc; # default compiler from nixpkgs stdenv
-      withoutDefaultCc = builtins.filter (dep: (dep.outPath or "") != defaultCc.outPath);
-    in
-    rustToolchainBase.overrideAttrs (old: {
-      propagatedBuildInputs = withoutDefaultCc (old.propagatedBuildInputs or [ ]);
-      depsHostHostPropagated = withoutDefaultCc (old.depsHostHostPropagated or [ ]);
-    });
+  rust = import ./rust.nix { inherit pkgs; };
 
   # Nix wraps its toolchain so that binaries are exposed only under unsuffixed
   # names (gcc, g++, clang-tidy, ...). Several tools probe for a
@@ -108,41 +92,38 @@ in
     mkGcov
     ;
 
-  commonPackages = with pkgs; [
-    clangToolLinks
-    runClangTidyLink
-    ccache
-    clangbuildanalyzer
-    clangTools
-    cmake
-    conan
-    curlMinimal # needed for codecov/codecov-action
-    doxygen
-    file # needed for cpack in Clio
-    gcovr
-    gh
-    git
-    git-cliff
-    git-lfs
-    gnumake
-    gnupg # needed for signing commits & codecov/codecov-action
-    graphviz
-    less # needed for git diff
-    mold
-    nettools # provides netstat, used to debug failures in CI
-    ninja
-    patchelf
-    perl # needed for openssl
-    pkg-config
-    pre-commit
-    python3
-    runClangTidy
-    vim
-    zip
-    # Rust packages
-    cargo-audit
-    cargo-llvm-cov
-    cargo-nextest
-    rustToolchain
-  ];
+  commonPackages =
+    (with pkgs; [
+      clangToolLinks
+      runClangTidyLink
+      ccache
+      clangbuildanalyzer
+      clangTools
+      cmake
+      conan
+      curlMinimal # needed for codecov/codecov-action
+      doxygen
+      file # needed for cpack in Clio
+      gcovr
+      gh
+      git
+      git-cliff
+      git-lfs
+      gnumake
+      gnupg # needed for signing commits & codecov/codecov-action
+      graphviz
+      less # needed for git diff
+      mold
+      nettools # provides netstat, used to debug failures in CI
+      ninja
+      patchelf
+      perl # needed for openssl
+      pkg-config
+      pre-commit
+      python3
+      runClangTidy
+      vim
+      zip
+    ])
+    ++ rust.packages;
 }
diff --git a/nix/rust-nightly.sh b/nix/rust-nightly.sh
new file mode 100644
index 0000000000..263e647d8e
--- /dev/null
+++ b/nix/rust-nightly.sh
@@ -0,0 +1,23 @@
+#!@runtimeShell@
+# Reaches the nightly Rust toolchain, which is deliberately kept off PATH.
+# Packaged by nix/rust.nix, which explains why.
+
+set -euo pipefail
+
+usage() {
+    echo "usage: rust-nightly (path | run <command>...)" >&2
+    exit 2
+}
+
+case "${1-}" in
+    path) printf '%s\n' "@rustNightlyBin@" ;;
+    run)
+        shift
+        if [[ $# -eq 0 ]]; then
+            usage
+        fi
+        export PATH="@rustNightlyBin@:${PATH}"
+        exec "$@"
+        ;;
+    *) usage ;;
+esac
diff --git a/nix/rust.nix b/nix/rust.nix
new file mode 100644
index 0000000000..8be48dcad0
--- /dev/null
+++ b/nix/rust.nix
@@ -0,0 +1,84 @@
+# The Rust half of the tool set shared by the CI environment and the dev shell:
+# the stable toolchain pinned by rust-toolchain.toml, the nightly the Rust
+# coverage job needs, and the cargo plugins. Consumed by packages.nix.
+{ pkgs }:
+let
+  # rust-overlay's toolchain propagates the *default* stdenv.cc onto the PATH (so
+  # cargo has a linker). That default may be different from the clang we pin
+  # elsewhere, so it shadows our clang and the build can silently use a different
+  # compiler version. Drop that cc from every propagation channel instead of
+  # pinning a replacement: the toolchain then carries no compiler and cargo just
+  # uses the active shell's stdenv cc.
+  #
+  # The channel list is every list mkDerivation propagates to a dependent's
+  # environment (including the two legacy aliases). rust-overlay currently only
+  # uses propagatedBuildInputs and depsHostHostPropagated, but covering all of
+  # them means an upstream switch to another channel cannot quietly put the
+  # compiler back on PATH.
+  dropDefaultCc =
+    toolchain:
+    let
+      defaultCc = pkgs.stdenv.cc; # default compiler from nixpkgs stdenv
+      withoutDefaultCc = builtins.filter (dep: (dep.outPath or "") != defaultCc.outPath);
+    in
+    toolchain.overrideAttrs (
+      old:
+      pkgs.lib.genAttrs [
+        "depsBuildBuildPropagated"
+        "propagatedNativeBuildInputs" # alias of depsBuildHostPropagated
+        "depsBuildTargetPropagated"
+        "depsHostHostPropagated"
+        "propagatedBuildInputs" # alias of depsHostTargetPropagated
+        "depsTargetTargetPropagated"
+      ] (channel: withoutDefaultCc (old.${channel} or [ ]))
+    );
+
+  rustToolchain = dropDefaultCc (pkgs.rust-bin.fromRustupToolchainFile ../rust-toolchain.toml);
+
+  # cargo-llvm-cov honours the #[coverage(off)] that keeps unit tests out of the
+  # coverage report only under a nightly rustc, and looks for llvm-profdata and
+  # llvm-cov in that same toolchain's sysroot — hence llvm-tools-preview.
+  #
+  # Not every nightly ships every component, so `nightly.latest` breaks on the
+  # days llvm-tools-preview is absent; selectLatestNightlyWith walks back to the
+  # newest one that has it. The result is the newest such nightly *known to the
+  # locked rust-overlay*, which means updating flake.lock moves the compiler that
+  # produces the coverage numbers — and with it the rustc version recorded in
+  # nix/check-tools/*.txt, so those snapshots need regenerating alongside.
+  rustNightly = dropDefaultCc (
+    pkgs.rust-bin.selectLatestNightlyWith (
+      toolchain: toolchain.minimal.override { extensions = [ "llvm-tools-preview" ]; }
+    )
+  );
+
+  # A second toolchain cannot go on PATH: its cargo and rustc would collide with
+  # the pinned stable's in the ci-env buildEnv, which resolves collisions by
+  # picking one silently. Reaching the nightly only through this wrapper keeps it
+  # in the image closure (the Docker build copies the whole closure, not just
+  # what is linked into /bin) while leaving it inactive everywhere that does not
+  # ask for it.
+  #
+  # The script's `path` subcommand exists for scopes wider than one command — a
+  # CI job appending to $GITHUB_PATH, so that the cargo cache action's own
+  # `rustc -vV` probe, which runs in a step of its own, agrees with the toolchain
+  # the build will use.
+  rustNightlyScript = pkgs.replaceVarsWith {
+    name = "rust-nightly";
+    src = ./rust-nightly.sh;
+    dir = "bin";
+    isExecutable = true;
+    replacements = {
+      inherit (pkgs) runtimeShell;
+      rustNightlyBin = "${rustNightly}/bin";
+    };
+  };
+in
+{
+  packages = [
+    pkgs.cargo-audit
+    pkgs.cargo-llvm-cov
+    pkgs.cargo-nextest
+    rustNightlyScript
+    rustToolchain
+  ];
+}
diff --git a/package/README.md b/package/README.md
index 027a374898..50c12734e0 100644
--- a/package/README.md
+++ b/package/README.md
@@ -15,7 +15,8 @@ package/
     publish_pkg.py      Uploads built packages to the XRPLF Nexus repositories (called by CI, and shipped in that image)
   rpm/
     xrpld.spec      RPM spec
-  debian/           Debian control files (control, rules, copyright, xrpld.docs, xrpld.links, source/format)
+  debian/           Debian control files (control.in, lintian-overrides.in, rules, copyright, docs, links, source/format).
+                    The `.in` files are templates rendered by `build_pkg.py`; `docs` and `links` are staged under the package name
   shared/
     xrpld.service       systemd unit file (used by both RPM and DEB)
     xrpld.sysusers      sysusers.d config (used by both RPM and DEB)
@@ -32,32 +33,94 @@ packaging job cannot drift apart. Today only `linux/amd64` is emitted. The map
 pins the full container image in `image` — edit that field to move to a new
 image and both CI and local builds pick it up — and names the format that image
 builds in `type`, which CI passes to `build_pkg.py` as `--package-type`; the two
-have to stay in step.
+have to stay in step. An optional `variant` names a flavour of the package (see
+[Package variants](#package-variants)), and CI passes it as `--variant`.
 
-| Package type | Image (`configs.<distro>[].package.image` in `linux.json`) | Tools required                                      |
-| ------------ | ---------------------------------------------------------- | --------------------------------------------------- |
-| RPM          | `ghcr.io/xrplf/xrpld/packaging-rhel:sha-<sha>`             | `rpmbuild`, `rpmsign`                               |
-| DEB          | `ghcr.io/xrplf/xrpld/packaging-debian:sha-<sha>`           | `dpkg-buildpackage`, debhelper with compat level 13 |
+| Package type | Image (`configs.<distro>[].package.image` in `linux.json`) | Tools required                                                 |
+| ------------ | ---------------------------------------------------------- | -------------------------------------------------------------- |
+| RPM          | `ghcr.io/xrplf/xrpld/packaging-rhel:sha-<sha>`             | `rpmbuild`, `rpmsign`                                          |
+| DEB          | `ghcr.io/xrplf/xrpld/packaging-debian:sha-<sha>`           | `dpkg-buildpackage`, debhelper with compat level 13, `lintian` |
 
-To print the full packaging matrix (artifact names and images) for the current
-`linux.json`:
+To print the full packaging matrix (artifact names, images and package names)
+for the current `linux.json`:
 
 ```bash
 ./.github/scripts/strategy-matrix/generate.py --packaging
 ```
 
+## Package variants
+
+A config whose binaries are not the plain release build cannot be packaged as
+`xrpld`: both would carry the same name and version, so whichever published last
+would win. It is packaged as a **variant** instead — `variant: "assert"` in its
+`package` map, which CI passes to `build_pkg.py` as `--variant assert`,
+producing `xrpld-assert`. What the build option itself does is a build concern,
+not a packaging one; see the options table in [`BUILD.md`](../BUILD.md).
+
+A variant ships the same paths as `xrpld` — `/usr/bin/xrpld`, `/etc/xrpld`,
+`xrpld.service`, `/etc/logrotate.d/xrpld` — differing only in the per-package
+documentation directory, so it declares itself a stand-in for the plain package
+rather than something installable next to it: `Conflicts`, `Replaces` and a
+versioned `Provides: xrpld` on Debian, `Conflicts` and `Provides` on RPM.
+Neither format declares `Obsoletes`, so `apt upgrade` and `dnf upgrade` keep an
+installed flavour on its own flavour, and switching is always explicit:
+
+```bash
+apt-get install xrpld-assert # apt removes the plain package itself
+dnf swap xrpld xrpld-VARIANT # 'dnf install' alone stops at the conflict
+```
+
+Only the DEB packages carry a variant today — `xrpld-assert` comes from the
+`debian` config alone, there being no call for an assert build on RHEL-based
+distributions — but the RPM side works the same way if one is added.
+
+A switch is a removal plus an installation rather than an upgrade, so unlike a
+version upgrade it stops the service: Debian's scriptlets start it again, while
+on RPM the operator runs `systemctl start xrpld`. Configuration survives either
+way, being conffiles on Debian and `%config(noreplace)` on RPM.
+
+`dnf` installs the replacement before erasing the old flavour, whose `%preun`
+would leave `xrpld.service` disabled, so `%postun` re-applies the preset when
+the unit file outlives the erase — which, since rpm keeps a file another
+installed package owns, happens only during a swap. The cost is that a
+deliberate `systemctl disable` is not carried across an RPM switch.
+
+The alternative is an `xrpld-common` package owning the unit, the sysusers and
+tmpfiles snippets and the configuration, required by both flavours at an exact
+version: nothing is erased mid-swap, so no scriptlet has to detect one. It is
+not worth it for a single variant — it moves files out of the production
+package, and a sanitizer flavour would likely need its own unit anyway, putting
+the lifecycle back where it is now.
+
+Adding a variant is the flavour in `VARIANTS` in `build_pkg.py`, which is the
+list `--variant` accepts, plus a config in `linux.json` with the CMake arguments
+and a `package` map naming it, for one format or for both: `generate.py
+--packaging` emits the package names per format, and the `test-install-deb` and
+`test-install-rpm` jobs install what their own format produced.
+
+Operators switch between the flavours as described in
+[`docs/install.md`](../docs/install.md#optional-the-assert-enabled-build).
+
 ## Building packages
 
 ### Via CI
 
 Caller workflows (`on-pr.yml`, `on-tag.yml`, `on-trigger.yml`) call
-`reusable-package.yml`. That workflow generates its own packaging matrix from
-the configs that carry a `package` map (via `generate.py --packaging`) and fans
-out one job per distro. Each job downloads the pre-built `xrpld` and
-`validator-keys` binary artifacts and runs in that distro's container, building
-the format `package.type` declares. The packaging script derives the package
-version from the downloaded binary's `xrpld --version` output; no CMake
-configure or build step is needed inside the packaging job.
+`reusable-package.yml`, which runs in three stages:
+
+1. `package` fans out one job per config carrying a `package` map, building and
+   signing in that config's container, and uploading `<config>-pkg` alongside
+   `<config>-pkg-debug` for the much larger debug symbols.
+2. `test-install-deb` and `test-install-rpm` call
+   [`reusable-package-test-install.yml`](../.github/workflows/reusable-package-test-install.yml)
+   with their format's package names and distro images, installing each package
+   in the container of every distro that format targets and running the binaries
+   there, so one that cannot be installed never reaches Nexus.
+3. `publish` uploads both artifacts, or lists what it would upload.
+
+The packaging script derives the package version from the downloaded binary's
+`xrpld --version` output; no CMake configure or build step is needed inside the
+packaging job.
 
 The binaries come from the `debian` and `rhel` build configs themselves — the
 ones carrying the `package` map — which pass `-Dvalidator_keys=ON` so that the
@@ -94,11 +157,13 @@ docker run --rm \
     --pkg-release "${PKG_RELEASE}" \
     --channel UNRELEASED
 
-# Output:
-#   build/debbuild/*.deb         (DEB + dbgsym; Debian names both .deb)
+# Output (the deb image writes build/debbuild/*.deb instead):
 #   build/rpmbuild/RPMS/x86_64/*.rpm
 ```
 
+Add `--variant assert` to package binaries built with `-Dassert=ON`; the package
+is then named `xrpld-assert`.
+
 ### Via CMake (host-side target)
 
 If you run CMake configure on a host that has `rpmbuild` or `dpkg-buildpackage`
@@ -128,11 +193,17 @@ The package version is not a CMake input on this path: `build_pkg.py` derives it
 from the just-built `xrpld` binary's `xrpld --version` output. The package
 release defaults to 1 and is overridable with `-Dpkg_release=N`.
 
+`-Dassert=ON` passes `--variant assert`, so such a build packages as
+`xrpld-assert` without anything else being asked for.
+
 ## Publishing packages
 
-Packages are published to the XRPLF repositories on Sonatype Nexus at
-`https://packages.xrplf.org`. The `release-info` action decides the channel from
-the event, and `publish_pkg.py` maps that channel to its repositories:
+Packages are published to the XRPLF repositories on Sonatype Nexus through
+`https://packages-upload.xrplf.org`. Reads go through
+`https://packages.xrplf.org`, which Cloudflare proxies to cache them and which
+rejects request bodies over 100 MB, so uploads use the DNS-only host instead.
+The `release-info` action decides the channel from the event, and
+`publish_pkg.py` maps that channel to its repositories:
 
 | Event                    | Version           | Channel   | DEB repository | RPM upload repository |
 | ------------------------ | ----------------- | --------- | -------------- | --------------------- |
@@ -142,6 +213,9 @@ the event, and `publish_pkg.py` maps that channel to its repositories:
 | push to `develop`        | `xrpld --version` | `develop` | `deb-develop`  | `rpm-develop-hosted`  |
 | tag, non-public codebase | _any_             | `private` | `deb-private`  | `rpm-private-hosted`  |
 
+A variant is published to the same channel under its own name, so
+`xrpld-assert` never overwrites `xrpld`.
+
 Only a tag names a channel — do not extend that to `develop`, where
 `BuildInfo.cpp`'s `versionString` moves through `-bN`, `-rcN` and even the final
 version during a release cycle, which would send develop builds into `stable`.
@@ -155,9 +229,9 @@ the last, and the date and hash say which commit a package on
 `packages.xrplf.org` came from. Both reach the packaging scripts as arguments,
 so neither script derives anything itself.
 
-Publishing is the last step of each packaging job, uploading from the container
-that built the packages with the `publish_pkg.py` shipped in the image — the
-same copy other repositories run. Without `publish: true` the step is a
+Publishing is its own job, gated behind the install tests, uploading from the same
+image that built the packages with the `publish_pkg.py` shipped in it — the
+same copy other repositories run. Without `publish: true` the job is a
 `--dry-run`, listing the uploads it would make without needing credentials, so
 any run that builds packages also exercises the upload routing. `on-trigger.yml`
 passes `publish: true` for develop pushes in `XRPLF/rippled` and `on-tag.yml`
@@ -170,7 +244,7 @@ Nexus owns the repository metadata; nothing here indexes anything. Worth knowing
 - Each apt-hosted repository needs a distribution (ours use `any`) and a PGP
   signing keypair configured in Nexus, which rejects one created without a
   keypair. Nexus signs the apt metadata with it, never the packages.
-- Hosted yum repositories cannot be signed by Nexus, so each `rpm-<channel>-hosted`
+- yum-hosted repositories cannot be signed by Nexus, so each `rpm-<channel>-hosted`
   repository sits behind a `rpm-<channel>` yum group repository whose metadata
   Nexus signs. Uploads go to the hosted repository; clients point at the group
   and verify the metadata with `repo_gpgcheck=1`. Nexus never signs the RPMs
@@ -202,6 +276,9 @@ the final release. If that normalized package version still contains `-`,
 packaging fails because RPM forbids `-` in `Version`, and Debian uses `-` as
 the upstream/revision separator.
 
+> [!NOTE]
+> Debug and sanitizer builds are not packaged yet.
+
 `pkg_version` is the normalized package metadata version derived inside
 `build_pkg.py` from the binary-reported `xrpld` version (`-` pre-release
 separator converted to `~`). It is not a separate user input.
@@ -236,6 +313,19 @@ pre-release ordering convention, so RPM filenames/NVRs begin with forms like
 `xrpld-3.2.0~b1-...` and `xrpld-3.2.0~rc1-...` instead of encoding
 pre-releases with an older `0.<release>.<suffix>` RPM `Release` value.
 
+`--variant` is the flavour of the package, empty by default and accepting only
+the flavours in `VARIANTS`; see [Package variants](#package-variants). The RPM
+path passes it to the spec as the `pkg_variant` macro, which suffixes `Name` and
+adds the `Conflicts`/`Provides` pair. Debian control files have no conditionals, so the DEB path renders
+`debian/control.in` and `debian/lintian-overrides.in` instead, substituting
+`@PKG@` with the package name and `@VARIANT_FIELDS@` with the
+`Conflicts`/`Replaces`/`Provides` block, empty for the plain package; a token
+with no value fails the build rather than reaching dpkg. The files debhelper
+keys by package name (`docs`, `links`, and the units) are staged under that same
+name. The paths inside the package are unchanged either way, so `debian/rules`
+reads its package name from `dh_listpackages` and names the unit, sysusers,
+tmpfiles and logrotate files with `--name xrpld`.
+
 The package format is `--package-type`, either `deb` or `rpm`. It is required,
 so a job never silently builds the wrong format for the image it runs in; the
 matching build tool still has to be on PATH.
@@ -278,38 +368,51 @@ service restart.
 1. Creates a staging source tree at `debbuild/source/` inside the build directory.
 2. Stages the binaries, configs, `README.md`, `LICENSE.md`, and
    `validator-keys-LICENSE`.
-3. Copies `package/debian/` control files into `debbuild/source/debian/`.
-4. Copies shared service/sysusers/tmpfiles into `debian/` where `dh_installsystemd`, `dh_installsysusers`, and `dh_installtmpfiles` pick them up automatically.
+3. Stages `package/debian/` into `debbuild/source/debian/`: the `.in` templates
+   are rendered, and the files debhelper keys by package name (`docs`, `links`,
+   `lintian-overrides`) are staged under the name being built.
+4. Copies shared service/sysusers/tmpfiles/logrotate into `debian/` as
+   `<package>.xrpld.*`, which `dh_installsystemd`, `dh_installsysusers`,
+   `dh_installtmpfiles` and `dh_installlogrotate` read because `debian/rules`
+   passes them `--name xrpld`.
 5. Generates a minimal `debian/changelog` using `${pkg_version}-${PKG_RELEASE}`,
    where `pkg_version` is derived from the binary-reported `xrpld` version.
 6. Runs `dpkg-buildpackage -b --no-sign -d` (`-d` skips the build-dependency check, since the binary is already built). `debian/rules` uses manual `install` commands.
+
+   It also rewrites the `libc6` bound to `LIBC_MIN` in `debian/rules`, the glibc
+   the Nix toolchain builds against. `dpkg-shlibdeps` would otherwise derive it
+   from the build host's symbols file — on trixie that yields `libc6 (>= 2.34)`
+   because of `sysconf`, locking out distros the binaries run on. A check fails
+   the build if either binary outgrows `LIBC_MIN`.
+
 7. Output: `debbuild/*.deb`, the binary package and the `-dbgsym` package.
    Debian gives dbgsym packages a `.deb` extension; only Ubuntu uses `.ddeb`.
 
 ## Post-build verification
 
 ```bash
-# DEB
-dpkg-deb -c debbuild/*.deb | grep -E 'systemd|sysusers|tmpfiles'
+# DEB (one invocation per package: the dbgsym package is a .deb too)
+for deb in debbuild/*.deb; do dpkg-deb -c "${deb}"; done | grep -E 'systemd|sysusers|tmpfiles'
+lintian -I debbuild/*.deb
 
 # RPM
 rpm -qlp rpmbuild/RPMS/x86_64/*.rpm
-
-# Optional, and not in the packaging image: apt-get install -y lintian
-lintian -I debbuild/*.deb
 ```
 
+`lintian` still reports `embedded-library zlib`, `no-manual-page` and
+`initial-upload-closes-no-bugs`; only the `/usr/local` tags are overridden.
+
 ## Reproducibility
 
-`build_pkg.py` sets `SOURCE_DATE_EPOCH` from the latest git commit time and
-exports it; the RPM spec clamps file modification times to it via
-`%build_mtime_policy`. The remaining variables
-below further improve reproducibility but are _not_ set by the script — export
-them yourself if needed:
+Both formats build reproducibly as they are: the same binaries at the same
+commit give byte-identical packages on a rebuild, and nothing has to be
+exported by hand.
 
-```bash
-export TZ=UTC
-export LC_ALL=C.UTF-8
-export GZIP=-n
-export DEB_BUILD_OPTIONS="noautodbgsym reproducible=+fixfilepath"
-```
+`build_pkg.py` sets `SOURCE_DATE_EPOCH` from the latest git commit time.
+`dpkg-buildpackage` honours it on its own; the RPM spec sets three macros:
+
+- `%clamp_mtime_to_source_date_epoch` — file modification times, from
+  `SOURCE_DATE_EPOCH`.
+- `%use_source_date_epoch_as_buildtime` — the `BUILDTIME` header, from the
+  same.
+- `%_buildhost` — pinned, so the builder's hostname stays out of the header.
diff --git a/package/build_pkg.py b/package/build_pkg.py
index 2518d8c1db..77ef8f3120 100755
--- a/package/build_pkg.py
+++ b/package/build_pkg.py
@@ -19,7 +19,15 @@ from pathlib import Path
 # This script lives in the repository it packages.
 SRC_DIR = Path(__file__).resolve().parents[1]
 
-PRE_RELEASE = re.compile(r"^(b0|b[1-9][0-9]*|rc[0-9]+)(\+.*)?$")
+PRE_RELEASE = re.compile(r"^(b|rc)(0|[1-9][0-9]*)(\+.*)?$")
+
+# The package name a variant suffixes, and the name every variant keeps for its
+# on-disk paths (/usr/bin/xrpld, /etc/xrpld, xrpld.service).
+BASE_NAME = "xrpld"
+
+# The flavours that can be built, '' being the plain xrpld package. A variant
+# needs a config in linux.json to be built by CI; see package/README.md.
+VARIANTS = ("", "assert")
 
 # Files both packaging systems consume, staged under the same names.
 STAGED_FROM_BUILD = ("xrpld", "validator-keys", "validator-keys-LICENSE")
@@ -31,6 +39,18 @@ STAGED_FROM_SRC = {
 }
 STAGED_UNITS = ("xrpld.service", "xrpld.sysusers", "xrpld.tmpfiles", "xrpld.logrotate")
 
+# debian/ files debhelper keys by package name, staged as '<package>.<name>'.
+DEBIAN_PKG_FILES = ("docs", "links")
+
+# Debian control files have no conditionals, so what makes a variant replace the
+# plain package is rendered into control.in rather than written there.
+DEB_VARIANT_FIELDS = """\
+Conflicts: xrpld
+Replaces: xrpld
+Provides: xrpld (= ${binary:Version})"""
+
+TOKEN = re.compile(r"@[A-Z_]+@")
+
 
 def run(*command: object, cwd: Path | None = None) -> None:
     """Echo a command and run it."""
@@ -75,6 +95,28 @@ def package_version(reported: str) -> str:
     return version
 
 
+def render(template: Path, dest: Path, values: dict[str, str]) -> None:
+    """Write template to dest with its @TOKEN@ placeholders substituted.
+
+    A token left without a value fails the build rather than reaching dpkg.
+    """
+    text = template.read_text()
+    for token, value in values.items():
+        text = text.replace(f"@{token}@", value)
+
+    missing = sorted(set(TOKEN.findall(text)))
+    assert not missing, f"{template}: no value for {', '.join(missing)}"
+
+    # An empty value at the end of a stanza would otherwise leave a blank line,
+    # which is what ends a stanza.
+    dest.write_text(text.rstrip("\n") + "\n")
+
+
+def package_name(variant: str) -> str:
+    """The binary package name for a variant: '' -> xrpld, 'assert' -> xrpld-assert."""
+    return f"{BASE_NAME}-{variant}" if variant else BASE_NAME
+
+
 def read_version(xrpld: Path) -> str:
     """Read the version from the binary that is about to be packaged."""
     fields = capture(xrpld, "--version").partition("\n")[0].split()
@@ -133,11 +175,20 @@ def stage_common(build_dir: Path, dest: Path) -> None:
         shutil.copy2(build_dir / name, dest / name)
     for source, name in STAGED_FROM_SRC.items():
         shutil.copy2(SRC_DIR / source, dest / name)
+
+
+def stage_units(dest: Path, *, prefix: str = "") -> None:
+    """Copy the systemd, sysusers, tmpfiles and logrotate files into dest.
+
+    Each format wants them somewhere else: rpmbuild reads them from SOURCES by
+    path, debhelper from debian/ by package name -- hence 'prefix', which makes
+    the copies 'xrpld-assert.xrpld.service' and so on.
+    """
     for name in STAGED_UNITS:
-        shutil.copy2(SRC_DIR / "package" / "shared" / name, dest / name)
+        shutil.copy2(SRC_DIR / "package" / "shared" / name, dest / f"{prefix}{name}")
 
 
-def build_rpm(build_dir: Path, *, version: str, pkg_release: str) -> None:
+def build_rpm(build_dir: Path, *, version: str, pkg_release: str, variant: str) -> None:
     """Stage the spec and its sources, then build the binary RPMs."""
     topdir = build_dir / "rpmbuild"
     for name in ("BUILD", "BUILDROOT", "RPMS", "SOURCES", "SPECS", "SRPMS"):
@@ -146,6 +197,10 @@ def build_rpm(build_dir: Path, *, version: str, pkg_release: str) -> None:
     spec = topdir / "SPECS" / "xrpld.spec"
     shutil.copy2(SRC_DIR / "package" / "rpm" / "xrpld.spec", spec)
     stage_common(build_dir, topdir / "SOURCES")
+    stage_units(topdir / "SOURCES")
+
+    # The spec defaults it to nothing, so a plain build is unchanged.
+    variant_defines = ["--define", f"pkg_variant {variant}"] if variant else []
 
     run(
         "rpmbuild",
@@ -159,10 +214,29 @@ def build_rpm(build_dir: Path, *, version: str, pkg_release: str) -> None:
         # The image tracks the newest distro, but the packages target el9.
         "--define",
         "dist .el9",
+        *variant_defines,
         spec,
     )
 
 
+def stage_debian(dest: Path, name: str) -> None:
+    """Stage the debian directory for the package name being built."""
+    source = SRC_DIR / "package" / "debian"
+    shutil.copytree(
+        source, dest, ignore=shutil.ignore_patterns("*.in", *DEBIAN_PKG_FILES)
+    )
+
+    values = {
+        "PKG": name,
+        "VARIANT_FIELDS": "" if name == BASE_NAME else DEB_VARIANT_FIELDS,
+    }
+    render(source / "control.in", dest / "control", values)
+    render(source / "lintian-overrides.in", dest / f"{name}.lintian-overrides", values)
+
+    for suffix in DEBIAN_PKG_FILES:
+        shutil.copy2(source / suffix, dest / f"{name}.{suffix}")
+
+
 def build_deb(
     build_dir: Path,
     *,
@@ -171,30 +245,29 @@ def build_deb(
     pkg_release: str,
     channel: str,
     epoch: int,
+    name: str,
 ) -> None:
     """Stage the debian directory and its sources, then build the binary DEBs."""
     staging = build_dir / "debbuild" / "source"
     stage_common(build_dir, staging)
-    shutil.copytree(SRC_DIR / "package" / "debian", staging / "debian")
+    stage_debian(staging / "debian", name)
 
-    # debhelper picks these up from debian/ automatically.
-    for name in STAGED_UNITS:
-        shutil.copy2(staging / name, staging / "debian" / name)
+    # Prefixed whether it is a variant's name or not: debian/rules names them
+    # explicitly either way.
+    stage_units(staging / "debian", prefix=f"{name}.")
 
     date = datetime.fromtimestamp(epoch, timezone.utc).strftime(
         "%a, %d %b %Y %H:%M:%S %z"
     )
     # The leading spaces are significant to dpkg.
     changelog = textwrap.dedent(f"""\
-        xrpld ({version}-{pkg_release}) {channel}; urgency=medium
+        {name} ({version}-{pkg_release}) {channel}; urgency=medium
           * Release {reported}.
 
          -- XRPL Foundation <contact@xrplf.org>  {date}
         """)
     (staging / "debian" / "changelog").write_text(changelog)
 
-    (staging / "debian" / "rules").chmod(0o755)
-
     run("dpkg-buildpackage", "-b", "--no-sign", "-d", cwd=staging)
 
 
@@ -217,6 +290,14 @@ def main() -> None:
         default="1",
         help="package release iteration (default: %(default)s)",
     )
+    parser.add_argument(
+        "--variant",
+        default="",
+        choices=VARIANTS,
+        help="the flavour of the package to build: 'assert' produces "
+        "xrpld-assert, which ships the same paths as xrpld and replaces it "
+        "(default: the plain xrpld package)",
+    )
     parser.add_argument(
         "--channel",
         required=True,
@@ -228,6 +309,8 @@ def main() -> None:
     build_dir: Path = args.build_dir.resolve()
     pkg_release: str = args.pkg_release
     channel: str = args.channel
+    variant: str = args.variant
+    name = package_name(variant)
 
     assert build_dir.is_dir(), (
         f"build directory not found: {build_dir}. Build the binaries before "
@@ -247,6 +330,8 @@ def main() -> None:
     for tree in ("debbuild", "rpmbuild"):
         shutil.rmtree(build_dir / tree, ignore_errors=True)
 
+    print(f"Building {package_type} {name} {version}-{pkg_release}", flush=True)
+
     if package_type == "deb":
         build_deb(
             build_dir,
@@ -255,9 +340,10 @@ def main() -> None:
             pkg_release=pkg_release,
             channel=channel,
             epoch=epoch,
+            name=name,
         )
     else:
-        build_rpm(build_dir, version=version, pkg_release=pkg_release)
+        build_rpm(build_dir, version=version, pkg_release=pkg_release, variant=variant)
 
 
 if __name__ == "__main__":
diff --git a/package/debian/control b/package/debian/control.in
similarity index 91%
rename from package/debian/control
rename to package/debian/control.in
index 62e5d79ef1..20486efc9a 100644
--- a/package/debian/control
+++ b/package/debian/control.in
@@ -1,18 +1,17 @@
-Source: xrpld
+Source: @PKG@
 Section: net
 Priority: optional
 Maintainer: XRPL Foundation <contact@xrplf.org>
 Rules-Requires-Root: no
 Build-Depends:
+ binutils,
  debhelper-compat (= 13)
 Standards-Version: 4.7.0
 Homepage: https://github.com/XRPLF/rippled
 Vcs-Git: https://github.com/XRPLF/rippled.git
 Vcs-Browser: https://github.com/XRPLF/rippled
 
-Package: xrpld
-Section: net
-Priority: optional
+Package: @PKG@
 Architecture: any
 Depends:
  ${shlibs:Depends},
@@ -23,3 +22,4 @@ Description: XRP Ledger daemon
  transactions, and maintains the ledger database.
  This package also includes the validator-keys tool for validator key
  management.
+@VARIANT_FIELDS@
diff --git a/package/debian/copyright b/package/debian/copyright
index 2cf673854a..baaa12e13c 100644
--- a/package/debian/copyright
+++ b/package/debian/copyright
@@ -1,5 +1,5 @@
 Format: https://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
-Upstream-Name: rippled
+Upstream-Name: xrpld
 Source: https://github.com/XRPLF/rippled
 
 Files: *
@@ -15,7 +15,7 @@ Copyright: 2016, Ripple Labs Inc.
  2009-2010, Satoshi Nakamoto
  2011, The Bitcoin developers
  2003-2005, Tom Wu
-License: ISC
+License: ISC and BSL-1.0 and MIT and Tom-Wu
 Comment: Built from https://github.com/ripple/validator-keys-tool at the commit
  pinned in cmake/XrplValidatorKeys.cmake. Besides ISC-licensed code it
  incorporates work under the Boost Software License 1.0 (ASIO), the MIT/X11
@@ -35,3 +35,74 @@ License: ISC
  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+License: BSL-1.0
+ Boost Software License - Version 1.0 - August 17th, 2003
+ .
+ Permission is hereby granted, free of charge, to any person or organization
+ obtaining a copy of the software and accompanying documentation covered by
+ this license (the "Software") to use, reproduce, display, distribute,
+ execute, and transmit the Software, and to prepare derivative works of the
+ Software, and to permit third-parties to whom the Software is furnished to
+ do so, all subject to the following:
+ .
+ The copyright notices in the Software and this entire statement, including
+ the above license grant, this restriction and the following disclaimer,
+ must be included in all copies of the Software, in whole or in part, and
+ all derivative works of the Software, unless such copies or derivative
+ works are solely in the form of machine-executable object code generated by
+ a source language processor.
+ .
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+ SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+ FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ DEALINGS IN THE SOFTWARE.
+
+License: MIT
+ Permission is hereby granted, free of charge, to any person obtaining a
+ copy of this software and associated documentation files (the "Software"),
+ to deal in the Software without restriction, including without limitation
+ the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ and/or sell copies of the Software, and to permit persons to whom the
+ Software is furnished to do so, subject to the following conditions:
+ .
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+ .
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ DEALINGS IN THE SOFTWARE.
+
+License: Tom-Wu
+ Permission is hereby granted, free of charge, to any person obtaining
+ a copy of this software and associated documentation files (the
+ "Software"), to deal in the Software without restriction, including
+ without limitation the rights to use, copy, modify, merge, publish,
+ distribute, sublicense, and/or sell copies of the Software, and to
+ permit persons to whom the Software is furnished to do so, subject to
+ the following conditions:
+ .
+ The above copyright notice and this permission notice shall be
+ included in all copies or substantial portions of the Software.
+ .
+ THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
+ WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
+ .
+ IN NO EVENT SHALL TOM WU BE LIABLE FOR ANY SPECIAL, INCIDENTAL,
+ INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, OR ANY DAMAGES WHATSOEVER
+ RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER OR NOT ADVISED OF
+ THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF LIABILITY, ARISING OUT
+ OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ .
+ In addition, the following condition applies:
+ .
+ All redistributions must retain an intact copy of this copyright notice
+ and disclaimer.
diff --git a/package/debian/xrpld.docs b/package/debian/docs
similarity index 75%
rename from package/debian/xrpld.docs
rename to package/debian/docs
index 77681ddc6e..97325dfcf5 100644
--- a/package/debian/xrpld.docs
+++ b/package/debian/docs
@@ -1,2 +1,3 @@
 README.md
+LICENSE.md
 validator-keys-LICENSE
diff --git a/package/debian/links b/package/debian/links
new file mode 100644
index 0000000000..6dea4f28f3
--- /dev/null
+++ b/package/debian/links
@@ -0,0 +1,3 @@
+# Legacy compatibility for pre-FHS package layouts.
+# TODO: remove after rippled fully deprecated.
+usr/bin/xrpld          usr/local/bin/rippled
diff --git a/package/debian/lintian-overrides.in b/package/debian/lintian-overrides.in
new file mode 100644
index 0000000000..5e72a5ef6b
--- /dev/null
+++ b/package/debian/lintian-overrides.in
@@ -0,0 +1,6 @@
+# The /usr/local/bin/rippled symlink is deliberate compatibility for pre-FHS
+# layouts, so the Policy 9.1.2 tags it raises are expected.
+# TODO: remove alongside debian/links after rippled fully deprecated.
+@PKG@: dir-in-usr-local [usr/local/bin/]
+@PKG@: file-in-usr-local [usr/local/bin/rippled]
+@PKG@: file-in-unusual-dir [usr/local/bin/rippled]
diff --git a/package/debian/rules b/package/debian/rules
old mode 100644
new mode 100755
index 8f880b8192..bc12f54218
--- a/package/debian/rules
+++ b/package/debian/rules
@@ -2,25 +2,76 @@
 
 export DH_VERBOSE = 1
 
+# The glibc the Nix toolchain builds against, and so the real floor for the
+# binaries. dpkg-shlibdeps would instead derive libc6 (>= 2.34) from the build
+# host's symbols file, where sysconf carries that minver, locking out distros
+# the binaries actually run on.
+LIBC_MIN = 2.31
+
+# The binary package's name, which a variant build changes to e.g. xrpld-assert,
+# and the directory debhelper expects its files staged in.
+PKG := $(firstword $(shell dh_listpackages))
+PKG_DIR = debian/$(PKG)
+
+# The base name, which every package ships under whatever it is called itself.
+BASE_NAME = xrpld
+
+# What build_pkg.py stages beside this directory, each installed under its own
+# name. The binaries are also the ones checked against LIBC_MIN below.
+BINARIES = $(BASE_NAME) validator-keys
+CONFIGS = $(BASE_NAME).cfg validators.txt
+
 %:
 	dh $@
 
 override_dh_auto_configure override_dh_auto_build override_dh_auto_test:
 	@:
 
+# The unit, sysusers, tmpfiles and logrotate files are named after the daemon
+# rather than after the package, so a variant still ships xrpld.service and
+# /etc/logrotate.d/xrpld. debhelper only reads debian/$(PKG).$(BASE_NAME).* when told
+# the name.
 override_dh_installsystemd:
-	dh_installsystemd --no-stop-on-upgrade xrpld.service
+	dh_installsystemd --no-stop-on-upgrade --name $(BASE_NAME)
 
+# The tmpfiles snippet sets ownership to the xrpld user, so the sysusers snippet
+# has to be emitted first: run it early and make its own sequence slot a no-op.
 execute_before_dh_installtmpfiles:
-	dh_installsysusers
+	dh_installsysusers --name $(BASE_NAME)
 
 override_dh_installsysusers:
 
+override_dh_installtmpfiles:
+	dh_installtmpfiles --name $(BASE_NAME)
+
+override_dh_installlogrotate:
+	dh_installlogrotate --name $(BASE_NAME)
+
 override_dh_install:
-	install -D -m 0755 xrpld            debian/xrpld/usr/bin/xrpld
-	install -D -m 0755 validator-keys   debian/xrpld/usr/bin/validator-keys
-	install -D -m 0644 xrpld.cfg        debian/xrpld/etc/xrpld/xrpld.cfg
-	install -D -m 0644 validators.txt   debian/xrpld/etc/xrpld/validators.txt
+	for binary in $(BINARIES); do \
+		install -D -m 0755 "$$binary" "$(PKG_DIR)/usr/bin/$$binary"; \
+	done
+	for config in $(CONFIGS); do \
+		install -D -m 0644 "$$config" "$(PKG_DIR)/etc/$(BASE_NAME)/$$config"; \
+	done
+
+override_dh_shlibdeps:
+	dh_shlibdeps
+	# Guards against the toolchain moving past LIBC_MIN and the packages then
+	# claiming a floor they do not meet.
+	for binary in $(BINARIES); do \
+		needed=$$(readelf --dyn-syms --wide $$binary \
+			| grep -o 'GLIBC_[0-9.]*' | sed 's/GLIBC_//' | sort -uV | tail -1); \
+		if [ -z "$$needed" ]; then \
+			echo "$$binary: no GLIBC_ symbol versions read, cannot check LIBC_MIN" >&2; \
+			exit 1; \
+		fi; \
+		if dpkg --compare-versions "$$needed" gt "$(LIBC_MIN)"; then \
+			echo "$$binary needs glibc $$needed, above LIBC_MIN $(LIBC_MIN)" >&2; \
+			exit 1; \
+		fi; \
+	done
+	sed -i 's/libc6 (>= [0-9.]*)/libc6 (>= $(LIBC_MIN))/' debian/$(PKG).substvars
 
 override_dh_dwz:
 	@:
diff --git a/package/debian/xrpld.links b/package/debian/xrpld.links
deleted file mode 100644
index 10d34f5b8c..0000000000
--- a/package/debian/xrpld.links
+++ /dev/null
@@ -1,2 +0,0 @@
-# Legacy compat symlinks (remove next major release)
-usr/bin/xrpld          usr/local/bin/rippled
diff --git a/package/docker/Dockerfile b/package/docker/Dockerfile
index b55c37b02a..adf372b6fa 100644
--- a/package/docker/Dockerfile
+++ b/package/docker/Dockerfile
@@ -2,9 +2,9 @@ ARG BASE_IMAGE=debian:trixie
 
 FROM ${BASE_IMAGE}
 
-COPY bin/install-packaging-tools.sh /tmp/install-packaging-tools.sh
-
-RUN /tmp/install-packaging-tools.sh
+# Bind-mounted rather than copied in, so the installer never lands in a layer.
+RUN --mount=type=bind,source=bin/install-packaging-tools.sh,target=/install-packaging-tools.sh \
+    /install-packaging-tools.sh
 
 # See ../README.md, "Publishing from other repositories".
 COPY package/docker/publish_pkg.py /usr/local/bin/publish_pkg.py
diff --git a/package/docker/publish_pkg.py b/package/docker/publish_pkg.py
index c9a6d3db1e..a112e284aa 100755
--- a/package/docker/publish_pkg.py
+++ b/package/docker/publish_pkg.py
@@ -1,8 +1,8 @@
 #!/usr/bin/env python3
 """Publish built DEB and RPM packages to the XRPLF repositories on Nexus.
 
-Takes packages and a channel, and nothing else, so it publishes whatever built
-them; see package/README.md, "Publishing from other repositories".
+Knows nothing about what it uploads beyond the channel, so it publishes whatever
+built the packages; see package/README.md, "Publishing from other repositories".
 
 RPMs are uploaded to the hosted repository, but yum clients install from the
 'rpm-<channel>' group repository in front of it, which serves signed metadata.
@@ -29,6 +29,9 @@ STALL_TIMEOUT = 300
 ATTEMPTS = 4
 RETRY_DELAY = 5
 
+# 429 is Nexus asking to slow down, not a rejection, so it retries like a 5xx.
+RETRYABLE_STATUSES = (429,)
+
 
 def build_opener() -> urllib.request.OpenerDirector:
     """An opener with no redirect handler, so a 3xx raises instead of being followed.
@@ -47,9 +50,9 @@ def build_opener() -> urllib.request.OpenerDirector:
 def upload(url: str, method: str, headers: dict[str, str], package: Path) -> None:
     """Send one package, retrying only what is worth retrying.
 
-    A 4xx is a deterministic rejection, so it is reported at once rather than
-    re-sending the whole body three more times. Nexus explains what it rejected
-    in the response body, so that body is always surfaced.
+    A 4xx other than 429 is a deterministic rejection, so it is reported at once
+    rather than re-sending the whole body three more times. Nexus explains what
+    it rejected in the response body, so that body is always surfaced.
     """
     opener = build_opener()
 
@@ -67,7 +70,7 @@ def upload(url: str, method: str, headers: dict[str, str], package: Path) -> Non
         except urllib.error.HTTPError as error:
             detail = error.read().decode(errors="replace").strip()
             reason = f"HTTP {error.code}: {detail}"
-            retryable = error.code >= 500
+            retryable = error.code >= 500 or error.code in RETRYABLE_STATUSES
         except (urllib.error.URLError, OSError) as error:
             reason = str(error)
             retryable = True
@@ -95,7 +98,7 @@ def main() -> None:
     )
     parser.add_argument(
         "--nexus-url",
-        default="https://packages.xrplf.org",
+        default="https://packages-upload.xrplf.org",
         help="the Nexus instance to publish to (default: %(default)s)",
     )
     parser.add_argument(
@@ -121,6 +124,8 @@ def main() -> None:
         token = base64.b64encode(f"{username}:{password}".encode()).decode()
         auth = {"Authorization": f"Basic {token}"}
 
+    # Deliberately not shared with sign_rpm.py: this script ships standalone in
+    # the packaging image for other repositories to run.
     packages = sorted(
         path
         for path in package_dir.rglob("*")
diff --git a/package/rpm/xrpld.spec b/package/rpm/xrpld.spec
index 23974c8900..45e7a78e42 100644
--- a/package/rpm/xrpld.spec
+++ b/package/rpm/xrpld.spec
@@ -6,10 +6,14 @@
 %{error:pkg_release must be defined}
 %endif
 
-Name:     xrpld
+# The base name, which every package ships under. A variant build
+# (build_pkg.py --variant) only suffixes the package name, e.g. xrpld-assert.
+%global base_name xrpld
+
+Name:     %{base_name}%{?pkg_variant:-%{pkg_variant}}
 Version:  %{pkg_version}
 Release:  %{pkg_release}%{?dist}
-Summary:  XRP Ledger daemon
+Summary:  XRP Ledger daemon%{?pkg_variant: (%{pkg_variant} build)}
 
 License:  ISC
 URL:      https://github.com/XRPLF/rippled
@@ -17,6 +21,17 @@ URL:      https://github.com/XRPLF/rippled
 ExclusiveArch: x86_64 aarch64
 BuildRequires: systemd-rpm-macros
 
+# A variant owns the same paths, so it stands in for the plain package.
+%if "%{?pkg_variant}" != ""
+Conflicts: %{base_name}
+Provides:  %{base_name} = %{version}-%{release}
+%endif
+
+# These have to precede %%debug_package: it opens the debuginfo subpackage, and
+# any tag after it is silently dropped from the main package.
+%{?systemd_requires}
+%{?sysusers_requires_compat}
+
 %undefine _debugsource_packages
 %debug_package
 # Level 3 rather than the el9 default of 19: it shrinks the multi-gigabyte
@@ -25,10 +40,13 @@ BuildRequires: systemd-rpm-macros
 %global _binary_payload w3.zstdio
 %global _find_debuginfo_dwz_opts %{nil}
 
-%build_mtime_policy clamp_to_source_date_epoch
+# Reproducibility: the first two take their value from the SOURCE_DATE_EPOCH
+# build_pkg.py exports. Without these the header records the wall clock and the
+# build container's hostname, so two builds of the same commit differ.
+%global clamp_mtime_to_source_date_epoch 1
+%global use_source_date_epoch_as_buildtime 1
+%global _buildhost xrplf.org
 
-%{?systemd_requires}
-%{?sysusers_requires_compat}
 
 %description
 xrpld is the reference implementation of the XRP Ledger protocol. It
@@ -44,22 +62,22 @@ management.
 :
 
 %install
-install -Dm0755 %{_sourcedir}/xrpld                %{buildroot}%{_bindir}/%{name}
+install -Dm0755 %{_sourcedir}/xrpld                %{buildroot}%{_bindir}/%{base_name}
 install -Dm0755 %{_sourcedir}/validator-keys       %{buildroot}%{_bindir}/validator-keys
-install -Dm0644 %{_sourcedir}/xrpld.cfg            %{buildroot}%{_sysconfdir}/%{name}/xrpld.cfg
-install -Dm0644 %{_sourcedir}/validators.txt       %{buildroot}%{_sysconfdir}/%{name}/validators.txt
+install -Dm0644 %{_sourcedir}/xrpld.cfg            %{buildroot}%{_sysconfdir}/%{base_name}/xrpld.cfg
+install -Dm0644 %{_sourcedir}/validators.txt       %{buildroot}%{_sysconfdir}/%{base_name}/validators.txt
 
 # systemd units, sysusers, tmpfiles, preset
 install -Dm0644 %{_sourcedir}/xrpld.service        %{buildroot}%{_unitdir}/xrpld.service
 install -Dm0644 %{_sourcedir}/xrpld.sysusers       %{buildroot}%{_sysusersdir}/xrpld.conf
 install -Dm0644 %{_sourcedir}/xrpld.tmpfiles       %{buildroot}%{_tmpfilesdir}/xrpld.conf
-install -Dm0644 /dev/null %{buildroot}%{_presetdir}/50-xrpld.preset
-cat >%{buildroot}%{_presetdir}/50-xrpld.preset <<'EOF'
+install -d %{buildroot}%{_presetdir}
+cat >%{buildroot}%{_presetdir}/50-%{base_name}.preset <<'EOF'
 enable xrpld.service
 EOF
 
 # Logrotate config
-install -Dm0644 %{_sourcedir}/xrpld.logrotate      %{buildroot}%{_sysconfdir}/logrotate.d/%{name}
+install -Dm0644 %{_sourcedir}/xrpld.logrotate      %{buildroot}%{_sysconfdir}/logrotate.d/%{base_name}
 
 # Docs
 install -Dm0644 %{_sourcedir}/LICENSE.md %{buildroot}%{_docdir}/%{name}/LICENSE.md
@@ -70,13 +88,13 @@ install -Dm0644 %{_sourcedir}/validator-keys-LICENSE %{buildroot}%{_docdir}/%{na
 # Legacy compatibility for pre-FHS package layouts.
 # TODO: remove after rippled fully deprecated.
 install -d %{buildroot}/usr/local/bin
-ln -s %{_bindir}/%{name} %{buildroot}/usr/local/bin/rippled
+ln -s %{_bindir}/%{base_name} %{buildroot}/usr/local/bin/rippled
 
 %pre
-%sysusers_create_package %{name} %{_sourcedir}/xrpld.sysusers
+%sysusers_create_package %{base_name} %{_sourcedir}/xrpld.sysusers
 
 %post
-systemd-tmpfiles --create %{_tmpfilesdir}/xrpld.conf || :
+%tmpfiles_create_package %{base_name} %{_sourcedir}/xrpld.tmpfiles
 %systemd_post xrpld.service
 
 %preun
@@ -84,24 +102,32 @@ systemd-tmpfiles --create %{_tmpfilesdir}/xrpld.conf || :
 
 %postun
 %systemd_postun xrpld.service
+# A flavour swap installs the replacement before erasing this package, so the
+# %%preun above has just disabled a unit the replacement still owns. rpm keeps a
+# file that another installed package owns, so the unit outliving our own erase
+# means exactly that; a plain erase takes it with us and re-presets nothing.
+if [ $1 -eq 0 ] && [ -f %{_unitdir}/xrpld.service ]; then
+    systemctl preset xrpld.service >/dev/null 2>&1 || :
+fi
 
 %files
+%attr(0755,root,root) %dir %{_docdir}/%{name}
 %license %{_docdir}/%{name}/LICENSE.md
 %license %{_docdir}/%{name}/validator-keys-LICENSE
 %doc %{_docdir}/%{name}/README.md
 
-%dir %{_sysconfdir}/%{name}
+%attr(0755,root,root) %dir %{_sysconfdir}/%{base_name}
 
-%{_bindir}/%{name}
+%{_bindir}/%{base_name}
 %{_bindir}/validator-keys
 
-%config(noreplace) %{_sysconfdir}/%{name}/xrpld.cfg
-%config(noreplace) %{_sysconfdir}/%{name}/validators.txt
-%config(noreplace) %{_sysconfdir}/logrotate.d/%{name}
+%config(noreplace) %{_sysconfdir}/%{base_name}/xrpld.cfg
+%config(noreplace) %{_sysconfdir}/%{base_name}/validators.txt
+%config(noreplace) %{_sysconfdir}/logrotate.d/%{base_name}
 
 
 %{_unitdir}/xrpld.service
-%{_presetdir}/50-xrpld.preset
+%attr(0644,root,root) %{_presetdir}/50-%{base_name}.preset
 %{_sysusersdir}/xrpld.conf
 %{_tmpfilesdir}/xrpld.conf
 %ghost %dir /var/lib/xrpld
diff --git a/package/shared/xrpld.service b/package/shared/xrpld.service
index 22e6359ef0..27dd6a5a3a 100644
--- a/package/shared/xrpld.service
+++ b/package/shared/xrpld.service
@@ -17,6 +17,8 @@ ProtectHome=true
 PrivateTmp=true
 User=xrpld
 Group=xrpld
+# xrpld.tmpfiles creates these at install and boot; these recreate them on
+# every start, so a removed directory does not stop the service.
 StateDirectory=xrpld
 StateDirectoryMode=0750
 LogsDirectory=xrpld
diff --git a/package/sign_rpm.py b/package/sign_rpm.py
index 05c719b710..07bda9f392 100755
--- a/package/sign_rpm.py
+++ b/package/sign_rpm.py
@@ -107,6 +107,8 @@ def main() -> None:
     args = parser.parse_args()
     package_dir: Path = args.package_dir
 
+    # Deliberately not shared with publish_pkg.py, which ships standalone in the
+    # packaging image.
     rpms = sorted(path for path in package_dir.rglob("*.rpm") if path.is_file())
     # Signing nothing would otherwise look like a successful signing.
     assert rpms, f"no RPMs found in {package_dir}"
diff --git a/src/libxrpl/ledger/View.cpp b/src/libxrpl/ledger/View.cpp
index 0cd082ff47..75a49187b4 100644
--- a/src/libxrpl/ledger/View.cpp
+++ b/src/libxrpl/ledger/View.cpp
@@ -543,12 +543,19 @@ doWithdraw(
 {
     auto const dstSle = ctx.view.read(keylet::account(dstAcct));
 
-    // Create trust line or MPToken for the receiving account
+    // Create a trust line or MPToken for a self-destination only when there
+    // is a payout to credit. Post-fixCleanup3_4_0, a zero-value withdraw
+    // (e.g. share redemption from a fully impaired vault) must not insert
+    // an empty holding: that records a one-sided zero delta and can also
+    // create+delete MPTokens in the same transaction.
     if (dstAcct == senderAcct)
     {
-        if (auto const ter = addEmptyHolding(ctx, senderAcct, priorBalance, amount.asset(), j);
-            !isTesSuccess(ter) && ter != tecDUPLICATE)
-            return ter;
+        if (amount > beast::kZero || !ctx.view.rules().enabled(fixCleanup3_4_0))
+        {
+            if (auto const ter = addEmptyHolding(ctx, senderAcct, priorBalance, amount.asset(), j);
+                !isTesSuccess(ter) && ter != tecDUPLICATE)
+                return ter;
+        }
     }
     else
     {
diff --git a/src/libxrpl/ledger/helpers/AMMHelpers.cpp b/src/libxrpl/ledger/helpers/AMMHelpers.cpp
index 20a793e4cb..fcad22d2d5 100644
--- a/src/libxrpl/ledger/helpers/AMMHelpers.cpp
+++ b/src/libxrpl/ledger/helpers/AMMHelpers.cpp
@@ -11,7 +11,6 @@
 #include <xrpl/ledger/ReadView.h>
 #include <xrpl/ledger/Sandbox.h>
 #include <xrpl/ledger/View.h>
-#include <xrpl/ledger/helpers/CredentialHelpers.h>
 #include <xrpl/ledger/helpers/MPTokenHelpers.h>
 #include <xrpl/ledger/helpers/RippleStateHelpers.h>
 #include <xrpl/ledger/helpers/TokenHelpers.h>
@@ -691,12 +690,6 @@ deleteAMMTrustLines(
 
                 return {deleteAMMTrustLine(sb, sleItem, ammAccountID, j), SkipEntry::No};
             }
-            // A credential naming the pseudo-account as subject can't be
-            // accepted or deleted by it and would otherwise permanently pin the
-            // AMM. Clean it up here, inside the same bounded walk, so the
-            // pinned AMM can still be deleted.
-            if (sb.rules().enabled(fixCleanup3_4_0) && nodeType == ltCREDENTIAL)
-                return {credentials::deleteSLE(sb, sleItem, j), SkipEntry::No};
             // LCOV_EXCL_START
             JLOG(j.error()) << "deleteAMMObjects: deleting non-trustline or non-MPT " << nodeType;
             return {tecINTERNAL, SkipEntry::No};
@@ -774,8 +767,6 @@ deleteAMMAccount(Sandbox& sb, Asset const& asset, Asset const& asset2, beast::Jo
         // LCOV_EXCL_STOP
     }
 
-    // deleteAMMTrustLines also removes any credentials pinned to the AMM
-    // pseudo-account, within its bounded walk.
     if (auto const ter = deleteAMMTrustLines(sb, ammAccountID, kMaxDeletableAmmTrustLines, j);
         !isTesSuccess(ter))
         return ter;
@@ -917,11 +908,6 @@ isOnlyLiquidityProvider(ReadView const& view, Issue const& ammIssue, AccountID c
                 ++nMPT;
                 continue;
             }
-            // A credential naming the pseudo-account as subject can be pinned
-            // to its owner directory. Ignore it here; deleteAMMTrustLines
-            // removes it when the AMM is deleted.
-            if (view.rules().enabled(fixCleanup3_4_0) && entryType == ltCREDENTIAL)
-                continue;
             if (entryType != ltRIPPLE_STATE)
                 return std::unexpected<TER>(tecINTERNAL);  // LCOV_EXCL_LINE
             auto const lowLimit = sle->getFieldAmount(sfLowLimit);
diff --git a/src/libxrpl/ledger/helpers/CredentialHelpers.cpp b/src/libxrpl/ledger/helpers/CredentialHelpers.cpp
index 9c3ca4ec78..5ba832957d 100644
--- a/src/libxrpl/ledger/helpers/CredentialHelpers.cpp
+++ b/src/libxrpl/ledger/helpers/CredentialHelpers.cpp
@@ -5,10 +5,8 @@
 #include <xrpl/basics/base_uint.h>
 #include <xrpl/basics/chrono.h>
 #include <xrpl/beast/utility/Journal.h>
-#include <xrpl/beast/utility/instrumentation.h>
 #include <xrpl/ledger/ApplyView.h>
 #include <xrpl/ledger/ReadView.h>
-#include <xrpl/ledger/View.h>
 #include <xrpl/ledger/helpers/AccountRootHelpers.h>
 #include <xrpl/protocol/AccountID.h>
 #include <xrpl/protocol/Feature.h>
@@ -129,36 +127,6 @@ deleteSLE(ApplyView& view, SLE::ref sleCredential, beast::Journal j)
     return tesSUCCESS;
 }
 
-TER
-deletePseudoAccountCredentials(
-    ApplyView& view,
-    AccountID const& pseudoAcct,
-    std::uint16_t maxNodesToDelete,
-    beast::Journal j)
-{
-    XRPL_ASSERT(
-        isPseudoAccount(view.read(keylet::account(pseudoAcct))),
-        "xrpl::credentials::deletePseudoAccountCredentials : is a pseudo-account");
-
-    // Delete the credentials linked into the pseudo-account's owner directory,
-    // visiting at most maxNodesToDelete entries. Any other object is left in
-    // place; the caller's own checks decide whether the remaining directory
-    // blocks deletion. If the bound is reached, cleanupOnAccountDelete returns
-    // tecINCOMPLETE and the caller propagates it so a later transaction resumes.
-    return cleanupOnAccountDelete(
-        view,
-        keylet::ownerDir(pseudoAcct),
-        [&view, &j](LedgerEntryType nodeType, uint256 const&, SLE::pointer& sleItem)
-            -> std::pair<TER, SkipEntry> {
-            if (nodeType == ltCREDENTIAL)
-                return {deleteSLE(view, sleItem, j), SkipEntry::No};
-
-            return {tesSUCCESS, SkipEntry::Yes};
-        },
-        j,
-        maxNodesToDelete);
-}
-
 NotTEC
 checkFields(STTx const& tx, Rules const& rules, beast::Journal j)
 {
diff --git a/src/libxrpl/ledger/helpers/LendingHelpers.cpp b/src/libxrpl/ledger/helpers/LendingHelpers.cpp
index 10c7e62c6c..2728a3b86f 100644
--- a/src/libxrpl/ledger/helpers/LendingHelpers.cpp
+++ b/src/libxrpl/ledger/helpers/LendingHelpers.cpp
@@ -179,7 +179,7 @@ isPaymentLate(ReadView const& view, SLE::const_ref loanSle)
                                               : ExpiryComparison::Inclusive);
 }
 
-namespace accrual {
+namespace instant_recognition {
 
 AccountingDeltas
 loanOriginationDeltas(Number const& principalRequested, Number const& interestDue)
@@ -217,7 +217,7 @@ loanPaymentDeltas(LoanPaymentParts const& parts)
         .debtTotalDelta = (parts.principalPaid + parts.interestPaid) - parts.valueChange};
 }
 
-}  // namespace accrual
+}  // namespace instant_recognition
 
 namespace cash_basis {
 
@@ -250,8 +250,8 @@ namespace {
 
 // Cash-basis accounting applies only when featureLendingProtocolV1_1 is
 // enabled AND the specific Vault was created under it (LEVersion ==
-// VaultVersion::CashBasis). Vaults created before activation keep accrual-basis
-// accounting forever, even after the amendment later turns on.
+// VaultVersion::CashBasis). Vaults created before activation keep instant
+// interest recognition forever, even after the amendment later turns on.
 bool
 cashBasisEnabled(SLE::const_ref vaultSle)
 {
@@ -268,7 +268,7 @@ loanOriginationDeltas(
 {
     return cashBasisEnabled(vaultSle)
         ? cash_basis::loanOriginationDeltas(principalRequested)
-        : accrual::loanOriginationDeltas(principalRequested, interestDue);
+        : instant_recognition::loanOriginationDeltas(principalRequested, interestDue);
 }
 
 bool
@@ -283,21 +283,22 @@ loanOriginationExceedsVaultMaximum(
         return false;
 
     auto const vaultMaximum = vaultSle->at(sfAssetsMaximum);
-    return accrual::loanOriginationExceedsVaultMaximum(vaultMaximum, vaultTotal, interestDue);
+    return instant_recognition::loanOriginationExceedsVaultMaximum(
+        vaultMaximum, vaultTotal, interestDue);
 }
 
 Number
 loanVaultExposure(SLE::const_ref vaultSle, SLE::const_ref loanSle)
 {
     return cashBasisEnabled(vaultSle) ? cash_basis::loanVaultExposure(loanSle)
-                                      : accrual::loanVaultExposure(loanSle);
+                                      : instant_recognition::loanVaultExposure(loanSle);
 }
 
 AccountingDeltas
 loanPaymentDeltas(SLE::const_ref vaultSle, LoanPaymentParts const& parts)
 {
     return cashBasisEnabled(vaultSle) ? cash_basis::loanPaymentDeltas(parts)
-                                      : accrual::loanPaymentDeltas(parts);
+                                      : instant_recognition::loanPaymentDeltas(parts);
 }
 
 namespace detail {
diff --git a/src/libxrpl/peerfinder/Config.cpp b/src/libxrpl/peerfinder/Config.cpp
index 60ac0ca547..2e0f793a3a 100644
--- a/src/libxrpl/peerfinder/Config.cpp
+++ b/src/libxrpl/peerfinder/Config.cpp
@@ -107,8 +107,12 @@ Config::makeConfig(
     else
     {
         config.outPeers = *limits.outPeers;
-        config.inPeers = *limits.inPeers;
-        config.maxPeers = 0;
+
+        // Inbound slots only exist if we accept incoming connections, and
+        // `maxPeers` is the total across both directions. The legacy branch
+        // above upholds the same two invariants.
+        config.inPeers = config.wantIncoming ? *limits.inPeers : 0;
+        config.maxPeers = config.inPeers + config.outPeers;
     }
 
     // This will cause servers configured as validators to request that
diff --git a/src/libxrpl/protocol/BuildInfo.cpp b/src/libxrpl/protocol/BuildInfo.cpp
index 0bc02f98ae..9788b4c025 100644
--- a/src/libxrpl/protocol/BuildInfo.cpp
+++ b/src/libxrpl/protocol/BuildInfo.cpp
@@ -23,7 +23,7 @@ namespace {
 //------------------------------------------------------------------------------
 // clang-format off
 // NOLINTNEXTLINE(readability-identifier-naming)
-char const* const versionString = "3.4.0-b3"
+char const* const versionString = "3.5.0-b0"
     // clang-format on
     ;
 
diff --git a/src/libxrpl/protocol/ConfidentialTransfer.cpp b/src/libxrpl/protocol/ConfidentialTransfer.cpp
index ecd4832928..a3e48b5f31 100644
--- a/src/libxrpl/protocol/ConfidentialTransfer.cpp
+++ b/src/libxrpl/protocol/ConfidentialTransfer.cpp
@@ -6,9 +6,11 @@
 #include <xrpl/basics/contract.h>
 #include <xrpl/beast/utility/instrumentation.h>
 #include <xrpl/protocol/AccountID.h>
+#include <xrpl/protocol/LedgerFormats.h>
 #include <xrpl/protocol/Protocol.h>
 #include <xrpl/protocol/SField.h>
 #include <xrpl/protocol/STBlob.h>
+#include <xrpl/protocol/STLedgerEntry.h>
 #include <xrpl/protocol/STObject.h>
 #include <xrpl/protocol/TER.h>
 #include <xrpl/protocol/UintTypes.h>
@@ -397,6 +399,79 @@ checkEncryptedAmountFormat(STObject const& object)
     return tesSUCCESS;
 }
 
+bool
+isIssuerMirrorCurrent(SLE const& issuance, SLE const& mptoken)
+{
+    XRPL_ASSERT(
+        issuance.getType() == ltMPTOKEN_ISSUANCE,
+        "xrpl::isIssuerMirrorCurrent : issuance MPTokenIssuance object");
+    XRPL_ASSERT(
+        mptoken.getType() == ltMPTOKEN, "xrpl::isIssuerMirrorCurrent : mptoken MPToken object");
+
+    return mptoken.isFieldPresent(sfIssuerEncryptedBalance) &&
+        mptoken[~sfIssuerKeyMirrorEpoch].value_or(0) == issuance[~sfIssuerKeyEpoch].value_or(0);
+}
+
+bool
+isAuditorMirrorCurrent(SLE const& issuance, SLE const& mptoken)
+{
+    XRPL_ASSERT(
+        issuance.getType() == ltMPTOKEN_ISSUANCE,
+        "xrpl::isAuditorMirrorCurrent : issuance MPTokenIssuance object");
+    XRPL_ASSERT(
+        mptoken.getType() == ltMPTOKEN, "xrpl::isAuditorMirrorCurrent : mptoken MPToken object");
+
+    if (!issuance.isFieldPresent(sfAuditorEncryptionKey))
+        return true;
+
+    return mptoken.isFieldPresent(sfAuditorEncryptedBalance) &&
+        mptoken[~sfAuditorKeyMirrorEpoch].value_or(0) == issuance[~sfAuditorKeyEpoch].value_or(0);
+}
+
+bool
+areMirrorsCurrent(SLE const& issuance, SLE const& mptoken)
+{
+    return isIssuerMirrorCurrent(issuance, mptoken) && isAuditorMirrorCurrent(issuance, mptoken);
+}
+
+void
+setIssuerMirrorEpoch(SLE const& issuance, SLE& mptoken)
+{
+    XRPL_ASSERT(
+        issuance.getType() == ltMPTOKEN_ISSUANCE,
+        "xrpl::setIssuerMirrorEpoch : issuance MPTokenIssuance object");
+    XRPL_ASSERT(
+        mptoken.getType() == ltMPTOKEN, "xrpl::setIssuerMirrorEpoch : mptoken MPToken object");
+
+    // Unlike the auditor mirror, the issuer mirror is not optional: every
+    // confidential MPToken carries one, so there is no existence check here.
+    if (auto const epoch = issuance[~sfIssuerKeyEpoch].value_or(0); epoch != 0)
+        mptoken[sfIssuerKeyMirrorEpoch] = epoch;
+}
+
+void
+setAuditorMirrorEpoch(SLE const& issuance, SLE& mptoken)
+{
+    XRPL_ASSERT(
+        issuance.getType() == ltMPTOKEN_ISSUANCE,
+        "xrpl::setAuditorMirrorEpoch : issuance MPTokenIssuance object");
+    XRPL_ASSERT(
+        mptoken.getType() == ltMPTOKEN, "xrpl::setAuditorMirrorEpoch : mptoken MPToken object");
+
+    if (!mptoken.isFieldPresent(sfAuditorEncryptedBalance))
+        return;
+
+    if (auto const epoch = issuance[~sfAuditorKeyEpoch].value_or(0); epoch != 0)
+        mptoken[sfAuditorKeyMirrorEpoch] = epoch;
+}
+
+void
+setMirrorEpochs(SLE const& issuance, SLE& mptoken)
+{
+    setIssuerMirrorEpoch(issuance, mptoken);
+    setAuditorMirrorEpoch(issuance, mptoken);
+}
+
 TER
 verifySchnorrProof(Slice const& pubKeySlice, Slice const& proofSlice, uint256 const& contextHash)
 {
diff --git a/src/libxrpl/protocol/STPathSet.cpp b/src/libxrpl/protocol/STPathSet.cpp
index 658aaa65dd..2c074c3f2f 100644
--- a/src/libxrpl/protocol/STPathSet.cpp
+++ b/src/libxrpl/protocol/STPathSet.cpp
@@ -1,6 +1,8 @@
 #include <xrpl/protocol/STPathSet.h>
 
+#include <xrpl/basics/CountedObject.h>
 #include <xrpl/basics/Log.h>
+#include <xrpl/basics/UnorderedContainers.h>
 #include <xrpl/basics/base_uint.h>
 #include <xrpl/basics/contract.h>
 #include <xrpl/beast/hash/uhash.h>
@@ -11,10 +13,12 @@
 #include <xrpl/protocol/STBase.h>
 #include <xrpl/protocol/Serializer.h>
 #include <xrpl/protocol/UintTypes.h>
+#include <xrpl/protocol/detail/STVar.h>
 #include <xrpl/protocol/jss.h>
 
 #include <algorithm>
 #include <cstddef>
+#include <memory>
 #include <stdexcept>
 #include <utility>
 #include <vector>
@@ -31,6 +35,11 @@ STPathElement::getHash(STPathElement const& element)
     // NIKB NOTE: This doesn't have to be a secure hash as speed is more
     //            important. We don't even really need to fully hash the whole
     //            base_uint here, as a few bytes would do for our use.
+    //
+    // The note above is only true because the result of this function reaches
+    // nothing but STPathElement::operator==, where it is a fast-reject
+    // prefilter ahead of the field comparisons that decide the answer.  Do not
+    // use it to key a container.
 
     for (auto const x : element.getAccountID())
         hashAccount += (hashAccount * 257) ^ x;
@@ -51,10 +60,49 @@ STPathElement::getHash(STPathElement const& element)
     return (hashAccount ^ hashCurrency ^ hashIssuer);
 }
 
-[[nodiscard]] size_t
-STPathElement::getHash() const
+// For guidance on deciding which option to pursue:
+// 1. Try to decrease the size of the STPathSet first.  For instance, if a std::optional was
+//    injected into the type, could you get the same functionality using a std::unique_ptr instead?
+// 2. If the size of the STPathSet is already as small as it can be, then consider what the cost
+//    of increasing STVar::kMaxSize would be on all the other STVar types.  Each of those types
+//    will carry the additional cost of accommodating the larger STPathSet in their SBO.
+// 3. If the cost of increasing STVar::kMaxSize is too high, then heap allocate the STPathSet and
+//    remove this static_assert.
+static_assert(
+    sizeof(STPathSet) <= detail::STVar::kMaxSize,
+    "STPathSet is too large to fit in STVar's small object optimization. Please verify if it "
+    "should, if the kMaxSize should be increased, or if STPathSet should be stored on the heap "
+    "instead of in STVar.");
+
+STPathSet::STPathSet(DeduplicationTag) : seen_{std::make_unique<hardened_hash_set<STPath>>()}
 {
-    return STPathElement::getHash(*this);
+}
+
+STPathSet::STPathSet(STPathSet const& other)
+    : STBase{other}
+    , CountedObject<STPathSet>{other}
+    , value_{other.value_}
+    , seen_{
+          other.seen_ != nullptr ? std::make_unique<hardened_hash_set<STPath>>(*other.seen_)
+                                 : nullptr}
+{
+}
+
+STPathSet&
+STPathSet::operator=(STPathSet const& other)
+{
+    if (this == &other)
+    {
+        return *this;
+    }
+    auto newSeen = other.seen_ != nullptr
+        ? std::make_unique<hardened_hash_set<STPath>>(*other.seen_)
+        : nullptr;
+    STBase::operator=(other);
+    CountedObject<STPathSet>::operator=(other);
+    value_ = other.value_;
+    seen_ = std::move(newSeen);
+    return *this;
 }
 
 STPathSet::STPathSet(SerialIter& sit, SField const& name) : STBase(name)
@@ -72,7 +120,8 @@ STPathSet::STPathSet(SerialIter& sit, SField const& name) : STBase(name)
                 Throw<std::runtime_error>("empty path");
             }
 
-            pushBack(path);
+            // Move rather than converting the vector to an STPath by copy.
+            value_.emplace_back(std::move(path));
             path.clear();
 
             if (iType == STPathElement::TypeNone)
@@ -132,16 +181,10 @@ STPathSet::move(std::size_t n, void* buf)
 bool
 STPathSet::assembleAdd(STPath const& base, STPathElement const& tail)
 {  // assemble base+tail and add it to the set if it's not a duplicate
+    XRPL_ASSERT(seen_ != nullptr, "xrpl::STPathSet::assembleAdd : DeduplicationTag");
     STPath combined = base;
     combined.pushBack(tail);
-
-    if (!seenHashes_.insert(combined).second)
-    {
-        return false;
-    }
-
-    value_.push_back(std::move(combined));
-    return true;
+    return appendUnique([&](auto& value) { value.push_back(std::move(combined)); });
 }
 
 bool
diff --git a/src/libxrpl/protocol/STTx.cpp b/src/libxrpl/protocol/STTx.cpp
index ce672b515d..3db6a3dc6c 100644
--- a/src/libxrpl/protocol/STTx.cpp
+++ b/src/libxrpl/protocol/STTx.cpp
@@ -168,10 +168,10 @@ STTx::getMentionedAccounts() const
 }
 
 static Blob
-getSigningData(STTx const& that)
+getSigningData(STTx const& that, HashPrefix prefix)
 {
     Serializer s;
-    s.add32(HashPrefix::TxSign);
+    s.add32(prefix);
     that.addWithoutSigningFields(s);
     return s.getData();
 }
@@ -212,30 +212,42 @@ STTx::getSeqProxy() const
     return SeqProxy::rawTicket(*ticketSeq);
 }
 
+void
+STTx::sign(PublicKey const& publicKey, SecretKey const& secretKey)
+{
+    // The account's own signature always covers the plain transaction prefix;
+    // see signingPrefix for the role signatures that do not.
+    auto const data = getSigningData(*this, HashPrefix::TxSign);
+
+    setFieldVL(sfTxnSignature, xrpl::sign(publicKey, secretKey, makeSlice(data)));
+    tid_ = getHash(HashPrefix::TransactionId);
+}
+
 void
 STTx::sign(
     PublicKey const& publicKey,
     SecretKey const& secretKey,
-    std::optional<std::reference_wrapper<SField const>> signatureTarget)
+    SignatureRole role,
+    Rules const& rules)
 {
-    auto const data = getSigningData(*this);
+    auto const data = getSigningData(*this, signingPrefix(role, false, rules));
 
     auto const sig = xrpl::sign(publicKey, secretKey, makeSlice(data));
 
-    if (signatureTarget)
+    if (auto const target = signatureField(role))
     {
-        auto& target = peekFieldObject(*signatureTarget);
-        target.setFieldVL(sfTxnSignature, sig);
+        peekFieldObject(*target).setFieldVL(sfTxnSignature, sig);
     }
     else
     {
         setFieldVL(sfTxnSignature, sig);
     }
+
     tid_ = getHash(HashPrefix::TransactionId);
 }
 
 std::expected<void, std::string>
-STTx::checkSign(Rules const& rules, STObject const& sigObject) const
+STTx::checkSign(Rules const& rules, STObject const& sigObject, SignatureRole role) const
 {
     try
     {
@@ -244,8 +256,10 @@ STTx::checkSign(Rules const& rules, STObject const& sigObject) const
         // multi-signing.  Otherwise we're single-signing.
 
         Blob const& signingPubKey = sigObject.getFieldVL(sfSigningPubKey);
-        return signingPubKey.empty() ? checkMultiSign(rules, sigObject)
-                                     : checkSingleSign(sigObject);
+        bool const multiSigning = signingPubKey.empty();
+        auto const prefix = signingPrefix(role, multiSigning, rules);
+        return multiSigning ? checkMultiSign(sigObject, prefix)
+                            : checkSingleSign(sigObject, prefix);
     }
     catch (...)
     {
@@ -256,20 +270,20 @@ STTx::checkSign(Rules const& rules, STObject const& sigObject) const
 std::expected<void, std::string>
 STTx::checkSign(Rules const& rules) const
 {
-    if (auto const ret = checkSign(rules, *this); !ret)
+    if (auto const ret = checkSign(rules, *this, SignatureRole::Transaction); !ret)
         return ret;
 
     if (isFieldPresent(sfCounterpartySignature))
     {
         auto const counterSig = getFieldObject(sfCounterpartySignature);
-        if (auto const ret = checkSign(rules, counterSig); !ret)
+        if (auto const ret = checkSign(rules, counterSig, SignatureRole::Counterparty); !ret)
             return std::unexpected("Counterparty: " + ret.error());
     }
 
     if (isFieldPresent(sfSponsorSignature))
     {
         auto const sponsorSignatureObj = getFieldObject(sfSponsorSignature);
-        if (auto const ret = checkSign(rules, sponsorSignatureObj); !ret)
+        if (auto const ret = checkSign(rules, sponsorSignatureObj, SignatureRole::Sponsor); !ret)
             return std::unexpected("Sponsor: " + ret.error());
     }
 
@@ -277,14 +291,14 @@ STTx::checkSign(Rules const& rules) const
     // of signature checking.
     if (isFieldPresent(sfBatchSigners))
     {
-        if (auto const ret = checkBatchSign(rules); !ret)
+        if (auto const ret = checkBatchSign(); !ret)
             return ret;
     }
     return {};
 }
 
 std::expected<void, std::string>
-STTx::checkBatchSign(Rules const& rules) const
+STTx::checkBatchSign() const
 {
     try
     {
@@ -318,7 +332,7 @@ STTx::checkBatchSign(Rules const& rules) const
         for (auto const& signer : signers)
         {
             Blob const& signingPubKey = signer.getFieldVL(sfSigningPubKey);
-            auto const result = signingPubKey.empty() ? checkBatchMultiSign(signer, rules, txIds)
+            auto const result = signingPubKey.empty() ? checkBatchMultiSign(signer, txIds)
                                                       : checkBatchSingleSign(signer, txIds);
 
             if (!result)
@@ -447,9 +461,9 @@ singleSignHelper(STObject const& sigObject, Slice const& data)
 }
 
 std::expected<void, std::string>
-STTx::checkSingleSign(STObject const& sigObject) const
+STTx::checkSingleSign(STObject const& sigObject, HashPrefix prefix) const
 {
-    auto const data = getSigningData(*this);
+    auto const data = getSigningData(*this, prefix);
     return singleSignHelper(sigObject, makeSlice(data));
 }
 
@@ -467,8 +481,7 @@ std::expected<void, std::string>
 multiSignHelper(
     STObject const& sigObject,
     std::optional<AccountID> txnAccountID,
-    std::function<Serializer(AccountID const&)> makeMsg,
-    Rules const& rules)
+    std::function<Serializer(AccountID const&)> makeMsg)
 {
     // Make sure the MultiSigners are present.  Otherwise they are not
     // attempting multi-signing and we just have a bad SigningPubKey.
@@ -541,10 +554,7 @@ multiSignHelper(
 }
 
 std::expected<void, std::string>
-STTx::checkBatchMultiSign(
-    STObject const& batchSigner,
-    Rules const& rules,
-    std::vector<uint256> const& txIds) const
+STTx::checkBatchMultiSign(STObject const& batchSigner, std::vector<uint256> const& txIds) const
 {
     XRPL_ASSERT(getTxnType() == ttBATCH, "STTx::checkBatchMultiSign : batch transaction");
     // We can ease the computational load inside the loop a bit by
@@ -555,18 +565,15 @@ STTx::checkBatchMultiSign(
     serializeBatch(dataStart, getAccountID(sfAccount), getSeqProxy().value(), getFlags(), txIds);
     dataStart.addBitString(batchSignerAccount);
     return multiSignHelper(
-        batchSigner,
-        batchSignerAccount,
-        [&dataStart](AccountID const& accountID) -> Serializer {
+        batchSigner, batchSignerAccount, [&dataStart](AccountID const& accountID) -> Serializer {
             Serializer s = dataStart;
             finishMultiSigningData(accountID, s);
             return s;
-        },
-        rules);
+        });
 }
 
 std::expected<void, std::string>
-STTx::checkMultiSign(Rules const& rules, STObject const& sigObject) const
+STTx::checkMultiSign(STObject const& sigObject, HashPrefix prefix) const
 {
     // Used inside the loop in multiSignHelper to enforce that
     // the account owner may not multisign for themselves.
@@ -578,16 +585,13 @@ STTx::checkMultiSign(Rules const& rules, STObject const& sigObject) const
     // We can ease the computational load inside the loop a bit by
     // pre-constructing part of the data that we hash.  Fill a Serializer
     // with the stuff that stays constant from signature to signature.
-    Serializer dataStart = startMultiSigningData(*this);
+    Serializer dataStart = startMultiSigningData(*this, prefix);
     return multiSignHelper(
-        sigObject,
-        txnAccountID,
-        [&dataStart](AccountID const& accountID) -> Serializer {
+        sigObject, txnAccountID, [&dataStart](AccountID const& accountID) -> Serializer {
             Serializer s = dataStart;
             finishMultiSigningData(accountID, s);
             return s;
-        },
-        rules);
+        });
 }
 
 void
diff --git a/src/libxrpl/protocol/STValidation.cpp b/src/libxrpl/protocol/STValidation.cpp
index 1656aad3a2..1fad610c83 100644
--- a/src/libxrpl/protocol/STValidation.cpp
+++ b/src/libxrpl/protocol/STValidation.cpp
@@ -1,6 +1,7 @@
 #include <xrpl/protocol/STValidation.h>
 
 #include <xrpl/basics/Blob.h>
+#include <xrpl/basics/Log.h>
 #include <xrpl/basics/Slice.h>
 #include <xrpl/basics/base_uint.h>
 #include <xrpl/basics/chrono.h>
@@ -15,6 +16,7 @@
 #include <xrpl/protocol/Serializer.h>
 
 #include <cstddef>
+#include <exception>
 #include <utility>
 
 namespace xrpl {
@@ -59,6 +61,10 @@ STValidation::validationFormat()
         {sfBaseFeeDrops,          SoeOptional},
         {sfReserveBaseDrops,      SoeOptional},
         {sfReserveIncrementDrops, SoeOptional},
+        // featureSmartEscrow
+        {sfGasLimit,               SoeOptional},
+        {sfBytecodeSizeLimit,      SoeOptional},
+        {sfGasPrice,               SoeOptional},
     };
     // clang-format on
 
@@ -104,11 +110,42 @@ STValidation::isValid() const noexcept
             publicKeyType(getSignerPublic()) == KeyType::Secp256k1,
             "xrpl::STValidation::isValid : valid key type");
 
-        valid_ = verifyDigest(
-            getSignerPublic(),
-            getSigningHash(),
-            makeSlice(getFieldVL(sfSignature)),
-            (getFlags() & kVfFullyCanonicalSig) != 0u);
+        // Log that the signature was never checked, so an operator does not
+        // read this as a bad key. The log is guarded because it can throw too.
+        auto reportUncheckable = [this](char const* reason) noexcept {
+            try
+            {
+                JLOG(debugLog().error())
+                    << "Cannot check the signature of the validation for ledger " << getLedgerHash()
+                    << ": " << reason;
+            }
+            catch (...)  // NOLINT(bugprone-empty-catch)
+            {
+                // Nothing can be reported when reporting is what failed.
+            }
+        };
+
+        // The signing hash re-serializes the fields, which can fail. This
+        // function is noexcept, so report the validation as invalid instead of
+        // throwing. valid_ stays unset, so a later call checks again.
+        try
+        {
+            valid_ = verifyDigest(
+                getSignerPublic(),
+                getSigningHash(),
+                makeSlice(getFieldVL(sfSignature)),
+                (getFlags() & kVfFullyCanonicalSig) != 0u);
+        }
+        catch (std::exception const& e)
+        {
+            reportUncheckable(e.what());
+            return false;
+        }
+        catch (...)
+        {
+            reportUncheckable("unknown exception");
+            return false;
+        }
     }
 
     return valid_.value();
diff --git a/src/libxrpl/protocol/Serializer.cpp b/src/libxrpl/protocol/Serializer.cpp
index 80ecdee6c8..7f6fe625c2 100644
--- a/src/libxrpl/protocol/Serializer.cpp
+++ b/src/libxrpl/protocol/Serializer.cpp
@@ -143,10 +143,10 @@ Serializer::addFieldID(int type, int name)
 }
 
 int
-Serializer::add8(unsigned char byte)
+Serializer::add8(unsigned char byteValue)
 {
     int const ret = data_.size();
-    data_.push_back(byte);
+    data_.push_back(byteValue);
     return ret;
 }
 
@@ -210,109 +210,138 @@ Serializer::addVL(void const* ptr, int len)
 int
 Serializer::addEncoded(int length)
 {
-    std::array<std::uint8_t, 4> bytes{};
+    // Without this, a negative length would fall into the 1 byte case below and
+    // be cast to a first byte no header uses. A size too big for int arrives
+    // here negative as well, since callers pass sizes through this parameter.
+    if (length < kMinValueOfLengthFor1ByteHeader)
+        Throw<std::overflow_error>("addEncoded: length is negative or did not fit in an int");
+
+    std::array<std::byte, kMaxNumberOfBytesInHeader> bytes{};
     int numBytes = 0;
 
-    if (length <= 192)
+    if (length <= kMaxValueOfLengthFor1ByteHeader)
     {
-        bytes[0] = static_cast<unsigned char>(length);
+        bytes[0] = static_cast<std::byte>(length);
         numBytes = 1;
     }
-    else if (length <= 12480)
+    else if (length <= kMaxValueOfLengthFor2ByteHeader)
     {
-        length -= 193;
-        bytes[0] = 193 + static_cast<unsigned char>(length >> 8);
-        bytes[1] = static_cast<unsigned char>(length & 0xff);
+        // Count from the smallest length a 2 byte header covers.
+        int const offset = length - kMinValueOfLengthFor2ByteHeader;
+        bytes[0] = static_cast<std::byte>(
+            kMinValueOfFirstByteFor2ByteHeader + (offset / kNumberOfValuesInOneByte));
+        bytes[1] = static_cast<std::byte>(offset % kNumberOfValuesInOneByte);
         numBytes = 2;
     }
-    else if (length <= 918744)
+    else if (length <= kMaxValueOfLengthFor3ByteHeader)
     {
-        length -= 12481;
-        bytes[0] = 241 + static_cast<unsigned char>(length >> 16);
-        bytes[1] = static_cast<unsigned char>((length >> 8) & 0xff);
-        bytes[2] = static_cast<unsigned char>(length & 0xff);
+        int const offset = length - kMinValueOfLengthFor3ByteHeader;
+        bytes[0] = static_cast<std::byte>(
+            kMinValueOfFirstByteFor3ByteHeader + (offset / kNumberOfValuesInTwoBytes));
+        bytes[1] =
+            static_cast<std::byte>((offset / kNumberOfValuesInOneByte) % kNumberOfValuesInOneByte);
+        bytes[2] = static_cast<std::byte>(offset % kNumberOfValuesInOneByte);
         numBytes = 3;
     }
     else
     {
-        Throw<std::overflow_error>("lenlen");
+        Throw<std::overflow_error>("addEncoded: length is too large to encode");
     }
 
-    return addRaw(&bytes[0], numBytes);
+    return addRaw(bytes.data(), numBytes);
 }
 
 int
 Serializer::encodeLengthLength(int length)
 {
-    if (length < 0)
-        Throw<std::overflow_error>("len<0");
+    if (length < kMinValueOfLengthFor1ByteHeader)
+    {
+        Throw<std::overflow_error>(
+            "encodeLengthLength: length is negative or did not fit in an int");
+    }
 
-    if (length <= 192)
+    if (length <= kMaxValueOfLengthFor1ByteHeader)
         return 1;
 
-    if (length <= 12480)
+    if (length <= kMaxValueOfLengthFor2ByteHeader)
         return 2;
 
-    if (length <= 918744)
+    if (length <= kMaxValueOfLengthFor3ByteHeader)
         return 3;
 
-    Throw<std::overflow_error>("len>918744");
-    return 0;  // Silence compiler warning.
+    Throw<std::overflow_error>("encodeLengthLength: length is too large to encode");
 }
 
 int
-Serializer::decodeLengthLength(int b1)
+Serializer::decodeLengthLength(std::byte firstByte)
 {
-    if (b1 < 0)
-        Throw<std::overflow_error>("b1<0");
+    int const firstByteValue = std::to_integer<int>(firstByte);
 
-    if (b1 <= 192)
+    if (firstByteValue <= kMaxValueOfFirstByteFor1ByteHeader)
         return 1;
 
-    if (b1 <= 240)
+    if (firstByteValue <= kMaxValueOfFirstByteFor2ByteHeader)
         return 2;
 
-    if (b1 <= 254)
+    if (firstByteValue <= kMaxValueOfFirstByteFor3ByteHeader)
         return 3;
 
-    Throw<std::overflow_error>("b1>254");
-    return 0;  // Silence compiler warning.
+    Throw<std::overflow_error>("decodeLengthLength: first byte does not start any header");
 }
 
 int
-Serializer::decodeVLLength(int b1)
+Serializer::decodeVLLength(std::byte firstByte)
 {
-    if (b1 < 0)
-        Throw<std::overflow_error>("b1<0");
+    int const length = std::to_integer<int>(firstByte);
 
-    if (b1 > 254)
-        Throw<std::overflow_error>("b1>254");
+    // A bigger value means a longer header, so it is not a length by itself.
+    if (length > kMaxValueOfLengthFor1ByteHeader)
+        Throw<std::overflow_error>("decodeVLLength 1 byte: first byte is not a length");
 
-    return b1;
+    return length;
 }
 
 int
-Serializer::decodeVLLength(int b1, int b2)
+Serializer::decodeVLLength(std::byte firstByte, std::byte secondByte)
 {
-    if (b1 < 193)
-        Throw<std::overflow_error>("b1<193");
+    int const firstByteValue = std::to_integer<int>(firstByte);
 
-    if (b1 > 240)
-        Throw<std::overflow_error>("b1>240");
+    if (firstByteValue < kMinValueOfFirstByteFor2ByteHeader)
+        Throw<std::overflow_error>("decodeVLLength 2 byte: first byte is below the range");
 
-    return 193 + ((b1 - 193) * 256) + b2;
+    if (firstByteValue > kMaxValueOfFirstByteFor2ByteHeader)
+        Throw<std::overflow_error>("decodeVLLength 2 byte: first byte is above the range");
+
+    // Both bytes are bounded by their own type, and the first one is bounded to
+    // the 2 byte range above, so this cannot leave the range the header covers.
+    return kMinValueOfLengthFor2ByteHeader +
+        ((firstByteValue - kMinValueOfFirstByteFor2ByteHeader) * kNumberOfValuesInOneByte) +
+        std::to_integer<int>(secondByte);
 }
 
 int
-Serializer::decodeVLLength(int b1, int b2, int b3)
+Serializer::decodeVLLength(std::byte firstByte, std::byte secondByte, std::byte thirdByte)
 {
-    if (b1 < 241)
-        Throw<std::overflow_error>("b1<241");
+    int const firstByteValue = std::to_integer<int>(firstByte);
 
-    if (b1 > 254)
-        Throw<std::overflow_error>("b1>254");
+    if (firstByteValue < kMinValueOfFirstByteFor3ByteHeader)
+        Throw<std::overflow_error>("decodeVLLength 3 byte: first byte is below the range");
 
-    return 12481 + ((b1 - 241) * 65536) + (b2 * 256) + b3;
+    if (firstByteValue > kMaxValueOfFirstByteFor3ByteHeader)
+        Throw<std::overflow_error>("decodeVLLength 3 byte: first byte is above the range");
+
+    int const length = kMinValueOfLengthFor3ByteHeader +
+        ((firstByteValue - kMinValueOfFirstByteFor3ByteHeader) * kNumberOfValuesInTwoBytes) +
+        (std::to_integer<int>(secondByte) * kNumberOfValuesInOneByte) +
+        std::to_integer<int>(thirdByte);
+
+    // A 3 byte header reaches further than kMaxValueOfLengthFor3ByteHeader, which
+    // is as far as the encoder goes. Refuse the rest, so every length accepted
+    // here is one that can be written back.
+    if (length > kMaxValueOfLengthFor3ByteHeader)
+        Throw<std::overflow_error>("decodeVLLength 3 byte: length is too large to re-encode");
+
+    return length;
 }
 
 //------------------------------------------------------------------------------
@@ -471,24 +500,24 @@ SerialIter::getRaw(int size)
 int
 SerialIter::getVLDataLength()
 {
-    int const b1 = get8();
+    std::byte const firstByte{get8()};
     int datLen = 0;
-    int const lenLen = Serializer::decodeLengthLength(b1);
+    int const lenLen = Serializer::decodeLengthLength(firstByte);
     if (lenLen == 1)
     {
-        datLen = Serializer::decodeVLLength(b1);
+        datLen = Serializer::decodeVLLength(firstByte);
     }
     else if (lenLen == 2)
     {
-        int const b2 = get8();
-        datLen = Serializer::decodeVLLength(b1, b2);
+        std::byte const secondByte{get8()};
+        datLen = Serializer::decodeVLLength(firstByte, secondByte);
     }
     else
     {
         XRPL_ASSERT(lenLen == 3, "xrpl::SerialIter::getVLDataLength : lenLen is 3");
-        int const b2 = get8();
-        int const b3 = get8();
-        datLen = Serializer::decodeVLLength(b1, b2, b3);
+        std::byte const secondByte{get8()};
+        std::byte const thirdByte{get8()};
+        datLen = Serializer::decodeVLLength(firstByte, secondByte, thirdByte);
     }
     return datLen;
 }
diff --git a/src/libxrpl/protocol/Sign.cpp b/src/libxrpl/protocol/Sign.cpp
index 9e7ef7f999..ce3dabde33 100644
--- a/src/libxrpl/protocol/Sign.cpp
+++ b/src/libxrpl/protocol/Sign.cpp
@@ -1,17 +1,77 @@
 #include <xrpl/protocol/Sign.h>
 
+#include <xrpl/beast/utility/instrumentation.h>
 #include <xrpl/protocol/AccountID.h>
+#include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/HashPrefix.h>
 #include <xrpl/protocol/KeyType.h>
 #include <xrpl/protocol/PublicKey.h>
+#include <xrpl/protocol/Rules.h>
 #include <xrpl/protocol/SField.h>
 #include <xrpl/protocol/STExchange.h>
 #include <xrpl/protocol/STObject.h>
 #include <xrpl/protocol/SecretKey.h>
 #include <xrpl/protocol/Serializer.h>
 
+#include <optional>
+
 namespace xrpl {
 
+SField const*
+signatureField(SignatureRole role)
+{
+    switch (role)
+    {
+        case SignatureRole::Transaction:
+            return nullptr;
+        case SignatureRole::Counterparty:
+            return &sfCounterpartySignature;
+        case SignatureRole::Sponsor:
+            return &sfSponsorSignature;
+    }
+    UNREACHABLE("xrpl::signatureField : unknown SignatureRole");
+    return nullptr;
+}
+
+std::optional<SignatureRole>
+signatureRole(SField const& sigField)
+{
+    if (sigField == sfCounterpartySignature)
+        return SignatureRole::Counterparty;
+    if (sigField == sfSponsorSignature)
+        return SignatureRole::Sponsor;
+    return std::nullopt;
+}
+
+// Signature validity depends on fixCleanup3_4_0: a role signature covers
+// different bytes before and after the amendment activates. checkValidity
+// caches its verdict per transaction ID, so it keeps two separate cache slots
+// for role-signature transactions (kSfSiggoodOldPrefix / kSfSigbadOldPrefix in
+// tx/apply.cpp) to keep a pre-fix verdict from being reused in the post-fix
+// era, and vice versa. See the block comment in tx/apply.cpp for the details
+// and the reason both directions matter.
+HashPrefix
+signingPrefix(SignatureRole role, bool multiSigning, Rules const& rules)
+{
+    // Before fixCleanup3_4_0 every signature on a transaction covered the same
+    // bytes, so a signature could be moved from one role to another.
+    if (!rules.enabled(fixCleanup3_4_0))
+        return multiSigning ? HashPrefix::TxMultiSign : HashPrefix::TxSign;
+
+    switch (role)
+    {
+        case SignatureRole::Transaction:
+            return multiSigning ? HashPrefix::TxMultiSign : HashPrefix::TxSign;
+        case SignatureRole::Counterparty:
+            return multiSigning ? HashPrefix::CounterpartyTxMultiSign
+                                : HashPrefix::CounterpartyTxSign;
+        case SignatureRole::Sponsor:
+            return multiSigning ? HashPrefix::SponsorTxMultiSign : HashPrefix::SponsorTxSign;
+    }
+    UNREACHABLE("xrpl::signingPrefix : unknown SignatureRole");
+    return multiSigning ? HashPrefix::TxMultiSign : HashPrefix::TxSign;
+}
+
 void
 sign(
     STObject& st,
@@ -70,18 +130,18 @@ verify(STObject const& st, HashPrefix const& prefix, PublicKey const& pk, SF_VL
 // So, if we support multiple levels of signing, then we'll need to
 // incorporate the "signing for" accounts into the signing data as well.
 Serializer
-buildMultiSigningData(STObject const& obj, AccountID const& signingID)
+buildMultiSigningData(STObject const& obj, AccountID const& signingID, HashPrefix prefix)
 {
-    Serializer s{startMultiSigningData(obj)};
+    Serializer s{startMultiSigningData(obj, prefix)};
     finishMultiSigningData(signingID, s);
     return s;
 }
 
 Serializer
-startMultiSigningData(STObject const& obj)
+startMultiSigningData(STObject const& obj, HashPrefix prefix)
 {
     Serializer s;
-    s.add32(HashPrefix::TxMultiSign);
+    s.add32(prefix);
     obj.addWithoutSigningFields(s);
     return s;
 }
diff --git a/src/libxrpl/protocol/TER.cpp b/src/libxrpl/protocol/TER.cpp
index c2167d58ce..c6ebe98642 100644
--- a/src/libxrpl/protocol/TER.cpp
+++ b/src/libxrpl/protocol/TER.cpp
@@ -108,6 +108,8 @@ transResults()
         MAKE_ERROR(tecPRECISION_LOSS,                "The amounts used by the transaction cannot interact."),
         MAKE_ERROR(tecBAD_PROOF,                     "Proof cannot be verified"),
         MAKE_ERROR(tecNO_SPONSOR_PERMISSION,         "Sponsor has not authorized this transaction."),
+        MAKE_ERROR(tecOUT_OF_GAS,                    "The WASM code ran out of gas during execution."),
+        MAKE_ERROR(tecBYTECODE_REJECTED,             "The custom WASM code that was run rejected your transaction."),
 
         MAKE_ERROR(tefALREADY,                     "The exact transaction was already in this ledger."),
         MAKE_ERROR(tefBAD_ADD_AUTH,                "Not authorized to add account."),
@@ -133,6 +135,8 @@ transResults()
         MAKE_ERROR(tefINVALID_LEDGER_FIX_TYPE,     "The LedgerFixType field has an invalid value."),
         MAKE_ERROR(tefNO_DST_PARTIAL,              "Partial payment to create account not allowed."),
         MAKE_ERROR(tefBAD_PATH_COUNT,              "Malformed: Too many paths."),
+        MAKE_ERROR(tefNO_BYTECODE,                 "There is no WASM code to run, but a WASM-specific field was included."),
+        MAKE_ERROR(tefBYTECODE_NOT_INCLUDED,       "WASM code requires a field that was not included."),
 
         MAKE_ERROR(telLOCAL_ERROR,            "Local failure."),
         MAKE_ERROR(telBAD_DOMAIN,             "Domain too long."),
@@ -204,6 +208,8 @@ transResults()
         MAKE_ERROR(temBAD_TRANSFER_FEE,          "Malformed: Transfer fee is outside valid range."),
         MAKE_ERROR(temINVALID_INNER_BATCH,       "Malformed: Invalid inner batch transaction."),
         MAKE_ERROR(temBAD_CIPHERTEXT,            "Malformed: Invalid ciphertext."),
+        MAKE_ERROR(temINVALID_BYTECODE,          "Malformed: Provided byte code is invalid."),
+        MAKE_ERROR(temTEMP_DISABLED,             "The transaction requires logic that is currently temporarily disabled."),
 
         MAKE_ERROR(terRETRY,                  "Retry transaction."),
         MAKE_ERROR(terFUNDS_SPENT,            "DEPRECATED."),
diff --git a/src/libxrpl/shamap/SHAMap.cpp b/src/libxrpl/shamap/SHAMap.cpp
index 3fa8d66be0..827bc4a591 100644
--- a/src/libxrpl/shamap/SHAMap.cpp
+++ b/src/libxrpl/shamap/SHAMap.cpp
@@ -97,7 +97,7 @@ SHAMap::snapShot(bool isMutable) const
 }
 
 void
-SHAMap::dirtyUp(SharedPtrNodeStack& stack, uint256 const& target, SHAMapTreeNodePtr child)
+SHAMap::dirtyUp(NodePathStack& stack, uint256 const& target, SHAMapTreeNodePtr child)
 {
     // walk the tree up from through the inner nodes to the root_
     // update hashes and links
@@ -126,29 +126,34 @@ SHAMap::dirtyUp(SharedPtrNodeStack& stack, uint256 const& target, SHAMapTreeNode
 }
 
 SHAMapLeafNode*
-SHAMap::walkTowardsKey(uint256 const& id, SharedPtrNodeStack* stack) const
+SHAMap::walkTowardsKey(uint256 const& id, NodePathStack* stack) const
 {
     XRPL_ASSERT(
         stack == nullptr || stack->empty(), "xrpl::SHAMap::walkTowardsKey : empty stack input");
     auto inNode = root_;
     SHAMapNodeID nodeID;
 
+    // Every node on this walk lies on the path to `id`, so the stack can derive each ID from the
+    // branch `id` selects at the node above it.
+    auto pushCurrent = [&] {
+        if (stack != nullptr)
+            stack->pushNode(inNode, id);
+    };
+
     while (inNode->isInner())
     {
-        if (stack != nullptr)
-            stack->emplace(inNode, nodeID);
+        pushCurrent();
 
-        auto const inner = intr_ptr::staticPointerCast<SHAMapInnerNode>(inNode);
+        auto& inner = safeDowncast<SHAMapInnerNode&>(*inNode);
         auto const branch = selectBranch(nodeID, id);
-        if (inner->isEmptyBranch(branch))
+        if (inner.isEmptyBranch(branch))
             return nullptr;
 
-        inNode = descendThrow(*inner, branch);
+        inNode = descendThrow(inner, branch);
         nodeID = nodeID.getChildNodeID(branch);
     }
 
-    if (stack != nullptr)
-        stack->emplace(inNode, nodeID);
+    pushCurrent();
     return safeDowncast<SHAMapLeafNode*>(inNode.get());
 }
 
@@ -428,65 +433,40 @@ SHAMap::unshareNode(intr_ptr::SharedPtr<Node> node, SHAMapNodeID const& nodeID)
 }
 
 SHAMapLeafNode*
-SHAMap::belowHelper(
-    SHAMapTreeNodePtr node,
-    SharedPtrNodeStack& stack,
-    unsigned int branch,
-    BelowDirection direction) const
+SHAMap::belowHelper(NodePathStack& stack, BelowDirection direction) const
 {
-    if (node->isLeaf())
-    {
-        auto n = intr_ptr::staticPointerCast<SHAMapLeafNode>(node);
-        stack.push({node, {kLeafDepth, n->peekItem()->key()}});
-        return n.get();
-    }
-    auto inner = intr_ptr::staticPointerCast<SHAMapInnerNode>(node);
-    if (stack.empty())
-    {
-        stack.emplace(inner, SHAMapNodeID{});
-    }
-    else
-    {
-        stack.emplace(inner, stack.top().second.getChildNodeID(branch));
-    }
-    // `scanned` counts how many branches of `inner` we have examined; the branch we look at is
-    // derived from it, so no index ever goes out of range.
+    XRPL_ASSERT(!stack.empty(), "xrpl::SHAMap::belowHelper : non-empty stack input");
+    if (auto const& top = stack.top().first; top->isLeaf())
+        return safeDowncast<SHAMapLeafNode*>(top.get());
+
+    // The stack owns the node/ID pairing, so descending is only ever "push the branch we took".
+    // `scanned` counts how many branches of the current node we have examined; the branch we look
+    // at is derived from it, so no index ever goes out of range. `inner` tracks the node on top of
+    // the stack, which keeps it alive, so it only needs recomputing after a push.
+    auto* inner = safeDowncast<SHAMapInnerNode*>(stack.top().first.get());
     for (auto scanned = 0u; scanned < kBranchFactor;)
     {
         auto const childBranch =
             (direction == BelowDirection::Last) ? (kBranchFactor - 1u - scanned) : scanned;
 
-        if (!inner->isEmptyBranch(childBranch))
-        {
-            node.adopt(descendThrow(inner.get(), childBranch));
-            XRPL_ASSERT(!stack.empty(), "xrpl::SHAMap::belowHelper : non-empty stack");
-            if (node->isLeaf())
-            {
-                auto n = intr_ptr::staticPointerCast<SHAMapLeafNode>(node);
-                stack.push({n, {kLeafDepth, n->peekItem()->key()}});
-                return n.get();
-            }
-            inner = intr_ptr::staticPointerCast<SHAMapInnerNode>(node);
-            stack.emplace(inner, stack.top().second.getChildNodeID(branch));
-            scanned = 0u;  // descend and restart the scan on the new node
-        }
-        else
+        if (inner->isEmptyBranch(childBranch))
         {
             ++scanned;  // scan next branch
+            continue;
         }
+
+        stack.pushChild(descendThrow(*inner, childBranch), childBranch);
+
+        auto const& child = stack.top().first;
+        if (child->isLeaf())
+            return safeDowncast<SHAMapLeafNode*>(child.get());
+
+        inner = safeDowncast<SHAMapInnerNode*>(child.get());
+        scanned = 0u;  // descend and restart the scan on the new node
     }
     return nullptr;
 }
-SHAMapLeafNode*
-SHAMap::lastBelow(SHAMapTreeNodePtr node, SharedPtrNodeStack& stack, unsigned int branch) const
-{
-    return belowHelper(node, stack, branch, BelowDirection::Last);
-}
-SHAMapLeafNode*
-SHAMap::firstBelow(SHAMapTreeNodePtr node, SharedPtrNodeStack& stack, unsigned int branch) const
-{
-    return belowHelper(node, stack, branch, BelowDirection::First);
-}
+
 static boost::intrusive_ptr<SHAMapItem const> const kNoItem;
 
 boost::intrusive_ptr<SHAMapItem const> const&
@@ -529,36 +509,36 @@ SHAMap::onlyBelow(SHAMapTreeNode* node) const
 }
 
 SHAMapLeafNode const*
-SHAMap::peekFirstItem(SharedPtrNodeStack& stack) const
+SHAMap::peekFirstItem(NodePathStack& stack) const
 {
     XRPL_ASSERT(stack.empty(), "xrpl::SHAMap::peekFirstItem : empty stack input");
-    SHAMapLeafNode const* node = firstBelow(root_, stack);
+    stack.pushRoot(root_);
+    SHAMapLeafNode const* node = belowHelper(stack, BelowDirection::First);
     if (node == nullptr)
     {
-        while (!stack.empty())
-            stack.pop();
+        stack.clear();
         return nullptr;
     }
     return node;
 }
 
 SHAMapLeafNode const*
-SHAMap::peekNextItem(uint256 const& id, SharedPtrNodeStack& stack) const
+SHAMap::peekNextItem(uint256 const& id, NodePathStack& stack) const
 {
     XRPL_ASSERT(!stack.empty(), "xrpl::SHAMap::peekNextItem : non-empty stack input");
     XRPL_ASSERT(stack.top().first->isLeaf(), "xrpl::SHAMap::peekNextItem : stack starts with leaf");
     stack.pop();
     while (!stack.empty())
     {
-        auto [node, nodeID] = stack.top();
+        auto const [node, nodeID] = stack.top();
         XRPL_ASSERT(!node->isLeaf(), "xrpl::SHAMap::peekNextItem : another node is not leaf");
-        auto inner = intr_ptr::staticPointerCast<SHAMapInnerNode>(node);
+        auto& inner = safeDowncast<SHAMapInnerNode&>(*node);
         for (auto i = selectBranch(nodeID, id) + 1; i < kBranchFactor; ++i)
         {
-            if (!inner->isEmptyBranch(i))
+            if (!inner.isEmptyBranch(i))
             {
-                node = descendThrow(*inner, i);
-                auto leaf = firstBelow(node, stack, i);
+                stack.pushChild(descendThrow(inner, i), i);
+                auto leaf = belowHelper(stack, BelowDirection::First);
                 if (leaf == nullptr)
                     Throw<SHAMapMissingNode>(type_, id);
                 XRPL_ASSERT(leaf->isLeaf(), "xrpl::SHAMap::peekNextItem : leaf is valid");
@@ -595,72 +575,56 @@ SHAMap::peekItem(uint256 const& id, SHAMapHash& hash) const
 }
 
 SHAMap::ConstIterator
-SHAMap::upperBound(uint256 const& id) const
+SHAMap::boundHelper(uint256 const& id, BelowDirection direction) const
 {
-    SharedPtrNodeStack stack;
+    auto const searchingForward = direction == BelowDirection::First;
+
+    NodePathStack stack;
     walkTowardsKey(id, &stack);
     while (!stack.empty())
     {
-        auto [node, nodeID] = stack.top();
+        auto const [node, nodeID] = stack.top();
         if (node->isLeaf())
         {
-            auto leaf = safeDowncast<SHAMapLeafNode*>(node.get());
-            if (leaf->peekItem()->key() > id)
-                return ConstIterator(this, leaf->peekItem().get(), std::move(stack));
+            auto const& item = safeDowncast<SHAMapLeafNode const&>(*node).peekItem();
+            if (searchingForward ? (item->key() > id) : (item->key() < id))
+                return ConstIterator(this, item.get(), std::move(stack));
         }
         else
         {
-            auto inner = intr_ptr::staticPointerCast<SHAMapInnerNode>(node);
-            for (auto branch = selectBranch(nodeID, id) + 1; branch < kBranchFactor; ++branch)
+            auto& inner = safeDowncast<SHAMapInnerNode&>(*node);
+            auto const taken = selectBranch(nodeID, id);
+            auto const remaining = searchingForward ? (kBranchFactor - 1u - taken) : taken;
+
+            for (auto scanned = 0u; scanned < remaining; ++scanned)
             {
-                if (!inner->isEmptyBranch(branch))
-                {
-                    node = descendThrow(*inner, branch);
-                    auto leaf = firstBelow(node, stack, branch);
-                    if (leaf == nullptr)
-                        Throw<SHAMapMissingNode>(type_, id);
-                    return ConstIterator(this, leaf->peekItem().get(), std::move(stack));
-                }
+                auto const branch =
+                    searchingForward ? (taken + 1u + scanned) : (taken - 1u - scanned);
+                if (inner.isEmptyBranch(branch))
+                    continue;
+
+                stack.pushChild(descendThrow(inner, branch), branch);
+                auto const leaf = belowHelper(stack, direction);
+                if (leaf == nullptr)
+                    Throw<SHAMapMissingNode>(type_, id);
+                return ConstIterator(this, leaf->peekItem().get(), std::move(stack));
             }
         }
         stack.pop();
     }
     return end();
 }
+
+SHAMap::ConstIterator
+SHAMap::upperBound(uint256 const& id) const
+{
+    return boundHelper(id, BelowDirection::First);
+}
+
 SHAMap::ConstIterator
 SHAMap::lowerBound(uint256 const& id) const
 {
-    SharedPtrNodeStack stack;
-    walkTowardsKey(id, &stack);
-    while (!stack.empty())
-    {
-        auto [node, nodeID] = stack.top();
-        if (node->isLeaf())
-        {
-            auto leaf = safeDowncast<SHAMapLeafNode*>(node.get());
-            if (leaf->peekItem()->key() < id)
-                return ConstIterator(this, leaf->peekItem().get(), std::move(stack));
-        }
-        else
-        {
-            auto inner = intr_ptr::staticPointerCast<SHAMapInnerNode>(node);
-            for (auto branch = selectBranch(nodeID, id); branch > 0u;)
-            {
-                --branch;
-                if (!inner->isEmptyBranch(branch))
-                {
-                    node = descendThrow(*inner, branch);
-                    auto leaf = lastBelow(node, stack, branch);
-                    if (leaf == nullptr)
-                        Throw<SHAMapMissingNode>(type_, id);
-                    return ConstIterator(this, leaf->peekItem().get(), std::move(stack));
-                }
-            }
-        }
-        stack.pop();
-    }
-    // TODO: what to return here?
-    return end();
+    return boundHelper(id, BelowDirection::Last);
 }
 
 bool
@@ -675,7 +639,7 @@ SHAMap::delItem(uint256 const& id)
     // delete the item with this ID
     XRPL_ASSERT(state_ != SHAMapState::Immutable, "xrpl::SHAMap::delItem : not immutable");
 
-    SharedPtrNodeStack stack;
+    NodePathStack stack;
     walkTowardsKey(id, &stack);
 
     if (stack.empty())
@@ -761,7 +725,7 @@ SHAMap::addGiveItem(SHAMapNodeType type, boost::intrusive_ptr<SHAMapItem const>
     // add the specified item, does not update
     uint256 const tag = item->key();
 
-    SharedPtrNodeStack stack;
+    NodePathStack stack;
     walkTowardsKey(tag, &stack);
 
     if (stack.empty())
@@ -801,7 +765,7 @@ SHAMap::addGiveItem(SHAMapNodeType type, boost::intrusive_ptr<SHAMapItem const>
 
         while ((b1 = selectBranch(nodeID, tag)) == (b2 = selectBranch(nodeID, otherItem->key())))
         {
-            stack.emplace(node, nodeID);
+            stack.pushNode(node, tag);
 
             // we need a new inner node, since both go on same branch at this
             // level
@@ -848,7 +812,7 @@ SHAMap::updateGiveItem(SHAMapNodeType type, boost::intrusive_ptr<SHAMapItem cons
 
     XRPL_ASSERT(state_ != SHAMapState::Immutable, "xrpl::SHAMap::updateGiveItem : not immutable");
 
-    SharedPtrNodeStack stack;
+    NodePathStack stack;
     walkTowardsKey(tag, &stack);
 
     if (stack.empty())
@@ -1170,7 +1134,7 @@ SHAMap::invariants() const
     auto node = root_.get();
     XRPL_ASSERT(node, "xrpl::SHAMap::invariants : non-null root node");
     XRPL_ASSERT(!node->isLeaf(), "xrpl::SHAMap::invariants : root node is not leaf");
-    SharedPtrNodeStack stack;
+    NodePathStack stack;
     for (auto leaf = peekFirstItem(stack); leaf != nullptr;
          leaf = peekNextItem(leaf->peekItem()->key(), stack))
         ;
diff --git a/src/libxrpl/shamap/SHAMapNodeID.cpp b/src/libxrpl/shamap/SHAMapNodeID.cpp
index 8fd7afe8fc..42b946b921 100644
--- a/src/libxrpl/shamap/SHAMapNodeID.cpp
+++ b/src/libxrpl/shamap/SHAMapNodeID.cpp
@@ -6,6 +6,7 @@
 #include <xrpl/protocol/Serializer.h>
 #include <xrpl/shamap/SHAMap.h>
 
+#include <algorithm>
 #include <cstddef>
 #include <optional>
 #include <stdexcept>
@@ -40,11 +41,41 @@ depthMask(unsigned int depth)
     return kMasks.entry[depth];
 }
 
+// The prefix of `key` at `depth`: the leading nibbles naming the subtree a node at that depth
+// identifies, with the remainder of the key masked off.
+static uint256
+maskedToDepth(uint256 const& key, unsigned int depth)
+{
+    return key & depthMask(depth);
+}
+
+// Whether `id` at `depth` is what `key` looks like once masked down to that depth, i.e.
+// whether an ID with this depth and id names a subtree that `key` falls under.
+static bool
+isPrefixOfAtDepth(uint256 const& id, unsigned int depth, uint256 const& key)
+{
+    return maskedToDepth(key, depth) == id;
+}
+
 // canonicalize the hash to a node ID for this depth
 SHAMapNodeID::SHAMapNodeID(unsigned int depth, uint256 const& hash) : id_(hash), depth_(depth)
 {
-    XRPL_ASSERT(
-        depth <= SHAMap::kLeafDepth, "xrpl::SHAMapNodeID::SHAMapNodeID : maximum depth input");
+    // Every SHAMapNodeID's depth is stored here, so this is the one place that can stop an
+    // out-of-range one from being kept: a depth past kLeafDepth would go on to index depthMask
+    // out of bounds, and getRawString would narrow it to a byte, silently renaming the node.
+    // Clamp rather than throw, since node IDs are built from peer-supplied depths on the ledger
+    // data path, where no caller catches an exception before it reaches a thread boundary.
+    if (depth_ > SHAMap::kLeafDepth)
+    {
+        // LCOV_EXCL_START
+        UNREACHABLE("xrpl::SHAMapNodeID::SHAMapNodeID : depth within tree");
+        depth_ = SHAMap::kLeafDepth;
+        id_ = maskedToDepth(id_, depth_);
+        // LCOV_EXCL_STOP
+    }
+
+    // Reads the clamped member rather than the depth argument, so it cannot index depthMask past
+    // its last entry even once the clamp above has reported the bad input and carried on.
     XRPL_ASSERT(
         isPrefixOf(id_), "xrpl::SHAMapNodeID::SHAMapNodeID : hash and depth inputs do match");
 }
@@ -89,7 +120,7 @@ SHAMapNodeID::getChildNodeID(unsigned int branch) const
 bool
 SHAMapNodeID::isPrefixOf(uint256 const& key) const
 {
-    return (key & depthMask(depth_)) == id_;
+    return isPrefixOfAtDepth(id_, depth_, key);
 }
 
 [[nodiscard]] std::optional<SHAMapNodeID>
@@ -102,9 +133,9 @@ deserializeSHAMapNodeID(void const* data, std::size_t size)
         unsigned int const depth = *(static_cast<unsigned char const*>(data) + 32);
         if (depth <= SHAMap::kLeafDepth)
         {
-            auto const id = uint256::fromVoid(data);
-
-            if (id == (id & depthMask(depth)))
+            // Reject a serialized ID carrying bits below its own depth. Checked before
+            // constructing, since the constructor asserts that same property.
+            if (auto const id = uint256::fromVoid(data); isPrefixOfAtDepth(id, depth, id))
                 ret.emplace(depth, id);
         }
     }
@@ -115,7 +146,11 @@ deserializeSHAMapNodeID(void const* data, std::size_t size)
 [[nodiscard]] unsigned int
 selectBranch(SHAMapNodeID const& id, uint256 const& hash)
 {
-    auto const depth = id.getDepth();
+    XRPL_ASSERT(id.getDepth() < SHAMap::kLeafDepth, "xrpl::selectBranch : depth below leaf depth");
+
+    // A depth-64 ID has no nibble left to select. Callers must not ask, but clamp anyway to keep
+    // the read below the end of the 32-byte key.
+    auto const depth = std::min(id.getDepth(), SHAMap::kLeafDepth - 1u);
     auto branch = static_cast<unsigned int>(*(hash.begin() + (depth / 2)));
 
     if ((depth & 1) != 0u)
@@ -134,8 +169,18 @@ selectBranch(SHAMapNodeID const& id, uint256 const& hash)
 SHAMapNodeID
 SHAMapNodeID::createID(unsigned int depth, uint256 const& key)
 {
-    XRPL_ASSERT(depth <= SHAMap::kLeafDepth, "xrpl::SHAMapNodeID::createID : valid depth");
-    return SHAMapNodeID(depth, key & depthMask(depth));
+    // The mask is chosen here, before the constructor runs, so the clamp there cannot cover this
+    // call: an out-of-range depth would index depthMask's table while still evaluating this
+    // argument. A public factory has to hold its own bound.
+    if (depth > SHAMap::kLeafDepth)
+    {
+        // LCOV_EXCL_START
+        UNREACHABLE("xrpl::SHAMapNodeID::createID : depth within tree");
+        depth = SHAMap::kLeafDepth;
+        // LCOV_EXCL_STOP
+    }
+
+    return SHAMapNodeID(depth, maskedToDepth(key, depth));
 }
 
 }  // namespace xrpl
diff --git a/src/libxrpl/shamap/SHAMapSync.cpp b/src/libxrpl/shamap/SHAMapSync.cpp
index 4319d0bcd4..602d8e629c 100644
--- a/src/libxrpl/shamap/SHAMapSync.cpp
+++ b/src/libxrpl/shamap/SHAMapSync.cpp
@@ -793,7 +793,7 @@ SHAMap::hasLeafNode(uint256 const& tag, SHAMapHash const& targetNodeHash) const
 std::optional<std::vector<Blob>>
 SHAMap::getProofPath(uint256 const& key) const
 {
-    SharedPtrNodeStack stack;
+    NodePathStack stack;
     walkTowardsKey(key, &stack);
 
     if (stack.empty())
diff --git a/src/libxrpl/tx/ApplyContext.cpp b/src/libxrpl/tx/ApplyContext.cpp
index 50f46fceef..96dcd5f587 100644
--- a/src/libxrpl/tx/ApplyContext.cpp
+++ b/src/libxrpl/tx/ApplyContext.cpp
@@ -6,6 +6,8 @@
 #include <xrpl/core/ServiceRegistry.h>
 #include <xrpl/ledger/ApplyView.h>
 #include <xrpl/ledger/OpenView.h>
+#include <xrpl/ledger/OrderBookDB.h>
+#include <xrpl/protocol/Book.h>
 #include <xrpl/protocol/STTx.h>
 #include <xrpl/protocol/TER.h>
 #include <xrpl/protocol/TxMeta.h>
@@ -54,6 +56,13 @@ ApplyContext::apply(TER ter)
     return view_->apply(base_, tx, ter, parentBatchId_, (flags_ & TapDryRun) != 0u, journal);
 }
 
+void
+ApplyContext::addOrderBook(Book const& book)
+{
+    if ((flags_ & TapDryRun) == TapNone)
+        registry.get().getOrderBookDB().addOrderBook(book);
+}
+
 std::size_t
 ApplyContext::size()
 {
diff --git a/src/libxrpl/tx/Transactor.cpp b/src/libxrpl/tx/Transactor.cpp
index 63092cc128..6bf99e567d 100644
--- a/src/libxrpl/tx/Transactor.cpp
+++ b/src/libxrpl/tx/Transactor.cpp
@@ -1246,7 +1246,7 @@ removeExpiredNFTokenOffers(
 }
 
 static void
-removeDeletedCredentials(ApplyView& view, std::vector<uint256> const& creds, beast::Journal viewJ)
+removeExpiredCredentials(ApplyView& view, std::vector<uint256> const& creds, beast::Journal viewJ)
 {
     for (auto const& index : creds)
     {
@@ -1255,7 +1255,7 @@ removeDeletedCredentials(ApplyView& view, std::vector<uint256> const& creds, bea
             if (auto const ter = credentials::deleteSLE(view, sle, viewJ); !isTesSuccess(ter))
             {
                 JLOG(viewJ.error())
-                    << "removeDeletedCredentials: failed to delete credential. Err: "
+                    << "removeExpiredCredentials: failed to delete expired credential. Err: "
                     << transToken(ter);
             }
         }
@@ -1437,8 +1437,7 @@ Transactor::processPersistentChanges(TER result, XRPAmount fee)
     //        should be used, making it possible to do more useful work
     //        when transactions fail with a `tec` code.
 
-    auto typesForResult = [credentialCleanup =
-                               view().rules().enabled(fixCleanup3_4_0)](TER const ter) {
+    auto typesForResult = [](TER const ter) {
         std::unordered_set<LedgerEntryType> types;
         if ((ter == tecOVERSIZE) || (ter == tecKILLED))
         {
@@ -1447,11 +1446,6 @@ Transactor::processPersistentChanges(TER result, XRPAmount fee)
         else if (ter == tecINCOMPLETE)
         {
             types.insert(ltRIPPLE_STATE);
-            // A bounded pseudo-account credential cleanup (VaultDelete /
-            // LoanBrokerDelete) persists its partial credential deletions so a
-            // later transaction can resume.
-            if (credentialCleanup)
-                types.insert(ltCREDENTIAL);
         }
         else if (ter == tecEXPIRED)
         {
@@ -1529,7 +1523,7 @@ Transactor::processPersistentChanges(TER result, XRPAmount fee)
                     removeDeletedTrustLines(view(), ids, viewJ);
                     break;
                 case ltCREDENTIAL:
-                    removeDeletedCredentials(view(), ids, viewJ);
+                    removeExpiredCredentials(view(), ids, viewJ);
                     break;
                 // LCOV_EXCL_START
                 default:
diff --git a/src/libxrpl/tx/apply.cpp b/src/libxrpl/tx/apply.cpp
index f93b19a158..688c585e2a 100644
--- a/src/libxrpl/tx/apply.cpp
+++ b/src/libxrpl/tx/apply.cpp
@@ -8,6 +8,7 @@
 #include <xrpl/core/ServiceRegistry.h>
 #include <xrpl/ledger/ApplyView.h>
 #include <xrpl/ledger/OpenView.h>
+#include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/Rules.h>
 #include <xrpl/protocol/SField.h>
 #include <xrpl/protocol/STObject.h>
@@ -23,13 +24,38 @@
 
 namespace xrpl {
 
-// These are the same flags defined as HashRouterFlags::PRIVATE1-4 in
-// HashRouter.h
+// This file owns HashRouterFlags::PRIVATE1-4 and PRIVATE7-8 in HashRouter.h.
+// These are the first four; the other two are below.
 constexpr HashRouterFlags kSfSigbad = HashRouterFlags::PRIVATE1;     // Signature is bad
 constexpr HashRouterFlags kSfSiggood = HashRouterFlags::PRIVATE2;    // Signature is good
 constexpr HashRouterFlags kSfLocalbad = HashRouterFlags::PRIVATE3;   // Local checks failed
 constexpr HashRouterFlags kSfLocalgood = HashRouterFlags::PRIVATE4;  // Local checks passed
 
+// Before fixCleanup3_4_0, a signature in an alternate role field, such as
+// sfSponsorSignature, covered the same bytes as the top level signature. Which
+// bytes a role signature must cover therefore depends on whether the fix is
+// enabled, but the four flags above record only the verdict, not the rules that
+// produced it. A verdict reached under one prefix would otherwise be reused
+// under the other.
+//
+// The two flags below hold the verdict for the pre-fix prefixes, so the pre-fix
+// and post-fix verdicts occupy separate slots and neither is ever read in the
+// other's era. Nothing is cleared when the amendment activates: setFlags only
+// sets bits, so a stale pre-fix verdict simply stops being read and ages out
+// with the rest of the routing table.
+//
+// This is not one switchover at a single instant. The era is chosen per call
+// from the rules passed in, and callers do not agree on the rules: relay and
+// submit verify against the validated rules, which lag the open ledger rules
+// that preflight2 verifies against. At the amendment's flag ledger the same
+// transaction can therefore be checked under both prefixes, on the same node,
+// at the same time.
+//
+// Remove these two flags, and oldPrefixSig below, when Cleanup3_4_0 is retired
+// in features.macro.
+constexpr HashRouterFlags kSfSigbadOldPrefix = HashRouterFlags::PRIVATE7;
+constexpr HashRouterFlags kSfSiggoodOldPrefix = HashRouterFlags::PRIVATE8;
+
 //------------------------------------------------------------------------------
 
 std::pair<Validity, std::string>
@@ -48,21 +74,41 @@ checkValidity(HashRouter& router, STTx const& tx, Rules const& rules)
         return {Validity::SigBad, "Batch inner transactions are never considered validly signed."};
     }
 
-    if (any(flags & kSfSigbad))
+    // Pick the cache slot for this call's era; see kSfSiggoodOldPrefix above.
+    // Only a transaction that carries a role signature, and only while the fix
+    // is disabled, uses the separate slot. Every other transaction, and every
+    // transaction once the fix is enabled, uses the ordinary flags and verifies
+    // exactly once, so there is no steady state cost.
+    //
+    // Both directions matter. A good verdict from before the fix must not let a
+    // signature moved between roles survive the amendment, and a bad verdict
+    // from before the fix must not condemn a transaction that the new prefixes
+    // accept.
+    //
+    // Whether a transaction carries a role signature is fixed for its ID: the
+    // fields are kNotSigning, so they are excluded from the signed bytes, but
+    // they are still covered by the transaction ID. Repeat calls for one ID
+    // therefore always agree on which slot pair to use.
+    bool const oldPrefixSig = !rules.enabled(fixCleanup3_4_0) &&
+        (tx.isFieldPresent(sfSponsorSignature) || tx.isFieldPresent(sfCounterpartySignature));
+    auto const sigbadFlag = oldPrefixSig ? kSfSigbadOldPrefix : kSfSigbad;
+    auto const siggoodFlag = oldPrefixSig ? kSfSiggoodOldPrefix : kSfSiggood;
+
+    if (any(flags & sigbadFlag))
     {
         // Signature is known bad
         return {Validity::SigBad, "Transaction has bad signature."};
     }
 
-    if (!any(flags & kSfSiggood))
+    if (!any(flags & siggoodFlag))
     {
         auto const sigVerify = tx.checkSign(rules);
         if (!sigVerify)
         {
-            router.setFlags(id, kSfSigbad);
+            router.setFlags(id, sigbadFlag);
             return {Validity::SigBad, sigVerify.error()};
         }
-        router.setFlags(id, kSfSiggood);
+        router.setFlags(id, siggoodFlag);
     }
 
     // Signature is now known good
@@ -94,6 +140,19 @@ checkValidity(HashRouter& router, STTx const& tx, Rules const& rules)
 void
 forceValidity(HashRouter& router, uint256 const& txid, Validity validity)
 {
+    // Callers reach here when they deliberately skip signature verification,
+    // such as a cluster peer that trusts its neighbor's checks, or a
+    // configuration that turns signature checks off. Nothing was verified, so
+    // there is no prefix era to record. Mark both of checkValidity's signature
+    // slots good: otherwise the forced verdict is ignored for a role-signature
+    // transaction until fixCleanup3_4_0 is enabled, and the signature the
+    // caller meant to skip gets verified after all. Marking both cannot leak a
+    // verdict across eras, because no verdict was reached, and this is the only
+    // place the distinction can be recorded: kSfSiggood alone does not say
+    // whether checkValidity verified a post-fix signature or a caller forced
+    // the result. An already cached bad verdict still wins, since checkValidity
+    // tests its bad flag first. Drop kSfSiggoodOldPrefix when Cleanup3_4_0 is
+    // retired.
     HashRouterFlags flags = HashRouterFlags::UNDEFINED;
     switch (validity)
     {
@@ -101,7 +160,7 @@ forceValidity(HashRouter& router, uint256 const& txid, Validity validity)
             flags |= kSfLocalgood;
             [[fallthrough]];
         case Validity::SigGoodOnly:
-            flags |= kSfSiggood;
+            flags |= kSfSiggood | kSfSiggoodOldPrefix;
             [[fallthrough]];
         case Validity::SigBad:
             // would be silly to call directly
diff --git a/src/libxrpl/tx/applySteps.cpp b/src/libxrpl/tx/applySteps.cpp
index 2c05c874d3..00ac9f9983 100644
--- a/src/libxrpl/tx/applySteps.cpp
+++ b/src/libxrpl/tx/applySteps.cpp
@@ -17,6 +17,7 @@
 
 #include <cstdint>
 #include <exception>
+#include <expected>
 #include <memory>
 #include <optional>
 #include <utility>
@@ -195,7 +196,12 @@ invokePreclaim(PreclaimContext const& ctx)
                     }())
                     return preSigResult;
 
-                if (TER const result = T::checkFee(ctx, calculateBaseFee(ctx.view, ctx.tx)))
+                // We can't check the fee if we can't compute it, so reject.
+                auto const baseFee = calculateBaseFee(ctx.view, ctx.tx);
+                if (!baseFee)
+                    return baseFee.error();
+
+                if (TER const result = T::checkFee(ctx, *baseFee))
                     return result;
             }
 
@@ -223,13 +229,12 @@ invokePreclaim(PreclaimContext const& ctx)
  *
  * @param view The ledger view to use for fee calculation.
  * @param tx The transaction for which the base fee is to be calculated.
- * @return The calculated base fee as an XRPAmount.
+ * @return The calculated base fee. Returns `std::unexpected(temUNKNOWN)` if the transaction
+ * type is not recognized, and `std::unexpected(tefEXCEPTION)` if the transactor's
+ * `calculateBaseFee` threw.
  *
- * @throws std::exception If an error occurs during fee calculation, including
- * but not limited to unknown transaction types or internal errors, the function
- * logs an error and returns an XRPAmount of zero.
  */
-static XRPAmount
+static std::expected<XRPAmount, TER>
 invokeCalculateBaseFee(ReadView const& view, STTx const& tx)
 {
     try
@@ -238,13 +243,25 @@ invokeCalculateBaseFee(ReadView const& view, STTx const& tx)
             return T::calculateBaseFee(view, tx);
         });
     }
-    catch (UnknownTxnType const& e)
+    catch (UnknownTxnType const&)
     {
         // LCOV_EXCL_START
         UNREACHABLE("xrpl::invoke_calculateBaseFee : unknown transaction type");
-        return XRPAmount{0};
+        return std::unexpected(temUNKNOWN);
         // LCOV_EXCL_STOP
     }
+    catch (std::exception const& e)
+    {
+        JLOG(debugLog().error()) << "calculateBaseFee: " << tx.getTransactionID()
+                                 << " threw an exception: " << e.what();
+        return std::unexpected(tefEXCEPTION);
+    }
+    catch (...)
+    {
+        JLOG(debugLog().error()) << "calculateBaseFee: " << tx.getTransactionID()
+                                 << " threw an unknown exception";
+        return std::unexpected(tefEXCEPTION);
+    }
 }
 
 TxConsequences::TxConsequences(NotTEC pfResult)
@@ -416,7 +433,7 @@ preclaim(PreflightResult const& preflightResult, ServiceRegistry& registry, Open
     }
 }
 
-XRPAmount
+std::expected<XRPAmount, TER>
 calculateBaseFee(ReadView const& view, STTx const& tx)
 {
     return invokeCalculateBaseFee(view, tx);
@@ -441,13 +458,26 @@ doApply(PreclaimResult const& preclaimResult, ServiceRegistry& registry, OpenVie
     {
         if (!preclaimResult.likelyToClaimFee)
             return {preclaimResult.ter, false};
+
+        // For any tx with a real account, preclaim already computed this fee
+        // successfully against this same view.
+        auto const baseFee = calculateBaseFee(view, preclaimResult.tx);
+        if (!baseFee)
+        {
+            // LCOV_EXCL_START
+            JLOG(preclaimResult.j.error())
+                << "apply: could not compute base fee: " << transToken(baseFee.error());
+            return {tefINTERNAL, false};
+            // LCOV_EXCL_STOP
+        }
+
         ApplyContext ctx(
             registry,
             view,
             preclaimResult.parentBatchId,
             preclaimResult.tx,
             preclaimResult.ter,
-            calculateBaseFee(view, preclaimResult.tx),
+            *baseFee,
             preclaimResult.flags,
             preclaimResult.j);
         return invokeApply(ctx);
diff --git a/src/libxrpl/tx/invariants/LoanInvariant.cpp b/src/libxrpl/tx/invariants/LoanInvariant.cpp
index b34d7088be..f87a7620af 100644
--- a/src/libxrpl/tx/invariants/LoanInvariant.cpp
+++ b/src/libxrpl/tx/invariants/LoanInvariant.cpp
@@ -231,17 +231,38 @@ ValidLoan::finalize(
             // must show that payment in its balance and schedule. A payment that clears
             // the loan outright instead drives PaymentRemaining to zero, which the
             // fully-paid-off and zero due-date checks above pin.
+            //
+            // PrincipalOutstanding may stay put on a non-final pay: at integer
+            // scale, fixCleanup3_2_0 rounds principal up so a fractional
+            // amortization step does not reduce it. Interest (TVO) still falls.
+            // Neither balance may grow: a payment never adds to what is owed,
+            // since late-payment penalties are charged in the same transaction
+            // rather than tracked in TotalValueOutstanding.
             if (isTesSuccess(result) && txType == ttLOAN_PAY)
             {
                 if (before && after->at(sfPaymentRemaining) != 0)
                 {
-                    if (!(after->at(sfPrincipalOutstanding) < before->at(sfPrincipalOutstanding)))
+                    if (after->at(sfPrincipalOutstanding) > before->at(sfPrincipalOutstanding))
                     {
-                        JLOG(j.fatal()) << "Invariant failed: loan pay must strictly decrease "
+                        JLOG(j.fatal()) << "Invariant failed: loan pay must not increase "
                                            "PrincipalOutstanding on a non-full-repayment";
                         return false;
                     }
-                    if (!(after->at(sfPaymentRemaining) < before->at(sfPaymentRemaining)))
+                    if (after->at(sfTotalValueOutstanding) > before->at(sfTotalValueOutstanding))
+                    {
+                        JLOG(j.fatal()) << "Invariant failed: loan pay must not increase "
+                                           "TotalValueOutstanding on a non-full-repayment";
+                        return false;
+                    }
+                    if (after->at(sfPrincipalOutstanding) == before->at(sfPrincipalOutstanding) &&
+                        after->at(sfTotalValueOutstanding) == before->at(sfTotalValueOutstanding))
+                    {
+                        JLOG(j.fatal()) << "Invariant failed: loan pay must decrease "
+                                           "PrincipalOutstanding or TotalValueOutstanding "
+                                           "on a non-full-repayment";
+                        return false;
+                    }
+                    if (after->at(sfPaymentRemaining) >= before->at(sfPaymentRemaining))
                     {
                         JLOG(j.fatal()) << "Invariant failed: loan pay must decrease "
                                            "PaymentRemaining on a non-full-repayment";
diff --git a/src/libxrpl/tx/invariants/MPTInvariant.cpp b/src/libxrpl/tx/invariants/MPTInvariant.cpp
index 09b4308165..060673c6e1 100644
--- a/src/libxrpl/tx/invariants/MPTInvariant.cpp
+++ b/src/libxrpl/tx/invariants/MPTInvariant.cpp
@@ -40,6 +40,7 @@ constexpr auto kConfidentialMptTxTypes = std::to_array<TxType>({
     ttCONFIDENTIAL_MPT_CONVERT_BACK,
     ttCONFIDENTIAL_MPT_MERGE_INBOX,
     ttCONFIDENTIAL_MPT_CLAWBACK,
+    ttCONFIDENTIAL_MPT_MIRROR_UPDATE,
 });
 
 // Clamp to the cap (== INT64_MAX) before the signed conversion. Invariant
@@ -234,14 +235,6 @@ ValidMPTIssuance::finalize(
 
         if (hasPrivilege(tx, Privilege::DestroyMptIssuance))
         {
-            // A VaultDelete that is still cleaning up credentials pinned to its
-            // pseudo-account returns tecINCOMPLETE and has not yet reached the
-            // share issuance. Don't require the issuance to be removed until
-            // the deletion completes (a later transaction).
-            if (rules.enabled(fixCleanup3_4_0) && txnType == ttVAULT_DELETE &&
-                result == tecINCOMPLETE)
-                return mptIssuancesDeleted_ == 0 && mptIssuancesCreated_ == 0;
-
             if (mptIssuancesDeleted_ == 0)
             {
                 JLOG(j.fatal()) << "Invariant failed: MPT issuance deletion "
@@ -307,27 +300,46 @@ ValidMPTIssuance::finalize(
                     return false;
                 }
             }
-            else if (lendingProtocolEnabled && (mptokensCreated_ + mptokensDeleted_) > 1)
+            else
             {
-                JLOG(j.fatal()) << "Invariant failed: MPT authorize succeeded "
-                                   "but created/deleted bad number mptokens";
-                return false;
-            }
-            else if (submittedByIssuer && (mptokensCreated_ > 0 || mptokensDeleted_ > 0))
-            {
-                JLOG(j.fatal()) << "Invariant failed: MPT authorize submitted by issuer "
-                                   "succeeded but created/deleted mptokens";
-                return false;
-            }
-            else if (
-                !submittedByIssuer && hasPrivilege(tx, Privilege::MustAuthorizeMpt) &&
-                (mptokensCreated_ + mptokensDeleted_ != 1))
-            {
-                // if the holder submitted this tx, then a mptoken must be
-                // either created or deleted.
-                JLOG(j.fatal()) << "Invariant failed: MPT authorize submitted by holder "
-                                   "succeeded but created/deleted bad number of mptokens";
-                return false;
+                // Cap on MPToken creates and deletes while featureLendingProtocol is enabled.
+                // - LoanSet: at most two creates and no deletes.
+                // - VaultWithdraw: at most one create and one delete.
+                // - Other MayAuthorizeMpt types: created + deleted <= 1.
+                // - MustAuthorizeMpt still requires exactly one create or delete below.
+                auto const mptokensExceedAuthorizeCap = [&] {
+                    if (!lendingProtocolEnabled)
+                        return false;
+                    if (rules.enabled(fixCleanup3_4_0))
+                    {
+                        if (txnType == ttLOAN_SET)
+                            return mptokensDeleted_ != 0 || mptokensCreated_ > 2;
+                        if (txnType == ttVAULT_WITHDRAW)
+                            return mptokensCreated_ > 1 || mptokensDeleted_ > 1;
+                    }
+                    return (mptokensCreated_ + mptokensDeleted_) > 1;
+                };
+                if (mptokensExceedAuthorizeCap())
+                {
+                    JLOG(j.fatal()) << "Invariant failed: MPT authorize succeeded "
+                                       "but created/deleted bad number mptokens";
+                    return false;
+                }
+                if (submittedByIssuer && (mptokensCreated_ > 0 || mptokensDeleted_ > 0))
+                {
+                    JLOG(j.fatal()) << "Invariant failed: MPT authorize submitted by issuer "
+                                       "succeeded but created/deleted mptokens";
+                    return false;
+                }
+                if (!submittedByIssuer && hasPrivilege(tx, Privilege::MustAuthorizeMpt) &&
+                    (mptokensCreated_ + mptokensDeleted_ != 1))
+                {
+                    // if the holder submitted this tx, then a mptoken must be
+                    // either created or deleted.
+                    JLOG(j.fatal()) << "Invariant failed: MPT authorize submitted by holder "
+                                       "succeeded but created/deleted bad number of mptokens";
+                    return false;
+                }
             }
 
             return true;
diff --git a/src/libxrpl/tx/invariants/VaultInvariant.cpp b/src/libxrpl/tx/invariants/VaultInvariant.cpp
index ff3a20c8ff..69c3ce92e0 100644
--- a/src/libxrpl/tx/invariants/VaultInvariant.cpp
+++ b/src/libxrpl/tx/invariants/VaultInvariant.cpp
@@ -1129,9 +1129,7 @@ ValidVault::finalize(
                         // only. If the receiver's trust line sits at a coarser scale, the inflow
                         // may safely round down to zero.
                         //
-                        // XRP and MPT remain strict. Because they are integer-exact, a zero
-                        // destination delta indicates a true accounting bug, not a rounding
-                        // artifact.
+                        // XRP and MPT remain strict for rounding artifacts.
                         bool const tolerateZeroDelta =
                             view.rules().enabled(fixCleanup3_2_0) && !vaultAsset.integral();
                         auto const invalidBalanceChange = tolerateZeroDelta
diff --git a/src/libxrpl/tx/transactors/check/CheckCash.cpp b/src/libxrpl/tx/transactors/check/CheckCash.cpp
index 857f759752..f753f604f0 100644
--- a/src/libxrpl/tx/transactors/check/CheckCash.cpp
+++ b/src/libxrpl/tx/transactors/check/CheckCash.cpp
@@ -439,6 +439,12 @@ CheckCash::doApply()
             AccountID const& deliverIssuer = flowDeliver.getIssuer();
             auto const err = flowDeliver.asset().visit(
                 [&](Issue const& issue) -> std::optional<TER> {
+                    // An issuer needs no holder-limit waiver to receive its own currency.
+                    if (deliverIssuer == accountID_ && ctx_.view().rules().enabled(fixCleanup3_4_0))
+                    {
+                        return std::nullopt;
+                    }
+
                     // If a trust line does not exist yet create one.
                     Issue const& trustLineIssue = issue;
                     AccountID const truster = deliverIssuer == accountID_ ? srcId : accountID_;
diff --git a/src/libxrpl/tx/transactors/dex/AMMClawback.cpp b/src/libxrpl/tx/transactors/dex/AMMClawback.cpp
index b25c90069c..f95f257ab6 100644
--- a/src/libxrpl/tx/transactors/dex/AMMClawback.cpp
+++ b/src/libxrpl/tx/transactors/dex/AMMClawback.cpp
@@ -237,6 +237,7 @@ AMMClawback::applyGuts(Sandbox& sb)
                 0,
                 FreezeHandling::IgnoreFreeze,
                 AuthHandling::IgnoreAuth,
+                ReserveHandling::IgnoreReserve,
                 WithdrawAll::Yes,
                 preFeeBalance_,
                 ctx_.journal);
@@ -345,6 +346,7 @@ AMMClawback::equalWithdrawMatchingOneAmount(
             0,
             FreezeHandling::IgnoreFreeze,
             AuthHandling::IgnoreAuth,
+            ReserveHandling::IgnoreReserve,
             WithdrawAll::Yes,
             preFeeBalance_,
             ctx_.journal);
@@ -385,6 +387,7 @@ AMMClawback::equalWithdrawMatchingOneAmount(
             0,
             FreezeHandling::IgnoreFreeze,
             AuthHandling::IgnoreAuth,
+            ReserveHandling::IgnoreReserve,
             WithdrawAll::No,
             preFeeBalance_,
             ctx_.journal);
@@ -406,6 +409,7 @@ AMMClawback::equalWithdrawMatchingOneAmount(
         0,
         FreezeHandling::IgnoreFreeze,
         AuthHandling::IgnoreAuth,
+        ReserveHandling::IgnoreReserve,
         WithdrawAll::No,
         preFeeBalance_,
         ctx_.journal);
diff --git a/src/libxrpl/tx/transactors/dex/AMMCreate.cpp b/src/libxrpl/tx/transactors/dex/AMMCreate.cpp
index 7c7d35497a..2bc9aa5ba1 100644
--- a/src/libxrpl/tx/transactors/dex/AMMCreate.cpp
+++ b/src/libxrpl/tx/transactors/dex/AMMCreate.cpp
@@ -2,8 +2,6 @@
 
 #include <xrpl/basics/Log.h>
 #include <xrpl/beast/utility/Zero.h>
-#include <xrpl/core/ServiceRegistry.h>
-#include <xrpl/ledger/OrderBookDB.h>
 #include <xrpl/ledger/ReadView.h>
 #include <xrpl/ledger/Sandbox.h>
 #include <xrpl/ledger/View.h>
@@ -397,7 +395,7 @@ applyCreate(ApplyContext& ctx, Sandbox& sb, AccountID const& account, beast::Jou
         Book const book{assetIn, assetOut, std::nullopt};
         auto const dir = keylet::quality(keylet::book(book), uRate);
         if (auto const bookExisted = static_cast<bool>(sb.read(dir)); !bookExisted)
-            ctx.registry.get().getOrderBookDB().addOrderBook(book);
+            ctx.addOrderBook(book);
     };
     addOrderBook(amount.asset(), amount2.asset(), getRate(amount2, amount));
     addOrderBook(amount2.asset(), amount.asset(), getRate(amount, amount2));
diff --git a/src/libxrpl/tx/transactors/dex/AMMWithdraw.cpp b/src/libxrpl/tx/transactors/dex/AMMWithdraw.cpp
index 7744c128af..77b9071cf8 100644
--- a/src/libxrpl/tx/transactors/dex/AMMWithdraw.cpp
+++ b/src/libxrpl/tx/transactors/dex/AMMWithdraw.cpp
@@ -527,6 +527,7 @@ AMMWithdraw::withdraw(
         tfee,
         issuerFreezeHandling(),
         AuthHandling::ZeroIfUnauthorized,
+        ReserveHandling::EnforceReserve,
         isWithdrawAll(ctx_.tx),
         preFeeBalance_,
         j_);
@@ -548,6 +549,7 @@ AMMWithdraw::withdraw(
     std::uint16_t tfee,
     FreezeHandling freezeHandling,
     AuthHandling authHandling,
+    ReserveHandling reserveHandling,
     WithdrawAll withdrawAll,
     XRPAmount const& priorBalance,
     beast::Journal const& journal)
@@ -681,6 +683,14 @@ AMMWithdraw::withdraw(
             });
         if (assetNotExists)
         {
+            // Intentionally ignore the reserve check for AMMClawback, so the
+            // holder can not avoid clawback by deleting the trustline/MPToken
+            // and keeping a low spendable balance. AMMClawback has a higher
+            // priority than the reserve check.
+            if (view.rules().enabled(fixCleanup3_4_0) &&
+                reserveHandling == ReserveHandling::IgnoreReserve)
+                return tesSUCCESS;
+
             auto sleAccount = view.peek(keylet::account(account));
             if (!sleAccount)
                 return tecINTERNAL;  // LCOV_EXCL_LINE
@@ -850,6 +860,7 @@ AMMWithdraw::equalWithdrawTokens(
         tfee,
         issuerFreezeHandling(),
         AuthHandling::ZeroIfUnauthorized,
+        ReserveHandling::EnforceReserve,
         isWithdrawAll(ctx_.tx),
         preFeeBalance_,
         ctx_.journal);
@@ -903,6 +914,7 @@ AMMWithdraw::equalWithdrawTokens(
     std::uint16_t tfee,
     FreezeHandling freezeHandling,
     AuthHandling authHandling,
+    ReserveHandling reserveHandling,
     WithdrawAll withdrawAll,
     XRPAmount const& priorBalance,
     beast::Journal const& journal)
@@ -926,6 +938,7 @@ AMMWithdraw::equalWithdrawTokens(
                 tfee,
                 freezeHandling,
                 authHandling,
+                reserveHandling,
                 WithdrawAll::Yes,
                 priorBalance,
                 journal);
@@ -962,6 +975,7 @@ AMMWithdraw::equalWithdrawTokens(
             tfee,
             freezeHandling,
             authHandling,
+            reserveHandling,
             withdrawAll,
             priorBalance,
             journal);
diff --git a/src/libxrpl/tx/transactors/dex/OfferCreate.cpp b/src/libxrpl/tx/transactors/dex/OfferCreate.cpp
index 7ab1143d12..6c3c04f1a0 100644
--- a/src/libxrpl/tx/transactors/dex/OfferCreate.cpp
+++ b/src/libxrpl/tx/transactors/dex/OfferCreate.cpp
@@ -6,11 +6,11 @@
 #include <xrpl/beast/utility/instrumentation.h>
 #include <xrpl/core/ServiceRegistry.h>
 #include <xrpl/ledger/ApplyView.h>
-#include <xrpl/ledger/OrderBookDB.h>
 #include <xrpl/ledger/PaymentSandbox.h>
 #include <xrpl/ledger/Sandbox.h>
 #include <xrpl/ledger/View.h>
 #include <xrpl/ledger/helpers/AccountRootHelpers.h>
+#include <xrpl/ledger/helpers/CredentialHelpers.h>
 #include <xrpl/ledger/helpers/DirectoryHelpers.h>
 #include <xrpl/ledger/helpers/MPTokenHelpers.h>
 #include <xrpl/ledger/helpers/OfferHelpers.h>
@@ -242,8 +242,31 @@ OfferCreate::preclaim(PreclaimContext const& ctx)
     // is part of the domain
     if (ctx.tx.isFieldPresent(sfDomainID))
     {
-        if (!permissioned_dex::accountInDomain(ctx.view, id, ctx.tx[sfDomainID]))
-            return tecNO_PERMISSION;
+        if (ctx.view.rules().enabled(fixCleanup3_4_0))
+        {
+            auto const domainID = ctx.tx[sfDomainID];
+            auto const sleDomain = ctx.view.read(keylet::permissionedDomain(domainID));
+            if (!sleDomain)
+                return tecNO_PERMISSION;
+
+            // Domain owner is always considered in the domain, no credential check
+            // needed. For all other accounts, use validDomain which detects expired
+            // credentials. Suppress tecEXPIRED here so doApply can run and delete
+            // the expired credential SLEs from the ledger.
+            if (sleDomain->getAccountID(sfOwner) != id)
+            {
+                // validDomain returns tecNO_AUTH when no matching credential is
+                // found. Map it to tecNO_PERMISSION to preserve existing behavior.
+                if (auto const err = credentials::validDomain(ctx.view, domainID, id);
+                    !isTesSuccess(err) && err != tecEXPIRED)
+                    return tecNO_PERMISSION;
+            }
+        }
+        else
+        {
+            if (!permissioned_dex::accountInDomain(ctx.view, id, ctx.tx[sfDomainID]))
+                return tecNO_PERMISSION;
+        }
     }
 
     if (auto const ter = canTrade(ctx.view, saTakerPays.asset()); !isTesSuccess(ter))
@@ -610,7 +633,7 @@ OfferCreate::applyHybrid(
     bookArr.pushBack(std::move(bookInfo));
 
     if (!bookExists)
-        ctx_.registry.get().getOrderBookDB().addOrderBook(book);
+        ctx_.addOrderBook(book);
 
     sleOffer->setFieldArray(sfAdditionalBooks, bookArr);
     return tesSUCCESS;
@@ -990,7 +1013,7 @@ OfferCreate::applyGuts(Sandbox& sb, Sandbox& sbCancel)
     sb.insert(sleOffer);
 
     if (!bookExisted)
-        ctx_.registry.get().getOrderBookDB().addOrderBook(book);
+        ctx_.addOrderBook(book);
 
     JLOG(j_.debug()) << "final result: success";
 
@@ -1000,6 +1023,27 @@ OfferCreate::applyGuts(Sandbox& sb, Sandbox& sbCancel)
 TER
 OfferCreate::doApply()
 {
+    // If a DomainID is present, verify the account is still in the domain and
+    // delete any expired credential SLEs. This must happen before the Sandboxes
+    // are created: if we return a tec error, the engine applies sbCancel (not
+    // sb) to rawView, so deletions made inside sb would be lost. Deletions made
+    // directly to ctx_.view() here are preserved regardless of which branch
+    // applyGuts takes.
+    if (ctx_.tx.isFieldPresent(sfDomainID) && ctx_.view().rules().enabled(fixCleanup3_4_0))
+    {
+        auto const domainID = ctx_.tx[sfDomainID];
+        auto const sleDomain = ctx_.view().read(keylet::permissionedDomain(domainID));
+        if (!sleDomain)
+            return tecINTERNAL;  // LCOV_EXCL_LINE
+
+        if (sleDomain->getAccountID(sfOwner) != accountID_)
+        {
+            if (auto const err = verifyValidDomain(ctx_.view(), accountID_, domainID, j_);
+                !isTesSuccess(err))
+                return err;
+        }
+    }
+
     // This is the ledger view that we work against. Transactions are applied
     // as we go on processing transactions.
     Sandbox sb(&ctx_.view());
diff --git a/src/libxrpl/tx/transactors/escrow/EscrowCancel.cpp b/src/libxrpl/tx/transactors/escrow/EscrowCancel.cpp
index 21e6bd2c30..32b56b909f 100644
--- a/src/libxrpl/tx/transactors/escrow/EscrowCancel.cpp
+++ b/src/libxrpl/tx/transactors/escrow/EscrowCancel.cpp
@@ -169,6 +169,12 @@ EscrowCancel::doApply()
     auto const sle = ctx_.view().peek(keylet::account(account));
     STAmount const amount = slep->getFieldAmount(sfAmount);
 
+    // The return can re-create a holding the owner deleted while the escrow
+    // was pending; the removed escrow must not be counted against its reserve.
+    bool const recycleReserve = ctx_.view().rules().enabled(fixCleanup3_4_0);
+    if (recycleReserve)
+        decreaseOwnerCountForObject(ctx_.view(), sle, slep, 1, ctx_.journal);
+
     // Transfer amount back to the owner
     if (isXRP(amount))
     {
@@ -212,7 +218,8 @@ EscrowCancel::doApply()
         }
     }
 
-    decreaseOwnerCountForObject(ctx_.view(), sle, slep, 1, ctx_.journal);
+    if (!recycleReserve)
+        decreaseOwnerCountForObject(ctx_.view(), sle, slep, 1, ctx_.journal);
 
     // Remove escrow from ledger
     ctx_.view().erase(slep);
diff --git a/src/libxrpl/tx/transactors/escrow/EscrowCreate.cpp b/src/libxrpl/tx/transactors/escrow/EscrowCreate.cpp
index 0fe27fb3ba..589ad70230 100644
--- a/src/libxrpl/tx/transactors/escrow/EscrowCreate.cpp
+++ b/src/libxrpl/tx/transactors/escrow/EscrowCreate.cpp
@@ -88,8 +88,13 @@ EscrowCreate::checkExtraFeatures(PreflightContext const& ctx)
     // Only require featureMPTokensV1 when the escrow amount is an MPT and
     // fixCleanup3_2_0 is active; XRP/IOU escrows are unaffected by this gate.
     if (ctx.rules.enabled(fixCleanup3_2_0) && ctx.tx[sfAmount].holds<MPTIssue>())
-        return ctx.rules.enabled(featureMPTokensV1);
-    return true;
+    {
+        if (!ctx.rules.enabled(featureMPTokensV1))
+            return false;
+    }
+
+    return (!ctx.tx.isFieldPresent(sfBytecode) && !ctx.tx.isFieldPresent(sfData)) ||
+        ctx.rules.enabled(featureSmartEscrow);
 }
 
 template <ValidIssueType T>
diff --git a/src/libxrpl/tx/transactors/escrow/EscrowFinish.cpp b/src/libxrpl/tx/transactors/escrow/EscrowFinish.cpp
index aa352d5e98..59bec8ca4c 100644
--- a/src/libxrpl/tx/transactors/escrow/EscrowFinish.cpp
+++ b/src/libxrpl/tx/transactors/escrow/EscrowFinish.cpp
@@ -65,7 +65,13 @@ checkCondition(Slice f, Slice c)
 bool
 EscrowFinish::checkExtraFeatures(PreflightContext const& ctx)
 {
-    return !ctx.tx.isFieldPresent(sfCredentialIDs) || ctx.rules.enabled(featureCredentials);
+    if (ctx.tx.isFieldPresent(sfCredentialIDs) && !ctx.rules.enabled(featureCredentials))
+        return false;
+
+    if (ctx.tx.isFieldPresent(sfGas) && !ctx.rules.enabled(featureSmartEscrow))
+        return false;
+
+    return true;
 }
 
 NotTEC
@@ -343,14 +349,12 @@ EscrowFinish::doApply()
         }
     }
 
-    // With the Sponsor amendment, release the escrow reserve before delivery.
-    // Token delivery can auto-create a destination holding, and the same
-    // sponsor (or the same account, for a self-escrow) may cover both the
-    // escrow being removed and the holding being created. Without the
-    // amendment, keep the legacy order: releasing early changes the reserve
-    // arithmetic for self-escrows and would break consensus if not gated.
-    bool const sponsorEnabled = ctx_.view().rules().enabled(featureSponsor);
-    if (sponsorEnabled)
+    // Delivery can auto-create the destination's holding; the removed escrow
+    // must not be counted against its reserve. The two share a reserve payer
+    // for a self-escrow, or when one sponsor covers both.
+    bool const recycleReserve =
+        ctx_.view().rules().enabled(featureSponsor) || ctx_.view().rules().enabled(fixCleanup3_4_0);
+    if (recycleReserve)
         decreaseOwnerCountForObject(ctx_.view(), account, slep, 1, ctx_.journal);
 
     STAmount const amount = slep->getFieldAmount(sfAmount);
@@ -402,8 +406,7 @@ EscrowFinish::doApply()
 
     ctx_.view().update(sled);
 
-    // Adjust source owner count (legacy position, pre-Sponsor)
-    if (!sponsorEnabled)
+    if (!recycleReserve)
         decreaseOwnerCountForObject(ctx_.view(), account, slep, 1, ctx_.journal);
 
     // Remove escrow from ledger
diff --git a/src/libxrpl/tx/transactors/lending/LoanBrokerDelete.cpp b/src/libxrpl/tx/transactors/lending/LoanBrokerDelete.cpp
index 06907ce366..433d77806a 100644
--- a/src/libxrpl/tx/transactors/lending/LoanBrokerDelete.cpp
+++ b/src/libxrpl/tx/transactors/lending/LoanBrokerDelete.cpp
@@ -4,13 +4,11 @@
 #include <xrpl/basics/Number.h>
 #include <xrpl/beast/utility/Zero.h>
 #include <xrpl/ledger/helpers/AccountRootHelpers.h>
-#include <xrpl/ledger/helpers/CredentialHelpers.h>
 #include <xrpl/ledger/helpers/LendingHelpers.h>
 #include <xrpl/ledger/helpers/TokenHelpers.h>
 #include <xrpl/protocol/Asset.h>
 #include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/Indexes.h>
-#include <xrpl/protocol/Protocol.h>
 #include <xrpl/protocol/SField.h>
 #include <xrpl/protocol/STAmount.h>
 #include <xrpl/protocol/STLedgerEntry.h>
@@ -142,19 +140,6 @@ LoanBrokerDelete::doApply()
 
     auto const brokerPseudoID = broker->at(sfAccount);
 
-    // Remove any credentials pinned to the broker pseudo-account before anything
-    // else. They would otherwise keep its owner directory alive and block
-    // deletion with tecHAS_OBLIGATIONS. Doing it first means a bounded,
-    // tecINCOMPLETE cleanup can be resumed by a later transaction without having
-    // already torn down the broker.
-    if (view().rules().enabled(fixCleanup3_4_0))
-    {
-        if (auto const ter = credentials::deletePseudoAccountCredentials(
-                view(), brokerPseudoID, kMaxDeletablePseudoAccountCredentials, j_);
-            !isTesSuccess(ter))
-            return ter;
-    }
-
     if (!view().dirRemove(
             keylet::ownerDir(accountID_), broker->at(sfOwnerNode), broker->key(), false))
     {
diff --git a/src/libxrpl/tx/transactors/lending/LoanPay.cpp b/src/libxrpl/tx/transactors/lending/LoanPay.cpp
index 18886b2682..624c4d0a84 100644
--- a/src/libxrpl/tx/transactors/lending/LoanPay.cpp
+++ b/src/libxrpl/tx/transactors/lending/LoanPay.cpp
@@ -36,6 +36,15 @@
 namespace xrpl {
 
 namespace {
+// Returns true if the transaction's payment amount is malformed. A loan
+// payment must be strictly positive: zero would move nothing, and a negative
+// amount is not a payment at all.
+bool
+isPaymentAmountInvalid(STAmount const& amount)
+{
+    return amount <= beast::kZero;
+}
+
 // Returns the account's true, unclamped balance in `asset`, for use only in
 // fund-conservation checks. accountHolds(..., SpendableHandling::FullBalance)
 // cannot be used for this: for XRP it always defers to xrpLiquid, which
@@ -81,7 +90,7 @@ LoanPay::preflight(PreflightContext const& ctx)
     if (ctx.tx[sfLoanID] == beast::kZero)
         return temINVALID;
 
-    if (ctx.tx[sfAmount] <= beast::kZero)
+    if (isPaymentAmountInvalid(ctx.tx[sfAmount]))
         return temBAD_AMOUNT;
 
     // The loan payment flags are all mutually exclusive. If more than one is
@@ -103,10 +112,19 @@ LoanPay::preflight(PreflightContext const& ctx)
 XRPAmount
 LoanPay::calculateBaseFee(ReadView const& view, STTx const& tx)
 {
+    auto fixEnabled313 = view.rules().enabled(fixCleanup3_1_3);
+    auto fixEnabled340 = view.rules().enabled(fixCleanup3_4_0);
+
     using namespace lending;
 
     auto const normalCost = Transactor::calculateBaseFee(view, tx);
 
+    if (fixEnabled340 && isPaymentAmountInvalid(tx[sfAmount]))
+    {
+        // Let preflight worry about the error for this
+        return normalCost;
+    }
+
     if (tx.isFlag(tfLoanFullPayment) || tx.isFlag(tfLoanLatePayment))
     {
         // The loan will be making one set of calculations for one full or late
@@ -179,8 +197,7 @@ LoanPay::calculateBaseFee(ReadView const& view, STTx const& tx)
     static constexpr std::int64_t kMaxFeeIncrements =
         kLoanMaximumPaymentsPerTransaction / kLoanPaymentsPerFeeIncrement;
 
-    if (view.rules().enabled(fixCleanup3_1_3) &&
-        amount >= regularPayment * kLoanMaximumPaymentsPerTransaction)
+    if (fixEnabled313 && amount >= regularPayment * kLoanMaximumPaymentsPerTransaction)
     {
         // The payment handler will never process more than
         // loanMaximumPaymentsPerTransaction payments (including overpayments),
diff --git a/src/libxrpl/tx/transactors/lending/LoanSet.cpp b/src/libxrpl/tx/transactors/lending/LoanSet.cpp
index f7b97dfedf..da2eb609d8 100644
--- a/src/libxrpl/tx/transactors/lending/LoanSet.cpp
+++ b/src/libxrpl/tx/transactors/lending/LoanSet.cpp
@@ -343,10 +343,10 @@ LoanSet::preclaim(PreclaimContext const& ctx)
         }
     }
 
-    // Accrual origination credits interestDue into AssetsTotal, so a vault
+    // Instant interest recognition credits interestDue into AssetsTotal, so a vault
     // already at AssetsMaximum cannot take another loan. Cash-basis origination
     // does not change AssetsTotal (see cash_basis::loanOriginationDeltas), so
-    // this leftover accrual gate must not apply there.
+    // this leftover instant-recognition gate must not apply there.
     if (getVaultVersion(vault) != VaultVersion::CashBasis && vault->at(sfAssetsMaximum) != 0 &&
         vault->at(sfAssetsTotal) >= vault->at(sfAssetsMaximum))
     {
@@ -499,7 +499,7 @@ LoanSet::doApply()
             getVaultVersion(vaultSle) == VaultVersion::CashBasis ||
             *vaultSle->at(sfAssetsMaximum) > *vaultTotalProxy,
         "xrpl::LoanSet::doApply",
-        "accrual vault is below maximum limit");
+        "instant-recognition vault is below maximum limit");
 
     if (loanOriginationExceedsVaultMaximum(vaultSle, vaultTotalProxy, state.interestDue))
     {
diff --git a/src/libxrpl/tx/transactors/payment/Payment.cpp b/src/libxrpl/tx/transactors/payment/Payment.cpp
index c8b00f0193..d2da173345 100644
--- a/src/libxrpl/tx/transactors/payment/Payment.cpp
+++ b/src/libxrpl/tx/transactors/payment/Payment.cpp
@@ -339,17 +339,36 @@ Payment::checkGranularSemantics(
             bool const accountIsHolder =
                 accountIsLow ? rawBalance > beast::kZero : rawBalance < beast::kZero;
 
+            bool const mayIssue =
+                heldGranularPermissions.contains(PaymentMint) && destLimit > beast::kZero;
+
             // PaymentMint requires the destination to be the holder and the account to be the
             // issuer. destLimit > 0: destination is willing to hold account's IOUs (account is the
             // issuer). !accountIsHolder: DirectStepI will issue, not redeem.
-            if (heldGranularPermissions.contains(PaymentMint) && destLimit > beast::kZero &&
-                !accountIsHolder)
+            if (mayIssue && !accountIsHolder)
                 return tesSUCCESS;
 
             // PaymentBurn requires the source account to be the holder and the destination to be
             // the issuer. accountIsHolder: DirectStepI will redeem, not issue.
             if (heldGranularPermissions.contains(PaymentBurn) && accountIsHolder)
-                return tesSUCCESS;
+            {
+                if (view.rules().enabled(fixCleanup3_4_0))
+                {
+                    // Redeeming stops at the balance held; beyond that the payment engine
+                    // crosses zero and issues the account's own IOUs, which is a mint. So with
+                    // only PaymentBurn we must check the amount against the balance held. The
+                    // granular template forbids sfPaths, tfPartialPayment and a cross-asset
+                    // sfSendMax, so this is a single direct step, sfAmount is what the
+                    // trustline is debited.
+                    STAmount const held = accountIsLow ? rawBalance : -rawBalance;
+                    if (dstAmount <= held || mayIssue)
+                        return tesSUCCESS;
+                }
+                else
+                {
+                    return tesSUCCESS;
+                }
+            }
 
             return terNO_DELEGATE_PERMISSION;
         });
@@ -458,11 +477,41 @@ Payment::preclaim(PreclaimContext const& ctx)
 
     if (ctx.tx.isFieldPresent(sfDomainID))
     {
-        if (!permissioned_dex::accountInDomain(ctx.view, ctx.tx[sfAccount], ctx.tx[sfDomainID]))
-            return tecNO_PERMISSION;
+        if (ctx.view.rules().enabled(fixCleanup3_4_0))
+        {
+            auto const domainID = ctx.tx[sfDomainID];
+            auto const sleDomain = ctx.view.read(keylet::permissionedDomain(domainID));
+            if (!sleDomain)
+                return tecNO_PERMISSION;
 
-        if (!permissioned_dex::accountInDomain(ctx.view, ctx.tx[sfDestination], ctx.tx[sfDomainID]))
-            return tecNO_PERMISSION;
+            // Domain owner is always considered in the domain. For other accounts,
+            // suppress tecEXPIRED so doApply can run and delete expired credential
+            // SLEs from the ledger.
+            auto const checkAccount = [&](AccountID const& acct) -> TER {
+                if (sleDomain->getAccountID(sfOwner) == acct)
+                    return tesSUCCESS;
+                // validDomain returns tecNO_AUTH when no matching credential is
+                // found. Map it to tecNO_PERMISSION to preserve existing behavior.
+                if (auto const err = credentials::validDomain(ctx.view, domainID, acct);
+                    !isTesSuccess(err) && err != tecEXPIRED)
+                    return tecNO_PERMISSION;
+                return tesSUCCESS;
+            };
+
+            if (auto const err = checkAccount(ctx.tx[sfAccount]); !isTesSuccess(err))
+                return err;
+            if (auto const err = checkAccount(ctx.tx[sfDestination]); !isTesSuccess(err))
+                return err;
+        }
+        else
+        {
+            if (!permissioned_dex::accountInDomain(ctx.view, ctx.tx[sfAccount], ctx.tx[sfDomainID]))
+                return tecNO_PERMISSION;
+
+            if (!permissioned_dex::accountInDomain(
+                    ctx.view, ctx.tx[sfDestination], ctx.tx[sfDomainID]))
+                return tecNO_PERMISSION;
+        }
     }
 
     return tesSUCCESS;
@@ -471,6 +520,31 @@ Payment::preclaim(PreclaimContext const& ctx)
 TER
 Payment::doApply()
 {
+    // If a DomainID is present, verify both sender and destination are still in
+    // the domain and delete any expired credential SLEs from the ledger.
+    if (ctx_.tx.isFieldPresent(sfDomainID) && ctx_.view().rules().enabled(fixCleanup3_4_0))
+    {
+        auto const domainID = ctx_.tx[sfDomainID];
+        auto const sleDomain = ctx_.view().read(keylet::permissionedDomain(domainID));
+        if (!sleDomain)
+            return tecINTERNAL;  // LCOV_EXCL_LINE
+
+        auto const cleanupFor = [&](AccountID const& acct) -> TER {
+            if (sleDomain->getAccountID(sfOwner) == acct)
+                return tesSUCCESS;
+            return verifyValidDomain(ctx_.view(), acct, domainID, j_);
+        };
+
+        auto const destination = ctx_.tx[sfDestination];
+        auto const senderErr = cleanupFor(accountID_);
+        auto const destinationErr = accountID_ == destination ? senderErr : cleanupFor(destination);
+
+        if (!isTesSuccess(senderErr))
+            return senderErr;
+        if (!isTesSuccess(destinationErr))
+            return destinationErr;
+    }
+
     auto const deliverMin = ctx_.tx[~sfDeliverMin];
 
     // Ripple if source or destination is non-native or if there are paths.
diff --git a/src/libxrpl/tx/transactors/sponsor/SponsorshipTransfer.cpp b/src/libxrpl/tx/transactors/sponsor/SponsorshipTransfer.cpp
index c3131714f8..642a415be7 100644
--- a/src/libxrpl/tx/transactors/sponsor/SponsorshipTransfer.cpp
+++ b/src/libxrpl/tx/transactors/sponsor/SponsorshipTransfer.cpp
@@ -2,6 +2,7 @@
 
 #include <xrpl/basics/Log.h>
 #include <xrpl/basics/base_uint.h>
+#include <xrpl/beast/utility/Zero.h>
 #include <xrpl/beast/utility/instrumentation.h>
 #include <xrpl/core/ServiceRegistry.h>
 #include <xrpl/ledger/ApplyView.h>
@@ -206,6 +207,13 @@ SponsorshipTransfer::preflight(PreflightContext const& ctx)
         return temMALFORMED;
     }
 
+    if (auto const objectID = ctx.tx[~sfObjectID];
+        ctx.rules.enabled(fixCleanup3_5_0) && objectID && *objectID == beast::kZero)
+    {
+        JLOG(ctx.j.debug()) << "preflight: sfObjectID must not be zero";
+        return temMALFORMED;
+    }
+
     return tesSUCCESS;
 }
 
diff --git a/src/libxrpl/tx/transactors/system/Batch.cpp b/src/libxrpl/tx/transactors/system/Batch.cpp
index ccb113e07b..dcd06453aa 100644
--- a/src/libxrpl/tx/transactors/system/Batch.cpp
+++ b/src/libxrpl/tx/transactors/system/Batch.cpp
@@ -73,14 +73,23 @@ Batch::calculateBaseFeeImpl(ReadView const& view, STTx const& tx)
     for (auto const& stx : tx.getBatchTransactions())
     {
         auto const fee = xrpl::calculateBaseFee(view, *stx);
-        // LCOV_EXCL_START
-        if (txnFees > maxAmount - fee)
+        if (!fee)
         {
+            JLOG(debugLog().error())
+                << "BatchTrace: base fee of inner transaction " << stx->getTransactionID()
+                << " could not be computed: " << transToken(fee.error());
+            return std::nullopt;
+        }
+
+        // LCOV_EXCL_START
+        if (txnFees > maxAmount - *fee)
+        {
+            UNREACHABLE("XRPAmount overflow in txnFees calculation");
             JLOG(debugLog().error()) << "BatchTrace: XRPAmount overflow in txnFees calculation.";
             return std::nullopt;
         }
         // LCOV_EXCL_STOP
-        txnFees += fee;
+        txnFees += *fee;
     }
 
     // Calculate the Signers/BatchSigners Fees
diff --git a/src/libxrpl/tx/transactors/system/Change.cpp b/src/libxrpl/tx/transactors/system/Change.cpp
index f27855a5c8..0d50b80af4 100644
--- a/src/libxrpl/tx/transactors/system/Change.cpp
+++ b/src/libxrpl/tx/transactors/system/Change.cpp
@@ -123,6 +123,12 @@ Change::preclaim(PreclaimContext const& ctx)
                     ctx.tx.isFieldPresent(sfReserveIncrementDrops))
                     return temDISABLED;
             }
+            // The ttFEE transaction format defines these fields as optional,
+            // but they are unconditionally forbidden until FeeVoteImpl is
+            // updated to populate them (SmartEscrow behavioral port).
+            if (ctx.tx.isFieldPresent(sfGasLimit) || ctx.tx.isFieldPresent(sfBytecodeSizeLimit) ||
+                ctx.tx.isFieldPresent(sfGasPrice))
+                return temDISABLED;
             return tesSUCCESS;
         case ttAMENDMENT:
         case ttUNL_MODIFY:
diff --git a/src/libxrpl/tx/transactors/token/ConfidentialMPTClawback.cpp b/src/libxrpl/tx/transactors/token/ConfidentialMPTClawback.cpp
index 19ec99702a..b3bd276e5f 100644
--- a/src/libxrpl/tx/transactors/token/ConfidentialMPTClawback.cpp
+++ b/src/libxrpl/tx/transactors/token/ConfidentialMPTClawback.cpp
@@ -5,6 +5,7 @@
 #include <xrpl/core/ServiceRegistry.h>
 #include <xrpl/ledger/ReadView.h>
 #include <xrpl/protocol/ConfidentialTransfer.h>
+#include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/Indexes.h>
 #include <xrpl/protocol/LedgerFormats.h>
 #include <xrpl/protocol/Protocol.h>
@@ -209,6 +210,12 @@ ConfidentialMPTClawback::doApply()
         (*sleHolderMPToken)[sfAuditorEncryptedBalance] = std::move(*encZeroForAuditor);
     }
 
+    // Allow clawback on stale mirrors since the issuer can still generate the
+    // proof using the corresponding stale private key. The mirrors are updated
+    // to the current epoch during execution.
+    if (view().rules().enabled(featureConfidentialMPTKeyRotation))
+        setMirrorEpochs(*sleIssuance, *sleHolderMPToken);
+
     // Decrease Global Confidential Outstanding Amount
     auto const oldCOA = (*sleIssuance)[sfConfidentialOutstandingAmount];
     if (clawAmount > oldCOA)
diff --git a/src/libxrpl/tx/transactors/token/ConfidentialMPTConvert.cpp b/src/libxrpl/tx/transactors/token/ConfidentialMPTConvert.cpp
index 5be3892151..0855f3230d 100644
--- a/src/libxrpl/tx/transactors/token/ConfidentialMPTConvert.cpp
+++ b/src/libxrpl/tx/transactors/token/ConfidentialMPTConvert.cpp
@@ -8,6 +8,7 @@
 #include <xrpl/ledger/ReadView.h>
 #include <xrpl/ledger/helpers/TokenHelpers.h>
 #include <xrpl/protocol/ConfidentialTransfer.h>
+#include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/Indexes.h>
 #include <xrpl/protocol/LedgerFormats.h>
 #include <xrpl/protocol/MPTIssue.h>
@@ -111,6 +112,17 @@ ConfidentialMPTConvert::preclaim(PreclaimContext const& ctx)
     if (!sleMptoken)
         return tecOBJECT_NOT_FOUND;
 
+    // An already-initialized holder has their new ciphertexts homomorphically
+    // added to their existing mirrors, so those mirrors must be encrypted under
+    // the currently registered keys. A first-time convert creates the mirrors
+    // under those keys instead, and has nothing to be stale.
+    if (ctx.view.rules().enabled(featureConfidentialMPTKeyRotation) &&
+        sleMptoken->isFieldPresent(sfIssuerEncryptedBalance) &&
+        !areMirrorsCurrent(*sleIssuance, *sleMptoken))
+    {
+        return tecNO_PERMISSION;
+    }
+
     auto const mptIssue = MPTIssue{issuanceID};
 
     // Explicit freeze and auth checks are required because accountHolds
@@ -331,6 +343,10 @@ ConfidentialMPTConvert::doApply()
         if (auditorEc)
             (*sleMptoken)[sfAuditorEncryptedBalance] = *auditorEc;
 
+        // Initialize key epochs when registering the keys.
+        if (view().rules().enabled(featureConfidentialMPTKeyRotation))
+            setMirrorEpochs(*sleIssuance, *sleMptoken);
+
         // Spending balance starts at zero. Must use canonical zero encryption
         // (deterministic ciphertext) so the ledger state is reproducible.
         auto zeroBalance = encryptCanonicalZeroAmount(
diff --git a/src/libxrpl/tx/transactors/token/ConfidentialMPTConvertBack.cpp b/src/libxrpl/tx/transactors/token/ConfidentialMPTConvertBack.cpp
index 1e3617ffbd..0c9b5d3345 100644
--- a/src/libxrpl/tx/transactors/token/ConfidentialMPTConvertBack.cpp
+++ b/src/libxrpl/tx/transactors/token/ConfidentialMPTConvertBack.cpp
@@ -7,6 +7,7 @@
 #include <xrpl/ledger/ReadView.h>
 #include <xrpl/ledger/helpers/TokenHelpers.h>
 #include <xrpl/protocol/ConfidentialTransfer.h>
+#include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/Indexes.h>
 #include <xrpl/protocol/LedgerFormats.h>
 #include <xrpl/protocol/Protocol.h>
@@ -197,6 +198,14 @@ ConfidentialMPTConvertBack::preclaim(PreclaimContext const& ctx)
         return tecNO_PERMISSION;
     }
 
+    // Converting back homomorphically subtracts from the holder's mirrors, so
+    // those mirrors must be current.
+    if (ctx.view.rules().enabled(featureConfidentialMPTKeyRotation) &&
+        !areMirrorsCurrent(*sleIssuance, *sleMptoken))
+    {
+        return tecNO_PERMISSION;
+    }
+
     // Sanity check: holder's MPToken must have auditor balance field if auditing
     // is enabled
     if (requiresAuditor && !sleMptoken->isFieldPresent(sfAuditorEncryptedBalance))
diff --git a/src/libxrpl/tx/transactors/token/ConfidentialMPTMirrorUpdate.cpp b/src/libxrpl/tx/transactors/token/ConfidentialMPTMirrorUpdate.cpp
new file mode 100644
index 0000000000..c00486e5e6
--- /dev/null
+++ b/src/libxrpl/tx/transactors/token/ConfidentialMPTMirrorUpdate.cpp
@@ -0,0 +1,273 @@
+#include <xrpl/tx/transactors/token/ConfidentialMPTMirrorUpdate.h>
+
+#include <xrpl/basics/Slice.h>
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/beast/utility/instrumentation.h>
+#include <xrpl/core/ServiceRegistry.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/protocol/ConfidentialTransfer.h>
+#include <xrpl/protocol/Feature.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/LedgerFormats.h>
+#include <xrpl/protocol/MPTIssue.h>
+#include <xrpl/protocol/Protocol.h>
+#include <xrpl/protocol/SField.h>
+#include <xrpl/protocol/STTx.h>
+#include <xrpl/protocol/TER.h>
+#include <xrpl/protocol/XRPAmount.h>
+#include <xrpl/tx/Transactor.h>
+
+namespace xrpl {
+
+bool
+ConfidentialMPTMirrorUpdate::checkExtraFeatures(PreflightContext const& ctx)
+{
+    // Key rotation makes sense only when featureConfidentialTransfer is enabled.
+    return ctx.rules.enabled(featureConfidentialTransfer);
+}
+
+NotTEC
+ConfidentialMPTMirrorUpdate::preflight(PreflightContext const& ctx)
+{
+    auto const account = ctx.tx[sfAccount];
+    auto const issuer = MPTIssue(ctx.tx[sfMPTokenIssuanceID]).getIssuer();
+    auto const holder = ctx.tx[~sfHolder];
+    bool const hasHolder = holder.has_value();
+
+    // The rotation mode is determined by the presence of the
+    // Holder field: Holder present is issuer mode, Holder absent is
+    // holder self-migration.
+    if (hasHolder)
+    {
+        // Issuer mode: account must be the issuer
+        if (account != issuer)
+            return temMALFORMED;
+
+        if (account == *holder)
+            return temMALFORMED;
+    }
+    else
+    {
+        // Holder self-migration: the submitter is the holder, account must not be the issuer.
+        if (account == issuer)
+            return temMALFORMED;
+    }
+
+    // At least one ciphertext will be updated.
+    bool const hasIssuerAmount = ctx.tx.isFieldPresent(sfIssuerEncryptedAmount);
+    bool const hasAuditorAmount = ctx.tx.isFieldPresent(sfAuditorEncryptedAmount);
+    if (!hasIssuerAmount && !hasAuditorAmount)
+        return temMALFORMED;
+
+    // Check the length of the encrypted amounts. Length check is cheaper than format check so put
+    // it before the format check.
+    if (hasIssuerAmount && ctx.tx[sfIssuerEncryptedAmount].length() != kEcGamalEncryptedTotalLength)
+        return temBAD_CIPHERTEXT;
+
+    if (hasAuditorAmount &&
+        ctx.tx[sfAuditorEncryptedAmount].length() != kEcGamalEncryptedTotalLength)
+        return temBAD_CIPHERTEXT;
+
+    // Check proof length.
+    if (ctx.tx[sfZKProof].length() != kEcEqualityProofLength)
+        return temMALFORMED;
+
+    // Check the encrypted amount formats. It is more expensive so put it at the end of preflight.
+    if (hasIssuerAmount && !isValidCiphertext(ctx.tx[sfIssuerEncryptedAmount]))
+        return temBAD_CIPHERTEXT;
+
+    if (hasAuditorAmount && !isValidCiphertext(ctx.tx[sfAuditorEncryptedAmount]))
+        return temBAD_CIPHERTEXT;
+
+    return tesSUCCESS;
+}
+
+XRPAmount
+ConfidentialMPTMirrorUpdate::calculateBaseFee(ReadView const& view, STTx const& tx)
+{
+    return Transactor::calculateBaseFee(view, tx, kConfidentialFeeMultiplier);
+}
+
+TER
+ConfidentialMPTMirrorUpdate::preclaim(PreclaimContext const& ctx)
+{
+    // Check if account exists
+    auto const account = ctx.tx[sfAccount];
+    if (!ctx.view.exists(keylet::account(account)))
+        return terNO_ACCOUNT;  // LCOV_EXCL_LINE
+
+    // The issuance must exist and have confidential balances enabled with a
+    // registered issuer encryption key; otherwise there is no mirror to update.
+    auto const mptIssuanceID = ctx.tx[sfMPTokenIssuanceID];
+    auto const sleIssuance = ctx.view.read(keylet::mptokenIssuance(mptIssuanceID));
+    if (!sleIssuance)
+        return tecOBJECT_NOT_FOUND;
+
+    // The issuance must have confidential balances enabled with a registered issuer encryption key.
+    if (!sleIssuance->isFlag(lsfMPTCanHoldConfidentialBalance) ||
+        !sleIssuance->isFieldPresent(sfIssuerEncryptionKey))
+        return tecNO_PERMISSION;
+
+    // Sanity check: preflight already enforced the issuer holder combination
+    // under different rotation modes.
+    auto const holder = ctx.tx[~sfHolder];
+    bool const hasHolder = holder.has_value();
+    auto const issuer = sleIssuance->getAccountID(sfIssuer);
+    if (hasHolder ? (issuer != account) : (issuer == account))
+    {
+        // LCOV_EXCL_START
+        UNREACHABLE(
+            "xrpl::ConfidentialMPTMirrorUpdate::preclaim : invalid issuer holder combination");
+        return tefINTERNAL;
+        // LCOV_EXCL_STOP
+    }
+
+    // The holder is sfHolder in issuer mode and is sfAccount in holder mode.
+    auto const holderID = hasHolder ? *holder : account;
+
+    // In issuer mode, the holder must exist. In holder mode, the account existence was checked
+    // already.
+    if (hasHolder && !ctx.view.exists(keylet::account(holderID)))
+        return tecNO_TARGET;
+
+    // In either issuer or holder mode, check the existence of the MPToken object.
+    auto const sleMptoken = ctx.view.read(keylet::mptoken(mptIssuanceID, holderID));
+    if (!sleMptoken)
+        return tecOBJECT_NOT_FOUND;
+
+    // The holder must already hold an issuer confidential balance.
+    if (!sleMptoken->isFieldPresent(sfIssuerEncryptedBalance))
+        return tecNO_PERMISSION;
+
+    bool const hasIssuerAmount = ctx.tx.isFieldPresent(sfIssuerEncryptedAmount);
+    bool const hasAuditorAmount = ctx.tx.isFieldPresent(sfAuditorEncryptedAmount);
+
+    // Migrating the auditor mirror requires the issuance to have a registered
+    // auditor encryption key.
+    if (hasAuditorAmount && !sleIssuance->isFieldPresent(sfAuditorEncryptionKey))
+        return tecNO_PERMISSION;
+
+    // An issuer mirror may only be re-encrypted while it is stale, reject if it is already current.
+    if (hasIssuerAmount && isIssuerMirrorCurrent(*sleIssuance, *sleMptoken))
+        return tecNO_PERMISSION;
+
+    if (hasAuditorAmount)
+    {
+        // An issuer-mode auditor-only migration: the issuer mirror must already be up to date.
+        if (hasHolder && !hasIssuerAmount && !isIssuerMirrorCurrent(*sleIssuance, *sleMptoken))
+            return tecNO_PERMISSION;
+
+        // An auditor mirror may only be re-encrypted while it is stale, reject if it is already
+        // current. isAuditorMirrorCurrent reports an absent auditor mirror as stale, which is what
+        // allows an auditor-only migration to create one for the first time.
+        if (isAuditorMirrorCurrent(*sleIssuance, *sleMptoken))
+            return tecNO_PERMISSION;
+    }
+
+    // Holder self-migration re-encrypts the mirror from the holder's own
+    // spending balance, which reflects the holder's full balance only once the
+    // inbox has been merged into it. Require the inbox to be canonical zero,
+    // i.e. ConfidentialMPTMergeInbox has already been applied.
+    if (!hasHolder)
+    {
+        // Sanity check: a holder that already carries an issuer mirror
+        // necessarily has a holder encryption key and a spending balance
+        if (!sleMptoken->isFieldPresent(sfHolderEncryptionKey) ||
+            !sleMptoken->isFieldPresent(sfConfidentialBalanceSpending))
+        {
+            // LCOV_EXCL_START
+            UNREACHABLE(
+                "xrpl::ConfidentialMPTMirrorUpdate::preclaim : an issuer mirror implies a holder "
+                "key and spending balance");
+            return tefINTERNAL;
+            // LCOV_EXCL_STOP
+        }
+
+        auto const expectedZeroInbox = encryptCanonicalZeroAmount(
+            (*sleMptoken)[sfHolderEncryptionKey], holderID, mptIssuanceID);
+        if (!expectedZeroInbox)
+        {
+            // LCOV_EXCL_START
+            UNREACHABLE(
+                "xrpl::ConfidentialMPTMirrorUpdate::preclaim : canonical zero encryption cannot "
+                "fail for an already-valid holder public key");
+            return tefINTERNAL;
+            // LCOV_EXCL_STOP
+        }
+
+        bool const inboxIsCanonicalZero = sleMptoken->isFieldPresent(sfConfidentialBalanceInbox) &&
+            Slice((*sleMptoken)[sfConfidentialBalanceInbox]) == Slice(*expectedZeroInbox);
+        if (!inboxIsCanonicalZero)
+            return tecNO_PERMISSION;
+    }
+
+    return tesSUCCESS;
+}
+
+TER
+ConfidentialMPTMirrorUpdate::doApply()
+{
+    auto const mptIssuanceID = ctx_.tx[sfMPTokenIssuanceID];
+
+    auto const sleIssuance = view().read(keylet::mptokenIssuance(mptIssuanceID));
+    if (!sleIssuance)
+    {
+        // LCOV_EXCL_START
+        UNREACHABLE(
+            "xrpl::ConfidentialMPTMirrorUpdate::doApply : preclaim already validated the "
+            "issuance exists");
+        return tecINTERNAL;
+        // LCOV_EXCL_STOP
+    }
+
+    // The holderID is sfHolder in issuer mode and sfAccount in holder mode.
+    auto const holder = ctx_.tx[~sfHolder];
+    auto const holderID = holder.value_or(accountID_);
+
+    auto sleMptoken = view().peek(keylet::mptoken(mptIssuanceID, holderID));
+    if (!sleMptoken)
+    {
+        // LCOV_EXCL_START
+        UNREACHABLE(
+            "xrpl::ConfidentialMPTMirrorUpdate::doApply : preclaim already validated the "
+            "MPToken exists");
+        return tecINTERNAL;
+        // LCOV_EXCL_STOP
+    }
+
+    // Re-encrypt the requested mirror(s) and advance the corresponding mirror
+    // epoch to match the issuance key epoch. Each mirror is stamped separately
+    // because this transaction may migrate either one or both.
+    if (ctx_.tx.isFieldPresent(sfIssuerEncryptedAmount))
+    {
+        (*sleMptoken)[sfIssuerEncryptedBalance] = ctx_.tx[sfIssuerEncryptedAmount];
+        setIssuerMirrorEpoch(*sleIssuance, *sleMptoken);
+    }
+
+    if (ctx_.tx.isFieldPresent(sfAuditorEncryptedAmount))
+    {
+        (*sleMptoken)[sfAuditorEncryptedBalance] = ctx_.tx[sfAuditorEncryptedAmount];
+        setAuditorMirrorEpoch(*sleIssuance, *sleMptoken);
+    }
+
+    view().update(sleMptoken);
+    return tesSUCCESS;
+}
+
+void
+ConfidentialMPTMirrorUpdate::visitInvariantEntry(bool, SLE::const_ref, SLE::const_ref)
+{
+}
+
+bool
+ConfidentialMPTMirrorUpdate::finalizeInvariants(
+    STTx const&,
+    TER,
+    XRPAmount,
+    ReadView const&,
+    beast::Journal const&)
+{
+    return true;
+}
+
+}  // namespace xrpl
diff --git a/src/libxrpl/tx/transactors/token/ConfidentialMPTSend.cpp b/src/libxrpl/tx/transactors/token/ConfidentialMPTSend.cpp
index e713ae5029..14ab874102 100644
--- a/src/libxrpl/tx/transactors/token/ConfidentialMPTSend.cpp
+++ b/src/libxrpl/tx/transactors/token/ConfidentialMPTSend.cpp
@@ -247,6 +247,15 @@ ConfidentialMPTSend::preclaim(PreclaimContext const& ctx)
         return tecNO_PERMISSION;
     }
 
+    // A send homomorphically updates the mirrors of both parties, so both must
+    // be current.
+    if (ctx.view.rules().enabled(featureConfidentialMPTKeyRotation) &&
+        (!areMirrorsCurrent(*sleIssuance, *sleSenderMPToken) ||
+         !areMirrorsCurrent(*sleIssuance, *sleDestinationMPToken)))
+    {
+        return tecNO_PERMISSION;
+    }
+
     // Sanity check: Both MPTokens' auditor fields must be present if auditing
     // is enabled
     if (requiresAuditor &&
diff --git a/src/libxrpl/tx/transactors/token/MPTokenIssuanceSet.cpp b/src/libxrpl/tx/transactors/token/MPTokenIssuanceSet.cpp
index e8fd2e22b6..6bd7140631 100644
--- a/src/libxrpl/tx/transactors/token/MPTokenIssuanceSet.cpp
+++ b/src/libxrpl/tx/transactors/token/MPTokenIssuanceSet.cpp
@@ -119,7 +119,15 @@ MPTokenIssuanceSet::preflight(PreflightContext const& ctx)
     if (hasHolder && (hasIssuerElGamalKey || hasAuditorElGamalKey))
         return temMALFORMED;
 
-    if (hasAuditorElGamalKey && !hasIssuerElGamalKey)
+    // Pre-ConfidentialMPTKeyRotation amendment, the auditor key could not be
+    // registered independently of the issuer key. The issuer could either:
+    // - Register only the issuer key (in which case an auditor key could not be added later), or
+    // - Register both the issuer and auditor keys simultaneously.
+    //
+    // Post-ConfidentialMPTKeyRotation amendment, the auditor key can be
+    // registered after the issuer key has already been registered.
+    if (hasAuditorElGamalKey && !hasIssuerElGamalKey &&
+        !ctx.rules.enabled(featureConfidentialMPTKeyRotation))
         return temMALFORMED;
 
     if (hasIssuerElGamalKey && !isValidCompressedECPoint(ctx.tx[sfIssuerEncryptionKey]))
@@ -219,18 +227,57 @@ MPTokenIssuanceSet::preclaim(PreclaimContext const& ctx)
             return tecNO_PERMISSION;
     }
 
-    // cannot update issuer public key
-    if (ctx.tx.isFieldPresent(sfIssuerEncryptionKey) &&
-        sleMptIssuance->isFieldPresent(sfIssuerEncryptionKey))
-    {
-        return tecNO_PERMISSION;
-    }
+    // Updating an existing encryption key requires the
+    // ConfidentialMPTKeyRotation amendment.
+    bool const canRotateKey = ctx.view.rules().enabled(featureConfidentialMPTKeyRotation);
 
-    // cannot update auditor public key
-    if (ctx.tx.isFieldPresent(sfAuditorEncryptionKey) &&
-        sleMptIssuance->isFieldPresent(sfAuditorEncryptionKey))
+    bool const txHasIssuerKey = ctx.tx.isFieldPresent(sfIssuerEncryptionKey);
+    bool const txHasAuditorKey = ctx.tx.isFieldPresent(sfAuditorEncryptionKey);
+    bool const sleHasIssuerKey = sleMptIssuance->isFieldPresent(sfIssuerEncryptionKey);
+    bool const sleHasAuditorKey = sleMptIssuance->isFieldPresent(sfAuditorEncryptionKey);
+
+    if (canRotateKey)
     {
-        return tecNO_PERMISSION;  // LCOV_EXCL_LINE
+        // Post-ConfidentialMPTKeyRotation amendment, the encryption keys can be updated.
+        // A first-time auditor key registration requires an issuer key,
+        // either already on the issuance or set by the same transaction.
+        bool const registersAuditorKey = txHasAuditorKey && !sleHasAuditorKey;
+        bool const issuerKeyExists = sleHasIssuerKey || txHasIssuerKey;
+        if (registersAuditorKey && !issuerKeyExists)
+            return tecNO_PERMISSION;
+
+        // Rotating a key to its current value is not permitted: a key epoch
+        // increment must always correspond to an actual key change.
+        if (txHasIssuerKey && sleHasIssuerKey &&
+            ctx.tx[sfIssuerEncryptionKey] == (*sleMptIssuance)[sfIssuerEncryptionKey])
+            return tecDUPLICATE;
+
+        if (txHasAuditorKey && sleHasAuditorKey &&
+            ctx.tx[sfAuditorEncryptionKey] == (*sleMptIssuance)[sfAuditorEncryptionKey])
+            return tecDUPLICATE;
+
+        // Key epochs must never wrap. Epoch 0 serves as the sentinel for "never
+        // rotated." Holders' mirror epochs are checked against it for equality,
+        // so a wrap would cause stale mirror ciphertexts to appear valid instead
+        // of failing loudly.
+        if (txHasIssuerKey && sleHasIssuerKey &&
+            (*sleMptIssuance)[~sfIssuerKeyEpoch].value_or(0) == kMaxKeyEpoch)
+            return tecNO_PERMISSION;
+
+        if (txHasAuditorKey && sleHasAuditorKey &&
+            (*sleMptIssuance)[~sfAuditorKeyEpoch].value_or(0) == kMaxKeyEpoch)
+            return tecNO_PERMISSION;
+    }
+    else
+    {
+        // Pre-ConfidentialMPTKeyRotation amendment, the encryption keys can not be updated.
+        // cannot update issuer public key
+        if (txHasIssuerKey && sleHasIssuerKey)
+            return tecNO_PERMISSION;
+
+        // cannot update auditor public key
+        if (txHasAuditorKey && sleHasAuditorKey)
+            return tecNO_PERMISSION;  // LCOV_EXCL_LINE
     }
 
     auto const enablesConfidentialBalance =
@@ -241,25 +288,30 @@ MPTokenIssuanceSet::preclaim(PreclaimContext const& ctx)
 
     // Encryption keys can only be set if confidential amounts are already
     // enabled on the issuance OR if the transaction is enabling it
-    if (ctx.tx.isFieldPresent(sfIssuerEncryptionKey) &&
-        !sleMptIssuance->isFlag(lsfMPTCanHoldConfidentialBalance) && !enablesConfidentialBalance)
+    if (txHasIssuerKey && !sleMptIssuance->isFlag(lsfMPTCanHoldConfidentialBalance) &&
+        !enablesConfidentialBalance)
     {
         return tecNO_PERMISSION;
     }
 
-    if (ctx.tx.isFieldPresent(sfAuditorEncryptionKey) &&
-        !sleMptIssuance->isFlag(lsfMPTCanHoldConfidentialBalance) && !enablesConfidentialBalance)
+    if (txHasAuditorKey && !sleMptIssuance->isFlag(lsfMPTCanHoldConfidentialBalance) &&
+        !enablesConfidentialBalance)
     {
         return tecNO_PERMISSION;
     }
 
-    // cannot upload key if there's circulating supply of COA
-    if ((ctx.tx.isFieldPresent(sfIssuerEncryptionKey) ||
-         ctx.tx.isFieldPresent(sfAuditorEncryptionKey) || enablesConfidentialBalance) &&
-        (*sleMptIssuance)[~sfConfidentialOutstandingAmount].value_or(0) > 0)
-    {
+    bool const hasConfidentialOA =
+        (*sleMptIssuance)[~sfConfidentialOutstandingAmount].value_or(0) > 0;
+
+    // Pre-ConfidentialMPTKeyRotation amendment, keys cannot be uploaded while
+    // COA > 0. Post-amendment they can be uploaded even if COA > 0.
+    if (!canRotateKey && (txHasIssuerKey || txHasAuditorKey) && hasConfidentialOA)
         return tecNO_PERMISSION;  // LCOV_EXCL_LINE
-    }
+
+    // Enabling confidential balances when COA > 0 is not permitted, regardless of
+    // ConfidentialMPTKeyRotation.
+    if (enablesConfidentialBalance && hasConfidentialOA)
+        return tecNO_PERMISSION;
 
     return tesSUCCESS;
 }
@@ -377,25 +429,69 @@ MPTokenIssuanceSet::doApply()
         }
     }
 
-    if (auto const pubKey = ctx_.tx[~sfIssuerEncryptionKey])
-    {
-        // This is enforced in preflight.
+    // Sets an encryption key on the issuance. Overwriting an existing key
+    // (a rotation) increments the corresponding key epoch; a first-time
+    // registration leaves the epoch absent (epoch 0), matching issuances
+    // whose keys were registered before the ConfidentialMPTKeyRotation
+    // amendment.
+    bool const canRotateKey = view().rules().enabled(featureConfidentialMPTKeyRotation);
+    auto const setEncryptionKey = [&](SF_VL const& keyField, SF_UINT32 const& epochField) -> TER {
+        auto const pubKey = ctx_.tx[~keyField];
+        if (!pubKey)
+            return tesSUCCESS;
+
+        // This is enforced in preflight, which rejects a transaction carrying
+        // both sfHolder and an encryption key.
         XRPL_ASSERT(
             sle->getType() == ltMPTOKEN_ISSUANCE,
             "MPTokenIssuanceSet::doApply : modifying MPTokenIssuance");
 
-        sle->setFieldVL(sfIssuerEncryptionKey, *pubKey);
-    }
+        // Add sanity check under the amendment ConfidentialMPTKeyRotation.
+        // Pre-confidentialMPTKeyRotation did not return tecINTERNAL so
+        // this should be under the amendment guard.
+        if (canRotateKey && sle->getType() != ltMPTOKEN_ISSUANCE)
+            return tecINTERNAL;  // LCOV_EXCL_LINE
 
-    if (auto const pubKey = ctx_.tx[~sfAuditorEncryptionKey])
-    {
-        // This is enforced in preflight.
-        XRPL_ASSERT(
-            sle->getType() == ltMPTOKEN_ISSUANCE,
-            "MPTokenIssuanceSet::doApply : modifying MPTokenIssuance");
+        // NOTE: presence must be checked before the key is overwritten below.
+        bool const isRotation = sle->isFieldPresent(keyField);
+        sle->setFieldVL(keyField, *pubKey);
 
-        sle->setFieldVL(sfAuditorEncryptionKey, *pubKey);
-    }
+        if (isRotation)
+        {
+            // Preclaim rejects overwriting an existing key unless the amendment is
+            // enabled.
+            if (!canRotateKey)
+            {
+                // LCOV_EXCL_START
+                UNREACHABLE("xrpl::MPTokenIssuanceSet::doApply : rotation without amendment");
+                return tecINTERNAL;
+                // LCOV_EXCL_STOP
+            }
+
+            auto const epoch = (*sle)[~epochField].valueOr(0);
+
+            // Preclaim rejects a rotation that would wrap the epoch. So this should never happen.
+            if (epoch >= kMaxKeyEpoch)
+            {
+                // LCOV_EXCL_START
+                UNREACHABLE("xrpl::MPTokenIssuanceSet::doApply : key epoch overflow");
+                return tecINTERNAL;
+                // LCOV_EXCL_STOP
+            }
+
+            (*sle)[epochField] = epoch + 1;
+        }
+
+        return tesSUCCESS;
+    };
+
+    if (auto const ter = setEncryptionKey(sfIssuerEncryptionKey, sfIssuerKeyEpoch);
+        !isTesSuccess(ter))
+        return ter;  // LCOV_EXCL_LINE
+
+    if (auto const ter = setEncryptionKey(sfAuditorEncryptionKey, sfAuditorKeyEpoch);
+        !isTesSuccess(ter))
+        return ter;  // LCOV_EXCL_LINE
 
     view().update(sle);
 
diff --git a/src/libxrpl/tx/transactors/vault/VaultDelete.cpp b/src/libxrpl/tx/transactors/vault/VaultDelete.cpp
index 35bf80c29f..9c6c41654b 100644
--- a/src/libxrpl/tx/transactors/vault/VaultDelete.cpp
+++ b/src/libxrpl/tx/transactors/vault/VaultDelete.cpp
@@ -4,7 +4,6 @@
 #include <xrpl/basics/base_uint.h>
 #include <xrpl/beast/utility/Zero.h>
 #include <xrpl/ledger/helpers/AccountRootHelpers.h>
-#include <xrpl/ledger/helpers/CredentialHelpers.h>
 #include <xrpl/ledger/helpers/MPTokenHelpers.h>
 #include <xrpl/ledger/helpers/TokenHelpers.h>
 #include <xrpl/protocol/AccountID.h>
@@ -102,19 +101,6 @@ VaultDelete::doApply()
     if (!vault)
         return tefINTERNAL;  // LCOV_EXCL_LINE
 
-    // Remove any credentials pinned to the vault pseudo-account before anything
-    // else. They would otherwise keep its owner directory alive and block
-    // deletion with tecHAS_OBLIGATIONS. Doing it first means a bounded,
-    // tecINCOMPLETE cleanup can be resumed by a later transaction without having
-    // already torn down the vault.
-    if (view().rules().enabled(fixCleanup3_4_0))
-    {
-        if (auto const ter = credentials::deletePseudoAccountCredentials(
-                view(), vault->at(sfAccount), kMaxDeletablePseudoAccountCredentials, j_);
-            !isTesSuccess(ter))
-            return ter;
-    }
-
     // Destroy the asset holding.
     auto asset = vault->at(sfAsset);
 
diff --git a/src/test/app/AMMClawbackMPT_test.cpp b/src/test/app/AMMClawbackMPT_test.cpp
index 1d75c4db22..44eb61395a 100644
--- a/src/test/app/AMMClawbackMPT_test.cpp
+++ b/src/test/app/AMMClawbackMPT_test.cpp
@@ -2198,6 +2198,89 @@ class AMMClawbackMPT_test : public beast::unit_test::Suite
         BEAST_EXPECT(amm.ammExists());
     }
 
+    void
+    testClawbackBypassesReserve(FeatureBitset features)
+    {
+        // Same as the IOU case, but the paired asset is an MPT alice does not
+        // hold yet. The reserve check is skipped on the clawback path while
+        // createMPToken() still runs, so alice's MPToken is created even though
+        // neither she nor the low-XRP issuer can cover the owner reserve.
+        testcase("test clawback bypasses recipient reserve (MPT)");
+        using namespace jtx;
+
+        Env env(*this, features);
+        Account const gw{"gateway"};    // IOU issuer + claw authority, low XRP
+        Account const gw2{"gateway2"};  // MPT issuer of the paired asset
+        Account const carol{"carol"};
+        Account const alice{"alice"};
+
+        auto const usd = gw["USD"];
+        auto const baseFee = env.current()->fees().base;
+
+        env.fund(XRP(1'000'000), gw2, carol);
+        // Low XRP so the legacy issuer-balance check cannot pass.
+        env.fund(env.current()->fees().accountReserve(0, 1) + baseFee * 10, gw);
+        // Reserve for the USD trustline and LP token trustline.
+        env.fund(env.current()->fees().accountReserve(2, 1) + baseFee * 5, alice);
+        env.close();
+
+        env(fset(gw, asfAllowTrustLineClawback));
+        env.close();
+
+        // The paired MPT: transferable so an AMM can hold it, and no
+        // RequireAuth so createMPToken()'s WeakAuth check passes.
+        MPT const btc = MPTTester(
+            {.env = env,
+             .issuer = gw2,
+             .holders = {carol},
+             .pay = 1'000'000,
+             .flags = kMptDexFlags});
+
+        env.trust(usd(1'000'000), carol);
+        env(pay(gw, carol, usd(100'000)));
+        env.close();
+        AMM amm(env, carol, usd(1'000), btc(1'000), Ter(tesSUCCESS));
+        env.close();
+
+        // alice holds a USD trustline and LP tokens, but no BTC MPToken.
+        env.trust(usd(100'000), alice);
+        env(pay(gw, alice, usd(1'000)));
+        env.close();
+        amm.deposit(alice, usd(100));
+
+        BEAST_EXPECT(env.ownerCount(alice) == 2);
+        BEAST_EXPECT(!env.le(keylet::mptoken(btc.issuanceID, alice.id())));
+
+        // AMMWithdraw still enforces the reserve check.
+        amm.withdrawAll(alice, std::nullopt, Ter(tecINSUFFICIENT_RESERVE));
+        BEAST_EXPECT(!env.le(keylet::mptoken(btc.issuanceID, alice.id())));
+        BEAST_EXPECT(env.ownerCount(alice) == 2);
+        // alice cannot afford a third owner object.
+        BEAST_EXPECT(env.balance(alice) < STAmount(env.current()->fees().accountReserve(3, 1)));
+
+        if (features[fixCleanup3_4_0])
+        {
+            // Reserve check skipped; the paired BTC returns to alice on a
+            // newly created MPToken.
+            env(amm::ammClawback(gw, alice, usd, btc, usd(10)), Ter(tesSUCCESS));
+            env.close();
+
+            BEAST_EXPECT(env.le(keylet::mptoken(btc.issuanceID, alice.id())));
+            BEAST_EXPECT(env.balance(alice, btc) > btc(0));
+            BEAST_EXPECT(env.ownerCount(alice) == 3);
+        }
+        else
+        {
+            // Legacy path: the check runs against max(issuer, holder) XRP,
+            // neither of which covers a third owner object.
+            env(amm::ammClawback(gw, alice, usd, btc, usd(10)), Ter(tecINSUFFICIENT_RESERVE));
+            env.close();
+
+            BEAST_EXPECT(!env.le(keylet::mptoken(btc.issuanceID, alice.id())));
+            BEAST_EXPECT(env.ownerCount(alice) == 2);
+        }
+    }
+
     void
     run() override
     {
@@ -2225,6 +2308,8 @@ class AMMClawbackMPT_test : public beast::unit_test::Suite
             featureLendingProtocol);
         testLastHolderLPTokenBalance(all - fixAMMClawbackRounding);
         testClawAssetCheck(all);
+        testClawbackBypassesReserve(all);
+        testClawbackBypassesReserve(all - fixCleanup3_4_0);
     }
 };
 
diff --git a/src/test/app/AMMClawback_test.cpp b/src/test/app/AMMClawback_test.cpp
index 230d148ff9..4f025f08eb 100644
--- a/src/test/app/AMMClawback_test.cpp
+++ b/src/test/app/AMMClawback_test.cpp
@@ -15,6 +15,7 @@
 #include <xrpl/ledger/helpers/AMMHelpers.h>
 #include <xrpl/protocol/AmountConversions.h>
 #include <xrpl/protocol/Feature.h>
+#include <xrpl/protocol/Indexes.h>
 #include <xrpl/protocol/STAmount.h>
 #include <xrpl/protocol/TER.h>
 #include <xrpl/protocol/TxFlags.h>
@@ -2715,6 +2716,81 @@ class AMMClawback_test : public beast::unit_test::Suite
         }
     }
 
+    void
+    testClawbackBypassesReserve(FeatureBitset features)
+    {
+        // Clawback must not fail the holder-side reserve check: a holder could
+        // otherwise veto it by omitting the paired trustline. AMMWithdraw still
+        // enforces the check. Pre-fixCleanup3_4_0 the holder's reserve was
+        // compared against max(issuer pre-fee, holder current) XRP, so the
+        // clawback was blocked when neither balance covered it.
+        testcase("test clawback bypasses recipient reserve");
+        using namespace jtx;
+
+        Env env(*this, features);
+        Account const gw{"gateway"};
+        Account const carol{"carol"};
+        Account const alice{"alice"};
+
+        auto const usd = gw["USD"];
+        auto const eur = gw["EUR"];
+        auto const baseFee = env.current()->fees().base;
+
+        env.fund(XRP(1'000'000), carol);
+        // Low XRP so the legacy issuer-balance check cannot pass.
+        env.fund(env.current()->fees().accountReserve(0, 1) + baseFee * 10, gw);
+        // Reserve for the USD trustline and LP token trustline.
+        env.fund(env.current()->fees().accountReserve(2, 1) + baseFee * 5, alice);
+        env.close();
+
+        env(fset(gw, asfAllowTrustLineClawback));
+        env.close();
+
+        env.trust(usd(1'000'000), carol);
+        env.trust(eur(1'000'000), carol);
+        env(pay(gw, carol, usd(100'000)));
+        env(pay(gw, carol, eur(100'000)));
+        env.close();
+        AMM amm(env, carol, usd(1'000), eur(1'000), Ter(tesSUCCESS));
+        env.close();
+
+        // alice holds a USD trustline and LP tokens, but no EUR trustline.
+        env.trust(usd(100'000), alice);
+        env(pay(gw, alice, usd(1'000)));
+        env.close();
+        amm.deposit(alice, usd(100));
+
+        BEAST_EXPECT(env.ownerCount(alice) == 2);
+        // alice cannot afford a third owner object.
+        BEAST_EXPECT(env.balance(alice) < STAmount(env.current()->fees().accountReserve(3, 1)));
+
+        // AMMWithdraw still enforces the reserve check.
+        amm.withdraw(
+            WithdrawArg{
+                .account = alice, .asset1Out = eur(1), .err = Ter(tecINSUFFICIENT_RESERVE)});
+        BEAST_EXPECT(env.ownerCount(alice) == 2);
+
+        if (features[fixCleanup3_4_0])
+        {
+            // Reserve check skipped; the paired EUR returns to alice on a
+            // newly created EUR trustline.
+            env(amm::ammClawback(gw, alice, usd, eur, usd(10)), Ter(tesSUCCESS));
+            env.close();
+
+            BEAST_EXPECT(env.le(keylet::trustLine(alice.id(), eur.issue())));
+            BEAST_EXPECT(env.balance(alice, eur) > eur(0));
+            BEAST_EXPECT(env.ownerCount(alice) == 3);
+        }
+        else
+        {
+            // Legacy path: the check runs against max(issuer, holder) XRP,
+            // neither of which covers a third owner object.
+            env(amm::ammClawback(gw, alice, usd, eur, usd(10)), Ter(tecINSUFFICIENT_RESERVE));
+            env.close();
+            BEAST_EXPECT(env.ownerCount(alice) == 2);
+        }
+    }
+
     void
     testExactLPTokenEquality(FeatureBitset features)
     {
@@ -2809,6 +2885,7 @@ class AMMClawback_test : public beast::unit_test::Suite
             testAssetFrozen(features);
             testSingleDepositAndClawback(features);
             testLastHolderLPTokenBalance(features);
+            testClawbackBypassesReserve(features);
             testExactLPTokenEquality(features);
         }
     }
diff --git a/src/test/app/AMM_test.cpp b/src/test/app/AMM_test.cpp
index a1d5260606..0212035c6e 100644
--- a/src/test/app/AMM_test.cpp
+++ b/src/test/app/AMM_test.cpp
@@ -4,7 +4,6 @@
 #include <test/jtx/Env.h>
 #include <test/jtx/TestHelpers.h>
 #include <test/jtx/amount.h>
-#include <test/jtx/credentials.h>
 #include <test/jtx/envconfig.h>
 #include <test/jtx/escrow.h>
 #include <test/jtx/fee.h>
@@ -5193,51 +5192,6 @@ private:
             {features});
     }
 
-    void
-    testCredentialPinsPseudoAccount()
-    {
-        testcase("Credential pins AMM pseudo-account");
-
-        using namespace jtx;
-        FeatureBitset const all{testableAmendments()};
-
-        // A credential issued to an AMM pseudo-account can't be accepted or
-        // deleted by it. A pin created before the cure activates stays pinned
-        // in the pseudo-account's owner directory and makes AMM deletion fail
-        // with tecINTERNAL (deleteAMMTrustLines rejects the unexpected
-        // directory entry).
-        Account const attacker{"attacker"};
-        char const credType[] = "FN36";
-
-        Env env(*this, all - fixCleanup3_3_0 - fixCleanup3_4_0);
-        fund(env, gw_, {alice_}, XRP(20'000), {USD(10'000)});
-        env.fund(XRP(1'000), attacker);
-        env.close();
-
-        AMM amm(env, alice_, XRP(10'000), USD(10'000));
-        Account const ammAcct{"amm pseudo-account", amm.ammAccount()};
-        env.memoize(ammAcct);
-
-        env(credentials::create(ammAcct, attacker, credType));
-        env.close();
-        auto const credKey = credentials::keylet(ammAcct, attacker, credType);
-        BEAST_EXPECT(env.le(credKey));
-
-        // Emptying the AMM would auto-delete it, but the pinned credential makes
-        // deleteAMMAccount fail; the withdraw is rolled back and the AMM stays.
-        amm.withdrawAll(alice_, std::nullopt, Ter(tecINTERNAL));
-        BEAST_EXPECT(amm.ammExists());
-
-        env.enableFeature(fixCleanup3_4_0);
-        env.close();
-
-        // The pre-existing pin is cleaned up and the AMM deletes.
-        amm.withdrawAll(alice_);
-        BEAST_EXPECT(!amm.ammExists());
-        BEAST_EXPECT(!env.le(credKey));
-        BEAST_EXPECT(!env.le(keylet::ownerDir(amm.ammAccount())));
-    }
-
     void
     testAutoDelete()
     {
@@ -7505,7 +7459,6 @@ private:
         FeatureBitset const all{testableAmendments()};
         testInvalidInstance();
         testInstanceCreate();
-        testCredentialPinsPseudoAccount();
         for (auto const& f : amendmentCombinations({fixCleanup3_3_0, featureAMMClawback}))
             testInvalidDeposit(f);
         testDeposit();
diff --git a/src/test/app/ConfidentialMPTKeyRotation_test.cpp b/src/test/app/ConfidentialMPTKeyRotation_test.cpp
new file mode 100644
index 0000000000..0db9e29d27
--- /dev/null
+++ b/src/test/app/ConfidentialMPTKeyRotation_test.cpp
@@ -0,0 +1,2498 @@
+#include <test/jtx/Account.h>
+#include <test/jtx/ConfidentialTransfer.h>
+#include <test/jtx/Env.h>
+#include <test/jtx/mpt.h>
+
+#include <xrpl/basics/Buffer.h>
+#include <xrpl/basics/strHex.h>
+#include <xrpl/beast/unit_test/suite.h>
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/OpenView.h>
+#include <xrpl/protocol/ConfidentialTransfer.h>
+#include <xrpl/protocol/Feature.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/Protocol.h>
+#include <xrpl/protocol/SField.h>
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/TER.h>
+#include <xrpl/protocol/TxFlags.h>
+
+#include <cstdint>
+#include <memory>
+#include <optional>
+#include <vector>
+
+namespace xrpl {
+
+class ConfidentialMPTKeyRotation_test : public ConfidentialTransferTestBase
+{
+    void
+    testMPTokenIssuanceSetRotateIssuerKey(FeatureBitset features)
+    {
+        testcase("MPTokenIssuanceSet rotate issuer key");
+        using namespace test::jtx;
+
+        Env env{*this, features};
+        Account const alice("alice");
+        Account const bob("bob");
+        MPTTester mptAlice(env, alice, {.holders = {bob}});
+
+        mptAlice.create({
+            .ownerCount = 1,
+            .flags = tfMPTCanTransfer | tfMPTCanHoldConfidentialBalance,
+        });
+
+        mptAlice.generateKeyPair(alice);
+        mptAlice.generateKeyPair(bob);
+
+        // First-time registration.
+        mptAlice.set({
+            .account = alice,
+            .issuerPubKey = mptAlice.getPubKey(alice),
+        });
+
+        // Verify that no epochs are set when registering for the first time.
+        BEAST_EXPECT(mptAlice.checkKeyEpochs(std::nullopt, std::nullopt));
+
+        // Rotating the issuer key requires the key rotation amendment
+        bool const rotationEnabled = features[featureConfidentialMPTKeyRotation];
+        mptAlice.set({
+            .account = alice,
+            .issuerPubKey = mptAlice.getPubKey(bob),
+            .err = rotationEnabled ? TER(tesSUCCESS) : TER(tecNO_PERMISSION),
+        });
+
+        // A rotation replaces the issuer key and bumps its epoch. The auditor
+        // key was never registered, so it and its epoch stay absent.
+        if (rotationEnabled)
+        {
+            BEAST_EXPECT(mptAlice.checkEncryptionKeys(bob, std::nullopt));
+            BEAST_EXPECT(mptAlice.checkKeyEpochs(1u, std::nullopt));
+        }
+        else
+        {
+            BEAST_EXPECT(mptAlice.checkEncryptionKeys(alice, std::nullopt));
+            BEAST_EXPECT(mptAlice.checkKeyEpochs(std::nullopt, std::nullopt));
+        }
+
+        if (rotationEnabled)
+        {
+            // A second rotation increments the epoch again
+            mptAlice.set({
+                .account = alice,
+                .issuerPubKey = mptAlice.getPubKey(alice),
+            });
+
+            BEAST_EXPECT(mptAlice.checkKeyEpochs(2u, std::nullopt));
+        }
+    }
+
+    void
+    testMPTokenIssuanceSetRotateBothKeys(FeatureBitset features)
+    {
+        testcase("MPTokenIssuanceSet rotate both issuer and auditor keys");
+        using namespace test::jtx;
+
+        Env env{*this, features};
+        Account const alice("alice");
+        Account const bob("bob");
+        Account const auditor("auditor");
+        MPTTester mptAlice(env, alice, {.holders = {bob}});
+
+        mptAlice.create({
+            .ownerCount = 1,
+            .flags = tfMPTCanTransfer | tfMPTCanHoldConfidentialBalance,
+        });
+
+        mptAlice.generateKeyPair(alice);
+        mptAlice.generateKeyPair(bob);
+        mptAlice.generateKeyPair(auditor);
+
+        // Register both keys together.
+        mptAlice.set({
+            .account = alice,
+            .issuerPubKey = mptAlice.getPubKey(alice),
+            .auditorPubKey = mptAlice.getPubKey(auditor),
+        });
+
+        // Verify that no epochs are set when registering for the first time.
+        BEAST_EXPECT(mptAlice.checkKeyEpochs(std::nullopt, std::nullopt));
+
+        // Rotating both keys requires the amendment
+        bool const rotationEnabled = features[featureConfidentialMPTKeyRotation];
+        mptAlice.set({
+            .account = alice,
+            .issuerPubKey = mptAlice.getPubKey(bob),
+            .auditorPubKey = mptAlice.getPubKey(alice),
+            .err = rotationEnabled ? TER(tesSUCCESS) : TER(tecNO_PERMISSION),
+        });
+
+        if (rotationEnabled)
+        {
+            BEAST_EXPECT(mptAlice.checkEncryptionKeys(bob, alice));
+            BEAST_EXPECT(mptAlice.checkKeyEpochs(1u, 1u));
+        }
+        else
+        {
+            BEAST_EXPECT(mptAlice.checkEncryptionKeys(alice, auditor));
+            BEAST_EXPECT(mptAlice.checkKeyEpochs(std::nullopt, std::nullopt));
+        }
+
+        if (rotationEnabled)
+        {
+            // Rotating the issuer key to its current value fails.
+            // Current issuer key is bob, duplicate.
+            mptAlice.set({
+                .account = alice,
+                .issuerPubKey = mptAlice.getPubKey(bob),
+                .err = tecDUPLICATE,
+            });
+
+            // Rotating the auditor key to its current value fails.
+            // Current auditor key is alice, duplicate.
+            mptAlice.set({
+                .account = alice,
+                .auditorPubKey = mptAlice.getPubKey(alice),
+                .err = tecDUPLICATE,
+            });
+
+            // The whole transaction fails when one key is unchanged, even if
+            // the other key is rotated to a new value.
+            // Current issuer key is bob, duplicate.
+            mptAlice.set({
+                .account = alice,
+                .issuerPubKey = mptAlice.getPubKey(bob),
+                .auditorPubKey = mptAlice.getPubKey(auditor),
+                .err = tecDUPLICATE,
+            });
+
+            // Current auditor key is alice, duplicate.
+            mptAlice.set({
+                .account = alice,
+                .issuerPubKey = mptAlice.getPubKey(auditor),
+                .auditorPubKey = mptAlice.getPubKey(alice),
+                .err = tecDUPLICATE,
+            });
+
+            // Nothing changed: keys and epochs are untouched
+            BEAST_EXPECT(mptAlice.checkKeyEpochs(1u, 1u));
+
+            // A second rotation increments both epochs again
+            mptAlice.set({
+                .account = alice,
+                .issuerPubKey = mptAlice.getPubKey(alice),
+                .auditorPubKey = mptAlice.getPubKey(auditor),
+            });
+
+            BEAST_EXPECT(mptAlice.checkKeyEpochs(2u, 2u));
+        }
+    }
+
+    void
+    testMPTokenIssuanceSetRotateAuditorKeyOnly(FeatureBitset features)
+    {
+        testcase("MPTokenIssuanceSet rotate auditor key only");
+        using namespace test::jtx;
+
+        Env env{*this, features};
+        Account const alice("alice");
+        Account const bob("bob");
+        Account const auditor("auditor");
+        MPTTester mptAlice(env, alice, {.holders = {bob}});
+
+        mptAlice.create({
+            .ownerCount = 1,
+            .flags = tfMPTCanTransfer | tfMPTCanHoldConfidentialBalance,
+        });
+
+        mptAlice.generateKeyPair(alice);
+        mptAlice.generateKeyPair(bob);
+        mptAlice.generateKeyPair(auditor);
+
+        // Register both keys together.
+        mptAlice.set({
+            .account = alice,
+            .issuerPubKey = mptAlice.getPubKey(alice),
+            .auditorPubKey = mptAlice.getPubKey(auditor),
+        });
+
+        // A transaction carrying only the auditor key fails preflight
+        // pre-ConfidentialMPTKeyRotation; post-ConfidentialMPTKeyRotation it rotates the auditor
+        // key
+        bool const rotationEnabled = features[featureConfidentialMPTKeyRotation];
+        mptAlice.set({
+            .account = alice,
+            .auditorPubKey = mptAlice.getPubKey(bob),
+            .err = rotationEnabled ? TER(tesSUCCESS) : TER(temMALFORMED),
+        });
+
+        // The issuer key keeps unchanged, and rotating only the auditor key
+        // bumps only its epoch.
+        if (rotationEnabled)
+        {
+            BEAST_EXPECT(mptAlice.checkEncryptionKeys(alice, bob));
+            BEAST_EXPECT(mptAlice.checkKeyEpochs(std::nullopt, 1u));
+        }
+        else
+        {
+            BEAST_EXPECT(mptAlice.checkEncryptionKeys(alice, auditor));
+            BEAST_EXPECT(mptAlice.checkKeyEpochs(std::nullopt, std::nullopt));
+        }
+
+        if (rotationEnabled)
+        {
+            // A second rotation increments the epoch again
+            mptAlice.set({
+                .account = alice,
+                .auditorPubKey = mptAlice.getPubKey(auditor),
+            });
+
+            // The issuer key epoch is still untouched.
+            BEAST_EXPECT(mptAlice.checkKeyEpochs(std::nullopt, 2u));
+        }
+    }
+
+    void
+    testMPTokenIssuanceSetRegisterAuditorKeyLater(FeatureBitset features)
+    {
+        testcase("MPTokenIssuanceSet register auditor key after issuer key");
+        using namespace test::jtx;
+
+        Env env{*this, features};
+        Account const alice("alice");
+        Account const auditor("auditor");
+        MPTTester mptAlice(env, alice);
+
+        mptAlice.create({
+            .ownerCount = 1,
+            .flags = tfMPTCanTransfer | tfMPTCanHoldConfidentialBalance,
+        });
+
+        mptAlice.generateKeyPair(alice);
+        mptAlice.generateKeyPair(auditor);
+
+        // Register the issuer key first. We'll register the auditor key in a separate transaction.
+        mptAlice.set({
+            .account = alice,
+            .issuerPubKey = mptAlice.getPubKey(alice),
+        });
+
+        // Register the auditor key separately.
+        // pre-ConfidentialMPTKeyRotation it fails preflight; post-ConfidentialMPTKeyRotation it
+        // succeeds without touching any epoch because it's a first-time registration.
+        bool const rotationEnabled = features[featureConfidentialMPTKeyRotation];
+        mptAlice.set({
+            .account = alice,
+            .auditorPubKey = mptAlice.getPubKey(auditor),
+            .err = rotationEnabled ? TER(tesSUCCESS) : TER(temMALFORMED),
+        });
+
+        BEAST_EXPECT(mptAlice.checkEncryptionKeys(
+            alice, rotationEnabled ? std::optional<Account>(auditor) : std::nullopt));
+        BEAST_EXPECT(mptAlice.checkKeyEpochs(std::nullopt, std::nullopt));
+    }
+
+    void
+    testMPTokenIssuanceSetRegisterAuditorKeyLaterWithCOA(FeatureBitset features)
+    {
+        testcase("MPTokenIssuanceSet register auditor key later with circulating supply");
+        using namespace test::jtx;
+
+        Env env{*this, features};
+        Account const alice("alice");
+        Account const bob("bob");
+        Account const auditor("auditor");
+        MPTTester mptAlice(env, alice, {.holders = {bob}});
+
+        mptAlice.create({
+            .ownerCount = 1,
+            .flags = tfMPTCanTransfer | tfMPTCanHoldConfidentialBalance,
+        });
+
+        mptAlice.authorize({.account = bob});
+        mptAlice.pay(alice, bob, 100);
+
+        mptAlice.generateKeyPair(alice);
+        mptAlice.generateKeyPair(bob);
+        mptAlice.generateKeyPair(auditor);
+
+        mptAlice.set({
+            .account = alice,
+            .issuerPubKey = mptAlice.getPubKey(alice),
+        });
+
+        // Convert some of bob's balance so that COA > 0
+        mptAlice.convert({
+            .account = bob,
+            .amt = 50,
+            .holderPubKey = mptAlice.getPubKey(bob),
+        });
+
+        auto const sleIssuanceBefore = env.le(keylet::mptokenIssuance(mptAlice.issuanceID()));
+        if (!BEAST_EXPECT(sleIssuanceBefore))
+            return;
+        auto const coaBefore = (*sleIssuanceBefore)[~sfConfidentialOutstandingAmount].value_or(0);
+        BEAST_EXPECT(coaBefore > 0);
+
+        // Registering the auditor key for the first time while confidential
+        // supply is circulating: pre-ConfidentialMPTKeyRotation an auditor-only
+        // transaction fails preflight; post-ConfidentialMPTKeyRotation it
+        // succeeds as a first-time late-registration even COA > 0.
+        bool const rotationEnabled = features[featureConfidentialMPTKeyRotation];
+        mptAlice.set({
+            .account = alice,
+            .auditorPubKey = mptAlice.getPubKey(auditor),
+            .err = rotationEnabled ? TER(tesSUCCESS) : TER(temMALFORMED),
+        });
+
+        auto const sleIssuance = env.le(keylet::mptokenIssuance(mptAlice.issuanceID()));
+        if (!BEAST_EXPECT(sleIssuance))
+            return;
+        BEAST_EXPECT(mptAlice.checkEncryptionKeys(
+            alice, rotationEnabled ? std::optional<Account>(auditor) : std::nullopt));
+        BEAST_EXPECT(mptAlice.checkKeyEpochs(std::nullopt, std::nullopt));
+
+        // The circulating supply itself is not affected.
+        BEAST_EXPECT((*sleIssuance)[~sfConfidentialOutstandingAmount].value_or(0) == coaBefore);
+    }
+
+    void
+    testMPTokenIssuanceSetAuditorKeyWithoutIssuerKey(FeatureBitset features)
+    {
+        testcase("MPTokenIssuanceSet auditor key requires issuer key");
+        using namespace test::jtx;
+
+        Env env{*this, features};
+        Account const alice("alice");
+        Account const auditor("auditor");
+        MPTTester mptAlice(env, alice);
+
+        mptAlice.create({
+            .ownerCount = 1,
+            .flags = tfMPTCanTransfer | tfMPTCanHoldConfidentialBalance,
+        });
+
+        mptAlice.generateKeyPair(auditor);
+        // The issuer key was never registered. pre-ConfidentialMPTKeyRotation an auditor-only
+        // transaction fails preflight; post-ConfidentialMPTKeyRotation it passes preflight
+        // but preclaim rejects registering an auditor key on an issuance
+        // without an issuer key.
+        bool const rotationEnabled = features[featureConfidentialMPTKeyRotation];
+        mptAlice.set({
+            .account = alice,
+            .auditorPubKey = mptAlice.getPubKey(auditor),
+            .err = rotationEnabled ? TER(tecNO_PERMISSION) : TER(temMALFORMED),
+        });
+
+        // The rejected transaction leaves the issuance without either key.
+        BEAST_EXPECT(mptAlice.checkEncryptionKeys(std::nullopt, std::nullopt));
+        BEAST_EXPECT(mptAlice.checkKeyEpochs(std::nullopt, std::nullopt));
+    }
+
+    void
+    testMPTokenIssuanceSetRotateWithCOA(FeatureBitset features)
+    {
+        testcase("MPTokenIssuanceSet rotate with circulating confidential supply");
+        using namespace test::jtx;
+
+        Env env{*this, features};
+        Account const alice("alice");
+        Account const bob("bob");
+        Account const carol("carol");
+        MPTTester mptAlice(env, alice, {.holders = {bob}});
+
+        mptAlice.create({
+            .ownerCount = 1,
+            .flags = tfMPTCanTransfer | tfMPTCanHoldConfidentialBalance,
+        });
+
+        mptAlice.authorize({.account = bob});
+        mptAlice.pay(alice, bob, 100);
+
+        mptAlice.generateKeyPair(alice);
+        mptAlice.generateKeyPair(bob);
+        mptAlice.generateKeyPair(carol);
+
+        mptAlice.set({
+            .account = alice,
+            .issuerPubKey = mptAlice.getPubKey(alice),
+        });
+
+        // Convert some of bob's balance to confidential spending, so that the
+        // issuance has confidential supply. COA > 0.
+        mptAlice.convert({
+            .account = bob,
+            .amt = 50,
+            .holderPubKey = mptAlice.getPubKey(bob),
+        });
+
+        auto const sleIssuanceBeforeRotation =
+            env.le(keylet::mptokenIssuance(mptAlice.issuanceID()));
+        if (!BEAST_EXPECT(sleIssuanceBeforeRotation))
+            return;
+        auto const coaBeforeRotation =
+            (*sleIssuanceBeforeRotation)[~sfConfidentialOutstandingAmount].value_or(0);
+        BEAST_EXPECT(coaBeforeRotation > 0);
+
+        // Rotating key requires the
+        // amendment.
+        bool const rotationEnabled = features[featureConfidentialMPTKeyRotation];
+        mptAlice.set({
+            .account = alice,
+            .issuerPubKey = mptAlice.getPubKey(carol),
+            .err = rotationEnabled ? TER(tesSUCCESS) : TER(tecNO_PERMISSION),
+        });
+
+        auto const sleIssuance = env.le(keylet::mptokenIssuance(mptAlice.issuanceID()));
+        if (!BEAST_EXPECT(sleIssuance))
+            return;
+        if (rotationEnabled)
+        {
+            BEAST_EXPECT(mptAlice.checkEncryptionKeys(carol, std::nullopt));
+            BEAST_EXPECT(mptAlice.checkKeyEpochs(1u, std::nullopt));
+        }
+        else
+        {
+            BEAST_EXPECT(mptAlice.checkEncryptionKeys(alice, std::nullopt));
+            BEAST_EXPECT(mptAlice.checkKeyEpochs(std::nullopt, std::nullopt));
+        }
+
+        // The confidential outstanding amount is not affected by the rotation
+        BEAST_EXPECT(
+            (*sleIssuance)[~sfConfidentialOutstandingAmount].value_or(0) == coaBeforeRotation);
+
+        // Re-enabling confidential balances while supply is circulating is
+        // rejected regardless of the ConfidentialMPTKeyRotation amendment.
+        mptAlice.set({
+            .account = alice,
+            .flags = tfMPTSetCanHoldConfidentialBalance,
+            .err = tecNO_PERMISSION,
+        });
+    }
+
+    void
+    testMPTokenIssuanceSetKeyEpochAtMax(FeatureBitset features)
+    {
+        using namespace test::jtx;
+        if (!features[featureConfidentialMPTKeyRotation])
+            return;
+
+        testcase("MPTokenIssuanceSet key epoch cannot wrap");
+
+        Env env{*this, features};
+        Account const alice("alice");
+        Account const bob("bob");
+        Account const carol("carol");
+        Account const auditor("auditor");
+
+        // Keep the ledger open so that we can write the key epochs directly into it.
+        MPTTester mptAlice(env, alice, {.holders = {bob}, .close = false});
+
+        mptAlice.create({
+            .ownerCount = 1,
+            .flags = tfMPTCanTransfer | tfMPTCanHoldConfidentialBalance,
+        });
+
+        mptAlice.generateKeyPair(alice);
+        mptAlice.generateKeyPair(bob);
+        mptAlice.generateKeyPair(carol);
+        mptAlice.generateKeyPair(auditor);
+
+        mptAlice.set({
+            .account = alice,
+            .issuerPubKey = mptAlice.getPubKey(alice),
+            .auditorPubKey = mptAlice.getPubKey(auditor),
+        });
+
+        auto const issuanceKeylet = keylet::mptokenIssuance(mptAlice.issuanceID());
+
+        // Writes the supplied key epochs straight into the open ledger so that
+        // the maximum epoch is reachable without submitting four billion
+        // rotations.
+        auto setEpochs = [&](std::optional<std::uint32_t> const& issuerKeyEpoch,
+                             std::optional<std::uint32_t> const& auditorKeyEpoch) {
+            env.app().getOpenLedger().modify([&](OpenView& view, beast::Journal) {
+                auto const sle = view.read(issuanceKeylet);
+                if (!sle)
+                    return false;  // LCOV_EXCL_LINE
+
+                auto replacement = std::make_shared<SLE>(*sle);
+                if (issuerKeyEpoch)
+                    (*replacement)[sfIssuerKeyEpoch] = *issuerKeyEpoch;
+                if (auditorKeyEpoch)
+                    (*replacement)[sfAuditorKeyEpoch] = *auditorKeyEpoch;
+                view.rawReplace(replacement);
+                return true;
+            });
+        };
+
+        BEAST_EXPECT(mptAlice.checkEncryptionKeys(alice, auditor));
+        BEAST_EXPECT(mptAlice.checkKeyEpochs(std::nullopt, std::nullopt));
+
+        // Increment the auditor epoch to kMaxKeyEpoch - 1, leaving the issuer epoch absent.
+        setEpochs(std::nullopt, kMaxKeyEpoch - 1);
+        BEAST_EXPECT(mptAlice.checkEncryptionKeys(alice, auditor));
+        BEAST_EXPECT(mptAlice.checkKeyEpochs(std::nullopt, kMaxKeyEpoch - 1));
+
+        // Rotating the auditor key to kMaxKeyEpoch succeeds.
+        mptAlice.set({
+            .account = alice,
+            .auditorPubKey = mptAlice.getPubKey(carol),
+        });
+
+        BEAST_EXPECT(mptAlice.checkEncryptionKeys(alice, carol));
+        BEAST_EXPECT(mptAlice.checkKeyEpochs(std::nullopt, kMaxKeyEpoch));
+
+        // A further auditor rotation is rejected because the epoch is exhausted.
+        mptAlice.set({
+            .account = alice,
+            .auditorPubKey = mptAlice.getPubKey(bob),
+            .err = tecNO_PERMISSION,
+        });
+
+        // Rotating both keys at once is rejected as a whole because the auditor
+        // epoch is exhausted.
+        mptAlice.set({
+            .account = alice,
+            .issuerPubKey = mptAlice.getPubKey(auditor),
+            .auditorPubKey = mptAlice.getPubKey(bob),
+            .err = tecNO_PERMISSION,
+        });
+
+        // Both rejections leave every key and epoch as it was.
+        BEAST_EXPECT(mptAlice.checkEncryptionKeys(alice, carol));
+        BEAST_EXPECT(mptAlice.checkKeyEpochs(std::nullopt, kMaxKeyEpoch));
+
+        // The issuer key is unaffected by the exhausted auditor epoch.
+        mptAlice.set({
+            .account = alice,
+            .issuerPubKey = mptAlice.getPubKey(bob),
+        });
+
+        BEAST_EXPECT(mptAlice.checkEncryptionKeys(bob, carol));
+        BEAST_EXPECT(mptAlice.checkKeyEpochs(1u, kMaxKeyEpoch));
+
+        // Increment the issuer epoch to kMaxKeyEpoch - 1.
+        setEpochs(kMaxKeyEpoch - 1, std::nullopt);
+        BEAST_EXPECT(mptAlice.checkEncryptionKeys(bob, carol));
+        BEAST_EXPECT(mptAlice.checkKeyEpochs(kMaxKeyEpoch - 1, kMaxKeyEpoch));
+
+        // Rotating the issuer key to kMaxKeyEpoch succeeds.
+        mptAlice.set({
+            .account = alice,
+            .issuerPubKey = mptAlice.getPubKey(auditor),
+        });
+
+        BEAST_EXPECT(mptAlice.checkEncryptionKeys(auditor, carol));
+        BEAST_EXPECT(mptAlice.checkKeyEpochs(kMaxKeyEpoch, kMaxKeyEpoch));
+
+        // With both epochs exhausted neither key can be rotated again.
+        mptAlice.set({
+            .account = alice,
+            .issuerPubKey = mptAlice.getPubKey(alice),
+            .err = tecNO_PERMISSION,
+        });
+        mptAlice.set({
+            .account = alice,
+            .auditorPubKey = mptAlice.getPubKey(bob),
+            .err = tecNO_PERMISSION,
+        });
+        mptAlice.set({
+            .account = alice,
+            .issuerPubKey = mptAlice.getPubKey(alice),
+            .auditorPubKey = mptAlice.getPubKey(bob),
+            .err = tecNO_PERMISSION,
+        });
+
+        BEAST_EXPECT(mptAlice.checkEncryptionKeys(auditor, carol));
+        BEAST_EXPECT(mptAlice.checkKeyEpochs(kMaxKeyEpoch, kMaxKeyEpoch));
+    }
+
+    void
+    testConfidentialMPTConvertEpoch(FeatureBitset features)
+    {
+        testcase("ConfidentialMPTConvert mirror epoch");
+        using namespace test::jtx;
+
+        Account const alice("alice");
+        Account const bob("bob");
+        Account const carol("carol");
+        Account const auditor("auditor");
+
+        // A first-time convert with no rotation leaves both mirror
+        // epochs absent.
+        {
+            Env env{*this, features};
+            MPTTester mptAlice(env, alice, {.holders = {bob}, .auditor = auditor});
+            setupConfidentialIssuance(mptAlice, alice, {bob}, {auditor});
+
+            mptAlice.set({
+                .account = alice,
+                .issuerPubKey = mptAlice.getPubKey(alice),
+                .auditorPubKey = mptAlice.getPubKey(auditor),
+            });
+
+            BEAST_EXPECT(mptAlice.checkKeyEpochs(std::nullopt, std::nullopt));
+
+            mptAlice.convert({
+                .account = bob,
+                .amt = 50,
+                .holderPubKey = mptAlice.getPubKey(bob),
+            });
+
+            BEAST_EXPECT(mptAlice.checkMirrorEpochs(bob, std::nullopt, std::nullopt));
+
+            // Both mirrors are current, so converting again is allowed and
+            // leaves the epochs untouched.
+            mptAlice.convert({
+                .account = bob,
+                .amt = 20,
+            });
+
+            BEAST_EXPECT(mptAlice.checkMirrorEpochs(bob, std::nullopt, std::nullopt));
+        }
+
+        // Every remaining case needs key rotation to be enabled.
+        if (!features[featureConfidentialMPTKeyRotation])
+            return;
+
+        // A first-time convert stamps the mirrors with whatever epochs the
+        // issuance currently sits at. Only issuer key rotated in this case.
+        {
+            Env env{*this, features};
+            MPTTester mptAlice(env, alice, {.holders = {bob, carol}, .auditor = auditor});
+            setupConfidentialIssuance(mptAlice, alice, {bob, carol}, {auditor});
+
+            mptAlice.set({
+                .account = alice,
+                .issuerPubKey = mptAlice.getPubKey(alice),
+                .auditorPubKey = mptAlice.getPubKey(auditor),
+            });
+
+            // Ten rotations, issuance's issuer epoch is 10.
+            for (int i = 0; i < 10; ++i)
+            {
+                mptAlice.generateKeyPair(alice);
+                mptAlice.set({.account = alice, .issuerPubKey = mptAlice.getPubKey(alice)});
+            }
+
+            BEAST_EXPECT(mptAlice.checkKeyEpochs(10u, std::nullopt));
+            BEAST_EXPECT(mptAlice.checkEncryptionKeys(alice, auditor));
+
+            // carol converts for the first time, and her mirrors are stamped with the current
+            // issuer epoch of 10.
+            mptAlice.convert({
+                .account = carol,
+                .amt = 50,
+                .holderPubKey = mptAlice.getPubKey(carol),
+            });
+
+            BEAST_EXPECT(mptAlice.checkMirrorEpochs(carol, 10u, std::nullopt));
+        }
+
+        // A first-time convert stamps the mirrors with whatever epochs the
+        // issuance currently sits at. Both keys rotated in this case.
+        {
+            Env env{*this, features};
+            MPTTester mptAlice(env, alice, {.holders = {bob, carol}, .auditor = auditor});
+            setupConfidentialIssuance(mptAlice, alice, {bob, carol}, {auditor});
+
+            mptAlice.set({
+                .account = alice,
+                .issuerPubKey = mptAlice.getPubKey(alice),
+                .auditorPubKey = mptAlice.getPubKey(auditor),
+            });
+
+            // 100 rotations of both keys, so both epochs are 100.
+            for (int i = 0; i < 100; ++i)
+            {
+                mptAlice.generateKeyPair(alice);
+                mptAlice.generateKeyPair(auditor);
+                mptAlice.set({
+                    .account = alice,
+                    .issuerPubKey = mptAlice.getPubKey(alice),
+                    .auditorPubKey = mptAlice.getPubKey(auditor),
+                });
+            }
+
+            // 5 more rotations of the auditor key alone, so the auditor epoch is 105 now.
+            for (int i = 0; i < 5; ++i)
+            {
+                mptAlice.generateKeyPair(auditor);
+                mptAlice.set({.account = alice, .auditorPubKey = mptAlice.getPubKey(auditor)});
+            }
+
+            BEAST_EXPECT(mptAlice.checkKeyEpochs(100u, 105u));
+            BEAST_EXPECT(mptAlice.checkEncryptionKeys(alice, auditor));
+
+            // carol converts for the first time, and each of her mirrors is stamped with the epoch
+            // of the key it was encrypted under.
+            mptAlice.convert({
+                .account = carol,
+                .amt = 50,
+                .holderPubKey = mptAlice.getPubKey(carol),
+            });
+
+            BEAST_EXPECT(mptAlice.checkMirrorEpochs(carol, 100u, 105u));
+        }
+
+        // An issuer key rotation leaves an existing holder's issuer mirror
+        // behind, converting will be blocked until the holder's mirror is updated to the new epoch.
+        {
+            Env env{*this, features};
+            MPTTester mptAlice(env, alice, {.holders = {bob, carol}, .auditor = auditor});
+            setupConfidentialIssuance(mptAlice, alice, {bob, carol}, {auditor});
+
+            mptAlice.set({
+                .account = alice,
+                .issuerPubKey = mptAlice.getPubKey(alice),
+                .auditorPubKey = mptAlice.getPubKey(auditor),
+            });
+
+            // carol initializes before any rotation, so her mirrors carry no epoch
+            // at all, the state every holder is in before the amendment.
+            mptAlice.convert({
+                .account = carol,
+                .amt = 50,
+                .holderPubKey = mptAlice.getPubKey(carol),
+            });
+
+            BEAST_EXPECT(mptAlice.checkMirrorEpochs(carol, std::nullopt, std::nullopt));
+
+            // Rotate the issuer key to epoch 1.
+            mptAlice.generateKeyPair(alice);
+            mptAlice.set({.account = alice, .issuerPubKey = mptAlice.getPubKey(alice)});
+
+            BEAST_EXPECT(mptAlice.checkKeyEpochs(1u, std::nullopt));
+
+            // bob converts for the first time which is allowed when registering the key.
+            mptAlice.convert({
+                .account = bob,
+                .amt = 50,
+                .holderPubKey = mptAlice.getPubKey(bob),
+            });
+
+            BEAST_EXPECT(mptAlice.checkMirrorEpochs(bob, 1u, std::nullopt));
+
+            // carol's absent epoch reads as 0 which is stale.
+            mptAlice.convert({
+                .account = carol,
+                .amt = 20,
+                .err = tecNO_PERMISSION,
+            });
+
+            BEAST_EXPECT(mptAlice.checkMirrorEpochs(carol, std::nullopt, std::nullopt));
+
+            // Rotate the issuer key to epoch 2, leaving bob's issuer mirror stale.
+            mptAlice.generateKeyPair(alice);
+            mptAlice.set({.account = alice, .issuerPubKey = mptAlice.getPubKey(alice)});
+
+            BEAST_EXPECT(mptAlice.checkKeyEpochs(2u, std::nullopt));
+
+            // This is not the first time convert, and bob's issuer mirror is behind the current
+            // epoch, so the convert is rejected.
+            mptAlice.convert({
+                .account = bob,
+                .amt = 20,
+                .err = tecNO_PERMISSION,
+            });
+
+            // The rejected convert leaves bob's mirrors exactly as they were.
+            BEAST_EXPECT(mptAlice.checkMirrorEpochs(bob, 1u, std::nullopt));
+
+            // carol still cannot convert.
+            mptAlice.convert({
+                .account = carol,
+                .amt = 20,
+                .err = tecNO_PERMISSION,
+            });
+
+            BEAST_EXPECT(mptAlice.checkMirrorEpochs(carol, std::nullopt, std::nullopt));
+        }
+
+        // The auditor mirror is checked the same way, so rotating only the
+        // auditor key blocks the convert on its own, with the issuer epoch
+        // untouched.
+        {
+            Env env{*this, features};
+            MPTTester mptAlice(env, alice, {.holders = {bob, carol}, .auditor = auditor});
+            setupConfidentialIssuance(mptAlice, alice, {bob, carol}, {auditor});
+
+            mptAlice.set({
+                .account = alice,
+                .issuerPubKey = mptAlice.getPubKey(alice),
+                .auditorPubKey = mptAlice.getPubKey(auditor),
+            });
+
+            // bob initializes his confidential balance at epoch 0, so both of his
+            // mirrors are current.
+            mptAlice.convert({
+                .account = bob,
+                .amt = 50,
+                .holderPubKey = mptAlice.getPubKey(bob),
+            });
+
+            BEAST_EXPECT(mptAlice.checkMirrorEpochs(bob, std::nullopt, std::nullopt));
+
+            // Rotate the auditor key only, leaving bob's auditor mirror behind
+            // while his issuer mirror stays current.
+            mptAlice.generateKeyPair(auditor);
+            mptAlice.set({.account = alice, .auditorPubKey = mptAlice.getPubKey(auditor)});
+
+            BEAST_EXPECT(mptAlice.checkKeyEpochs(std::nullopt, 1u));
+            BEAST_EXPECT(mptAlice.checkEncryptionKeys(alice, auditor));
+
+            mptAlice.convert({
+                .account = bob,
+                .amt = 20,
+                .err = tecNO_PERMISSION,
+            });
+
+            BEAST_EXPECT(mptAlice.checkMirrorEpochs(bob, std::nullopt, std::nullopt));
+
+            // Carol converts for the first time, and her auditor mirror is stamped with the current
+            // auditor epoch of 1.
+            mptAlice.convert({
+                .account = carol,
+                .amt = 50,
+                .holderPubKey = mptAlice.getPubKey(carol),
+            });
+
+            BEAST_EXPECT(mptAlice.checkMirrorEpochs(carol, std::nullopt, 1u));
+        }
+
+        // A late auditor key registration bumps no epoch.
+        // Although both epochs are still zero, the convert is blocked
+        // because auditor mirror is missing.
+        {
+            Env env{*this, features};
+            MPTTester mptAlice(env, alice, {.holders = {bob}, .auditor = auditor});
+            setupConfidentialIssuance(mptAlice, alice, {bob}, {auditor});
+
+            // Register the issuer key only.
+            mptAlice.set({
+                .account = alice,
+                .issuerPubKey = mptAlice.getPubKey(alice),
+            });
+
+            // The issuance has no auditor yet, so no auditor mirror is created.
+            mptAlice.convert({
+                .account = bob,
+                .amt = 50,
+                .fillAuditorEncryptedAmt = false,
+                .holderPubKey = mptAlice.getPubKey(bob),
+            });
+
+            BEAST_EXPECT(mptAlice.checkMirrorEpochs(bob, std::nullopt, std::nullopt));
+
+            // Register the auditor key later, which bumps no epoch.
+            mptAlice.set({
+                .account = alice,
+                .auditorPubKey = mptAlice.getPubKey(auditor),
+            });
+
+            BEAST_EXPECT(mptAlice.checkKeyEpochs(std::nullopt, std::nullopt));
+
+            // bob's auditor mirror is still missing, so the convert is rejected.
+            mptAlice.convert({
+                .account = bob,
+                .amt = 20,
+                .err = tecNO_PERMISSION,
+            });
+
+            BEAST_EXPECT(mptAlice.checkMirrorEpochs(bob, std::nullopt, std::nullopt));
+        }
+    }
+
+    void
+    testConfidentialMPTSendEpoch(FeatureBitset features)
+    {
+        testcase("ConfidentialMPTSend mirror epoch");
+        using namespace test::jtx;
+
+        Account const alice("alice");
+        Account const bob("bob");
+        Account const carol("carol");
+        Account const auditor("auditor");
+
+        // Two holders that both initialized after a rotation are current, so a
+        // send between them succeeds and leaves both mirrors untouched.
+        {
+            Env env{*this, features};
+            MPTTester mptAlice(env, alice, {.holders = {bob, carol}});
+            setupConfidentialIssuance(mptAlice, alice, {bob, carol});
+            mptAlice.set({.account = alice, .issuerPubKey = mptAlice.getPubKey(alice)});
+
+            // Rotate the issuer key to epoch 1 before anyone holds a confidential
+            // balance.
+            mptAlice.generateKeyPair(alice);
+            mptAlice.set({.account = alice, .issuerPubKey = mptAlice.getPubKey(alice)});
+
+            BEAST_EXPECT(mptAlice.checkKeyEpochs(1u, std::nullopt));
+
+            for (auto const& holder : {bob, carol})
+            {
+                mptAlice.convert({
+                    .account = holder,
+                    .amt = 50,
+                    .holderPubKey = mptAlice.getPubKey(holder),
+                });
+                mptAlice.mergeInbox({.account = holder});
+            }
+
+            BEAST_EXPECT(mptAlice.checkMirrorEpochs(bob, 1u, std::nullopt));
+            BEAST_EXPECT(mptAlice.checkMirrorEpochs(carol, 1u, std::nullopt));
+
+            mptAlice.send({.account = bob, .dest = carol, .amt = 10});
+
+            // The epochs are unchanged after send.
+            BEAST_EXPECT(mptAlice.checkMirrorEpochs(bob, 1u, std::nullopt));
+            BEAST_EXPECT(mptAlice.checkMirrorEpochs(carol, 1u, std::nullopt));
+        }
+
+        // Either the sender or the destination being stale will be rejected.
+        {
+            Env env{*this, features};
+            MPTTester mptAlice(env, alice, {.holders = {bob, carol}});
+            setupConfidentialIssuance(mptAlice, alice, {bob, carol});
+            mptAlice.set({.account = alice, .issuerPubKey = mptAlice.getPubKey(alice)});
+
+            // carol initializes at epoch 0.
+            mptAlice.convert({
+                .account = carol,
+                .amt = 50,
+                .holderPubKey = mptAlice.getPubKey(carol),
+            });
+            mptAlice.mergeInbox({.account = carol});
+
+            // Rotate the issuer key to epoch 1, leaving carol behind.
+            mptAlice.generateKeyPair(alice);
+            mptAlice.set({.account = alice, .issuerPubKey = mptAlice.getPubKey(alice)});
+
+            // bob initializes after the rotation, so his mirrors are current.
+            mptAlice.convert({
+                .account = bob,
+                .amt = 50,
+                .holderPubKey = mptAlice.getPubKey(bob),
+            });
+            mptAlice.mergeInbox({.account = bob});
+
+            BEAST_EXPECT(mptAlice.checkMirrorEpochs(carol, std::nullopt, std::nullopt));
+            BEAST_EXPECT(mptAlice.checkMirrorEpochs(bob, 1u, std::nullopt));
+
+            // This is rejected because the sender is the stale even though the destination is
+            // current.
+            mptAlice.send({
+                .account = carol,
+                .dest = bob,
+                .amt = 10,
+                .err = tecNO_PERMISSION,
+            });
+
+            // This is rejected because the destination is the stale even though the sender is
+            // current.
+            mptAlice.send({
+                .account = bob,
+                .dest = carol,
+                .amt = 10,
+                .err = tecNO_PERMISSION,
+            });
+
+            // The rejected sends leave both mirrors as they were.
+            BEAST_EXPECT(mptAlice.checkMirrorEpochs(carol, std::nullopt, std::nullopt));
+            BEAST_EXPECT(mptAlice.checkMirrorEpochs(bob, 1u, std::nullopt));
+        }
+
+        // Auditor mirror is stale, the send will be rejected.
+        {
+            Env env{*this, features};
+            MPTTester mptAlice(env, alice, {.holders = {bob, carol}, .auditor = auditor});
+            setupConfidentialIssuance(mptAlice, alice, {bob, carol}, {auditor});
+            mptAlice.set({
+                .account = alice,
+                .issuerPubKey = mptAlice.getPubKey(alice),
+                .auditorPubKey = mptAlice.getPubKey(auditor),
+            });
+
+            for (auto const& holder : {bob, carol})
+            {
+                mptAlice.convert({
+                    .account = holder,
+                    .amt = 50,
+                    .holderPubKey = mptAlice.getPubKey(holder),
+                });
+                mptAlice.mergeInbox({.account = holder});
+            }
+
+            // Rotate the auditor key only
+            mptAlice.generateKeyPair(auditor);
+            mptAlice.set({.account = alice, .auditorPubKey = mptAlice.getPubKey(auditor)});
+
+            BEAST_EXPECT(mptAlice.checkKeyEpochs(std::nullopt, 1u));
+
+            mptAlice.send({
+                .account = bob,
+                .dest = carol,
+                .amt = 10,
+                .err = tecNO_PERMISSION,
+            });
+
+            mptAlice.send({
+                .account = carol,
+                .dest = bob,
+                .amt = 10,
+                .err = tecNO_PERMISSION,
+            });
+
+            BEAST_EXPECT(mptAlice.checkMirrorEpochs(bob, std::nullopt, std::nullopt));
+            BEAST_EXPECT(mptAlice.checkMirrorEpochs(carol, std::nullopt, std::nullopt));
+        }
+    }
+
+    void
+    testConfidentialMPTConvertBackEpoch(FeatureBitset features)
+    {
+        testcase("ConfidentialMPTConvertBack mirror epoch");
+        using namespace test::jtx;
+
+        Account const alice("alice");
+        Account const bob("bob");
+        Account const auditor("auditor");
+
+        // A holder who initialized after a rotation is current, so converting
+        // back is allowed and leaves the epoch it was stamped with alone.
+        {
+            Env env{*this, features};
+            MPTTester mptAlice(env, alice, {.holders = {bob}});
+            setupConfidentialIssuance(mptAlice, alice, {bob});
+            mptAlice.set({.account = alice, .issuerPubKey = mptAlice.getPubKey(alice)});
+
+            // Rotate the issuer key to epoch 1 before bob holds a confidential
+            // balance.
+            mptAlice.generateKeyPair(alice);
+            mptAlice.set({.account = alice, .issuerPubKey = mptAlice.getPubKey(alice)});
+
+            BEAST_EXPECT(mptAlice.checkKeyEpochs(1u, std::nullopt));
+
+            mptAlice.convert({
+                .account = bob,
+                .amt = 50,
+                .holderPubKey = mptAlice.getPubKey(bob),
+            });
+            mptAlice.mergeInbox({.account = bob});
+
+            BEAST_EXPECT(mptAlice.checkMirrorEpochs(bob, 1u, std::nullopt));
+
+            mptAlice.convertBack({.account = bob, .amt = 20});
+
+            BEAST_EXPECT(mptAlice.checkMirrorEpochs(bob, 1u, std::nullopt));
+        }
+
+        // Converting back with stale mirrors is rejected.
+        {
+            Env env{*this, features};
+            MPTTester mptAlice(env, alice, {.holders = {bob}});
+            setupConfidentialIssuance(mptAlice, alice, {bob});
+            mptAlice.set({.account = alice, .issuerPubKey = mptAlice.getPubKey(alice)});
+
+            // bob initializes at epoch 0.
+            mptAlice.convert({
+                .account = bob,
+                .amt = 50,
+                .holderPubKey = mptAlice.getPubKey(bob),
+            });
+            mptAlice.mergeInbox({.account = bob});
+
+            // Converting back is allowed while his mirrors are still current.
+            mptAlice.convertBack({.account = bob, .amt = 20});
+
+            // Rotate the issuer key to epoch 1, leaving bob behind.
+            mptAlice.generateKeyPair(alice);
+            mptAlice.set({.account = alice, .issuerPubKey = mptAlice.getPubKey(alice)});
+
+            mptAlice.convertBack({
+                .account = bob,
+                .amt = 10,
+                .err = tecNO_PERMISSION,
+            });
+
+            // The rejected convert back leaves bob's mirrors as they were.
+            BEAST_EXPECT(mptAlice.checkMirrorEpochs(bob, std::nullopt, std::nullopt));
+        }
+
+        // Converting back with a stale auditor mirror is rejected, even if the issuer mirror is
+        // current.
+        {
+            Env env{*this, features};
+            MPTTester mptAlice(env, alice, {.holders = {bob}, .auditor = auditor});
+            setupConfidentialIssuance(mptAlice, alice, {bob}, {auditor});
+            mptAlice.set({
+                .account = alice,
+                .issuerPubKey = mptAlice.getPubKey(alice),
+                .auditorPubKey = mptAlice.getPubKey(auditor),
+            });
+
+            mptAlice.convert({
+                .account = bob,
+                .amt = 50,
+                .holderPubKey = mptAlice.getPubKey(bob),
+            });
+            mptAlice.mergeInbox({.account = bob});
+
+            // Rotate the auditor key only, leaving bob behind on that mirror alone.
+            mptAlice.generateKeyPair(auditor);
+            mptAlice.set({.account = alice, .auditorPubKey = mptAlice.getPubKey(auditor)});
+
+            BEAST_EXPECT(mptAlice.checkKeyEpochs(std::nullopt, 1u));
+
+            mptAlice.convertBack({
+                .account = bob,
+                .amt = 10,
+                .err = tecNO_PERMISSION,
+            });
+
+            BEAST_EXPECT(mptAlice.checkMirrorEpochs(bob, std::nullopt, std::nullopt));
+        }
+    }
+
+    void
+    testConfidentialMPTClawbackEpoch(FeatureBitset features)
+    {
+        testcase("ConfidentialMPTClawback mirror epoch");
+        using namespace test::jtx;
+
+        Account const alice("alice");
+        Account const bob("bob");
+        Account const auditor("auditor");
+
+        std::uint32_t const clawbackFlags =
+            tfMPTCanTransfer | tfMPTCanHoldConfidentialBalance | tfMPTCanClawback;
+
+        // Clawback is not blocked on
+        // a stale auditor mirror.
+        {
+            Env env{*this, features};
+            MPTTester mptAlice(env, alice, {.holders = {bob}, .auditor = auditor});
+            setupConfidentialIssuance(mptAlice, alice, {bob}, {auditor}, clawbackFlags);
+            mptAlice.set({
+                .account = alice,
+                .issuerPubKey = mptAlice.getPubKey(alice),
+                .auditorPubKey = mptAlice.getPubKey(auditor),
+            });
+
+            // bob initializes both mirrors at epoch 0.
+            mptAlice.convert({
+                .account = bob,
+                .amt = 50,
+                .holderPubKey = mptAlice.getPubKey(bob),
+            });
+
+            // Rotate the auditor key twice, leaving bob's auditor mirror behind.
+            for (int i = 0; i < 2; ++i)
+            {
+                mptAlice.generateKeyPair(auditor);
+                mptAlice.set({.account = alice, .auditorPubKey = mptAlice.getPubKey(auditor)});
+            }
+
+            BEAST_EXPECT(mptAlice.checkKeyEpochs(std::nullopt, 2u));
+            BEAST_EXPECT(mptAlice.checkMirrorEpochs(bob, std::nullopt, std::nullopt));
+
+            mptAlice.confidentialClaw({.account = alice, .holder = bob, .amt = 50});
+            BEAST_EXPECT(mptAlice.checkMirrorEpochs(bob, std::nullopt, 2u));
+        }
+
+        // A holder who initialized after a rotation is clawed back successfully, and
+        // the issuer mirror is updated to the current epoch.
+        {
+            Env env{*this, features};
+            MPTTester mptAlice(env, alice, {.holders = {bob}});
+            setupConfidentialIssuance(mptAlice, alice, {bob}, {}, clawbackFlags);
+            mptAlice.set({.account = alice, .issuerPubKey = mptAlice.getPubKey(alice)});
+
+            // Rotate the issuer key five times, issuance's issuer epoch is 5.
+            for (int i = 0; i < 5; ++i)
+            {
+                mptAlice.generateKeyPair(alice);
+                mptAlice.set({.account = alice, .issuerPubKey = mptAlice.getPubKey(alice)});
+            }
+
+            mptAlice.convert({
+                .account = bob,
+                .amt = 50,
+                .holderPubKey = mptAlice.getPubKey(bob),
+            });
+            BEAST_EXPECT(mptAlice.checkMirrorEpochs(bob, 5u, std::nullopt));
+
+            mptAlice.confidentialClaw({.account = alice, .holder = bob, .amt = 50});
+            BEAST_EXPECT(mptAlice.checkMirrorEpochs(bob, 5u, std::nullopt));
+        }
+
+        // Clawback is not blocked on
+        // a stale issuer mirror. For now the proof cannot verify: it is checked
+        // against the key registered on the issuance, while the mirror is still
+        // encrypted under the key it was written with, and that older key is
+        // nowhere on the ledger yet. This will be added in a separate PR.
+        {
+            Env env{*this, features};
+            MPTTester mptAlice(env, alice, {.holders = {bob}});
+            setupConfidentialIssuance(mptAlice, alice, {bob}, {}, clawbackFlags);
+            mptAlice.set({.account = alice, .issuerPubKey = mptAlice.getPubKey(alice)});
+
+            // bob initializes at epoch 0.
+            mptAlice.convert({
+                .account = bob,
+                .amt = 50,
+                .holderPubKey = mptAlice.getPubKey(bob),
+            });
+
+            // Rotate the issuer key to epoch 1, leaving bob behind.
+            mptAlice.generateKeyPair(alice);
+            mptAlice.set({.account = alice, .issuerPubKey = mptAlice.getPubKey(alice)});
+
+            BEAST_EXPECT(mptAlice.checkKeyEpochs(1u, std::nullopt));
+
+            mptAlice.confidentialClaw({
+                .account = alice,
+                .holder = bob,
+                .amt = 50,
+                .err = tecBAD_PROOF,
+            });
+
+            BEAST_EXPECT(mptAlice.checkMirrorEpochs(bob, std::nullopt, std::nullopt));
+        }
+    }
+
+    void
+    testConfidentialMPTMirrorUpdatePreflight(FeatureBitset features)
+    {
+        testcase("ConfidentialMPTMirrorUpdate preflight");
+        using namespace test::jtx;
+
+        Env env{*this, features};
+        Account const alice("alice");
+        Account const bob("bob");
+        Account const carol("carol");
+        MPTTester mptAlice(env, alice, {.holders = {bob, carol}});
+
+        // A well-formed 66-byte ElGamal ciphertext
+        Buffer const& validCipher = getTrivialCiphertext();
+
+        // Both amendments are required: ConfidentialMPTKeyRotation and ConfidentialTransfer.
+        if (!features[featureConfidentialMPTKeyRotation] || !features[featureConfidentialTransfer])
+        {
+            mptAlice.create({.ownerCount = 1, .flags = tfMPTCanTransfer});
+            mptAlice.mirrorUpdate({
+                .account = bob,
+                .issuerEncryptedAmount = validCipher,
+                .err = temDISABLED,
+            });
+            return;
+        }
+
+        mptAlice.create({
+            .ownerCount = 1,
+            .flags = tfMPTCanTransfer | tfMPTCanHoldConfidentialBalance,
+        });
+        // Issuer mode but account is not the issuer.
+        mptAlice.mirrorUpdate({
+            .account = bob,
+            .holder = carol,
+            .issuerEncryptedAmount = validCipher,
+            .err = temMALFORMED,
+        });
+
+        // Issuer mode but the holder is the same as the issuer.
+        mptAlice.mirrorUpdate({
+            .account = alice,
+            .holder = alice,
+            .issuerEncryptedAmount = validCipher,
+            .err = temMALFORMED,
+        });
+
+        // Issuer mode but holder is not provided.
+        mptAlice.mirrorUpdate({
+            .account = alice,
+            .issuerEncryptedAmount = validCipher,
+            .err = temMALFORMED,
+        });
+
+        // At least one of issuer or auditor amount must be present.
+        mptAlice.mirrorUpdate({
+            .account = alice,
+            .holder = bob,
+            .err = temMALFORMED,
+        });
+
+        // Issuer amount has the wrong length.
+        mptAlice.mirrorUpdate({
+            .account = alice,
+            .holder = bob,
+            .issuerEncryptedAmount = gMakeZeroBuffer(10),
+            .err = temBAD_CIPHERTEXT,
+        });
+
+        // Auditor amount has the wrong length.
+        mptAlice.mirrorUpdate({
+            .account = alice,
+            .holder = bob,
+            .auditorEncryptedAmount = gMakeZeroBuffer(10),
+            .err = temBAD_CIPHERTEXT,
+        });
+
+        // The proof has the wrong length.
+        mptAlice.mirrorUpdate({
+            .account = alice,
+            .holder = bob,
+            .issuerEncryptedAmount = validCipher,
+            .zkProof = gMakeZeroBuffer(kEcEqualityProofLength - 1),
+            .err = temMALFORMED,
+        });
+
+        // Issuer amount is the right length but not a valid ciphertext.
+        mptAlice.mirrorUpdate({
+            .account = alice,
+            .holder = bob,
+            .issuerEncryptedAmount = getBadCiphertext(),
+            .err = temBAD_CIPHERTEXT,
+        });
+
+        // Auditor amount is the right length but not a valid ciphertext.
+        mptAlice.mirrorUpdate({
+            .account = alice,
+            .holder = bob,
+            .issuerEncryptedAmount = validCipher,
+            .auditorEncryptedAmount = getBadCiphertext(),
+            .err = temBAD_CIPHERTEXT,
+        });
+    }
+
+    void
+    testConfidentialMPTMirrorUpdatePreclaim(FeatureBitset features)
+    {
+        testcase("ConfidentialMPTMirrorUpdate preclaim");
+        using namespace test::jtx;
+
+        Buffer const& validCipher = getTrivialCiphertext();
+
+        // The issuance does not exist.
+        {
+            Env env{*this, features};
+            Account const alice("alice");
+            Account const bob("bob");
+            MPTTester mptAlice(env, alice, {.holders = {bob}});
+
+            mptAlice.create({
+                .flags = tfMPTCanTransfer | tfMPTCanHoldConfidentialBalance,
+            });
+            // Destroy the issuance to test issuance not found.
+            mptAlice.destroy();
+
+            mptAlice.mirrorUpdate({
+                .account = bob,
+                .issuerEncryptedAmount = validCipher,
+                .err = tecOBJECT_NOT_FOUND,
+            });
+        }
+
+        // The issuance has not enabled confidential balances.
+        {
+            Env env{*this, features};
+            Account const alice("alice");
+            Account const bob("bob");
+            MPTTester mptAlice(env, alice, {.holders = {bob}});
+            mptAlice.create({.ownerCount = 1, .flags = tfMPTCanTransfer});
+
+            mptAlice.mirrorUpdate({
+                .account = alice,
+                .holder = bob,
+                .issuerEncryptedAmount = validCipher,
+                .err = tecNO_PERMISSION,
+            });
+        }
+
+        // The issuer encryption key was not already registered.
+        {
+            Env env{*this, features};
+            Account const alice("alice");
+            Account const bob("bob");
+            MPTTester mptAlice(env, alice, {.holders = {bob}});
+            mptAlice.create(
+                {.ownerCount = 1, .flags = tfMPTCanTransfer | tfMPTCanHoldConfidentialBalance});
+            mptAlice.authorize({.account = bob});
+
+            mptAlice.mirrorUpdate({
+                .account = alice,
+                .holder = bob,
+                .issuerEncryptedAmount = validCipher,
+                .err = tecNO_PERMISSION,
+            });
+        }
+
+        // In issuer mode, the specified holder account does not exist.
+        {
+            Env env{*this, features};
+            Account const alice("alice");
+            Account const carol("carol");
+            MPTTester mptAlice(env, alice);
+            mptAlice.create(
+                {.ownerCount = 1, .flags = tfMPTCanTransfer | tfMPTCanHoldConfidentialBalance});
+            mptAlice.generateKeyPair(alice);
+            mptAlice.set({.account = alice, .issuerPubKey = mptAlice.getPubKey(alice)});
+
+            // Carol never got funded so it does not exist.
+            mptAlice.mirrorUpdate({
+                .account = alice,
+                .holder = carol,
+                .issuerEncryptedAmount = validCipher,
+                .err = tecNO_TARGET,
+            });
+        }
+
+        // The holder's MPToken does not exist (holder never authorized).
+        {
+            Env env{*this, features};
+            Account const alice("alice");
+            Account const bob("bob");
+            MPTTester mptAlice(env, alice, {.holders = {bob}});
+            mptAlice.create(
+                {.ownerCount = 1, .flags = tfMPTCanTransfer | tfMPTCanHoldConfidentialBalance});
+            mptAlice.generateKeyPair(alice);
+            mptAlice.set({.account = alice, .issuerPubKey = mptAlice.getPubKey(alice)});
+
+            mptAlice.mirrorUpdate({
+                .account = alice,
+                .holder = bob,
+                .issuerEncryptedAmount = validCipher,
+                .err = tecOBJECT_NOT_FOUND,
+            });
+        }
+
+        // The holder has an MPToken but no confidential issuer balance (sfIssuerEncryptedBalance).
+        {
+            Env env{*this, features};
+            Account const alice("alice");
+            Account const bob("bob");
+            MPTTester mptAlice(env, alice, {.holders = {bob}});
+            mptAlice.create(
+                {.ownerCount = 1, .flags = tfMPTCanTransfer | tfMPTCanHoldConfidentialBalance});
+            mptAlice.authorize({.account = bob});
+            mptAlice.generateKeyPair(alice);
+            mptAlice.set({.account = alice, .issuerPubKey = mptAlice.getPubKey(alice)});
+
+            mptAlice.mirrorUpdate({
+                .account = alice,
+                .holder = bob,
+                .issuerEncryptedAmount = validCipher,
+                .err = tecNO_PERMISSION,
+            });
+        }
+
+        // Auditor mirror migration on an issuance with no auditor key.
+        {
+            Env env{*this, features};
+            Account const alice("alice");
+            Account const bob("bob");
+
+            // This setup has issuer key but no auditor key.
+            ConfidentialEnv ct{env, alice, {{.account = bob}}};
+
+            ct.mpt.mirrorUpdate({
+                .account = alice,
+                .holder = bob,
+                .auditorEncryptedAmount = validCipher,
+                .err = tecNO_PERMISSION,
+            });
+        }
+
+        // Issuer mirror is already most up-to-date so
+        // there is nothing to migrate.
+        {
+            Env env{*this, features};
+            Account const alice("alice");
+            Account const bob("bob");
+            ConfidentialEnv ct{env, alice, {{.account = bob}}};
+
+            ct.mpt.mirrorUpdate({
+                .account = alice,
+                .holder = bob,
+                .issuerEncryptedAmount = validCipher,
+                .err = tecNO_PERMISSION,
+            });
+        }
+
+        // Issuer-mode auditor-only migration while the issuer mirror is stale:
+        // the issuer mirror must be brought up to date before the auditor
+        // mirror can be migrated.
+        {
+            Env env{*this, features};
+            Account const alice("alice");
+            Account const bob("bob");
+            Account const auditor("auditor");
+            Account const newIssuerKey("newIssuerKey");
+
+            // Issuance has both an issuer key and an auditor key, and bob holds
+            // both mirrors at epoch 0.
+            ConfidentialEnv ct{
+                env,
+                alice,
+                {{.account = bob}},
+                tfMPTCanHoldConfidentialBalance | tfMPTCanTransfer,
+                auditor};
+
+            // Rotate the issuer key: issuer key epoch 0 -> 1, while bob's
+            // issuer-mirror epoch stays 0 (stale).
+            ct.mpt.generateKeyPair(newIssuerKey);
+            ct.mpt.set({.account = alice, .issuerPubKey = ct.mpt.getPubKey(newIssuerKey)});
+
+            ct.mpt.mirrorUpdate({
+                .account = alice,
+                .holder = bob,
+                .auditorEncryptedAmount = validCipher,
+                .err = tecNO_PERMISSION,
+            });
+        }
+
+        // Auditor mirror is already current (the auditor key has not rotated),
+        // so there is nothing to migrate.
+        {
+            Env env{*this, features};
+            Account const alice("alice");
+            Account const bob("bob");
+            Account const auditor("auditor");
+
+            // Issuance has both keys and bob holds both mirrors at epoch 0.
+            ConfidentialEnv ct{
+                env,
+                alice,
+                {{.account = bob}},
+                tfMPTCanHoldConfidentialBalance | tfMPTCanTransfer,
+                auditor};
+
+            // No key has rotated, so the auditor mirror is up to date
+            // so there is nothing to migrate.
+            ct.mpt.mirrorUpdate({
+                .account = alice,
+                .holder = bob,
+                .auditorEncryptedAmount = validCipher,
+                .err = tecNO_PERMISSION,
+            });
+        }
+
+        // In an issuer-mode simultaneous migration, both mirrors must be stale. Here
+        // only the issuer key has rotated so its mirror is stale but the auditor mirror is not.
+        {
+            Env env{*this, features};
+            Account const alice("alice");
+            Account const bob("bob");
+            Account const auditor("auditor");
+            Account const newIssuerKey("newIssuerKey");
+
+            ConfidentialEnv ct{
+                env,
+                alice,
+                {{.account = bob}},
+                tfMPTCanHoldConfidentialBalance | tfMPTCanTransfer,
+                auditor};
+
+            // Rotate only the issuer key: issuer key epoch 0 -> 1, auditor key
+            // epoch stays 0. The issuer mirror is now stale but the auditor
+            // mirror is still current.
+            ct.mpt.generateKeyPair(newIssuerKey);
+            ct.mpt.set({.account = alice, .issuerPubKey = ct.mpt.getPubKey(newIssuerKey)});
+
+            ct.mpt.mirrorUpdate({
+                .account = alice,
+                .holder = bob,
+                .issuerEncryptedAmount = validCipher,
+                .auditorEncryptedAmount = validCipher,
+                .err = tecNO_PERMISSION,
+            });
+        }
+
+        // In an issuer-mode simultaneous migration, both mirrors must be stale.
+        // Here only the auditor key has rotated so its mirror is stale but the
+        // issuer mirror is not.
+        {
+            Env env{*this, features};
+            Account const alice("alice");
+            Account const bob("bob");
+            Account const auditor("auditor");
+            Account const newAuditorKey("newAuditorKey");
+
+            ConfidentialEnv ct{
+                env,
+                alice,
+                {{.account = bob}},
+                tfMPTCanHoldConfidentialBalance | tfMPTCanTransfer,
+                auditor};
+
+            // Rotate only the auditor key: auditor key epoch 0 -> 1, issuer key
+            // epoch stays 0. The auditor mirror is now stale but the issuer
+            // mirror is still current.
+            ct.mpt.generateKeyPair(newAuditorKey);
+            ct.mpt.set({.account = alice, .auditorPubKey = ct.mpt.getPubKey(newAuditorKey)});
+
+            ct.mpt.mirrorUpdate({
+                .account = alice,
+                .holder = bob,
+                .issuerEncryptedAmount = validCipher,
+                .auditorEncryptedAmount = validCipher,
+                .err = tecNO_PERMISSION,
+            });
+        }
+
+        // Holder self-migration mode runs the same staleness checks.
+        // No key has rotated, so the holder's own issuer mirror is current and
+        // there is nothing to migrate.
+        {
+            Env env{*this, features};
+            Account const alice("alice");
+            Account const bob("bob");
+            ConfidentialEnv ct{env, alice, {{.account = bob}}};
+
+            ct.mpt.mirrorUpdate({
+                .account = bob,
+                .issuerEncryptedAmount = validCipher,
+                .err = tecNO_PERMISSION,
+            });
+        }
+
+        // Holder self-migration mode, simultaneously migrating both keys: only the issuer key
+        // has rotated, so the holder's issuer mirror is stale but the auditor
+        // mirror is still current.
+        {
+            Env env{*this, features};
+            Account const alice("alice");
+            Account const bob("bob");
+            Account const auditor("auditor");
+            Account const newIssuerKey("newIssuerKey");
+
+            ConfidentialEnv ct{
+                env,
+                alice,
+                {{.account = bob}},
+                tfMPTCanHoldConfidentialBalance | tfMPTCanTransfer,
+                auditor};
+
+            // Rotate only the issuer key: issuer key epoch 0 -> 1, auditor key
+            // epoch stays 0.
+            ct.mpt.generateKeyPair(newIssuerKey);
+            ct.mpt.set({.account = alice, .issuerPubKey = ct.mpt.getPubKey(newIssuerKey)});
+
+            // Holder mode (no Holder field) needs no previous issuer key.
+            ct.mpt.mirrorUpdate({
+                .account = bob,
+                .issuerEncryptedAmount = validCipher,
+                .auditorEncryptedAmount = validCipher,
+                .err = tecNO_PERMISSION,
+            });
+        }
+
+        // Holder self-migration mode, simultaneously migrating both keys:
+        // only the auditor key has rotated, so the holder's auditor mirror is stale but the issuer
+        // mirror is still current.
+        {
+            Env env{*this, features};
+            Account const alice("alice");
+            Account const bob("bob");
+            Account const auditor("auditor");
+            Account const newAuditorKey("newAuditorKey");
+
+            ConfidentialEnv ct{
+                env,
+                alice,
+                {{.account = bob}},
+                tfMPTCanHoldConfidentialBalance | tfMPTCanTransfer,
+                auditor};
+
+            // Rotate only the auditor key: auditor key epoch 0 -> 1, issuer key
+            // epoch stays 0.
+            ct.mpt.generateKeyPair(newAuditorKey);
+            ct.mpt.set({.account = alice, .auditorPubKey = ct.mpt.getPubKey(newAuditorKey)});
+
+            // Auditor mirror is stale but issuer mirror is current so this is rejected.
+            ct.mpt.mirrorUpdate({
+                .account = bob,
+                .issuerEncryptedAmount = validCipher,
+                .auditorEncryptedAmount = validCipher,
+                .err = tecNO_PERMISSION,
+            });
+        }
+
+        // Holder self-migration requires the holder's inbox to be canonical
+        // zero, because the cross-key equality proof anchors on the spending
+        // balance, which only reflects the full balance after the inbox is
+        // merged. A holder with a non-zero inbox is rejected.
+        {
+            Env env{*this, features};
+            Account const alice("alice");
+            Account const bob("bob");
+            Account const carol("carol");
+            Account const newIssuerKey("newIssuerKey");
+
+            ConfidentialEnv ct{env, alice, {{.account = bob}, {.account = carol}}};
+
+            // Carol sends Bob a confidential amount; Bob does NOT merge it, so
+            // his inbox is no longer canonical zero.
+            ct.mpt.send({.account = carol, .dest = bob, .amt = 10});
+
+            // Rotate the issuer key so the issuer mirror is stale and the
+            // migration gets past the epoch check to reach the inbox check.
+            ct.mpt.generateKeyPair(newIssuerKey);
+            ct.mpt.set({.account = alice, .issuerPubKey = ct.mpt.getPubKey(newIssuerKey)});
+
+            ct.mpt.mirrorUpdate({
+                .account = bob,
+                .issuerEncryptedAmount = validCipher,
+                .err = tecNO_PERMISSION,
+            });
+
+            // Merging the inbox makes the migration succeed.
+            ct.mpt.mergeInbox({.account = bob});
+            ct.mpt.mirrorUpdate({
+                .account = bob,
+                .issuerEncryptedAmount = validCipher,
+                .err = tesSUCCESS,
+            });
+        }
+
+        // A lock does not block a migration.
+        {
+            Env env{*this, features};
+            Account const alice("alice");
+            Account const bob("bob");
+            Account const carol("carol");
+            Account const newIssuerKey("newIssuerKey");
+            Account const newerIssuerKey("newerIssuerKey");
+
+            ConfidentialEnv ct{env, alice, {{.account = bob}, {.account = carol}}};
+            ct.mpt.set({.account = alice, .holder = bob, .flags = tfMPTLock});
+            ct.mpt.set({.account = alice, .holder = carol, .flags = tfMPTLock});
+
+            // Rotate the issuer key so both holders' mirrors are stale.
+            ct.mpt.generateKeyPair(newIssuerKey);
+            ct.mpt.set({.account = alice, .issuerPubKey = ct.mpt.getPubKey(newIssuerKey)});
+
+            // The issuer migrates an individually locked holder.
+            ct.mpt.mirrorUpdate({
+                .account = alice,
+                .holder = bob,
+                .issuerEncryptedAmount = validCipher,
+                .err = tesSUCCESS,
+            });
+
+            // An individually locked holder migrates itself.
+            ct.mpt.mirrorUpdate({
+                .account = carol,
+                .issuerEncryptedAmount = validCipher,
+                .err = tesSUCCESS,
+            });
+
+            // Release the individual locks and lock the whole issuance instead. Rotate again so
+            // both mirrors are stale once more.
+            ct.mpt.set({.account = alice, .holder = bob, .flags = tfMPTUnlock});
+            ct.mpt.set({.account = alice, .holder = carol, .flags = tfMPTUnlock});
+            ct.mpt.set({.account = alice, .flags = tfMPTLock});
+            ct.mpt.generateKeyPair(newerIssuerKey);
+            ct.mpt.set({.account = alice, .issuerPubKey = ct.mpt.getPubKey(newerIssuerKey)});
+
+            ct.mpt.mirrorUpdate({
+                .account = alice,
+                .holder = bob,
+                .issuerEncryptedAmount = validCipher,
+                .err = tesSUCCESS,
+            });
+
+            ct.mpt.mirrorUpdate({
+                .account = carol,
+                .issuerEncryptedAmount = validCipher,
+                .err = tesSUCCESS,
+            });
+        }
+    }
+
+    void
+    testConfidentialMPTMirrorUpdateDoApply(FeatureBitset features)
+    {
+        testcase("ConfidentialMPTMirrorUpdate doApply");
+        using namespace test::jtx;
+
+        // The holder's confidential balance, matching the ConfidentialEnv default
+        // convertAmount. The migration re-encrypts this amount under the new key.
+        std::uint64_t const amount = 100;
+
+        // Issuer mode issuer-mirror migration. The new issuer mirror is written
+        // and the auditor mirror epoch advances to the issuer key epoch.
+        {
+            Env env{*this, features};
+            Account const alice("alice");
+            Account const bob("bob");
+            Account const newIssuerKey("newIssuerKey");
+            ConfidentialEnv ct{env, alice, {{.account = bob}}};
+
+            // Rotate the issuer key: issuer key epoch 0 -> 1.
+            ct.mpt.generateKeyPair(newIssuerKey);
+            ct.mpt.set({.account = alice, .issuerPubKey = ct.mpt.getPubKey(newIssuerKey)});
+
+            // Re-encrypt Bob's balance under the new issuer key.
+            Buffer const newIssuerCipher =
+                ct.mpt.encryptAmount(newIssuerKey, amount, generateBlindingFactor());
+
+            // The previous issuer key is the pre-rotation issuer key (alice's),
+            // no longer on-ledger after the rotation, provide it in the transaction.
+            ct.mpt.mirrorUpdate({
+                .account = alice,
+                .holder = bob,
+                .issuerEncryptedAmount = newIssuerCipher,
+            });
+
+            auto const sle = env.le(keylet::mptoken(ct.mpt.issuanceID(), bob.id()));
+            if (!BEAST_EXPECT(sle))
+                return;
+
+            BEAST_EXPECT(strHex((*sle)[sfIssuerEncryptedBalance]) == strHex(newIssuerCipher));
+            BEAST_EXPECT((*sle)[~sfIssuerKeyMirrorEpoch] == 1u);
+
+            // The issuer mirror is now current, so re-migrating it is rejected.
+            ct.mpt.mirrorUpdate({
+                .account = alice,
+                .holder = bob,
+                .issuerEncryptedAmount = newIssuerCipher,
+                .err = tecNO_PERMISSION,
+            });
+        }
+
+        // Issuer mode auditor-mirror migration. The new auditor mirror is written
+        // and the auditor mirror epoch advances to the auditor key epoch.
+        {
+            Env env{*this, features};
+            Account const alice("alice");
+            Account const bob("bob");
+            Account const auditor("auditor");
+            Account const newAuditorKey("newAuditorKey");
+            ConfidentialEnv ct{
+                env,
+                alice,
+                {{.account = bob}},
+                tfMPTCanHoldConfidentialBalance | tfMPTCanTransfer,
+                auditor};
+
+            // Rotate only the auditor key: auditor key epoch 0 -> 1.
+            ct.mpt.generateKeyPair(newAuditorKey);
+            ct.mpt.set({.account = alice, .auditorPubKey = ct.mpt.getPubKey(newAuditorKey)});
+
+            // Re-encrypt Bob's balance under the new auditor key.
+            Buffer const newAuditorCipher =
+                ct.mpt.encryptAmount(newAuditorKey, amount, generateBlindingFactor());
+
+            ct.mpt.mirrorUpdate({
+                .account = alice,
+                .holder = bob,
+                .auditorEncryptedAmount = newAuditorCipher,
+            });
+
+            auto const sle = env.le(keylet::mptoken(ct.mpt.issuanceID(), bob.id()));
+            if (!BEAST_EXPECT(sle))
+                return;
+
+            BEAST_EXPECT(strHex((*sle)[sfAuditorEncryptedBalance]) == strHex(newAuditorCipher));
+            BEAST_EXPECT((*sle)[~sfAuditorKeyMirrorEpoch] == 1u);
+        }
+
+        // Issuer mode simultaneous migration: both mirrors are written in one transaction and
+        // both epochs advance.
+        {
+            Env env{*this, features};
+            Account const alice("alice");
+            Account const bob("bob");
+            Account const auditor("auditor");
+            Account const newIssuerKey("newIssuerKey");
+            Account const newAuditorKey("newAuditorKey");
+            ConfidentialEnv ct{
+                env,
+                alice,
+                {{.account = bob}},
+                tfMPTCanHoldConfidentialBalance | tfMPTCanTransfer,
+                auditor};
+
+            // Rotate both keys: both key epochs 0 -> 1.
+            ct.mpt.generateKeyPair(newIssuerKey);
+            ct.mpt.generateKeyPair(newAuditorKey);
+            ct.mpt.set({
+                .account = alice,
+                .issuerPubKey = ct.mpt.getPubKey(newIssuerKey),
+                .auditorPubKey = ct.mpt.getPubKey(newAuditorKey),
+            });
+
+            // Re-encrypt Bob's balance under each new key.
+            Buffer const bf = generateBlindingFactor();
+            Buffer const newIssuerCipher = ct.mpt.encryptAmount(newIssuerKey, amount, bf);
+            Buffer const newAuditorCipher = ct.mpt.encryptAmount(newAuditorKey, amount, bf);
+
+            ct.mpt.mirrorUpdate({
+                .account = alice,
+                .holder = bob,
+                .issuerEncryptedAmount = newIssuerCipher,
+                .auditorEncryptedAmount = newAuditorCipher,
+            });
+
+            auto const sle = env.le(keylet::mptoken(ct.mpt.issuanceID(), bob.id()));
+            if (!BEAST_EXPECT(sle))
+                return;
+
+            BEAST_EXPECT(strHex((*sle)[sfIssuerEncryptedBalance]) == strHex(newIssuerCipher));
+            BEAST_EXPECT(strHex((*sle)[sfAuditorEncryptedBalance]) == strHex(newAuditorCipher));
+            BEAST_EXPECT((*sle)[~sfIssuerKeyMirrorEpoch] == 1u);
+            BEAST_EXPECT((*sle)[~sfAuditorKeyMirrorEpoch] == 1u);
+        }
+
+        // Issuer mode auditor late-registration: the auditor key is registered for the first
+        // time (key epoch absent), so setting the initial auditor mirror leaves
+        // the auditor mirror epoch absent as well.
+        {
+            Env env{*this, features};
+            Account const alice("alice");
+            Account const bob("bob");
+            Account const auditor("auditor");
+            // No auditor in the confidential setup, so bob has no auditor mirror.
+            ConfidentialEnv ct{env, alice, {{.account = bob}}};
+
+            // Register an auditor key for the first time (auditor key epoch stays
+            // absent).
+            ct.mpt.generateKeyPair(auditor);
+            ct.mpt.set({.account = alice, .auditorPubKey = ct.mpt.getPubKey(auditor)});
+
+            // Encrypt Bob's balance under the newly registered auditor key.
+            Buffer const auditorCipher =
+                ct.mpt.encryptAmount(auditor, amount, generateBlindingFactor());
+
+            ct.mpt.mirrorUpdate({
+                .account = alice,
+                .holder = bob,
+                .auditorEncryptedAmount = auditorCipher,
+            });
+
+            auto const sle = env.le(keylet::mptoken(ct.mpt.issuanceID(), bob.id()));
+            if (!BEAST_EXPECT(sle))
+                return;
+            BEAST_EXPECT(strHex((*sle)[sfAuditorEncryptedBalance]) == strHex(auditorCipher));
+            // First-time registration leaves the mirror epoch absent (== 0).
+            BEAST_EXPECT(!sle->isFieldPresent(sfAuditorKeyMirrorEpoch));
+        }
+
+        // Holder self-migration migrates from the holder's own spending balance
+        // (Holder being Account field, no Holder field, and no previous issuer key in any flow
+        // because the anchor is the spending balance, not the old issuer mirror). ConfidentialEnv
+        // already merged the inbox so the holder's inbox is canonical zero.
+
+        // Holder issuer-mirror migration.
+        {
+            Env env{*this, features};
+            Account const alice("alice");
+            Account const bob("bob");
+            Account const newIssuerKey("newIssuerKey");
+            ConfidentialEnv ct{env, alice, {{.account = bob}}};
+
+            ct.mpt.generateKeyPair(newIssuerKey);
+            ct.mpt.set({.account = alice, .issuerPubKey = ct.mpt.getPubKey(newIssuerKey)});
+
+            // The holder re-encrypts their own balance under the new issuer key.
+            Buffer const newIssuerCipher =
+                ct.mpt.encryptAmount(newIssuerKey, amount, generateBlindingFactor());
+
+            ct.mpt.mirrorUpdate({
+                .account = bob,
+                .issuerEncryptedAmount = newIssuerCipher,
+            });
+
+            auto const sle = env.le(keylet::mptoken(ct.mpt.issuanceID(), bob.id()));
+            if (!BEAST_EXPECT(sle))
+                return;
+            BEAST_EXPECT(strHex((*sle)[sfIssuerEncryptedBalance]) == strHex(newIssuerCipher));
+            BEAST_EXPECT((*sle)[~sfIssuerKeyMirrorEpoch] == 1u);
+        }
+
+        // Holder auditor-mirror migration.
+        {
+            Env env{*this, features};
+            Account const alice("alice");
+            Account const bob("bob");
+            Account const auditor("auditor");
+            Account const newAuditorKey("newAuditorKey");
+            ConfidentialEnv ct{
+                env,
+                alice,
+                {{.account = bob}},
+                tfMPTCanHoldConfidentialBalance | tfMPTCanTransfer,
+                auditor};
+
+            ct.mpt.generateKeyPair(newAuditorKey);
+            ct.mpt.set({.account = alice, .auditorPubKey = ct.mpt.getPubKey(newAuditorKey)});
+
+            // The holder re-encrypts their own balance under the new auditor key.
+            Buffer const newAuditorCipher =
+                ct.mpt.encryptAmount(newAuditorKey, amount, generateBlindingFactor());
+
+            ct.mpt.mirrorUpdate({
+                .account = bob,
+                .auditorEncryptedAmount = newAuditorCipher,
+            });
+
+            auto const sle = env.le(keylet::mptoken(ct.mpt.issuanceID(), bob.id()));
+            if (!BEAST_EXPECT(sle))
+                return;
+            BEAST_EXPECT(strHex((*sle)[sfAuditorEncryptedBalance]) == strHex(newAuditorCipher));
+            BEAST_EXPECT((*sle)[~sfAuditorKeyMirrorEpoch] == 1u);
+        }
+
+        // Holder simultaneous migration of both mirrors.
+        {
+            Env env{*this, features};
+            Account const alice("alice");
+            Account const bob("bob");
+            Account const auditor("auditor");
+            Account const newIssuerKey("newIssuerKey");
+            Account const newAuditorKey("newAuditorKey");
+            ConfidentialEnv ct{
+                env,
+                alice,
+                {{.account = bob}},
+                tfMPTCanHoldConfidentialBalance | tfMPTCanTransfer,
+                auditor};
+
+            ct.mpt.generateKeyPair(newIssuerKey);
+            ct.mpt.generateKeyPair(newAuditorKey);
+            ct.mpt.set({
+                .account = alice,
+                .issuerPubKey = ct.mpt.getPubKey(newIssuerKey),
+                .auditorPubKey = ct.mpt.getPubKey(newAuditorKey),
+            });
+
+            Buffer const bf = generateBlindingFactor();
+            Buffer const newIssuerCipher = ct.mpt.encryptAmount(newIssuerKey, amount, bf);
+            Buffer const newAuditorCipher = ct.mpt.encryptAmount(newAuditorKey, amount, bf);
+
+            // Holder mode needs no previous issuer key even for the issuer mirror.
+            ct.mpt.mirrorUpdate({
+                .account = bob,
+                .issuerEncryptedAmount = newIssuerCipher,
+                .auditorEncryptedAmount = newAuditorCipher,
+            });
+
+            auto const sle = env.le(keylet::mptoken(ct.mpt.issuanceID(), bob.id()));
+            if (!BEAST_EXPECT(sle))
+                return;
+            BEAST_EXPECT(strHex((*sle)[sfIssuerEncryptedBalance]) == strHex(newIssuerCipher));
+            BEAST_EXPECT(strHex((*sle)[sfAuditorEncryptedBalance]) == strHex(newAuditorCipher));
+            BEAST_EXPECT((*sle)[~sfIssuerKeyMirrorEpoch] == 1u);
+            BEAST_EXPECT((*sle)[~sfAuditorKeyMirrorEpoch] == 1u);
+        }
+
+        // Holder auditor late-registration: the auditor key is registered for the first time (key
+        // epoch absent), so the holder setting their initial auditor mirror leaves the auditor
+        // mirror epoch absent as well.
+        {
+            Env env{*this, features};
+            Account const alice("alice");
+            Account const bob("bob");
+            Account const auditor("auditor");
+            // No auditor in the confidential setup, so bob has no auditor mirror.
+            ConfidentialEnv ct{env, alice, {{.account = bob}}};
+
+            // Register an auditor key for the first time (auditor key epoch stays
+            // absent).
+            ct.mpt.generateKeyPair(auditor);
+            ct.mpt.set({.account = alice, .auditorPubKey = ct.mpt.getPubKey(auditor)});
+
+            // The holder encrypts their own balance under the newly registered auditor key.
+            Buffer const auditorCipher =
+                ct.mpt.encryptAmount(auditor, amount, generateBlindingFactor());
+
+            ct.mpt.mirrorUpdate({
+                .account = bob,
+                .auditorEncryptedAmount = auditorCipher,
+            });
+
+            auto const sle = env.le(keylet::mptoken(ct.mpt.issuanceID(), bob.id()));
+            if (!BEAST_EXPECT(sle))
+                return;
+            BEAST_EXPECT(strHex((*sle)[sfAuditorEncryptedBalance]) == strHex(auditorCipher));
+            // First-time registration leaves the mirror epoch absent.
+            BEAST_EXPECT(!sle->isFieldPresent(sfAuditorKeyMirrorEpoch));
+        }
+    }
+
+    void
+    testConfidentialMPTMirrorUpdateMultipleRotationsIssuerMode(FeatureBitset features)
+    {
+        testcase("ConfidentialMPTMirrorUpdate issuer migrates after several rotations");
+        using namespace test::jtx;
+
+        std::uint64_t const amount = 100;
+
+        Env env{*this, features};
+        Account const alice("alice");
+        Account const bob("bob");
+        Account const auditor("auditor");
+        Account const issuerKey1("issuerKey1");
+        Account const issuerKey2("issuerKey2");
+        Account const issuerKey3("issuerKey3");
+        Account const issuerKey4("issuerKey4");
+        Account const issuerKey5("issuerKey5");
+        Account const auditorKey1("auditorKey1");
+        Account const auditorKey2("auditorKey2");
+        Account const auditorKey3("auditorKey3");
+        Account const auditorKey4("auditorKey4");
+        ConfidentialEnv ct{
+            env,
+            alice,
+            {{.account = bob}},
+            tfMPTCanHoldConfidentialBalance | tfMPTCanTransfer,
+            auditor};
+
+        // Rotate the issuer key three times: issuer key epoch 0 -> 3. Bob never
+        // migrates in between, so his issuer mirror stays at mirror epoch 0 and
+        // is still encrypted under the original issuer key (alice's).
+        ct.mpt.generateKeyPair(issuerKey1);
+        ct.mpt.generateKeyPair(issuerKey2);
+        ct.mpt.generateKeyPair(issuerKey3);
+        ct.mpt.set({.account = alice, .issuerPubKey = ct.mpt.getPubKey(issuerKey1)});
+        ct.mpt.set({.account = alice, .issuerPubKey = ct.mpt.getPubKey(issuerKey2)});
+        ct.mpt.set({.account = alice, .issuerPubKey = ct.mpt.getPubKey(issuerKey3)});
+
+        {
+            auto const sleIssuance = env.le(keylet::mptokenIssuance(ct.mpt.issuanceID()));
+            BEAST_EXPECT(sleIssuance && (*sleIssuance)[~sfIssuerKeyEpoch] == 3u);
+        }
+
+        // A single migration re-encrypts the mirror under the newest key and
+        // jumps the mirror epoch straight to the current key epoch (3), rather
+        // than advancing one rotation at a time. The previous issuer key is the
+        // original key (alice's) that the stale mirror is still encrypted under,
+        // not any intermediate rotation.
+        Buffer const newIssuerCipher =
+            ct.mpt.encryptAmount(issuerKey3, amount, generateBlindingFactor());
+
+        ct.mpt.mirrorUpdate({
+            .account = alice,
+            .holder = bob,
+            .issuerEncryptedAmount = newIssuerCipher,
+        });
+
+        {
+            auto const sle = env.le(keylet::mptoken(ct.mpt.issuanceID(), bob.id()));
+            if (!BEAST_EXPECT(sle))
+                return;
+            BEAST_EXPECT(strHex((*sle)[sfIssuerEncryptedBalance]) == strHex(newIssuerCipher));
+            BEAST_EXPECT((*sle)[~sfIssuerKeyMirrorEpoch] == 3u);
+        }
+
+        // The issuer mirror is now current (epoch 3 == key epoch 3), so a second
+        // issuer migration is rejected.
+        ct.mpt.mirrorUpdate({
+            .account = alice,
+            .holder = bob,
+            .issuerEncryptedAmount = newIssuerCipher,
+            .err = tecNO_PERMISSION,
+        });
+
+        // Now rotate the auditor key twice: auditor key epoch 0 -> 2. Bob's
+        // auditor mirror is still at mirror epoch 0, under the original auditor
+        // key. The issuer key and its epoch are untouched.
+        ct.mpt.generateKeyPair(auditorKey1);
+        ct.mpt.generateKeyPair(auditorKey2);
+        ct.mpt.set({.account = alice, .auditorPubKey = ct.mpt.getPubKey(auditorKey1)});
+        ct.mpt.set({.account = alice, .auditorPubKey = ct.mpt.getPubKey(auditorKey2)});
+
+        {
+            auto const sleIssuance = env.le(keylet::mptokenIssuance(ct.mpt.issuanceID()));
+            BEAST_EXPECT(sleIssuance && (*sleIssuance)[~sfAuditorKeyEpoch] == 2u);
+            BEAST_EXPECT(sleIssuance && (*sleIssuance)[~sfIssuerKeyEpoch] == 3u);
+        }
+
+        // A single auditor-only migration jumps the auditor mirror epoch straight
+        // to the current auditor key epoch (2). This is an issuer-mode
+        // auditor-only migration, which is allowed because the issuer mirror is
+        // already current; no previous issuer key is needed for an auditor
+        // migration.
+        Buffer const newAuditorCipher =
+            ct.mpt.encryptAmount(auditorKey2, amount, generateBlindingFactor());
+
+        ct.mpt.mirrorUpdate({
+            .account = alice,
+            .holder = bob,
+            .auditorEncryptedAmount = newAuditorCipher,
+        });
+
+        {
+            auto const sle = env.le(keylet::mptoken(ct.mpt.issuanceID(), bob.id()));
+            if (!BEAST_EXPECT(sle))
+                return;
+            BEAST_EXPECT(strHex((*sle)[sfAuditorEncryptedBalance]) == strHex(newAuditorCipher));
+            BEAST_EXPECT((*sle)[~sfAuditorKeyMirrorEpoch] == 2u);
+            // The issuer mirror and its epoch are unaffected by the auditor
+            // migration.
+            BEAST_EXPECT(strHex((*sle)[sfIssuerEncryptedBalance]) == strHex(newIssuerCipher));
+            BEAST_EXPECT((*sle)[~sfIssuerKeyMirrorEpoch] == 3u);
+        }
+
+        // The auditor mirror is now current (epoch 2 == key epoch 2), so a second
+        // auditor migration is rejected.
+        ct.mpt.mirrorUpdate({
+            .account = alice,
+            .holder = bob,
+            .auditorEncryptedAmount = newAuditorCipher,
+            .err = tecNO_PERMISSION,
+        });
+
+        // Now rotate BOTH keys together twice: issuer key epoch 3 -> 5, auditor
+        // key epoch 2 -> 4. Bob's mirrors stay at epoch 3 / 2 (stale again).
+        ct.mpt.generateKeyPair(issuerKey4);
+        ct.mpt.generateKeyPair(issuerKey5);
+        ct.mpt.generateKeyPair(auditorKey3);
+        ct.mpt.generateKeyPair(auditorKey4);
+        ct.mpt.set({
+            .account = alice,
+            .issuerPubKey = ct.mpt.getPubKey(issuerKey4),
+            .auditorPubKey = ct.mpt.getPubKey(auditorKey3),
+        });
+        ct.mpt.set({
+            .account = alice,
+            .issuerPubKey = ct.mpt.getPubKey(issuerKey5),
+            .auditorPubKey = ct.mpt.getPubKey(auditorKey4),
+        });
+
+        {
+            auto const sleIssuance = env.le(keylet::mptokenIssuance(ct.mpt.issuanceID()));
+            BEAST_EXPECT(sleIssuance && (*sleIssuance)[~sfIssuerKeyEpoch] == 5u);
+            BEAST_EXPECT(sleIssuance && (*sleIssuance)[~sfAuditorKeyEpoch] == 4u);
+        }
+
+        // A single simultaneous migration brings both mirrors current in one
+        // transaction: issuer mirror epoch 3 -> 5, auditor mirror epoch 2 -> 4.
+        // The previous issuer key is issuerKey3, which is the key Bob's current
+        // (stale) issuer mirror is encrypted under after the earlier issuer
+        // migration, not alice's original key nor any intermediate rotation.
+        Buffer const bothIssuerCipher =
+            ct.mpt.encryptAmount(issuerKey5, amount, generateBlindingFactor());
+        Buffer const bothAuditorCipher =
+            ct.mpt.encryptAmount(auditorKey4, amount, generateBlindingFactor());
+
+        ct.mpt.mirrorUpdate({
+            .account = alice,
+            .holder = bob,
+            .issuerEncryptedAmount = bothIssuerCipher,
+            .auditorEncryptedAmount = bothAuditorCipher,
+        });
+
+        {
+            auto const sle = env.le(keylet::mptoken(ct.mpt.issuanceID(), bob.id()));
+            if (!BEAST_EXPECT(sle))
+                return;
+            BEAST_EXPECT(strHex((*sle)[sfIssuerEncryptedBalance]) == strHex(bothIssuerCipher));
+            BEAST_EXPECT(strHex((*sle)[sfAuditorEncryptedBalance]) == strHex(bothAuditorCipher));
+            BEAST_EXPECT((*sle)[~sfIssuerKeyMirrorEpoch] == 5u);
+            BEAST_EXPECT((*sle)[~sfAuditorKeyMirrorEpoch] == 4u);
+        }
+
+        // Both mirrors are current now, so a second simultaneous migration is
+        // rejected.
+        ct.mpt.mirrorUpdate({
+            .account = alice,
+            .holder = bob,
+            .issuerEncryptedAmount = bothIssuerCipher,
+            .auditorEncryptedAmount = bothAuditorCipher,
+            .err = tecNO_PERMISSION,
+        });
+    }
+
+    void
+    testConfidentialMPTMirrorUpdateMultipleRotationsHolderMode(FeatureBitset features)
+    {
+        testcase("ConfidentialMPTMirrorUpdate holder migrates after several rotations");
+        using namespace test::jtx;
+
+        std::uint64_t const amount = 100;
+
+        Env env{*this, features};
+        Account const alice("alice");
+        Account const bob("bob");
+        Account const auditor("auditor");
+        Account const issuerKey1("issuerKey1");
+        Account const issuerKey2("issuerKey2");
+        Account const issuerKey3("issuerKey3");
+        Account const issuerKey4("issuerKey4");
+        Account const issuerKey5("issuerKey5");
+        Account const auditorKey1("auditorKey1");
+        Account const auditorKey2("auditorKey2");
+        Account const auditorKey3("auditorKey3");
+        Account const auditorKey4("auditorKey4");
+        ConfidentialEnv ct{
+            env,
+            alice,
+            {{.account = bob}},
+            tfMPTCanHoldConfidentialBalance | tfMPTCanTransfer,
+            auditor};
+
+        // In holder self-migration mode the holder submits (account = bob, no
+        // Holder field) and never provides a previous issuer key.
+        // Bob's inbox is canonical zero after the ConfidentialEnv merge.
+
+        // Rotate the issuer key three times: issuer key epoch 0 -> 3.
+        ct.mpt.generateKeyPair(issuerKey1);
+        ct.mpt.generateKeyPair(issuerKey2);
+        ct.mpt.generateKeyPair(issuerKey3);
+        ct.mpt.set({.account = alice, .issuerPubKey = ct.mpt.getPubKey(issuerKey1)});
+        ct.mpt.set({.account = alice, .issuerPubKey = ct.mpt.getPubKey(issuerKey2)});
+        ct.mpt.set({.account = alice, .issuerPubKey = ct.mpt.getPubKey(issuerKey3)});
+
+        // A single holder migration jumps the issuer mirror epoch straight to 3.
+        Buffer const newIssuerCipher =
+            ct.mpt.encryptAmount(issuerKey3, amount, generateBlindingFactor());
+
+        ct.mpt.mirrorUpdate({
+            .account = bob,
+            .issuerEncryptedAmount = newIssuerCipher,
+        });
+
+        {
+            auto const sle = env.le(keylet::mptoken(ct.mpt.issuanceID(), bob.id()));
+            if (!BEAST_EXPECT(sle))
+                return;
+            BEAST_EXPECT(strHex((*sle)[sfIssuerEncryptedBalance]) == strHex(newIssuerCipher));
+            BEAST_EXPECT((*sle)[~sfIssuerKeyMirrorEpoch] == 3u);
+        }
+
+        // The issuer mirror is current, so a second holder issuer migration is
+        // rejected.
+        ct.mpt.mirrorUpdate({
+            .account = bob,
+            .issuerEncryptedAmount = newIssuerCipher,
+            .err = tecNO_PERMISSION,
+        });
+
+        // Rotate the auditor key twice: auditor key epoch 0 -> 2.
+        ct.mpt.generateKeyPair(auditorKey1);
+        ct.mpt.generateKeyPair(auditorKey2);
+        ct.mpt.set({.account = alice, .auditorPubKey = ct.mpt.getPubKey(auditorKey1)});
+        ct.mpt.set({.account = alice, .auditorPubKey = ct.mpt.getPubKey(auditorKey2)});
+
+        // A single holder auditor migration jumps the auditor mirror epoch to 2.
+        Buffer const newAuditorCipher =
+            ct.mpt.encryptAmount(auditorKey2, amount, generateBlindingFactor());
+
+        ct.mpt.mirrorUpdate({
+            .account = bob,
+            .auditorEncryptedAmount = newAuditorCipher,
+        });
+
+        {
+            auto const sle = env.le(keylet::mptoken(ct.mpt.issuanceID(), bob.id()));
+            if (!BEAST_EXPECT(sle))
+                return;
+            BEAST_EXPECT(strHex((*sle)[sfAuditorEncryptedBalance]) == strHex(newAuditorCipher));
+            BEAST_EXPECT((*sle)[~sfAuditorKeyMirrorEpoch] == 2u);
+            // The issuer mirror is unaffected.
+            BEAST_EXPECT(strHex((*sle)[sfIssuerEncryptedBalance]) == strHex(newIssuerCipher));
+            BEAST_EXPECT((*sle)[~sfIssuerKeyMirrorEpoch] == 3u);
+        }
+
+        // The auditor mirror is current, so a second holder auditor migration is
+        // rejected.
+        ct.mpt.mirrorUpdate({
+            .account = bob,
+            .auditorEncryptedAmount = newAuditorCipher,
+            .err = tecNO_PERMISSION,
+        });
+
+        // Rotate both keys together twice: issuer key epoch 3 -> 5, auditor key
+        // epoch 2 -> 4.
+        ct.mpt.generateKeyPair(issuerKey4);
+        ct.mpt.generateKeyPair(issuerKey5);
+        ct.mpt.generateKeyPair(auditorKey3);
+        ct.mpt.generateKeyPair(auditorKey4);
+        ct.mpt.set({
+            .account = alice,
+            .issuerPubKey = ct.mpt.getPubKey(issuerKey4),
+            .auditorPubKey = ct.mpt.getPubKey(auditorKey3),
+        });
+        ct.mpt.set({
+            .account = alice,
+            .issuerPubKey = ct.mpt.getPubKey(issuerKey5),
+            .auditorPubKey = ct.mpt.getPubKey(auditorKey4),
+        });
+
+        // A single holder migration brings both mirrors current: issuer mirror
+        // epoch 3 -> 5, auditor mirror epoch 2 -> 4. Still no previous issuer key.
+        Buffer const bothIssuerCipher =
+            ct.mpt.encryptAmount(issuerKey5, amount, generateBlindingFactor());
+        Buffer const bothAuditorCipher =
+            ct.mpt.encryptAmount(auditorKey4, amount, generateBlindingFactor());
+
+        ct.mpt.mirrorUpdate({
+            .account = bob,
+            .issuerEncryptedAmount = bothIssuerCipher,
+            .auditorEncryptedAmount = bothAuditorCipher,
+        });
+
+        {
+            auto const sle = env.le(keylet::mptoken(ct.mpt.issuanceID(), bob.id()));
+            if (!BEAST_EXPECT(sle))
+                return;
+            BEAST_EXPECT(strHex((*sle)[sfIssuerEncryptedBalance]) == strHex(bothIssuerCipher));
+            BEAST_EXPECT(strHex((*sle)[sfAuditorEncryptedBalance]) == strHex(bothAuditorCipher));
+            BEAST_EXPECT((*sle)[~sfIssuerKeyMirrorEpoch] == 5u);
+            BEAST_EXPECT((*sle)[~sfAuditorKeyMirrorEpoch] == 4u);
+        }
+
+        // Both mirrors are current, so a second holder migration is rejected.
+        ct.mpt.mirrorUpdate({
+            .account = bob,
+            .issuerEncryptedAmount = bothIssuerCipher,
+            .auditorEncryptedAmount = bothAuditorCipher,
+            .err = tecNO_PERMISSION,
+        });
+    }
+
+public:
+    void
+    testMPTokenIssuanceSetWithFeats(FeatureBitset features)
+    {
+        testMPTokenIssuanceSetRotateIssuerKey(features);
+        testMPTokenIssuanceSetRotateBothKeys(features);
+        testMPTokenIssuanceSetRotateAuditorKeyOnly(features);
+        testMPTokenIssuanceSetRegisterAuditorKeyLater(features);
+        testMPTokenIssuanceSetRegisterAuditorKeyLaterWithCOA(features);
+        testMPTokenIssuanceSetAuditorKeyWithoutIssuerKey(features);
+        testMPTokenIssuanceSetRotateWithCOA(features);
+        testMPTokenIssuanceSetKeyEpochAtMax(features);
+    }
+
+    void
+    run() override
+    {
+        using namespace test::jtx;
+        FeatureBitset const all{testableAmendments()};
+
+        testMPTokenIssuanceSetWithFeats(all);
+        testMPTokenIssuanceSetWithFeats(all - featureConfidentialMPTKeyRotation);
+
+        testConfidentialMPTConvertEpoch(all);
+        testConfidentialMPTConvertEpoch(all - featureConfidentialMPTKeyRotation);
+        testConfidentialMPTSendEpoch(all);
+        testConfidentialMPTConvertBackEpoch(all);
+        testConfidentialMPTClawbackEpoch(all);
+
+        testConfidentialMPTMirrorUpdatePreflight(all);
+        testConfidentialMPTMirrorUpdatePreflight(all - featureConfidentialMPTKeyRotation);
+        testConfidentialMPTMirrorUpdatePreflight(all - featureConfidentialTransfer);
+        testConfidentialMPTMirrorUpdatePreclaim(all);
+        testConfidentialMPTMirrorUpdateDoApply(all);
+        testConfidentialMPTMirrorUpdateMultipleRotationsIssuerMode(all);
+        testConfidentialMPTMirrorUpdateMultipleRotationsHolderMode(all);
+    }
+};
+
+BEAST_DEFINE_TESTSUITE(ConfidentialMPTKeyRotation, app, xrpl);
+
+}  // namespace xrpl
diff --git a/src/test/app/ConfidentialTransfer_test.cpp b/src/test/app/ConfidentialTransfer_test.cpp
index 6450ceeb61..9ff9270a7d 100644
--- a/src/test/app/ConfidentialTransfer_test.cpp
+++ b/src/test/app/ConfidentialTransfer_test.cpp
@@ -736,12 +736,8 @@ class ConfidentialTransfer_test : public ConfidentialTransferTestBase
                 .err = temMALFORMED,
             });
 
-            // Cannot set auditor key without issuer key
-            mptAlice.set({
-                .account = alice,
-                .auditorPubKey = mptAlice.getPubKey(alice),
-                .err = temMALFORMED,
-            });
+            // Note: "auditor key without issuer key" (temMALFORMED before
+            // ConfidentialMPTKeyRotation) is covered in ConfidentialMPTKeyRotation_test
 
             // Cannot set Holder and issuer Keys in the same transaction
             mptAlice.set({
@@ -787,9 +783,9 @@ class ConfidentialTransfer_test : public ConfidentialTransferTestBase
             });
         }
 
-        // Cannot update issuer public key once set
+        // Cannot update issuer public key once set (pre-ConfidentialMPTKeyRotation behavior)
         {
-            Env env{*this, features};
+            Env env{*this, features - featureConfidentialMPTKeyRotation};
             Account const alice("alice");
             Account const bob("bob");
             MPTTester mptAlice(env, alice, {.holders = {bob}});
@@ -819,8 +815,9 @@ class ConfidentialTransfer_test : public ConfidentialTransferTestBase
         // Cannot update issuer and auditor public keys once set
         // Note: trying to set only auditor key fails in preflight (temMALFORMED)
         // so we must provide both keys, which fails on issuer key check first
+        // (pre-ConfidentialMPTKeyRotation behavior)
         {
-            Env env{*this, features};
+            Env env{*this, features - featureConfidentialMPTKeyRotation};
             Account const alice("alice");
             Account const bob("bob");
             Account const auditor("auditor");
@@ -900,8 +897,9 @@ class ConfidentialTransfer_test : public ConfidentialTransferTestBase
         }
 
         // Set issuer key first, then auditor key in a separate tx
+        // (pre-ConfidentialMPTKeyRotation behavior)
         {
-            Env env{*this, features};
+            Env env{*this, features - featureConfidentialMPTKeyRotation};
             Account const alice("alice");
             Account const auditor("auditor");
             MPTTester mptAlice(env, alice, {.holders = {}, .auditor = auditor});
@@ -2193,6 +2191,7 @@ class ConfidentialTransfer_test : public ConfidentialTransferTestBase
                 .account = bob,
                 .dest = bob,
                 .amt = 10,
+                .proof = getTrivialSendProofHex(),
                 .err = temMALFORMED,
             });
 
@@ -2899,22 +2898,6 @@ class ConfidentialTransfer_test : public ConfidentialTransferTestBase
         auto& mptAlice = confEnv.mpt;
 
         {
-            // Bob has 60, tries to send 70. Invalid remaining balance.
-            mptAlice.send({
-                .account = bob,
-                .dest = carol,
-                .amt = 70,
-                .err = tecBAD_PROOF,
-            });
-
-            // Bob has 60, tries to send 61. Invalid remaining balance.
-            mptAlice.send({
-                .account = bob,
-                .dest = carol,
-                .amt = 61,
-                .err = tecBAD_PROOF,
-            });
-
             // Bob has 60, sends 60. Remainder is exactly 0. Valid remaining balance.
             mptAlice.send({
                 .account = bob,
@@ -2935,12 +2918,12 @@ class ConfidentialTransfer_test : public ConfidentialTransferTestBase
             });
 
             // Bob has 100, tries to send 2^64-1. Invalid remaining balance.
-            mptAlice.send({
-                .account = bob,
-                .dest = carol,
-                .amt = std::numeric_limits<std::uint64_t>::max(),
-                .err = tecBAD_PROOF,
-            });
+            {
+                ConfidentialSendSetup const setup(
+                    mptAlice, bob, carol, alice, std::numeric_limits<std::uint64_t>::max());
+                auto const forged = getForgedSendProof(mptAlice, env, bob, carol, setup);
+                mptAlice.send(setup.sendArgs(bob, carol, forged, tecBAD_PROOF));
+            }
 
             // Bob sends 1, remaining 99.
             mptAlice.send({
@@ -2949,14 +2932,6 @@ class ConfidentialTransfer_test : public ConfidentialTransferTestBase
                 .amt = 1,
                 .err = tesSUCCESS,
             });
-
-            // Bob sends 100, but only has 99. Invalid remaining balance.
-            mptAlice.send({
-                .account = bob,
-                .dest = carol,
-                .amt = 100,
-                .err = tecBAD_PROOF,
-            });
         }
 
         // send when spending balance is 0 (key registered, inbox merged, but nothing converted)
@@ -2973,18 +2948,13 @@ class ConfidentialTransfer_test : public ConfidentialTransferTestBase
 
             // Trying to send any amount with 0 spending balance must fail:
             // the range proof for < 0 is invalid.
-            mptAlice2.send({
-                .account = bob2,
-                .dest = carol2,
-                .amt = 1,
-                .err = tecBAD_PROOF,
-            });
+            ConfidentialSendSetup const setup(mptAlice2, bob2, carol2, alice2, 1);
+            auto const forged = getForgedSendProof(mptAlice2, env2, bob2, carol2, setup);
+            mptAlice2.send(setup.sendArgs(bob2, carol2, forged, tecBAD_PROOF));
 
             BEAST_EXPECT(
                 mptAlice2.getDecryptedBalance(bob2, MPTTester::holderEncryptedSpending) == 0);
         }
-
-        // todo: test m exceeding range, require using scala and refactor
     }
 
     /* The equality proof library and range proof library do not
@@ -3464,7 +3434,7 @@ class ConfidentialTransfer_test : public ConfidentialTransferTestBase
             uint256 const convertBackContextHash =
                 getConvertBackContextHash(bob.id(), mptAlice.issuanceID(), env.seq(bob), version);
 
-            Buffer const proof = mptAlice.getConvertBackProof(
+            auto const proof = mptAlice.getConvertBackProof(
                 bob,
                 convertBackAmt,
                 convertBackContextHash,
@@ -3474,6 +3444,8 @@ class ConfidentialTransfer_test : public ConfidentialTransferTestBase
                     .encryptedAmt = encryptedSpendingBalance,
                     .blindingFactor = pcBlindingFactor,
                 });
+            if (!BEAST_EXPECT(proof.has_value()))
+                return;
 
             {
                 json::Value jv;
@@ -3485,7 +3457,7 @@ class ConfidentialTransfer_test : public ConfidentialTransferTestBase
                 jv[sfIssuerEncryptedAmount.jsonName] = strHex(convertBackIssuerCiphertext);
                 jv[sfBlindingFactor.jsonName] = strHex(convertBackBlindingFactor);
                 jv[sfBalanceCommitment.jsonName] = strHex(pedersenCommitment);
-                jv[sfZKProof.jsonName] = strHex(proof);
+                jv[sfZKProof.jsonName] = strHex(requireOptionalRef(proof, "Missing proof"));
 
                 env(jv, Ter(tesSUCCESS));
             }
@@ -5285,7 +5257,7 @@ class ConfidentialTransfer_test : public ConfidentialTransferTestBase
                 getConvertBackContextHash(bob, mptAlice.issuanceID(), env.seq(bob), version);
             Buffer const badPedersenCommitment =
                 mptAlice.getPedersenCommitment(1, pcBlindingFactor);
-            Buffer const proof = mptAlice.getConvertBackProof(
+            auto const proof = mptAlice.getConvertBackProof(
                 bob,
                 amt,
                 contextHash,
@@ -5295,6 +5267,8 @@ class ConfidentialTransfer_test : public ConfidentialTransferTestBase
                     .encryptedAmt = encryptedSpendingBalance,
                     .blindingFactor = pcBlindingFactor,
                 });
+            if (!BEAST_EXPECT(proof.has_value()))
+                return;
 
             mptAlice.convertBack({
                 .account = bob,
@@ -5315,7 +5289,7 @@ class ConfidentialTransfer_test : public ConfidentialTransferTestBase
             uint256 const contextHash =
                 getConvertBackContextHash(bob, mptAlice.issuanceID(), env.seq(bob), version);
 
-            Buffer const proof = mptAlice.getConvertBackProof(
+            auto const proof = mptAlice.getConvertBackProof(
                 bob,
                 amt,
                 contextHash,
@@ -5325,6 +5299,8 @@ class ConfidentialTransfer_test : public ConfidentialTransferTestBase
                     .encryptedAmt = encryptedSpendingBalance,
                     .blindingFactor = generateBlindingFactor(),  // wrong blinding factor
                 });
+            if (!BEAST_EXPECT(proof.has_value()))
+                return;
 
             mptAlice.convertBack({
                 .account = bob,
@@ -5339,22 +5315,26 @@ class ConfidentialTransfer_test : public ConfidentialTransferTestBase
         }
 
         // Test 3: Proof generated with wrong balance value.
-        // The proof claims balance=1 but the encrypted spending balance contains
-        // the actual balance. Verification fails because the values don't match.
+        // The sigma proof claims balance=20 but the pedersen commitment and
+        // encrypted spending balance were built for the actual balance (40).
+        // we cannot call mpt_get_convert_back_proof because it has client-side
+        // verification.
         {
             uint256 const contextHash =
                 getConvertBackContextHash(bob, mptAlice.issuanceID(), env.seq(bob), version);
 
-            Buffer const proof = mptAlice.getConvertBackProof(
+            uint64_t constexpr claimedBalance = 20;  // wrong: real balance is 40
+
+            auto const proof = getForgedConvertBackProof(
+                mptAlice,
                 bob,
+                claimedBalance,
+                spendingBalance,
                 amt,
-                contextHash,
-                {
-                    .pedersenCommitment = pedersenCommitment,
-                    .amt = 1,  // wrong balance
-                    .encryptedAmt = encryptedSpendingBalance,
-                    .blindingFactor = pcBlindingFactor,
-                });
+                pedersenCommitment,
+                encryptedSpendingBalance,
+                pcBlindingFactor,
+                contextHash);
 
             mptAlice.convertBack({
                 .account = bob,
@@ -5377,7 +5357,7 @@ class ConfidentialTransfer_test : public ConfidentialTransferTestBase
                 getConvertBackContextHash(bob, mptAlice.issuanceID(), env.seq(bob), version);
             Buffer const badPedersenCommitment =
                 mptAlice.getPedersenCommitment(1, pcBlindingFactor);
-            Buffer const proof = mptAlice.getConvertBackProof(
+            auto const proof = mptAlice.getConvertBackProof(
                 bob,
                 amt,
                 contextHash,
@@ -5387,6 +5367,8 @@ class ConfidentialTransfer_test : public ConfidentialTransferTestBase
                     .encryptedAmt = encryptedSpendingBalance,
                     .blindingFactor = pcBlindingFactor,
                 });
+            if (!BEAST_EXPECT(proof.has_value()))
+                return;
 
             mptAlice.convertBack({
                 .account = bob,
@@ -5407,7 +5389,7 @@ class ConfidentialTransfer_test : public ConfidentialTransferTestBase
         {
             uint256 const badContextHash{1};
 
-            Buffer const proof = mptAlice.getConvertBackProof(
+            auto const proof = mptAlice.getConvertBackProof(
                 bob,
                 amt,
                 badContextHash,  // wrong context hash
@@ -5417,6 +5399,8 @@ class ConfidentialTransfer_test : public ConfidentialTransferTestBase
                     .encryptedAmt = encryptedSpendingBalance,
                     .blindingFactor = pcBlindingFactor,
                 });
+            if (!BEAST_EXPECT(proof.has_value()))
+                return;
 
             mptAlice.convertBack({
                 .account = bob,
@@ -5436,7 +5420,7 @@ class ConfidentialTransfer_test : public ConfidentialTransferTestBase
             uint256 const contextHash =
                 getConvertBackContextHash(bob, mptAlice.issuanceID(), env.seq(bob), version);
 
-            Buffer const proof = mptAlice.getConvertBackProof(
+            auto const proof = mptAlice.getConvertBackProof(
                 bob,
                 amt,
                 contextHash,
@@ -5446,6 +5430,8 @@ class ConfidentialTransfer_test : public ConfidentialTransferTestBase
                     .encryptedAmt = encryptedSpendingBalance,
                     .blindingFactor = pcBlindingFactor,
                 });
+            if (!BEAST_EXPECT(proof.has_value()))
+                return;
 
             mptAlice.convertBack({
                 .account = bob,
@@ -5921,22 +5907,26 @@ class ConfidentialTransfer_test : public ConfidentialTransferTestBase
         // linkage, and that the remaining balance is non-negative.
 
         // Test 1: Proof generated with wrong balance value.
-        // The sigma proof claims balance=1 but the spending balance contains the
-        // actual balance. The compact proof's balance-linkage check fails.
+        // The sigma proof claims balance=20 but the pedersen commitment and
+        // encrypted spending balance were built for the actual balance (40).
+        // we cannot call mpt_get_convert_back_proof because it has client-side
+        // verification.
         {
             uint256 const contextHash =
                 getConvertBackContextHash(bob, mptAlice.issuanceID(), env.seq(bob), version);
 
-            Buffer const proof = mptAlice.getConvertBackProof(
+            uint64_t constexpr claimedBalance = 20;  // wrong: real balance is 40
+
+            auto const proof = getForgedConvertBackProof(
+                mptAlice,
                 bob,
+                claimedBalance,
+                spendingBalance,
                 amt,
-                contextHash,
-                {
-                    .pedersenCommitment = pedersenCommitment,
-                    .amt = 1,  // wrong balance (actual balance is ~40)
-                    .encryptedAmt = encryptedSpendingBalance,
-                    .blindingFactor = pcBlindingFactor,
-                });
+                pedersenCommitment,
+                encryptedSpendingBalance,
+                pcBlindingFactor,
+                contextHash);
 
             mptAlice.convertBack({
                 .account = bob,
@@ -5958,7 +5948,7 @@ class ConfidentialTransfer_test : public ConfidentialTransferTestBase
             uint256 const contextHash =
                 getConvertBackContextHash(bob, mptAlice.issuanceID(), env.seq(bob), version);
 
-            Buffer const proof = mptAlice.getConvertBackProof(
+            auto const proof = mptAlice.getConvertBackProof(
                 bob,
                 amt,
                 contextHash,
@@ -5968,6 +5958,8 @@ class ConfidentialTransfer_test : public ConfidentialTransferTestBase
                     .encryptedAmt = encryptedSpendingBalance,
                     .blindingFactor = generateBlindingFactor(),  // wrong blinding factor
                 });
+            if (!BEAST_EXPECT(proof.has_value()))
+                return;
 
             mptAlice.convertBack({
                 .account = bob,
@@ -5987,7 +5979,7 @@ class ConfidentialTransfer_test : public ConfidentialTransferTestBase
         // makes the proof invalid for this transaction, preventing replay attacks.
         {
             uint256 const badContextHash{1};
-            Buffer const proof = mptAlice.getConvertBackProof(
+            auto const proof = mptAlice.getConvertBackProof(
                 bob,
                 amt,
                 badContextHash,  // wrong context hash
@@ -5997,6 +5989,8 @@ class ConfidentialTransfer_test : public ConfidentialTransferTestBase
                     .encryptedAmt = encryptedSpendingBalance,
                     .blindingFactor = pcBlindingFactor,
                 });
+            if (!BEAST_EXPECT(proof.has_value()))
+                return;
 
             mptAlice.convertBack({
                 .account = bob,
@@ -6016,7 +6010,7 @@ class ConfidentialTransfer_test : public ConfidentialTransferTestBase
             uint256 const contextHash =
                 getConvertBackContextHash(bob, mptAlice.issuanceID(), env.seq(bob), version);
 
-            Buffer const proof = mptAlice.getConvertBackProof(
+            auto const proof = mptAlice.getConvertBackProof(
                 bob,
                 amt,
                 contextHash,
@@ -6026,6 +6020,8 @@ class ConfidentialTransfer_test : public ConfidentialTransferTestBase
                     .encryptedAmt = encryptedSpendingBalance,
                     .blindingFactor = pcBlindingFactor,
                 });
+            if (!BEAST_EXPECT(proof.has_value()))
+                return;
 
             mptAlice.convertBack({
                 .account = bob,
@@ -6075,7 +6071,7 @@ class ConfidentialTransfer_test : public ConfidentialTransferTestBase
             Buffer const bobCiphertext = mptAlice.encryptAmount(bob, amt, blindingFactor);
             auto const version = mptAlice.getMPTokenVersion(bob);
 
-            Buffer const proof = mptAlice.getConvertBackProof(
+            auto const proof = mptAlice.getConvertBackProof(
                 bob,
                 amt,
                 makeContextHash(env, mptAlice, alice, bob, carol, version),
@@ -6086,6 +6082,8 @@ class ConfidentialTransfer_test : public ConfidentialTransferTestBase
                         encryptedSpendingBalance, "Missing encrypted spending balance"),
                     .blindingFactor = pcBlindingFactor,
                 });
+            if (!BEAST_EXPECT(proof.has_value()))
+                return;
 
             mptAlice.convertBack({
                 .account = bob,
@@ -6175,7 +6173,7 @@ class ConfidentialTransfer_test : public ConfidentialTransferTestBase
         uint256 const contextHashA =
             getConvertBackContextHash(bob, mptAlice.issuanceID(), currentSeq, version);
 
-        Buffer const proofA = mptAlice.getConvertBackProof(
+        auto const proofA = mptAlice.getConvertBackProof(
             bob,
             amtA,
             contextHashA,
@@ -6185,6 +6183,8 @@ class ConfidentialTransfer_test : public ConfidentialTransferTestBase
                 .encryptedAmt = encryptedSpendingBalance,
                 .blindingFactor = pcBlindingFactor,
             });
+        if (!BEAST_EXPECT(proofA.has_value()))
+            return;
 
         // Construct Transaction B with Amount m2 = 20 and attach Proof pi
         uint64_t const amtB = 20;
@@ -6256,7 +6256,7 @@ class ConfidentialTransfer_test : public ConfidentialTransferTestBase
         uint256 const oldContextHash =
             getConvertBackContextHash(bob, mptAlice.issuanceID(), currentSeq, versionV);
 
-        Buffer const oldProof = mptAlice.getConvertBackProof(
+        auto const oldProof = mptAlice.getConvertBackProof(
             bob,
             amt,
             oldContextHash,
@@ -6266,6 +6266,8 @@ class ConfidentialTransfer_test : public ConfidentialTransferTestBase
                 .encryptedAmt = encryptedSpendingBalanceV,
                 .blindingFactor = pcBlindingFactor,
             });
+        if (!BEAST_EXPECT(oldProof.has_value()))
+            return;
 
         // Submit and verify failure
         mptAlice.convertBack({
@@ -6328,7 +6330,7 @@ class ConfidentialTransfer_test : public ConfidentialTransferTestBase
         uint256 const contextHash =
             getConvertBackContextHash(bob, mptAlice.issuanceID(), env.seq(bob), currentVersion);
 
-        Buffer const proof = mptAlice.getConvertBackProof(
+        auto const proof = mptAlice.getConvertBackProof(
             bob,
             amt,
             contextHash,
@@ -6338,6 +6340,8 @@ class ConfidentialTransfer_test : public ConfidentialTransferTestBase
                 .encryptedAmt = spendingBalEnc,
                 .blindingFactor = pcBf,
             });
+        if (!BEAST_EXPECT(proof.has_value()))
+            return;
 
         // Submit transaction with Divergent Ciphertexts
         // Holder Ciphertext encrypts 11. Issuer Ciphertext encrypts 10.
@@ -6471,7 +6475,7 @@ class ConfidentialTransfer_test : public ConfidentialTransferTestBase
         uint256 const contextHash =
             getConvertBackContextHash(bob, mptAlice.issuanceID(), env.seq(bob), currentVersion);
 
-        Buffer const proof = mptAlice.getConvertBackProof(
+        auto const proof = mptAlice.getConvertBackProof(
             bob,
             1,
             contextHash,
@@ -6481,6 +6485,8 @@ class ConfidentialTransfer_test : public ConfidentialTransferTestBase
                 .encryptedAmt = underflowedCt,
                 .blindingFactor = pcBf,
             });
+        if (!BEAST_EXPECT(proof.has_value()))
+            return;
 
         mptAlice.convertBack({
             .account = bob,
@@ -7125,6 +7131,18 @@ class ConfidentialTransfer_test : public ConfidentialTransferTestBase
                 mptAlice.confidentialClaw(
                     {.account = alice, .holder = carol, .amt = 15, .fee = expectedFee});
             });
+
+            // Check fee for the mirror update transaction.
+            Account const newIssuerKey("newIssuerKey");
+            mptAlice.generateKeyPair(newIssuerKey);
+            mptAlice.set({.account = alice, .issuerPubKey = mptAlice.getPubKey(newIssuerKey)});
+            checkFee(alice, [&]() {
+                mptAlice.mirrorUpdate(
+                    {.account = alice,
+                     .holder = bob,
+                     .issuerEncryptedAmount = getTrivialCiphertext(),
+                     .fee = expectedFee});
+            });
         }
 
         // test insufficient fee for confidential transactions
@@ -7156,6 +7174,12 @@ class ConfidentialTransfer_test : public ConfidentialTransferTestBase
                  .amt = 1,
                  .fee = baseFee,
                  .err = telINSUF_FEE_P});
+            mptAlice.mirrorUpdate(
+                {.account = alice,
+                 .holder = bob,
+                 .issuerEncryptedAmount = getTrivialCiphertext(),
+                 .fee = baseFee,
+                 .err = telINSUF_FEE_P});
         }
 
         // test excessive fee for confidential transactions
@@ -7743,7 +7767,7 @@ class ConfidentialTransfer_test : public ConfidentialTransferTestBase
             uint256 const convertBackCtxHash =
                 getConvertBackContextHash(bob.id(), mptAlice.issuanceID(), env.seq(bob), version);
 
-            Buffer const convertBackProof = mptAlice.getConvertBackProof(
+            auto const convertBackProof = mptAlice.getConvertBackProof(
                 bob,
                 sendAmount,
                 convertBackCtxHash,
@@ -7753,14 +7777,18 @@ class ConfidentialTransfer_test : public ConfidentialTransferTestBase
                     .encryptedAmt = encryptedSpending,
                     .blindingFactor = pcBlindingFactor,
                 });
+            if (!BEAST_EXPECT(convertBackProof.has_value()))
+                return;
 
             // Resize the convertBack proof to match the expected send proof
             // size so it passes preflight's size check and reaches the actual
             // ZK verification in doApply.
             auto const expectedSendSize = kEcSendProofLength;
             Buffer resizedProof(expectedSendSize);
-            auto const copyLen = std::min(convertBackProof.size(), expectedSendSize);
-            std::memcpy(resizedProof.data(), convertBackProof.data(), copyLen);
+            Buffer const& convertBackProofRef =
+                requireOptionalRef(convertBackProof, "Missing proof");
+            auto const copyLen = std::min(convertBackProofRef.size(), expectedSendSize);
+            std::memcpy(resizedProof.data(), convertBackProofRef.data(), copyLen);
             // Zero-pad the rest (if convertBack proof is shorter)
             if (copyLen < expectedSendSize)
                 std::memset(resizedProof.data() + copyLen, 0, expectedSendSize - copyLen);
diff --git a/src/test/app/Delegate_test.cpp b/src/test/app/Delegate_test.cpp
index 3ff90c2a8f..5f57cfa21b 100644
--- a/src/test/app/Delegate_test.cpp
+++ b/src/test/app/Delegate_test.cpp
@@ -1144,6 +1144,88 @@ class Delegate_test : public beast::unit_test::Suite
             env.require(Balance(gw, aliceUSD(-20)));
         }
 
+        // PaymentBurn must not exceed the balance the account holds. Redeeming past
+        // zero makes the payment engine issue the account's own IOUs, which is a mint.
+        {
+            Env env(*this, features);
+            Account const alice{"alice"};
+            Account const bob{"bob"};
+            Account const gw{"gateway"};
+            auto const gwUSD = gw["USD"];
+            auto const aliceUSD = alice["USD"];
+
+            env.fund(XRP(10000), alice, bob, gw);
+            env.trust(gwUSD(200), alice);
+            env.close();
+
+            env(pay(gw, alice, gwUSD(50)));
+            env.close();
+            env.require(Balance(alice, gwUSD(50)));
+
+            // gw accepts alice-issued USD, so the engine has issuing liquidity
+            // available once the trustline reaches zero.
+            env(trust(gw, aliceUSD(200)));
+            env.close();
+
+            env(delegate::set(alice, bob, {"PaymentBurn"}));
+            env.close();
+
+            if (!features[fixCleanup3_4_0])
+            {
+                // Pre-fixCleanup3_4_0: the balance direction alone authorizes the payment, so it
+                // redeems alice's 50 and then mints 50 alice-issued USD.
+                env(pay(alice, gw, gwUSD(100)), delegate::As(bob));
+                env.require(Balance(alice, gwUSD(-50)));
+                env.require(Balance(gw, aliceUSD(50)));
+            }
+            else
+            {
+                // Post-fixCleanup3_4_0: Rejected because it exceeds what alice holds.
+                env(pay(alice, gw, gwUSD(100)), delegate::As(bob), Ter(terNO_DELEGATE_PERMISSION));
+                env.require(Balance(alice, gwUSD(50)));
+                env.require(Balance(gw, aliceUSD(-50)));
+
+                // Allowed because it is less than what alice holds.
+                env(pay(alice, gw, gwUSD(20)), delegate::As(bob));
+                env.require(Balance(alice, gwUSD(30)));
+                env.close();
+
+                // Exactly what alice holds: allowed, and settles at zero.
+                env(pay(alice, gw, gwUSD(30)), delegate::As(bob));
+                env.require(Balance(alice, gwUSD(0)));
+                env.close();
+
+                // Nothing left to burn: rejected.
+                env(pay(alice, gw, gwUSD(1)), delegate::As(bob), Ter(terNO_DELEGATE_PERMISSION));
+                env.require(Balance(gw, aliceUSD(0)));
+            }
+        }
+
+        // A delegate holding both PaymentMint and PaymentBurn may cross zero.
+        {
+            Env env(*this, features);
+            Account const alice{"alice"};
+            Account const bob{"bob"};
+            Account const gw{"gateway"};
+            auto const gwUSD = gw["USD"];
+            auto const aliceUSD = alice["USD"];
+
+            env.fund(XRP(10000), alice, bob, gw);
+            env.trust(gwUSD(200), alice);
+            env.close();
+
+            env(pay(gw, alice, gwUSD(50)));
+            env(trust(gw, aliceUSD(200)));
+            env.close();
+
+            env(delegate::set(alice, bob, {"PaymentBurn", "PaymentMint"}));
+            env.close();
+
+            env(pay(alice, gw, gwUSD(100)), delegate::As(bob));
+            env.require(Balance(alice, gwUSD(-50)));
+            env.require(Balance(gw, aliceUSD(50)));
+        }
+
         // Test invalid fields or flags not allowed in granular permission template
         {
             Env env(*this, features);
@@ -2756,7 +2838,7 @@ class Delegate_test : public beast::unit_test::Suite
         // DO NOT modify expectedDelegableCount unless all scenarios, including
         // edge cases, have been fully tested and verified.
         // ====================================================================
-        std::size_t const expectedDelegableCount = 56;
+        std::size_t const expectedDelegableCount = 57;
 
         BEAST_EXPECTS(
             delegableCount == expectedDelegableCount,
@@ -2916,6 +2998,7 @@ class Delegate_test : public beast::unit_test::Suite
         testAccountDelete();
         testDelegateTransaction();
         testPaymentGranular(all);
+        testPaymentGranular(all - fixCleanup3_4_0);
         testTrustSetGranular();
         testAccountSetGranular();
         testMPTokenIssuanceSetGranular();
diff --git a/src/test/app/EscrowToken_test.cpp b/src/test/app/EscrowToken_test.cpp
index 72db63bd3f..3a2bc14183 100644
--- a/src/test/app/EscrowToken_test.cpp
+++ b/src/test/app/EscrowToken_test.cpp
@@ -951,6 +951,99 @@ struct EscrowToken_test : public beast::unit_test::Suite
         }
     }
 
+    void
+    testIOUCancelReserveRecycle(FeatureBitset features)
+    {
+        testcase("IOU Cancel Reserve Recycle");
+        using namespace jtx;
+        using namespace std::literals;
+
+        // Escrowing the whole IOU balance lets the owner delete the now-zero
+        // trust line, so cancelling has to re-create it: one object destroyed,
+        // one created, and the reserve requirement unchanged.
+        Env env{*this, features};
+        bool const fixEnabled = env.current()->rules().enabled(fixCleanup3_4_0);
+
+        auto const baseFee = env.current()->fees().base;
+        auto const alice = Account("alice");
+        auto const bob = Account("bob");
+        auto const gw = Account("gw");
+        auto const usd = gw["USD"];
+
+        env.fund(XRP(10'000), alice, bob, gw);
+        env.close();
+
+        env(fset(gw, asfAllowTrustLineLocking));
+        env.close();
+
+        env.trust(usd(10'000), alice);
+        env.close();
+
+        env(pay(gw, alice, usd(10'000)));
+        env.close();
+        BEAST_EXPECT(env.ownerCount(alice) == 1);
+
+        auto const cancelAfter = env.now() + 100s;
+        auto const seq = env.seq(alice);
+        env(escrow::create(alice, bob, usd(10'000)),
+            escrow::kFinishTime(env.now() + 1s),
+            escrow::kCancelTime(cancelAfter),
+            Fee(baseFee));
+        env.close();
+        BEAST_EXPECT(env.ownerCount(alice) == 2);
+
+        auto const trustLineKey = keylet::trustLine(alice.id(), gw.id(), usd.currency);
+        env(trust(alice, usd(0)));
+        env.close();
+        BEAST_EXPECT(!env.current()->exists(trustLineKey));
+        BEAST_EXPECT(env.ownerCount(alice) == 1);
+
+        // Leave alice holding the reserve for exactly one owned object. That
+        // is the escrow now and the re-created trust line after the cancel.
+        auto const oneObject = env.current()->fees().accountReserve(1, 1);
+        auto const twoObjects = env.current()->fees().accountReserve(2, 1);
+        auto const balance = env.balance(alice).value().xrp();
+        auto const feeCushion = baseFee.drops() * 20;
+        env(pay(alice, bob, drops(balance.drops() - oneObject.drops() - feeCushion)));
+        env.close();
+        BEAST_EXPECT(env.balance(alice).value().xrp() >= oneObject);
+        BEAST_EXPECT(env.balance(alice).value().xrp() < twoObjects);
+
+        for (; env.now() < cancelAfter; env.close())
+        {
+        }
+        env.close();
+        env.close();
+
+        auto const expectedResult = fixEnabled ? Ter(tesSUCCESS) : Ter(tecNO_LINE_INSUF_RESERVE);
+        env(escrow::cancel(alice, alice, seq), Fee(baseFee), expectedResult);
+        env.close();
+
+        auto const escrowKey = keylet::escrow(alice.id(), SeqProxy::rawSequence(seq));
+        if (fixEnabled)
+        {
+            BEAST_EXPECT(!env.le(escrowKey));
+            BEAST_EXPECT(env.current()->exists(trustLineKey));
+            BEAST_EXPECT(env.balance(alice, usd) == usd(10'000));
+            BEAST_EXPECT(env.ownerCount(alice) == 1);
+        }
+        else
+        {
+            // The tec keeps the escrow, so one more owner reserve lets the
+            // retry through.
+            BEAST_EXPECT(env.le(escrowKey) != nullptr);
+            BEAST_EXPECT(!env.current()->exists(trustLineKey));
+            BEAST_EXPECT(env.ownerCount(alice) == 1);
+
+            env(pay(bob, alice, drops(twoObjects.drops() - oneObject.drops())));
+            env.close();
+            env(escrow::cancel(alice, alice, seq), Fee(baseFee), Ter(tesSUCCESS));
+            env.close();
+            BEAST_EXPECT(!env.le(escrowKey));
+            BEAST_EXPECT(env.balance(alice, usd) == usd(10'000));
+        }
+    }
+
     void
     testIOUBalances(FeatureBitset features)
     {
@@ -4250,6 +4343,8 @@ public:
         }
         testMPTSplitEscrowTransferFee(all - fixCleanup3_4_0);
         testMPTSplitEscrowTransferFee(all);
+        testIOUCancelReserveRecycle(all - fixCleanup3_4_0);
+        testIOUCancelReserveRecycle(all);
     }
 };
 
diff --git a/src/test/app/LedgerMaster_test.cpp b/src/test/app/LedgerMaster_test.cpp
index ece25356fd..2f2f81bb8a 100644
--- a/src/test/app/LedgerMaster_test.cpp
+++ b/src/test/app/LedgerMaster_test.cpp
@@ -11,14 +11,18 @@
 #include <xrpl/basics/ToString.h>
 #include <xrpl/basics/base_uint.h>
 #include <xrpl/beast/unit_test/suite.h>
+#include <xrpl/core/JobQueue.h>
 #include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/Protocol.h>
 #include <xrpl/protocol/SField.h>
 #include <xrpl/protocol/STObject.h>
 #include <xrpl/protocol/STTx.h>
 
+#include <chrono>
 #include <cstdint>
 #include <memory>
+#include <optional>
+#include <ostream>
 #include <sstream>
 #include <vector>
 
@@ -115,6 +119,96 @@ class LedgerMaster_test : public beast::unit_test::Suite
         }
     }
 
+    // Wait until the SHAMapStore has finished processing the ledger that the
+    // preceding env.close() produced.
+    //
+    // env.close() returns as soon as the ledger_accept RPC returns, but the
+    // validated ledger path -- LedgerMaster::setValidLedger() ->
+    // SHAMapStore::onLedgerClosed() -- runs on a job queue thread. Without
+    // draining the job queue first, the store may not have been handed the
+    // ledger at all, in which case rendezvous() observes working_ == false and
+    // returns immediately, before any work has been done.
+    [[nodiscard]] static bool
+    syncStore(jtx::Env& env)
+    {
+        // Drain the job queue first, so that onLedgerClosed() has run and
+        // working_ is set. Then use the store's timeout overload, so a store
+        // that never finishes fails this test instead of blocking on it.
+        //
+        // Only the second wait is bounded: JobQueue::rendezvous() has no
+        // timeout overload, so a job that never completes hangs here. That is
+        // pre-existing -- ~AppBundle waits on it the same way for every jtx
+        // test -- but it does mean this helper is not hang-proof end to end.
+        env.app().getJobQueue().rendezvous();
+        return env.app().getSHAMapStore().rendezvous(std::chrono::seconds{60});
+    }
+
+    // Bring the SHAMapStore to the point where it has been handed a validated
+    // ledger and initialized lastRotated, and report how many extra ledgers had
+    // to be closed to get it there (normally none). Returns std::nullopt if
+    // syncStore() itself failed.
+    //
+    // syncStore() alone does not guarantee that, because
+    // SHAMapStoreImp::run()'s loop does not use the notification and the
+    // working_ flag safely:
+    //
+    //   * onLedgerClosed() notifies cond_ whether or not run()'s thread is
+    //     parked on it, and run() waits on cond_ without a predicate, so a
+    //     notification that lands while the thread is still starting up --
+    //     before it first reaches that wait -- is lost.
+    //   * run() clears working_ at the top of its loop without checking
+    //     whether newLedger_ is still set, so rendezvous() can report the
+    //     store idle with a validated ledger queued.
+    //
+    // Either way the store ends up parked with work pending, and only another
+    // notification gets it moving again. In a standalone test nothing else
+    // closes ledgers, so that has to come from here: this closes a ledger
+    // rather than polling getLastRotated(), because polling would just time
+    // out. onLedgerClosed() keeps only the most recent ledger in newLedger_,
+    // so the ledger the store picks up -- and therefore lastRotated -- is a
+    // timing detail, which is why the caller derives its expectations from the
+    // value it observes instead of assuming one.
+    //
+    // run() is deliberately left as it is. In production the only effect is
+    // latency: the trigger is validatedSeq >= lastRotated + deleteInterval, so
+    // a lost notification delays rotation to the next validated ledger and
+    // nothing is skipped or accumulated -- starting at 513 instead of 512 does
+    // not matter. Two consequences do follow from leaving it in place, and both
+    // hold today: nothing in production decides anything from working_ or
+    // rendezvous() (rendezvous() has no production callers at all), and a node
+    // whose ledgers only advance on demand -- standalone, driven by
+    // ledger_accept -- can sit on a queued ledger until something closes the
+    // next one, which is exactly the situation this helper is working around.
+    //
+    // So this helper is permanent rather than a stopgap. Working around the
+    // race must not make it invisible, so every extra close is logged. That
+    // keeps how often it is actually hit observable in the unit test output --
+    // which is the only signal left once this testcase stops flaking on it.
+    [[nodiscard]] std::optional<int>
+    initializeStore(jtx::Env& env, int const maxExtraCloses = 3)
+    {
+        auto& store = env.app().getSHAMapStore();
+
+        for (int extraCloses = 0;; ++extraCloses)
+        {
+            if (!syncStore(env))
+                return std::nullopt;
+            if (store.getLastRotated() != 0 || extraCloses == maxExtraCloses)
+            {
+                if (extraCloses != 0)
+                {
+                    log << "initializeStore: the store needed " << extraCloses
+                        << " extra ledger close(s) to pick up a validated ledger. "
+                           "SHAMapStoreImp::run() dropped the notification for the "
+                           "first one; see the comment on initializeStore()."
+                        << std::endl;
+                }
+                return extraCloses;
+            }
+            env.close();
+        }
+    }
+
     void
     testCompleteLedgerRange(FeatureBitset features)
     {
@@ -136,15 +230,42 @@ class LedgerMaster_test : public beast::unit_test::Suite
 
         auto& lm = env.app().getLedgerMaster();
         LedgerIndex minSeq = 2;
-        LedgerIndex maxSeq = env.closed()->header().seq;
         auto& store = env.app().getSHAMapStore();
-        BEAST_EXPECT(store.rendezvous());
+        // Which of the existing complete ledgers the store initializes
+        // lastRotated from is a timing detail; all this test needs is that it is
+        // one of them. Everything below derives from the observed value rather
+        // than assuming a particular one.
+        //
+        // The range check and the initializeStore() one both end the testcase
+        // rather than merely reporting, because lastRotated is the only value
+        // from the store that enters minSeq. A lastRotated of 0 -- the value
+        // getLastRotated() reports until the store has been handed a
+        // validated ledger -- makes minSeq 0 below, and the minSeq - 1 and
+        // minSeq - 2 ranges then underflow to first > last, which aborts a
+        // Debug build inside missingFromCompleteLedgerRange().
+        auto const extraCloses = initializeStore(env);
+        if (!BEAST_EXPECT(extraCloses.has_value()))
+            return;
+        LedgerIndex maxSeq = env.closed()->header().seq;
         LedgerIndex lastRotated = store.getLastRotated();
-        BEAST_EXPECTS(maxSeq == 3, to_string(maxSeq));
-        BEAST_EXPECTS(lm.getCompleteLedgers() == "2-3", lm.getCompleteLedgers());
-        BEAST_EXPECTS(lastRotated == 3, to_string(lastRotated));
+        if (!BEAST_EXPECTS(lastRotated >= minSeq && lastRotated <= maxSeq, to_string(lastRotated)))
+            return;
+        // The BEAST_EXPECT above already returned if this is nullopt, but that
+        // is invisible to clang-tidy's optional model.
+        // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+        BEAST_EXPECTS(maxSeq == 3 + *extraCloses, to_string(maxSeq));
+        std::stringstream initialRange;
+        initialRange << minSeq << "-" << maxSeq;
+        BEAST_EXPECTS(lm.getCompleteLedgers() == initialRange.str(), lm.getCompleteLedgers());
         BEAST_EXPECT(lm.missingFromCompleteLedgerRange(minSeq, maxSeq) == 0);
-        BEAST_EXPECT(minSeq + 1 > maxSeq - 1);
+        // The inner range is empty unless initializeStore() had to close extra
+        // ledgers, and missingFromCompleteLedgerRange() treats first > last as a
+        // precondition violation that aborts a Debug build via UNREACHABLE, so
+        // only check it when it is well formed.
+        if (minSeq + 1 <= maxSeq - 1)
+        {
+            BEAST_EXPECT(lm.missingFromCompleteLedgerRange(minSeq + 1, maxSeq - 1) == 0);
+        }
         BEAST_EXPECT(lm.missingFromCompleteLedgerRange(minSeq - 1, maxSeq + 1) == 2);
         BEAST_EXPECT(lm.missingFromCompleteLedgerRange(minSeq - 2, maxSeq - 2) == 2);
         BEAST_EXPECT(lm.missingFromCompleteLedgerRange(minSeq + 2, maxSeq + 2) == 2);
@@ -157,7 +278,7 @@ class LedgerMaster_test : public beast::unit_test::Suite
                 env(noop(alice));
             }
             env.close();
-            BEAST_EXPECT(store.rendezvous());
+            BEAST_EXPECT(syncStore(env));
 
             ++maxSeq;
 
@@ -173,7 +294,19 @@ class LedgerMaster_test : public beast::unit_test::Suite
             expectedRange << minSeq << "-" << maxSeq;
             BEAST_EXPECTS(lm.getCompleteLedgers() == expectedRange.str(), lm.getCompleteLedgers());
             BEAST_EXPECT(lm.missingFromCompleteLedgerRange(minSeq, maxSeq) == 0);
-            BEAST_EXPECT(lm.missingFromCompleteLedgerRange(minSeq + 1, maxSeq - 1) == 0);
+            // missingFromCompleteLedgerRange() treats first > last as a
+            // precondition violation and aborts a Debug build via UNREACHABLE.
+            // The range can only collapse if this test's model of minSeq /
+            // maxSeq has desynced from the store, so report that as a failure
+            // instead of taking down the whole unit test job.
+            if (minSeq + 1 <= maxSeq - 1)
+            {
+                BEAST_EXPECT(lm.missingFromCompleteLedgerRange(minSeq + 1, maxSeq - 1) == 0);
+            }
+            else
+            {
+                BEAST_EXPECTS(false, to_string(minSeq) + "-" + to_string(maxSeq));
+            }
             BEAST_EXPECT(lm.missingFromCompleteLedgerRange(minSeq - 1, maxSeq + 1) == 2);
             BEAST_EXPECT(lm.missingFromCompleteLedgerRange(minSeq - 2, maxSeq - 2) == 2);
             BEAST_EXPECT(lm.missingFromCompleteLedgerRange(minSeq + 2, maxSeq + 2) == 2);
diff --git a/src/test/app/LedgerNodeHelpers_test.cpp b/src/test/app/LedgerNodeHelpers_test.cpp
index a9e4e3ebfc..76c3e3cc52 100644
--- a/src/test/app/LedgerNodeHelpers_test.cpp
+++ b/src/test/app/LedgerNodeHelpers_test.cpp
@@ -8,6 +8,7 @@
 #include <xrpl/shamap/SHAMapAccountStateLeafNode.h>
 #include <xrpl/shamap/SHAMapInnerNode.h>
 #include <xrpl/shamap/SHAMapItem.h>
+#include <xrpl/shamap/SHAMapNodeID.h>
 #include <xrpl/shamap/SHAMapTreeNode.h>
 
 #include <boost/smart_ptr/intrusive_ptr.hpp>
diff --git a/src/test/app/LedgerReplay_test.cpp b/src/test/app/LedgerReplay_test.cpp
index 0853affab7..bb0c790e37 100644
--- a/src/test/app/LedgerReplay_test.cpp
+++ b/src/test/app/LedgerReplay_test.cpp
@@ -1,5 +1,6 @@
 #include <test/jtx/Account.h>
 #include <test/jtx/Env.h>
+#include <test/jtx/PeerStub.h>
 #include <test/jtx/amount.h>
 #include <test/jtx/batch.h>
 #include <test/jtx/envconfig.h>
@@ -21,7 +22,6 @@
 #include <xrpld/app/ledger/detail/LedgerReplayMsgHandler.h>
 #include <xrpld/app/ledger/detail/SkipListAcquire.h>
 #include <xrpld/core/Config.h>
-#include <xrpld/overlay/Message.h>
 #include <xrpld/overlay/Peer.h>
 #include <xrpld/overlay/PeerSet.h>
 #include <xrpld/overlay/detail/Handshake.h>
@@ -29,19 +29,14 @@
 #include <xrpl/basics/Slice.h>
 #include <xrpl/basics/base_uint.h>
 #include <xrpl/beast/net/IPAddress.h>
-#include <xrpl/beast/net/IPEndpoint.h>
 #include <xrpl/beast/unit_test/suite.h>
 #include <xrpl/beast/utility/Journal.h>
 #include <xrpl/json/json_value.h>
 #include <xrpl/ledger/ApplyView.h>
 #include <xrpl/protocol/Indexes.h>
-#include <xrpl/protocol/KeyType.h>
-#include <xrpl/protocol/PublicKey.h>
 #include <xrpl/protocol/RippleLedgerHash.h>
-#include <xrpl/protocol/SecretKey.h>
 #include <xrpl/protocol/TER.h>
 #include <xrpl/protocol/TxFlags.h>
-#include <xrpl/resource/Charge.h>
 #include <xrpl/server/Handoff.h>
 #include <xrpl/shamap/SHAMapItem.h>
 
@@ -268,136 +263,33 @@ enum class PeerFeature {
  * Simulate a network peer.
  * Depending on the configured PeerFeature,
  * it either supports the ProtocolFeature::LedgerReplay or not
+ *
+ * `PeerStub` supplies the rest of the `Peer` interface as no-ops.
  */
-class TestPeer : public Peer
+class TestPeer : public PeerStub
 {
 public:
-    TestPeer(bool enableLedgerReplay)
-        : ledgerReplayEnabled_(enableLedgerReplay)
-        , nodePublicKey_(derivePublicKey(KeyType::Ed25519, randomSecretKey()))
+    // Arbitrary but fixed: the replay code only compares ids.
+    explicit TestPeer(bool enableLedgerReplay)
+        : PeerStub(1234), ledgerReplayEnabled_(enableLedgerReplay)
     {
     }
 
-    void
-    send(std::shared_ptr<Message> const& m) override
-    {
-    }
-    [[nodiscard]] beast::ip::Endpoint
-    getRemoteAddress() const override
-    {
-        return {};
-    }
-    void
-    charge(resource::Charge const& fee, std::string const& context = {}) override
-    {
-    }
-    [[nodiscard]] id_t
-    id() const override
-    {
-        return 1234;
-    }
-    [[nodiscard]] bool
-    cluster() const override
-    {
-        return false;
-    }
-    [[nodiscard]] bool
-    isHighLatency() const override
-    {
-        return false;
-    }
-    [[nodiscard]] int
-    getScore(bool) const override
-    {
-        return 0;
-    }
-    [[nodiscard]] PublicKey const&
-    getNodePublic() const override
-    {
-        return nodePublicKey_;
-    }
-    json::Value
-    json() override
-    {
-        return {};
-    }
     [[nodiscard]] bool
     supportsFeature(ProtocolFeature f) const override
     {
         return f == ProtocolFeature::LedgerReplay && ledgerReplayEnabled_;
     }
-    [[nodiscard]] std::optional<std::size_t>
-    publisherListSequence(PublicKey const&) const override
-    {
-        return {};
-    }
-    void
-    setPublisherListSequence(PublicKey const&, std::size_t const) override
-    {
-    }
-    [[nodiscard]] uint256
-    getClosedLedgerHash() const override
-    {
-        static uint256 const kHash{};
-        return kHash;
-    }
+
+    // The replay code only asks peers that already have the ledger.
     [[nodiscard]] bool
-    hasLedger(uint256 const& hash, std::uint32_t seq) const override
+    hasLedger(uint256 const&, std::uint32_t) const override
     {
         return true;
     }
-    void
-    ledgerRange(std::uint32_t& minSeq, std::uint32_t& maxSeq) const override
-    {
-    }
-    [[nodiscard]] bool
-    hasTxSet(uint256 const& hash) const override
-    {
-        return false;
-    }
-    void
-    cycleStatus() override
-    {
-    }
-    bool
-    hasRange(std::uint32_t uMin, std::uint32_t uMax) override
-    {
-        return false;
-    }
-    [[nodiscard]] bool
-    compressionEnabled() const override
-    {
-        return false;
-    }
-    void
-    sendTxQueue() override
-    {
-    }
-    void
-    addTxQueue(uint256 const&) override
-    {
-    }
-    void
-    removeTxQueue(uint256 const&) override
-    {
-    }
-    [[nodiscard]] bool
-    txReduceRelayEnabled() const override
-    {
-        return false;
-    }
 
-    [[nodiscard]] std::string const&
-    fingerprint() const override
-    {
-        return fingerprint_;
-    }
-
-    // NOLINTBEGIN(readability-identifier-naming)
-    std::string fingerprint_;
+private:
     bool ledgerReplayEnabled_;
-    PublicKey nodePublicKey_;
-    // NOLINTEND(readability-identifier-naming)
 };
 
 enum class PeerSetBehavior {
diff --git a/src/test/app/Path_test.cpp b/src/test/app/Path_test.cpp
index cd61668b03..5ecad1a420 100644
--- a/src/test/app/Path_test.cpp
+++ b/src/test/app/Path_test.cpp
@@ -25,6 +25,7 @@
 #include <xrpld/rpc/detail/Tuning.h>
 
 #include <xrpl/basics/base_uint.h>
+#include <xrpl/basics/hardened_hash.h>
 #include <xrpl/beast/unit_test/suite.h>
 #include <xrpl/core/Job.h>
 #include <xrpl/core/JobQueue.h>
@@ -46,16 +47,20 @@
 #include <xrpl/resource/Consumer.h>
 #include <xrpl/resource/Fees.h>
 
+#include <algorithm>
 #include <chrono>
 #include <condition_variable>
+#include <cstddef>
 #include <cstdint>
 #include <memory>
 #include <mutex>
 #include <optional>
+#include <set>
 #include <string>
 #include <string_view>
 #include <tuple>
 #include <utility>
+#include <vector>
 
 namespace xrpl::test {
 
@@ -1943,7 +1948,7 @@ public:
         static constexpr AccountID kAccountID7{kAccount7};
         static constexpr AccountID kAccountID8{kAccount8};
 
-        auto ps = STPathSet{};
+        auto ps = STPathSet{STPathSet::DeduplicationTag{}};
 
         auto createPathElements = [](auto const& account1, auto const& account2) {
             auto base = STPath{};
@@ -2017,6 +2022,215 @@ public:
         BEAST_EXPECT(ps.size() == 6);
     }
 
+    void
+    testPushBackDeduplication()
+    {
+        testcase("STPathSet::pushBack/emplaceBack deduplication");
+
+        // pushBack and emplaceBack reject duplicates on a set built with the
+        // DeduplicationTag, and append unconditionally without it.  Both
+        // report which happened.  The unconditional case is the one the wire
+        // and JSON paths rely on: collapsing duplicates there would change the
+        // signed content of a transaction.
+
+        static constexpr AccountID kAccountID1{"A3F19C7B2E5D08146FB93A7C0E2D5184BC6F3A09"};
+        static constexpr AccountID kAccountID2{"1D7E4B90C2A6F3851E0B9D47A2C5F8136E0A4B7D"};
+        static constexpr AccountID kAccountID3{"F08C36A1D95E27B40CA1F63E8D204B7950E1C3A6"};
+
+        auto makePath = [](AccountID const& account) {
+            auto p = STPath{};
+            p.pushBack(STPathElement{STPathElement::TypeAccount, account, xrpCurrency(), account});
+            return p;
+        };
+
+        auto const first = makePath(kAccountID1);
+        auto const second = makePath(kAccountID2);
+        auto const third = makePath(kAccountID3);
+
+        // Deduplicating set: the second insert of a path is rejected, and the
+        // rejection is reported rather than silently swallowed.
+        {
+            auto ps = STPathSet{STPathSet::DeduplicationTag{}};
+
+            BEAST_EXPECT(ps.pushBack(first));
+            BEAST_EXPECT(ps.size() == 1);
+
+            BEAST_EXPECT(!ps.pushBack(first));
+            BEAST_EXPECT(ps.size() == 1);
+
+            // emplaceBack sees paths registered by pushBack...
+            BEAST_EXPECT(!ps.emplaceBack(first));
+            BEAST_EXPECT(ps.size() == 1);
+
+            BEAST_EXPECT(ps.emplaceBack(second));
+            BEAST_EXPECT(ps.size() == 2);
+
+            // ...and pushBack sees paths registered by emplaceBack.
+            BEAST_EXPECT(!ps.pushBack(second));
+            BEAST_EXPECT(ps.size() == 2);
+
+            // emplaceBack's forwarding form registers the same way.
+            BEAST_EXPECT(ps.emplaceBack(std::vector<STPathElement>{third.front()}));
+            BEAST_EXPECT(ps.size() == 3);
+            BEAST_EXPECT(!ps.pushBack(third));
+            BEAST_EXPECT(ps.size() == 3);
+
+            // A rejected duplicate must not disturb what is already stored.
+            BEAST_EXPECT(ps[0] == first);
+            BEAST_EXPECT(ps[1] == second);
+            BEAST_EXPECT(ps[2] == third);
+        }
+
+        // Without the tag there is no index, so duplicates are appended and
+        // both methods report success every time.
+        {
+            auto plain = STPathSet{};
+            BEAST_EXPECT(plain.pushBack(first));
+            BEAST_EXPECT(plain.pushBack(first));
+            BEAST_EXPECT(plain.emplaceBack(first));
+            BEAST_EXPECT(plain.size() == 3);
+
+            auto named = STPathSet{sfPaths};
+            BEAST_EXPECT(named.pushBack(first));
+            BEAST_EXPECT(named.pushBack(first));
+            BEAST_EXPECT(named.size() == 2);
+        }
+    }
+
+    void
+    testPathHashInjectivity()
+    {
+        testcase("STPathElement hash injectivity");
+
+        auto const zeroCurrency =
+            STPathElement{AccountID{}, PathAsset{Currency{}}, AccountID{}, true};
+        auto const zeroMPT = STPathElement{AccountID{}, PathAsset{MPTID{}}, AccountID{}, true};
+
+        BEAST_EXPECT(!(zeroCurrency == zeroMPT));
+
+        auto path = [](std::vector<STPathElement> const& elements) {
+            auto p = STPath{};
+            for (auto const& element : elements)
+                p.pushBack(element);
+            return p;
+        };
+
+        auto const currencyFirst = path({zeroCurrency, zeroMPT});
+        auto const mptFirst = path({zeroMPT, zeroCurrency});
+
+        BEAST_EXPECT(!(currencyFirst == mptFirst));
+
+        auto const hasher = HardenedHash<>{};
+        BEAST_EXPECT(hasher(currencyFirst) != hasher(mptFirst));
+
+        auto mask = std::vector<int>{0, 0, 1, 1};
+        auto hashes = std::set<std::size_t>{};
+        auto orderings = 0uz;
+        do
+        {
+            auto elements = std::vector<STPathElement>{};
+            for (auto const isMPT : mask)
+            {
+                elements.push_back(isMPT != 0 ? zeroMPT : zeroCurrency);
+            }
+            hashes.insert(hasher(path(elements)));
+            ++orderings;
+        } while (std::ranges::next_permutation(mask).found);
+
+        BEAST_EXPECT(orderings == 6);
+        BEAST_EXPECT(hashes.size() == orderings);
+
+        auto seen = hardened_hash_set<STPath>{};
+        for (auto const& p : {currencyFirst, mptFirst})
+        {
+            seen.emplace(p);
+        }
+        BEAST_EXPECT(seen.size() == 2);
+
+        // The other half of the invariant: equal elements must hash equally.
+        // STPathElement::operator== masks type_ down to the TypeAccount bit, so
+        // elements whose remaining type bits differ still compare equal --
+        // hashing the full type_ would give them distinct hashes and silently
+        // defeat deduplication.
+        static constexpr AccountID kAccount{"A3F19C7B2E5D08146FB93A7C0E2D5184BC6F3A09"};
+        static constexpr AccountID kIssuer{"1D7E4B90C2A6F3851E0B9D47A2C5F8136E0A4B7D"};
+
+        auto const equivalent = std::vector<std::pair<STPathElement, STPathElement>>{
+            // forceAsset toggles TypeCurrency on an XRP asset.
+            {STPathElement{kAccount, PathAsset{xrpCurrency()}, kIssuer, true},
+             STPathElement{kAccount, PathAsset{xrpCurrency()}, kIssuer, false}},
+            // An explicit type mask vs. one derived from the populated fields.
+            {STPathElement{STPathElement::TypeAccount, kAccount, xrpCurrency(), kIssuer},
+             STPathElement{kAccount, PathAsset{xrpCurrency()}, kIssuer, false}},
+        };
+
+        for (auto const& [lhs, rhs] : equivalent)
+        {
+            BEAST_EXPECT(lhs.getNodeType() != rhs.getNodeType());
+            BEAST_EXPECT(lhs == rhs);
+
+            auto const lhsPath = path({lhs});
+            auto const rhsPath = path({rhs});
+            BEAST_EXPECT(hasher(lhsPath) == hasher(rhsPath));
+
+            auto equal = hardened_hash_set<STPath>{};
+            equal.emplace(lhsPath);
+            equal.emplace(rhsPath);
+            BEAST_EXPECT(equal.size() == 1);
+        }
+    }
+
+    void
+    testDeserializationPreservesDuplicates()
+    {
+        testcase("STPathSet deserialization preserves duplicate paths");
+
+        // The `Paths` field of a signed transaction must round-trip byte for
+        // byte.  The deduplication index exists solely for pathfinding, so the
+        // deserializing constructor must never engage it: collapsing duplicates
+        // on parse would silently change the signed content of a transaction.
+
+        static constexpr AccountID kAccountID1{"A3F19C7B2E5D08146FB93A7C0E2D5184BC6F3A09"};
+        static constexpr AccountID kAccountID2{"1D7E4B90C2A6F3851E0B9D47A2C5F8136E0A4B7D"};
+
+        auto const element =
+            STPathElement{kAccountID1, PathAsset{xrpCurrency()}, kAccountID2, true};
+
+        auto path = STPath{};
+        path.pushBack(element);
+
+        static constexpr auto kDuplicates = 64uz;
+
+        auto original = STPathSet{sfPaths};
+        for (auto i = 0uz; i < kDuplicates; ++i)
+        {
+            original.pushBack(path);
+        }
+
+        // No index was requested, so nothing is deduplicated on the way in.
+        BEAST_EXPECT(original.size() == kDuplicates);
+
+        auto s = Serializer{};
+        original.add(s);
+
+        auto sit = SerialIter{s.slice()};
+        auto const parsed = STPathSet{sit, sfPaths};
+
+        // The duplicates survive the round trip...
+        BEAST_EXPECT(parsed.size() == kDuplicates);
+        BEAST_EXPECT(parsed.isEquivalent(original));
+
+        // ...and re-serializing reproduces the original bytes exactly.
+        auto serialized = Serializer{};
+        parsed.add(serialized);
+        BEAST_EXPECT(serialized.getData() == s.getData());
+
+        // A parsed set holds no index, so appending to it stays append-only.
+        auto appended = parsed;
+        appended.pushBack(path);
+        BEAST_EXPECT(appended.size() == kDuplicates + 1);
+    }
+
     void
     run() override
     {
@@ -2031,6 +2245,9 @@ public:
         issuesPathNegativeRippleClientIssue23Larger();
         qualityPathsQualitySetAndTest();
         testAssembleAddDeduplication();
+        testPushBackDeduplication();
+        testPathHashInjectivity();
+        testDeserializationPreservesDuplicates();
         trustAutoClearTrustNormalClear();
         trustAutoClearTrustAutoClear();
         norippleCombinations();
diff --git a/src/test/app/PermissionedDEX_test.cpp b/src/test/app/PermissionedDEX_test.cpp
index ddb56a1480..fbe942948d 100644
--- a/src/test/app/PermissionedDEX_test.cpp
+++ b/src/test/app/PermissionedDEX_test.cpp
@@ -21,6 +21,7 @@
 #include <test/jtx/trust.h>
 #include <test/jtx/txflags.h>
 
+#include <xrpl/basics/Slice.h>
 #include <xrpl/basics/base_uint.h>
 #include <xrpl/beast/unit_test/suite.h>
 #include <xrpl/beast/utility/Journal.h>
@@ -179,7 +180,10 @@ class PermissionedDEX_test : public beast::unit_test::Suite
     void
     testOfferCreate(FeatureBitset features)
     {
-        testcase("OfferCreate");
+        bool const fixEnabled = features[fixCleanup3_4_0];
+
+        testcase << "OfferCreate"
+                 << (fixEnabled ? " (Cleanup3_4_0 enabled)" : " (Cleanup3_4_0 disabled)");
 
         // test preflight
         {
@@ -273,8 +277,10 @@ class PermissionedDEX_test : public beast::unit_test::Suite
             // time advance
             env.close(std::chrono::seconds(20));
 
-            // devin cannot create offer with expired cred
-            env(offer(devin, XRP(10), USD(10)), Domain(domainID), Ter(tecNO_PERMISSION));
+            // Devin cannot create offer with expired cred. After fixCleanup3_4_0,
+            // doApply deletes the expired credential SLE and returns tecEXPIRED.
+            TER const expectedExpiredCredTer = fixEnabled ? tecEXPIRED : tecNO_PERMISSION;
+            env(offer(devin, XRP(10), USD(10)), Domain(domainID), Ter(expectedExpiredCredTer));
             env.close();
         }
 
@@ -1510,7 +1516,9 @@ class PermissionedDEX_test : public beast::unit_test::Suite
         env.close(std::chrono::seconds(100));
 
         // Confirm devin can no longer create domain offers.
-        env(offer(devin, XRP(1), USD(1)), Domain(domainID), Ter(tecNO_PERMISSION));
+        // After fixCleanup3_4_0, OfferCreate deletes the expired credential and
+        // returns tecEXPIRED (covered in depth by testExpiredCredentialCleanup).
+        env(offer(devin, XRP(1), USD(1)), Domain(domainID), Ter(tecEXPIRED));
         env.close();
 
         // The hybrid offer must still exist in the open book after expiry.
@@ -1635,6 +1643,202 @@ class PermissionedDEX_test : public beast::unit_test::Suite
         BEAST_EXPECT(!offerExists(env, bob, carolOfferSeq));
     }
 
+    void
+    testExpiredCredentialCleanup(FeatureBitset features)
+    {
+        bool const fixEnabled = features[fixCleanup3_4_0];
+
+        testcase << "Expired credential cleanup"
+                 << (fixEnabled ? " (Cleanup3_4_0 enabled)" : " (Cleanup3_4_0 disabled)");
+
+        TER const expectedExpiredCredTer = fixEnabled ? tecEXPIRED : tecNO_PERMISSION;
+
+        auto const fundAccount =
+            [](Env& env, Account const& account, Account const& gw, IOU const& usd) {
+                env.fund(XRP(1000), account);
+                env.close();
+                env.trust(usd(1000), account);
+                env.close();
+                env(pay(gw, account, usd(100)));
+                env.close();
+            };
+
+        auto const fundDevin = [&](Env& env, Account const& gw, IOU const& usd) {
+            Account const devin("devin");
+            fundAccount(env, devin, gw, usd);
+            return devin;
+        };
+
+        auto const createExpiringCredential = [](Env& env,
+                                                 Account const& subject,
+                                                 Account const& issuer,
+                                                 std::string const& credType) {
+            auto jv = credentials::create(subject, issuer, credType);
+            uint32_t const t = env.current()->header().parentCloseTime.time_since_epoch().count();
+            jv[sfExpiration.jsonName] = t + 20;
+            env(jv);
+            env(credentials::accept(subject, issuer, credType));
+            env.close();
+
+            return keylet::credential(subject.id(), issuer.id(), makeSlice(credType));
+        };
+
+        auto const expectExpiredCredentialState = [&](Env const& env, Keylet const& credKey) {
+            if (fixEnabled)
+            {
+                BEAST_EXPECT(!env.le(credKey));
+            }
+            else
+            {
+                BEAST_EXPECT(env.le(credKey));
+            }
+        };
+
+        // A payment referencing a non-existent domain is rejected in preclaim.
+        {
+            Env env(*this, features);
+            auto const& [gw, domainOwner, alice, bob, carol, USD, domainID, credType] =
+                PermissionedDEX(env);
+
+            uint256 const badDomain{
+                "F10D0CC9A0F9A3CBF585B80BE09A186483668FDBDD39AA7E3370F3649CE134"
+                "E5"};
+
+            env(offer(bob, XRP(10), USD(10)), Domain(domainID));
+            env.close();
+
+            env(pay(alice, bob, USD(10)),
+                Path(~USD),
+                Sendmax(XRP(10)),
+                Domain(badDomain),
+                Ter(tecNO_PERMISSION));
+            env.close();
+        }
+
+        // OfferCreate with an expired credential.
+        {
+            Env env(*this, features);
+            auto const& [gw, domainOwner, alice, bob, carol, USD, domainID, credType] =
+                PermissionedDEX(env);
+
+            Account const devin = fundDevin(env, gw, USD);
+            auto const credKey = createExpiringCredential(env, devin, domainOwner, credType);
+            BEAST_EXPECT(env.le(credKey));  // credential exists before expiry
+
+            env.close(std::chrono::seconds(20));
+
+            env(offer(devin, XRP(10), USD(10)), Domain(domainID), Ter(expectedExpiredCredTer));
+            env.close();
+
+            expectExpiredCredentialState(env, credKey);
+        }
+
+        // Payment where the sender's credential is expired.
+        {
+            Env env(*this, features);
+            auto const& [gw, domainOwner, alice, bob, carol, USD, domainID, credType] =
+                PermissionedDEX(env);
+
+            Account const devin = fundDevin(env, gw, USD);
+            auto const credKey = createExpiringCredential(env, devin, domainOwner, credType);
+
+            auto const bobOfferSeq{env.seq(bob)};
+            auto const bobCredKey =
+                keylet::credential(bob.id(), domainOwner.id(), makeSlice(credType));
+            env(offer(bob, XRP(10), USD(10)), Domain(domainID));
+            env.close();
+
+            BEAST_EXPECT(env.le(credKey));
+            BEAST_EXPECT(env.le(bobCredKey));
+            BEAST_EXPECT(offerExists(env, bob, bobOfferSeq));
+
+            env.close(std::chrono::seconds(20));
+
+            env(pay(devin, alice, USD(10)),
+                Path(~USD),
+                Sendmax(XRP(10)),
+                Domain(domainID),
+                Ter(expectedExpiredCredTer));
+            env.close();
+
+            expectExpiredCredentialState(env, credKey);
+            BEAST_EXPECT(env.le(bobCredKey));
+            BEAST_EXPECT(offerExists(env, bob, bobOfferSeq));
+        }
+
+        // Payment where the destination's credential is expired.
+        {
+            Env env(*this, features);
+            auto const& [gw, domainOwner, alice, bob, carol, USD, domainID, credType] =
+                PermissionedDEX(env);
+
+            Account const devin = fundDevin(env, gw, USD);
+            auto const credKey = createExpiringCredential(env, devin, domainOwner, credType);
+
+            auto const bobOfferSeq{env.seq(bob)};
+            auto const bobCredKey =
+                keylet::credential(bob.id(), domainOwner.id(), makeSlice(credType));
+            env(offer(bob, XRP(10), USD(10)), Domain(domainID));
+            env.close();
+
+            BEAST_EXPECT(env.le(credKey));
+            BEAST_EXPECT(env.le(bobCredKey));
+            BEAST_EXPECT(offerExists(env, bob, bobOfferSeq));
+
+            env.close(std::chrono::seconds(20));
+
+            env(pay(alice, devin, USD(10)),
+                Path(~USD),
+                Sendmax(XRP(10)),
+                Domain(domainID),
+                Ter(expectedExpiredCredTer));
+            env.close();
+
+            expectExpiredCredentialState(env, credKey);
+            BEAST_EXPECT(env.le(bobCredKey));
+            BEAST_EXPECT(offerExists(env, bob, bobOfferSeq));
+        }
+
+        // Payment where both sender and destination credentials are expired.
+        {
+            Env env(*this, features);
+            auto const& [gw, domainOwner, alice, bob, carol, USD, domainID, credType] =
+                PermissionedDEX(env);
+
+            Account const devin = fundDevin(env, gw, USD);
+            Account const erin("erin");
+            fundAccount(env, erin, gw, USD);
+
+            auto const devinCredKey = createExpiringCredential(env, devin, domainOwner, credType);
+            auto const erinCredKey = createExpiringCredential(env, erin, domainOwner, credType);
+
+            auto const bobOfferSeq{env.seq(bob)};
+            auto const bobCredKey =
+                keylet::credential(bob.id(), domainOwner.id(), makeSlice(credType));
+            env(offer(bob, XRP(10), USD(10)), Domain(domainID));
+            env.close();
+
+            BEAST_EXPECT(env.le(devinCredKey));
+            BEAST_EXPECT(env.le(erinCredKey));
+            BEAST_EXPECT(env.le(bobCredKey));
+            BEAST_EXPECT(offerExists(env, bob, bobOfferSeq));
+
+            env.close(std::chrono::seconds(20));
+
+            env(pay(devin, erin, USD(10)),
+                Path(~USD),
+                Sendmax(XRP(10)),
+                Domain(domainID),
+                Ter(expectedExpiredCredTer));
+            env.close();
+
+            expectExpiredCredentialState(env, devinCredKey);
+            expectExpiredCredentialState(env, erinCredKey);
+            BEAST_EXPECT(env.le(bobCredKey));
+            BEAST_EXPECT(offerExists(env, bob, bobOfferSeq));
+        }
+    }
+
     void
     testHybridMalformedOffer(FeatureBitset features)
     {
@@ -2209,6 +2413,7 @@ public:
         // Test domain offer (w/o hybrid)
         testOfferCreate(all);
         testOfferCreate(all - fixCleanup3_2_0);
+        testOfferCreate(all - fixCleanup3_4_0);
         testPayment(all);
         testPayment(all - fixCleanup3_2_0);
         testBookStep(all);
@@ -2219,6 +2424,8 @@ public:
         testAmmQualityNotLeaked(all);
         testAmmQualityNotLeaked(all - fixCleanup3_3_0);
         testAutoBridge(all);
+        testExpiredCredentialCleanup(all);
+        testExpiredCredentialCleanup(all - fixCleanup3_4_0);
 
         // Test hybrid offers
         testHybridOfferCreate(all);
diff --git a/src/test/app/SHAMapStore_test.cpp b/src/test/app/SHAMapStore_test.cpp
index 0a8c51c56a..4a69ac17f9 100644
--- a/src/test/app/SHAMapStore_test.cpp
+++ b/src/test/app/SHAMapStore_test.cpp
@@ -1,3 +1,4 @@
+#include <test/jtx/Account.h>
 #include <test/jtx/Env.h>
 #include <test/jtx/amount.h>
 #include <test/jtx/envconfig.h>
@@ -11,10 +12,13 @@
 #include <xrpld/core/Config.h>
 
 #include <xrpl/basics/ByteUtilities.h>
+#include <xrpl/basics/Log.h>
 #include <xrpl/basics/base_uint.h>
 #include <xrpl/beast/unit_test/suite.h>
+#include <xrpl/beast/utility/Journal.h>
 #include <xrpl/config/BasicConfig.h>
 #include <xrpl/config/Constants.h>
+#include <xrpl/core/JobQueue.h>
 #include <xrpl/json/json_value.h>
 #include <xrpl/nodestore/Backend.h>
 #include <xrpl/nodestore/Manager.h>
@@ -26,14 +30,21 @@
 #include <xrpl/protocol/jss.h>
 #include <xrpl/server/NetworkOPs.h>
 
+#include <algorithm>
 #include <atomic>
+#include <chrono>
+#include <condition_variable>
 #include <cstddef>
 #include <cstdint>
+#include <exception>
 #include <filesystem>
+#include <functional>
 #include <limits>
 #include <map>
 #include <memory>
+#include <mutex>
 #include <optional>
+#include <ostream>
 #include <sstream>
 #include <string>
 #include <thread>
@@ -44,7 +55,170 @@ namespace xrpl::test {
 
 class SHAMapStore_test : public beast::unit_test::Suite
 {
-    static auto const kDeleteInterval = 8;
+    static constexpr int kDeleteInterval = 8;
+
+    // Mirrors SHAMapStoreImp::kMinimumDeletionIntervalSa, the floor that
+    // online_delete is held to in standalone mode. Note that the
+    // max_waiting_ledgers floor is derived from this minimum rather than from
+    // the configured interval -- SHAMapStoreImp.cpp computes it as
+    // minInterval / 4 -- so both constants below stay put if kDeleteInterval is
+    // ever raised.
+    static constexpr int kMinDeleteInterval = 8;
+    static constexpr int kMinWaitingLedgers = kMinDeleteInterval / 4;
+    static_assert(kDeleteInterval >= kMinDeleteInterval);
+
+    // The two wait durations healthWait() can choose from, spelled as they
+    // appear in its log message. onlineDelete() below sets
+    // recovery_wait_seconds to 1, so the full wait is 1000ms and the shortened
+    // wait is a tenth of that. Note that "Waiting 1000ms" does not contain
+    // "Waiting 100ms", so the two are distinguishable by substring.
+    static constexpr char const* kFullWait = "Waiting 1000ms for node to stabilize";
+    static constexpr char const* kShortWait = "Waiting 100ms for node to stabilize";
+
+    // Distinctive fragments of the other messages the tests below key off. Each
+    // is unique among everything SHAMapStoreImp logs, so a substring match
+    // identifies the message unambiguously.
+    //
+    // kRotating is logged once run() has committed to a rotation, immediately
+    // after the health check that gates it, and kFinished once a rotation has
+    // run to completion. kExpired is logged by healthWait() when the circuit
+    // breaker trips.
+    static constexpr char const* kRotating = "rotating";
+    static constexpr char const* kFinished = "finished rotation";
+    static constexpr char const* kExpired = "unable to make progress";
+
+    // A Logs implementation that records every message the store's own
+    // partition emits, keeping each message's severity alongside its text, and
+    // lets a test block until a given message has appeared.
+    //
+    // Severity is recorded because healthWait() picks the severity and the wait
+    // duration together, so the pair identifies which of its three logging
+    // branches ran: warn at the full wait when the server is unhealthy for a
+    // reason that is not expected to resolve on its own, trace at a tenth of
+    // the wait when the only missing ledger is the one currently being built,
+    // and info at the full wait otherwise. Matching on the pair is what lets
+    // the tests below assert which branch was taken instead of merely that some
+    // wait happened.
+    //
+    // waitFor() exists because run() logs on entry to a rotation, which is the
+    // only signal a test has that the store has passed the health check gating
+    // the rotation and is now inside it. Several of the branches under test are
+    // only reachable from there, and no other handle on the store exposes it.
+    class StoreLogs : public Logs
+    {
+        mutable std::mutex mutex_;
+        std::condition_variable cond_;
+        std::vector<std::pair<beast::Severity, std::string>> messages_;
+
+        class Sink : public beast::Journal::Sink
+        {
+            StoreLogs& owner_;
+
+        public:
+            Sink(beast::Severity threshold, StoreLogs& owner)
+                : beast::Journal::Sink(threshold, false), owner_(owner)
+            {
+            }
+
+            // Env::AppBundle calls Logs::threshold() after the Application is
+            // built, which would otherwise raise this sink above Trace and
+            // discard the messages the buildingIndex branch logs.
+            void
+            threshold(beast::Severity) override
+            {
+            }
+
+            void
+            write(beast::Severity level, std::string const& text) override
+            {
+                {
+                    std::scoped_lock const lock(owner_.mutex_);
+                    owner_.messages_.emplace_back(level, text);
+                }
+                owner_.cond_.notify_all();
+            }
+
+            void
+            writeAlways(beast::Severity level, std::string const& text) override
+            {
+                write(level, text);
+            }
+        };
+
+        // Caller must hold mutex_. A nullopt severity matches any severity.
+        [[nodiscard]] std::size_t
+        countLocked(std::optional<beast::Severity> severity, std::string const& text) const
+        {
+            return std::count_if(messages_.begin(), messages_.end(), [&](auto const& message) {
+                return (!severity || message.first == *severity) &&
+                    message.second.find(text) != std::string::npos;
+            });
+        }
+
+    public:
+        StoreLogs() : Logs(beast::Severity::Trace)
+        {
+        }
+
+        // Only the store's own partition is logged at Trace; everything else
+        // is silenced, so that enabling trace for this one branch does not pay
+        // for formatting every trace message in the server.
+        std::unique_ptr<beast::Journal::Sink>
+        makeSink(std::string const& partition, beast::Severity) override
+        {
+            return std::make_unique<Sink>(
+                partition == "SHAMapStore" ? beast::Severity::Trace : beast::Severity::Disabled,
+                *this);
+        }
+
+        // How many recorded messages were logged at `severity` and contain
+        // `text`.
+        [[nodiscard]] std::size_t
+        count(beast::Severity severity, std::string const& text) const
+        {
+            std::scoped_lock const lock(mutex_);
+            return countLocked(severity, text);
+        }
+
+        // How many recorded messages contain `text`, at any severity.
+        [[nodiscard]] std::size_t
+        count(std::string const& text) const
+        {
+            std::scoped_lock const lock(mutex_);
+            return countLocked(std::nullopt, text);
+        }
+
+        // Blocks until `text` has been logged at least `expected` times at
+        // `severity` -- or at any severity, if that is nullopt -- or until the
+        // timeout expires. Returns whether it got there.
+        //
+        // Waiting rather than sleeping-then-counting matters for the branches
+        // that are only reached after a rotation has started: the store gets
+        // there when it gets there, so a fixed sleep has to be sized for the
+        // slowest plausible machine, whereas this returns as soon as the
+        // message appears.
+        [[nodiscard]] bool
+        waitFor(
+            std::optional<beast::Severity> severity,
+            std::string const& text,
+            std::chrono::milliseconds timeout,
+            std::size_t expected = 1)
+        {
+            std::unique_lock lock(mutex_);
+            return cond_.wait_for(
+                lock, timeout, [&] { return countLocked(severity, text) >= expected; });
+        }
+
+        // As above, at any severity.
+        [[nodiscard]] bool
+        waitFor(
+            std::string const& text,
+            std::chrono::milliseconds timeout,
+            std::size_t expected = 1)
+        {
+            return waitFor(std::nullopt, text, timeout, expected);
+        }
+    };
 
     static auto
     onlineDelete(std::unique_ptr<Config> cfg)
@@ -54,6 +228,32 @@ class SHAMapStore_test : public beast::unit_test::Suite
         return cfg;
     }
 
+    // online delete tuned so that a rotation, once it has started, spends a
+    // long time in clearPrior() before reaching the first health check inside
+    // the rotation body.
+    //
+    // clearSql() sleeps back_off_milliseconds at the top of every iteration and
+    // advances by delete_batch rows per iteration, so a delete_batch of 1 costs
+    // one sleep per ledger removed, for each of the three tables it is called
+    // on. That is what gives parkMidRotation() below a window measured in
+    // seconds rather than in microseconds. delete_batch is therefore the actual
+    // lever; back_off_milliseconds is set to the value SHAMapStoreImp already
+    // defaults to, and is spelled out only so the arithmetic above can be
+    // checked against the config rather than against the implementation.
+    //
+    // max_waiting_ledgers is pinned to its floor so that tripping the circuit
+    // breaker takes the fewest possible ledger closes.
+    static auto
+    slowOnlineDelete(std::unique_ptr<Config> cfg)
+    {
+        cfg = onlineDelete(std::move(cfg));
+        auto& section = cfg->section(Sections::kNodeDatabase);
+        section.set(Keys::kDeleteBatch, "1");
+        section.set(Keys::kBackOffMilliseconds, "100");
+        section.set(Keys::kMaxWaitingLedgers, std::to_string(kMinWaitingLedgers));
+        return cfg;
+    }
+
     static auto
     advisoryDelete(std::unique_ptr<Config> cfg)
     {
@@ -141,6 +341,96 @@ class SHAMapStore_test : public beast::unit_test::Suite
         BEAST_EXPECT(env.app().getRelationalDatabase().getAccountTransactionCount() == rows);
     }
 
+    // Wait until the SHAMapStore has finished processing the ledger that the
+    // preceding env.close() produced.
+    //
+    // env.close() returns as soon as the ledger_accept RPC returns, but the
+    // validated ledger path -- LedgerMaster::setValidLedger() ->
+    // SHAMapStore::onLedgerClosed() -- runs on a job queue thread. Without
+    // draining the job queue first, the store may not have been handed the
+    // ledger at all, in which case rendezvous() observes working_ == false and
+    // returns immediately, before any work has been done.
+    [[nodiscard]] static bool
+    syncStore(jtx::Env& env)
+    {
+        // Drain the job queue first, so that onLedgerClosed() has run and
+        // working_ is set. Then use the store's timeout overload, so a store
+        // that never finishes fails this test instead of blocking on it.
+        //
+        // Only the second wait is bounded: JobQueue::rendezvous() has no
+        // timeout overload, so a job that never completes hangs here. That is
+        // pre-existing -- ~AppBundle waits on it the same way for every jtx
+        // test -- but it does mean this helper is not hang-proof end to end.
+        env.app().getJobQueue().rendezvous();
+        return env.app().getSHAMapStore().rendezvous(std::chrono::seconds{60});
+    }
+
+    // Bring the SHAMapStore to the point where it has been handed a validated
+    // ledger and initialized lastRotated, and report how many extra ledgers had
+    // to be closed to get it there (normally none). Returns std::nullopt if
+    // syncStore() itself failed.
+    //
+    // syncStore() alone does not guarantee that, because
+    // SHAMapStoreImp::run()'s loop does not use the notification and the
+    // working_ flag safely:
+    //
+    //   * onLedgerClosed() notifies cond_ whether or not run()'s thread is
+    //     parked on it, and run() waits on cond_ without a predicate, so a
+    //     notification that lands while the thread is still starting up --
+    //     before it first reaches that wait -- is lost.
+    //   * run() clears working_ at the top of its loop without checking
+    //     whether newLedger_ is still set, so rendezvous() can report the
+    //     store idle with a validated ledger queued.
+    //
+    // Either way the store ends up parked with work pending, and only another
+    // notification gets it moving again. In a standalone test nothing else
+    // closes ledgers, so that has to come from here: this closes a ledger
+    // rather than polling getLastRotated(), because polling would just time
+    // out. onLedgerClosed() keeps only the most recent ledger in newLedger_,
+    // so the ledger the store picks up -- and therefore lastRotated -- is a
+    // timing detail, which is why the callers derive their expectations from
+    // the value they observe instead of assuming one.
+    //
+    // run() is deliberately left as it is. In production the only effect is
+    // latency: the trigger is validatedSeq >= lastRotated + deleteInterval, so
+    // a lost notification delays rotation to the next validated ledger and
+    // nothing is skipped or accumulated -- starting at 513 instead of 512 does
+    // not matter. Two consequences do follow from leaving it in place, and both
+    // hold today: nothing in production decides anything from working_ or
+    // rendezvous() (rendezvous() has no production callers at all), and a node
+    // whose ledgers only advance on demand -- standalone, driven by
+    // ledger_accept -- can sit on a queued ledger until something closes the
+    // next one, which is exactly the situation this helper is working around.
+    //
+    // So this helper is permanent rather than a stopgap. Working around the
+    // race must not make it invisible, so every extra close is logged. That
+    // keeps how often it is actually hit observable in the unit test output --
+    // which is the only signal left once these testcases stop flaking on it.
+    [[nodiscard]] std::optional<int>
+    initializeStore(jtx::Env& env, int const maxExtraCloses = 3)
+    {
+        auto& store = env.app().getSHAMapStore();
+
+        for (int extraCloses = 0;; ++extraCloses)
+        {
+            if (!syncStore(env))
+                return std::nullopt;
+            if (store.getLastRotated() != 0 || extraCloses == maxExtraCloses)
+            {
+                if (extraCloses != 0)
+                {
+                    log << "initializeStore: the store needed " << extraCloses
+                        << " extra ledger close(s) to pick up a validated ledger. "
+                           "SHAMapStoreImp::run() dropped the notification for the "
+                           "first one; see the comment on initializeStore()."
+                        << std::endl;
+                }
+                return extraCloses;
+            }
+            env.close();
+        }
+    }
+
     int
     waitForReady(jtx::Env& env)
     {
@@ -149,11 +439,11 @@ class SHAMapStore_test : public beast::unit_test::Suite
         auto& store = env.app().getSHAMapStore();
 
         int ledgerSeq = 3;
-        BEAST_EXPECT(store.rendezvous());
+        BEAST_EXPECT(syncStore(env));
         BEAST_EXPECT(!store.getLastRotated());
 
         env.close();
-        BEAST_EXPECT(store.rendezvous());
+        BEAST_EXPECT(syncStore(env));
 
         auto ledger = env.rpc("ledger", "validated");
         BEAST_EXPECT(goodLedger(env, ledger, std::to_string(ledgerSeq++)));
@@ -162,7 +452,417 @@ class SHAMapStore_test : public beast::unit_test::Suite
         return ledgerSeq;
     }
 
+    // Construct an Env whose config has online_delete enabled and is then
+    // mutated by `tweak`, and report how SHAMapStoreImp's constructor judged
+    // it: the message of the exception it threw, or std::nullopt if the Env was
+    // constructed successfully.
+    //
+    // SHAMapStoreImp is built from ApplicationImp's member initializer list, so
+    // a configuration it rejects surfaces as an exception thrown out of the Env
+    // constructor rather than as a failure at some later point.
+    //
+    // Note that ~AppBundle does not run when the Env constructor throws, so the
+    // global debug log sink it installed -- which holds a reference to this
+    // suite -- would outlive the suite. The catch below clears it, so callers
+    // are free to end on a configuration that is rejected.
+    std::optional<std::string>
+    storeConfigResult(std::function<void(Config&)> const& tweak)
+    {
+        using namespace test::jtx;
+
+        try
+        {
+            Env const env{
+                *this,
+                envconfig([&tweak](std::unique_ptr<Config> cfg) {
+                    cfg = onlineDelete(std::move(cfg));
+                    tweak(*cfg);
+                    return cfg;
+                }),
+                nullptr,
+                beast::Severity::Disabled};
+            return std::nullopt;
+        }
+        // Deliberately broader than the std::runtime_error that
+        // SHAMapStoreImp throws: an unexpected exception type then shows up as
+        // a message mismatch naming the actual failure, rather than escaping
+        // this testcase.
+        catch (std::exception const& e)
+        {
+            // ~AppBundle did not run, so drop the sink it installed by hand
+            // rather than leaving a reference to this suite live in a global.
+            setDebugLogSink(nullptr);
+            return std::string{e.what()};
+        }
+    }
+
+    void
+    expectConfigRejected(std::string const& expected, std::function<void(Config&)> const& tweak)
+    {
+        auto const result = storeConfigResult(tweak);
+        BEAST_EXPECTS(result == expected, result.value_or("<accepted>"));
+    }
+
+    void
+    expectConfigAccepted(std::function<void(Config&)> const& tweak)
+    {
+        auto const result = storeConfigResult(tweak);
+        BEAST_EXPECTS(!result, result.value_or(""));
+    }
+
+    // The state parkInHealthWait() leaves behind.
+    struct Parked
+    {
+        // Value of getLastRotated() before the rotation attempt began. The
+        // store must still report this for as long as it stays parked.
+        LedgerIndex lastRotated = 0;
+        // The validated ledger the store is waiting on, and the sequence
+        // getLastRotated() will report once the rotation finally completes.
+        LedgerIndex validated = 0;
+        // Sequence removed from LedgerMaster to create the gap, or 0 if
+        // `createGap` was false.
+        LedgerIndex gap = 0;
+    };
+
+    // Drive the store to the point where it is parked inside healthWait(),
+    // unable to proceed with a rotation: close ledgers until one more close
+    // would make the store due to rotate, optionally remove the newest ledger
+    // from LedgerMaster so that the attempt sees a gap in the range, close the
+    // triggering ledger, and then set the operating mode to `modeAfterClose`.
+    //
+    // Once parked, the store stays parked indefinitely. Its wait loop reruns
+    // every recovery_wait_seconds and exits only when the server looks healthy,
+    // when it is stopped, or when the validated ledger index reaches the
+    // circuit breaker -- and that index only advances when this test closes
+    // another ledger. So a caller can establish any server state it likes,
+    // hold it, and be sure the store observes it. That is what makes the tests
+    // below state machines rather than races.
+    //
+    // Returns std::nullopt if the setup did not reach a parked store, having
+    // already reported the failure.
+    std::optional<Parked>
+    parkInHealthWait(jtx::Env& env, bool createGap, OperatingMode modeAfterClose)
+    {
+        using namespace std::chrono_literals;
+        using namespace test::jtx;
+
+        auto& lm = env.app().getLedgerMaster();
+        auto& store = env.app().getSHAMapStore();
+        auto& netOPs = env.app().getOPs();
+
+        env.fund(XRP(1000), Account("alice"));
+        env.close();
+        if (!BEAST_EXPECT(initializeStore(env).has_value()))
+            return std::nullopt;
+
+        Parked parked;
+        // The store adopts the first validated ledger it sees as lastRotated,
+        // and which one that is depends on timing, so read it rather than
+        // assuming a value.
+        parked.lastRotated = store.getLastRotated();
+        if (!BEAST_EXPECT(parked.lastRotated))
+            return std::nullopt;
+
+        // Close ledgers until the next close is the one that makes
+        // validatedSeq reach lastRotated + deleteInterval.
+        LedgerIndex maxSeq = env.closed()->header().seq;
+        while (maxSeq + 1 < parked.lastRotated + kDeleteInterval)
+        {
+            env.close();
+            ++maxSeq;
+            if (!BEAST_EXPECT(syncStore(env)))
+                return std::nullopt;
+            if (!BEAST_EXPECTS(
+                    store.getLastRotated() == parked.lastRotated,
+                    std::to_string(store.getLastRotated())))
+                return std::nullopt;
+        }
+
+        // Drop out of FULL before touching LedgerMaster's internals, matching
+        // testLedgerGaps. This also keeps the store from rotating on the
+        // triggering close before the caller has set the state it wants
+        // observed.
+        netOPs.setMode(OperatingMode::CONNECTED);
+
+        // The gap goes one below the sequence that the close further down makes
+        // validated, never at that sequence itself: healthWait() derives
+        // buildingIndex from numMissing == 1 && !haveLedger(index), so a gap at
+        // the validated index reads as "that ledger is about to be built" and
+        // takes the short trace wait, whereas a gap below it reads as a
+        // genuinely incomplete range and takes the full wait. Nothing refills
+        // the gap, so the wait loop ends only when the circuit breaker trips or
+        // stop() intervenes.
+        if (createGap)
+        {
+            std::size_t iterations = 30;
+            while (!lm.haveLedger(maxSeq) && --iterations > 0)
+            {
+                std::this_thread::sleep_for(10ms);
+            }
+            if (!BEAST_EXPECTS(lm.haveLedger(maxSeq), std::to_string(maxSeq)))
+                return std::nullopt;
+
+            // Give the server a moment to finish any internal work on the
+            // ledger about to be removed, as testLedgerGaps does.
+            std::this_thread::sleep_for(250ms);
+
+            lm.clearLedger(maxSeq);
+            if (!BEAST_EXPECT(!lm.haveLedger(maxSeq)))
+                return std::nullopt;
+            parked.gap = maxSeq;
+        }
+
+        // This close makes the store due to rotate.
+        env.close();
+        ++maxSeq;
+        parked.validated = maxSeq;
+        netOPs.setMode(modeAfterClose);
+
+        // Drain the job queue so that onLedgerClosed() has handed the ledger to
+        // the store. Without this, working_ may still be false from the
+        // previous cycle and rendezvous() would report "done" before the store
+        // has even looked at this ledger.
+        env.app().getJobQueue().rendezvous();
+
+        if (!BEAST_EXPECT(!store.rendezvous(1s)))
+            return std::nullopt;
+        if (!BEAST_EXPECTS(
+                store.getLastRotated() == parked.lastRotated,
+                std::to_string(store.getLastRotated())))
+            return std::nullopt;
+
+        return parked;
+    }
+
+    // Drive the store to the point where it has passed the health check that
+    // gates a rotation and is inside the rotation body, then make the server
+    // unhealthy so that the next health check in there parks it.
+    //
+    // The gap cannot be created up front the way parkInHealthWait() does it,
+    // because the gating check would see it and refuse to start the rotation at
+    // all -- which is what testLedgerGaps() exercises. So this waits for the
+    // message run() logs immediately after that check, which is the store
+    // publishing that it is committed to the rotation, and creates the gap then.
+    //
+    // The margin that makes that safe is clearPrior(), which runs between the
+    // log and the first health check inside the rotation. Under
+    // slowOnlineDelete() it works through three tables one sequence at a time,
+    // sleeping back_off_milliseconds before each, and checks health after every
+    // one of those sleeps. So the store spends on the order of a second per
+    // table repeatedly asking whether it is healthy, against the microseconds
+    // this function needs to clear a ledger once waitFor() has returned.
+    //
+    // The gap has to be the validated ledger itself. healthWait() counts missing
+    // ledgers over the range from lastGoodValidatedLedger_ to the validated
+    // index, and run() sets the former to the latter just before starting the
+    // rotation, so for the duration of the rotation that range begins as a
+    // single sequence and grows only as the caller closes more ledgers.
+    //
+    // Which health check inside the rotation ends up observing the gap is not
+    // pinned down, and does not need to be: whichever one it is returns the same
+    // answer, clearPrior() gives up, and run() reaches its first switch on
+    // healthWait() with the condition still in force. Every assertion below
+    // holds for any of them.
+    //
+    // Returns std::nullopt if the setup did not reach a parked store, having
+    // already reported the failure.
+    std::optional<Parked>
+    parkMidRotation(jtx::Env& env, StoreLogs& log)
+    {
+        using namespace std::chrono_literals;
+        using namespace test::jtx;
+
+        auto& lm = env.app().getLedgerMaster();
+        auto& store = env.app().getSHAMapStore();
+
+        auto const alice = Account("alice");
+        env.fund(XRP(1000), alice);
+        env.close();
+        if (!BEAST_EXPECT(initializeStore(env).has_value()))
+            return std::nullopt;
+
+        LedgerIndex maxSeq = env.closed()->header().seq;
+        // Close one ledger, carrying a transaction so that the sequence has rows
+        // in all three of the tables clearSql() works through.
+        auto closeOne = [&]() -> bool {
+            env(noop(alice));
+            env.close();
+            ++maxSeq;
+            return BEAST_EXPECT(syncStore(env));
+        };
+
+        // Let one rotation complete before setting up the one to be parked. The
+        // window this helper depends on only exists once the tables hold a full
+        // delete interval of rows: on the very first rotation there is at most
+        // one sequence to remove, so clearSql() sleeps once or not at all.
+        LedgerIndex const firstRotated = store.getLastRotated();
+        if (!BEAST_EXPECT(firstRotated))
+            return std::nullopt;
+        while (store.getLastRotated() == firstRotated)
+        {
+            if (!closeOne())
+                return std::nullopt;
+            // The rotation is due once maxSeq reaches firstRotated +
+            // kDeleteInterval. Allow one close beyond that before giving up,
+            // rather than closing ledgers forever.
+            if (!BEAST_EXPECTS(maxSeq <= firstRotated + kDeleteInterval, std::to_string(maxSeq)))
+                return std::nullopt;
+        }
+
+        Parked parked;
+        parked.lastRotated = store.getLastRotated();
+
+        // Close ledgers until the next close is the one that makes the store due
+        // to rotate again.
+        while (maxSeq + 1 < parked.lastRotated + kDeleteInterval)
+        {
+            if (!closeOne())
+                return std::nullopt;
+            if (!BEAST_EXPECTS(
+                    store.getLastRotated() == parked.lastRotated,
+                    std::to_string(store.getLastRotated())))
+                return std::nullopt;
+        }
+
+        // One rotation has already been logged, so wait for the next one rather
+        // than for the first.
+        auto const rotationsBefore = log.count(kRotating);
+
+        // This close makes the store due to rotate. Deliberately do not drain
+        // the store here: the point is to interrupt it partway through.
+        env(noop(alice));
+        env.close();
+        ++maxSeq;
+        parked.validated = maxSeq;
+
+        // Draining the job queue, on the other hand, is required. In standalone
+        // mode switchLCL() inserts the closed ledger into LedgerMaster's
+        // complete range and then posts an advance job, and publishing the
+        // ledger from that job inserts it a second time. Clearing the ledger
+        // between those two inserts does not leave a lasting gap: publication
+        // puts it straight back, the rotation's health checks see a healthy
+        // node, and the rotation runs to completion. Waiting for the queue to
+        // drain closes that window, because publication is what advances
+        // pubLedger_ -- once it has happened, the ledger is never published, and
+        // so never inserted, again.
+        //
+        // This waits only for the job queue, not for the store, whose thread is
+        // its own and is the thing being interrupted here.
+        env.app().getJobQueue().rendezvous();
+
+        // Publishing the ledger is what advances pubLedger_, so this is the
+        // observable confirmation that the window above has closed. Asserting it
+        // here means that if anything ever reopens it, this setup step says so
+        // directly instead of the tests below failing for reasons that look
+        // nothing like the cause.
+        auto const published = lm.getPublishedLedger();
+        if (!BEAST_EXPECTS(
+                published && published->header().seq >= parked.validated,
+                std::to_string(published ? published->header().seq : 0)))
+            return std::nullopt;
+
+        if (!BEAST_EXPECT(log.waitFor(kRotating, 10s, rotationsBefore + 1)))
+            return std::nullopt;
+
+        // The store is now inside clearPrior(). Remove the validated ledger so
+        // that every health check from here on reports a gap.
+        if (!BEAST_EXPECTS(lm.haveLedger(parked.validated), std::to_string(parked.validated)))
+            return std::nullopt;
+        lm.clearLedger(parked.validated);
+        parked.gap = parked.validated;
+        if (!BEAST_EXPECT(!lm.haveLedger(parked.gap)))
+            return std::nullopt;
+
+        // The rotation must now be stuck. Wait longer than
+        // recovery_wait_seconds, so that this is a settled state rather than a
+        // store that has yet to reach its next health check.
+        if (!BEAST_EXPECT(!store.rendezvous(1500ms)))
+            return std::nullopt;
+        if (!BEAST_EXPECTS(
+                store.getLastRotated() == parked.lastRotated,
+                std::to_string(store.getLastRotated())))
+            return std::nullopt;
+        // The rotation started, has not finished, and has not yet given up.
+        if (!BEAST_EXPECTS(
+                log.count(kRotating) == rotationsBefore + 1, std::to_string(log.count(kRotating))))
+            return std::nullopt;
+        if (!BEAST_EXPECTS(log.count(kFinished) == 1, std::to_string(log.count(kFinished))))
+            return std::nullopt;
+        if (!BEAST_EXPECTS(log.count(kExpired) == 0, std::to_string(log.count(kExpired))))
+            return std::nullopt;
+
+        return parked;
+    }
+
 public:
+    // Cover the [node_db] validation that SHAMapStoreImp performs when it is
+    // constructed. The rejected cases stop inside SHAMapStoreImp's constructor,
+    // so they cost only a partial Application construction; the accepted ones
+    // start a full node and immediately tear it down.
+    void
+    testConfig()
+    {
+        testcase("config validation");
+
+        // online_delete below the standalone minimum. ledger_history is still
+        // kDeleteInterval here, so it is too large for this online_delete as
+        // well; the assertion pins which of the two errors wins.
+        expectConfigRejected(
+            "online_delete must be at least " + std::to_string(kMinDeleteInterval),
+            [](Config& cfg) {
+                cfg.section(Sections::kNodeDatabase)
+                    .set(Keys::kOnlineDelete, std::to_string(kMinDeleteInterval - 1));
+            });
+
+        // ledger_history above online_delete asks the node to retain more
+        // history than online delete is allowed to keep.
+        expectConfigRejected(
+            "online_delete must not be less than ledger_history (currently " +
+                std::to_string(kDeleteInterval + 1) + ")",
+            [](Config& cfg) { cfg.ledgerHistory = kDeleteInterval + 1; });
+
+        // recovery_wait_seconds is the interval at which online delete rechecks
+        // the node's health while it waits for missing ledgers to arrive, so a
+        // zero wait would turn that into a spin.
+        expectConfigRejected("recovery_wait_seconds must be at least 1 second", [](Config& cfg) {
+            cfg.section(Sections::kNodeDatabase).set(Keys::kRecoveryWaitSeconds, "0");
+        });
+
+        // max_waiting_ledgers is the circuit breaker that eventually lets
+        // online delete stop waiting, so it has a floor rather than being
+        // free-form.
+        auto const tooFewWaiting =
+            "max_waiting_ledgers must be at least " + std::to_string(kMinWaitingLedgers);
+        expectConfigRejected(tooFewWaiting, [](Config& cfg) {
+            cfg.section(Sections::kNodeDatabase)
+                .set(Keys::kMaxWaitingLedgers, std::to_string(kMinWaitingLedgers - 1));
+        });
+        // 0 is not a magic "never give up" value, just a value below the floor.
+        expectConfigRejected(tooFewWaiting, [](Config& cfg) {
+            cfg.section(Sections::kNodeDatabase).set(Keys::kMaxWaitingLedgers, "0");
+        });
+
+        // The floor itself is accepted, and so is a value far above
+        // online_delete: there is no upper bound.
+        expectConfigAccepted([](Config& cfg) {
+            cfg.section(Sections::kNodeDatabase)
+                .set(Keys::kMaxWaitingLedgers, std::to_string(kMinWaitingLedgers));
+        });
+        expectConfigAccepted([](Config& cfg) {
+            cfg.section(Sections::kNodeDatabase)
+                .set(Keys::kMaxWaitingLedgers, std::to_string(kDeleteInterval * 100));
+        });
+
+        // All of the above is gated on online_delete being enabled. With it
+        // turned off, the same values are ignored rather than rejected.
+        expectConfigAccepted([](Config& cfg) {
+            auto& section = cfg.section(Sections::kNodeDatabase);
+            section.set(Keys::kOnlineDelete, "0");
+            section.set(Keys::kMaxWaitingLedgers, "0");
+            section.set(Keys::kRecoveryWaitSeconds, "0");
+        });
+    }
+
     void
     testClear()
     {
@@ -233,7 +933,7 @@ public:
             BEAST_EXPECT(goodLedger(env, ledger, std::to_string(kDeleteInterval + 4)));
         }
 
-        BEAST_EXPECT(store.rendezvous());
+        BEAST_EXPECT(syncStore(env));
 
         BEAST_EXPECT(store.getLastRotated() == kDeleteInterval + 3);
         lastRotated = store.getLastRotated();
@@ -260,7 +960,7 @@ public:
                 !getHash(ledgers[i]).empty());
         }
 
-        BEAST_EXPECT(store.rendezvous());
+        BEAST_EXPECT(syncStore(env));
 
         BEAST_EXPECT(store.getLastRotated() == kDeleteInterval + lastRotated);
 
@@ -298,7 +998,7 @@ public:
             BEAST_EXPECT(goodLedger(env, ledger, std::to_string(ledgerSeq), true));
         }
 
-        BEAST_EXPECT(store.rendezvous());
+        BEAST_EXPECT(syncStore(env));
 
         // The database will always have back to ledger 2,
         // regardless of lastRotated.
@@ -313,7 +1013,7 @@ public:
             BEAST_EXPECT(goodLedger(env, ledger, std::to_string(ledgerSeq++), true));
         }
 
-        BEAST_EXPECT(store.rendezvous());
+        BEAST_EXPECT(syncStore(env));
 
         ledgerCheck(env, ledgerSeq - lastRotated, lastRotated);
         BEAST_EXPECT(lastRotated != store.getLastRotated());
@@ -329,7 +1029,7 @@ public:
             BEAST_EXPECT(goodLedger(env, ledger, std::to_string(ledgerSeq), true));
         }
 
-        BEAST_EXPECT(store.rendezvous());
+        BEAST_EXPECT(syncStore(env));
 
         ledgerCheck(env, kDeleteInterval + 1, lastRotated);
         BEAST_EXPECT(lastRotated != store.getLastRotated());
@@ -368,7 +1068,7 @@ public:
             BEAST_EXPECT(goodLedger(env, ledger, std::to_string(ledgerSeq), true));
         }
 
-        BEAST_EXPECT(store.rendezvous());
+        BEAST_EXPECT(syncStore(env));
 
         ledgerCheck(env, ledgerSeq - 2, 2);
         BEAST_EXPECT(lastRotated == store.getLastRotated());
@@ -378,7 +1078,7 @@ public:
         BEAST_EXPECT(!rpc::containsError(canDelete[jss::result]));
         BEAST_EXPECT(canDelete[jss::result][jss::can_delete] == ledgerSeq + (kDeleteInterval / 2));
 
-        BEAST_EXPECT(store.rendezvous());
+        BEAST_EXPECT(syncStore(env));
 
         ledgerCheck(env, ledgerSeq - 2, 2);
         BEAST_EXPECT(store.getLastRotated() == lastRotated);
@@ -391,7 +1091,7 @@ public:
             BEAST_EXPECT(goodLedger(env, ledger, std::to_string(ledgerSeq++), true));
         }
 
-        BEAST_EXPECT(store.rendezvous());
+        BEAST_EXPECT(syncStore(env));
 
         ledgerCheck(env, ledgerSeq - lastRotated, lastRotated);
 
@@ -407,7 +1107,7 @@ public:
             BEAST_EXPECT(goodLedger(env, ledger, std::to_string(ledgerSeq), true));
         }
 
-        BEAST_EXPECT(store.rendezvous());
+        BEAST_EXPECT(syncStore(env));
 
         BEAST_EXPECT(store.getLastRotated() == lastRotated);
 
@@ -419,7 +1119,7 @@ public:
             BEAST_EXPECT(goodLedger(env, ledger, std::to_string(ledgerSeq++), true));
         }
 
-        BEAST_EXPECT(store.rendezvous());
+        BEAST_EXPECT(syncStore(env));
 
         ledgerCheck(env, ledgerSeq - firstBatch, firstBatch);
 
@@ -441,7 +1141,7 @@ public:
             BEAST_EXPECT(goodLedger(env, ledger, std::to_string(ledgerSeq), true));
         }
 
-        BEAST_EXPECT(store.rendezvous());
+        BEAST_EXPECT(syncStore(env));
 
         BEAST_EXPECT(store.getLastRotated() == lastRotated);
 
@@ -453,7 +1153,7 @@ public:
             BEAST_EXPECT(goodLedger(env, ledger, std::to_string(ledgerSeq++), true));
         }
 
-        BEAST_EXPECT(store.rendezvous());
+        BEAST_EXPECT(syncStore(env));
 
         ledgerCheck(env, ledgerSeq - lastRotated, lastRotated);
 
@@ -474,7 +1174,7 @@ public:
             BEAST_EXPECT(goodLedger(env, ledger, std::to_string(ledgerSeq), true));
         }
 
-        BEAST_EXPECT(store.rendezvous());
+        BEAST_EXPECT(syncStore(env));
 
         BEAST_EXPECT(store.getLastRotated() == lastRotated);
 
@@ -486,7 +1186,7 @@ public:
             BEAST_EXPECT(goodLedger(env, ledger, std::to_string(ledgerSeq++), true));
         }
 
-        BEAST_EXPECT(store.rendezvous());
+        BEAST_EXPECT(syncStore(env));
 
         ledgerCheck(env, ledgerSeq - lastRotated, lastRotated);
 
@@ -634,19 +1334,45 @@ public:
 
         auto& lm = env.app().getLedgerMaster();
         LedgerIndex minSeq = 2;
-        LedgerIndex maxSeq = env.closed()->header().seq;
         auto& store = env.app().getSHAMapStore();
-        LedgerIndex lastRotated = store.getLastRotated();
         auto& netOPs = env.app().getOPs();
-        while (lastRotated != 3)
-        {
-            BEAST_EXPECT(store.rendezvous());
-            lastRotated = store.getLastRotated();
-        }
-        BEAST_EXPECTS(maxSeq == 3, std::to_string(maxSeq));
-        BEAST_EXPECTS(lm.getCompleteLedgers() == "2-3", lm.getCompleteLedgers());
+        // Which of the existing complete ledgers the store initializes
+        // lastRotated from is a timing detail, so everything below derives from
+        // the observed value rather than assuming a particular one. Spinning
+        // until it equals a hard-coded value never terminates when a different
+        // one legitimately wins.
+        //
+        // The range check and the initializeStore() one both end the testcase
+        // rather than merely reporting, because lastRotated is the only value
+        // from the store that enters minSeq. A lastRotated of 0 -- the value
+        // getLastRotated() reports until the store has been handed a validated
+        // ledger -- makes minSeq 0 below, and the minSeq - 1 and minSeq - 2
+        // ranges then underflow to first > last, which aborts a Debug build
+        // inside missingFromCompleteLedgerRange().
+        auto const extraCloses = initializeStore(env);
+        if (!BEAST_EXPECT(extraCloses.has_value()))
+            return;
+        LedgerIndex maxSeq = env.closed()->header().seq;
+        LedgerIndex lastRotated = store.getLastRotated();
+        if (!BEAST_EXPECTS(
+                lastRotated >= minSeq && lastRotated <= maxSeq, std::to_string(lastRotated)))
+            return;
+        // The BEAST_EXPECT above already returned if this is nullopt, but that
+        // is invisible to clang-tidy's optional model.
+        // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+        BEAST_EXPECTS(maxSeq == 3 + *extraCloses, std::to_string(maxSeq));
+        std::stringstream initialRange;
+        initialRange << minSeq << "-" << maxSeq;
+        BEAST_EXPECTS(lm.getCompleteLedgers() == initialRange.str(), lm.getCompleteLedgers());
         BEAST_EXPECT(lm.missingFromCompleteLedgerRange(minSeq, maxSeq) == 0);
-        BEAST_EXPECT(minSeq + 1 > maxSeq - 1);
+        // The inner range is empty unless initializeStore() had to close extra
+        // ledgers, and missingFromCompleteLedgerRange() treats first > last as a
+        // precondition violation that aborts a Debug build via UNREACHABLE, so
+        // only check it when it is well formed.
+        if (minSeq + 1 <= maxSeq - 1)
+        {
+            BEAST_EXPECT(lm.missingFromCompleteLedgerRange(minSeq + 1, maxSeq - 1) == 0);
+        }
         BEAST_EXPECT(lm.missingFromCompleteLedgerRange(minSeq - 1, maxSeq + 1) == 2);
         BEAST_EXPECT(lm.missingFromCompleteLedgerRange(minSeq - 2, maxSeq - 2) == 2);
         BEAST_EXPECT(lm.missingFromCompleteLedgerRange(minSeq + 2, maxSeq + 2) == 2);
@@ -759,7 +1485,7 @@ public:
                 env(noop(alice));
             }
             env.close();
-            BEAST_EXPECT(store.rendezvous());
+            BEAST_EXPECT(syncStore(env));
 
             ++maxSeq;
 
@@ -825,7 +1551,7 @@ public:
                             lm.getCompleteLedgers()));
 
                     // The circuit breaker has been triggered.
-                    BEAST_EXPECT(store.rendezvous());
+                    BEAST_EXPECT(syncStore(env));
                 }
                 {
                     // Recover before the circuit breaker triggers, so the test can continue.
@@ -870,7 +1596,7 @@ public:
                     deleteSeqs.pop_back();
 
                     // Wait for the rotation to finish
-                    BEAST_EXPECT(store.rendezvous());
+                    BEAST_EXPECT(syncStore(env));
 
                     minSeq = lastRotated;
                     while (deleteSeqs.front() < minSeq)
@@ -894,8 +1620,20 @@ public:
                     failureMessage("CompleteLedgers", expected, lm.getCompleteLedgers()));
             }
             BEAST_EXPECT(lm.missingFromCompleteLedgerRange(minSeq, maxSeq) == deleteSeqs.size());
-            BEAST_EXPECT(
-                lm.missingFromCompleteLedgerRange(minSeq + 1, maxSeq - 1) == deleteSeqs.size());
+            // missingFromCompleteLedgerRange() treats first > last as a
+            // precondition violation and aborts a Debug build via UNREACHABLE.
+            // The range can only collapse if this test's model of minSeq /
+            // maxSeq has desynced from the store, so report that as a failure
+            // instead of taking down the whole unit test job.
+            if (minSeq + 1 <= maxSeq - 1)
+            {
+                BEAST_EXPECT(
+                    lm.missingFromCompleteLedgerRange(minSeq + 1, maxSeq - 1) == deleteSeqs.size());
+            }
+            else
+            {
+                BEAST_EXPECTS(false, failureMessage("range collapsed", minSeq, maxSeq));
+            }
             BEAST_EXPECT(
                 lm.missingFromCompleteLedgerRange(minSeq - 1, maxSeq + 1) == deleteSeqs.size() + 2);
             BEAST_EXPECT(
@@ -905,14 +1643,297 @@ public:
         }
     }
 
+    // Cover the branches of SHAMapStoreImp::healthWait() that decide whether
+    // the server is healthy enough to rotate, and how loudly to complain while
+    // it is not. testLedgerGaps() covers the case where a gap holds the
+    // rotation back until the circuit breaker trips; these cover the rest of
+    // the decision table.
+    void
+    testHealthWaitState()
+    {
+        testcase("healthWait server state");
+
+        using namespace std::chrono_literals;
+        using namespace test::jtx;
+
+        auto logs = std::make_unique<StoreLogs>();
+        // Not `auto const*`: waitFor() blocks, so it is not const.
+        auto* const log = logs.get();
+        Env env{*this, envconfig(onlineDelete), std::move(logs), beast::Severity::Trace};
+
+        auto& store = env.app().getSHAMapStore();
+        auto& netOPs = env.app().getOPs();
+
+        // No gap: the only thing holding the store back is the operating mode.
+        auto const parked = parkInHealthWait(env, false, OperatingMode::CONNECTED);
+        if (!parked)
+            return;
+
+        // Hold the non-FULL mode until the store has logged that it is waiting
+        // on it. With no gap, a fresh validated ledger and a mode that is not
+        // DISCONNECTED, the only check left that can report unhealthy is
+        // "mode != FULL", and a mode that is not FULL is not expected to fix
+        // itself, so the wait is logged at warn, for the full duration.
+        //
+        // Waiting for the message rather than sleeping past it is what keeps
+        // this from depending on how quickly the store gets around to sampling.
+        // The store cannot leave the wait loop while the mode stays put -- the
+        // validated ledger index does not advance, so the circuit breaker is
+        // never reached -- so the rendezvous() below is not racing it.
+        BEAST_EXPECT(log->waitFor(beast::Severity::Warning, kFullWait, 10s));
+        BEAST_EXPECT(!store.rendezvous(10ms));
+        BEAST_EXPECT(netOPs.getOperatingMode() != OperatingMode::FULL);
+        BEAST_EXPECT(netOPs.getOperatingMode() != OperatingMode::DISCONNECTED);
+        BEAST_EXPECTS(
+            store.getLastRotated() == parked->lastRotated, std::to_string(store.getLastRotated()));
+
+        // Now make the mode FULL but the validated ledger stale. Advancing the
+        // clock without closing a ledger ages the validated ledger past
+        // age_threshold_seconds, which defaults to 60. The mode check can no
+        // longer be the reason the store is unhealthy, so the age check is.
+        //
+        // This one does sleep: what is being asserted is that the store did not
+        // rotate, and 1500ms is long enough for it to have re-sampled the server
+        // at least once -- the full wait is 1000ms -- so the age check, not a
+        // stale sample of the old mode, is what held it back.
+        auto const closeTime = env.now();
+        env.timeKeeper().set(closeTime + 2min);
+        netOPs.setMode(OperatingMode::FULL);
+        BEAST_EXPECT(netOPs.getOperatingMode() == OperatingMode::FULL);
+        BEAST_EXPECT(!store.rendezvous(1500ms));
+        BEAST_EXPECTS(
+            store.getLastRotated() == parked->lastRotated, std::to_string(store.getLastRotated()));
+
+        // Restore the clock. Nothing is wrong any more, so the rotation that
+        // has been waiting all along runs to completion.
+        env.timeKeeper().set(closeTime);
+        BEAST_EXPECT(syncStore(env));
+        BEAST_EXPECTS(
+            store.getLastRotated() == parked->validated, std::to_string(store.getLastRotated()));
+    }
+
+    void
+    testHealthWaitGapLevels()
+    {
+        testcase("healthWait gap wait levels");
+
+        using namespace std::chrono_literals;
+        using namespace test::jtx;
+
+        auto logs = std::make_unique<StoreLogs>();
+        // Not `auto const*`: waitFor() blocks, so it is not const.
+        auto* const log = logs.get();
+        Env env{*this, envconfig(onlineDelete), std::move(logs), beast::Severity::Trace};
+
+        auto& lm = env.app().getLedgerMaster();
+        auto& store = env.app().getSHAMapStore();
+
+        auto const parked = parkInHealthWait(env, true, OperatingMode::FULL);
+        if (!parked)
+            return;
+
+        // The missing ledger is an older one; the validated ledger itself is
+        // present. The store has no reason to think the gap will close on its
+        // own, so it waits the full duration and says so at info -- not warn,
+        // because the server is otherwise healthy and has not been waiting long
+        // enough to have fallen behind.
+        BEAST_EXPECT(lm.haveLedger(parked->validated));
+        BEAST_EXPECT(!lm.haveLedger(parked->gap));
+        BEAST_EXPECT(log->waitFor(beast::Severity::Info, kFullWait, 10s));
+        // Nothing so far should have looked like a ledger being built.
+        BEAST_EXPECT(log->count(beast::Severity::Trace, kShortWait) == 0);
+        // Nothing fills the gap in, so the store is still in the wait loop.
+        BEAST_EXPECT(!store.rendezvous(10ms));
+
+        // Move the gap onto the validated ledger itself. That is the one case
+        // the store treats as transient -- the ledger is expected to be built
+        // shortly -- so it drops to trace and waits a tenth as long. Asserting
+        // that the shortened wait appears only after this swap is what pins the
+        // branch to the buildingIndex condition, rather than to anything
+        // incidental about a store that happens to be waiting.
+        lm.setLedgerRangePresent(parked->gap, parked->gap);
+        lm.clearLedger(parked->validated);
+        BEAST_EXPECT(lm.haveLedger(parked->gap));
+        BEAST_EXPECT(!lm.haveLedger(parked->validated));
+        BEAST_EXPECT(log->waitFor(beast::Severity::Trace, kShortWait, 10s));
+        BEAST_EXPECT(!store.rendezvous(10ms));
+        BEAST_EXPECTS(
+            store.getLastRotated() == parked->lastRotated, std::to_string(store.getLastRotated()));
+
+        // Fill it in and the rotation completes.
+        lm.setLedgerRangePresent(parked->validated, parked->validated);
+        BEAST_EXPECT(syncStore(env));
+        BEAST_EXPECTS(
+            store.getLastRotated() == parked->validated, std::to_string(store.getLastRotated()));
+    }
+
+    void
+    testHealthWaitDisconnected()
+    {
+        testcase("healthWait disconnected");
+
+        using namespace std::chrono_literals;
+        using namespace test::jtx;
+
+        Env env{*this, envconfig(onlineDelete)};
+
+        auto& lm = env.app().getLedgerMaster();
+        auto& store = env.app().getSHAMapStore();
+        auto& netOPs = env.app().getOPs();
+
+        auto const parked = parkInHealthWait(env, true, OperatingMode::FULL);
+        if (!parked)
+            return;
+
+        // While the server is FULL, the gap holds the rotation back.
+        BEAST_EXPECT(!store.rendezvous(1500ms));
+        BEAST_EXPECTS(
+            store.getLastRotated() == parked->lastRotated, std::to_string(store.getLastRotated()));
+
+        // A disconnected server is not doing any ledger I/O, so the gap cannot
+        // have been caused by its own activity and will not close until it has
+        // peers again. The store deliberately takes advantage of that to get as
+        // much rotation done as possible: this is the one case where a gap does
+        // not hold online delete back at all.
+        netOPs.setMode(OperatingMode::DISCONNECTED);
+        BEAST_EXPECT(netOPs.getOperatingMode() == OperatingMode::DISCONNECTED);
+        BEAST_EXPECT(syncStore(env));
+        BEAST_EXPECTS(
+            store.getLastRotated() == parked->validated, std::to_string(store.getLastRotated()));
+        // The rotation ran with the gap still present -- nothing filled it in.
+        BEAST_EXPECT(!lm.haveLedger(parked->gap));
+    }
+
+    void
+    testHealthWaitStop()
+    {
+        testcase("healthWait stop");
+
+        using namespace test::jtx;
+
+        Env env{*this, envconfig(onlineDelete)};
+
+        auto& store = env.app().getSHAMapStore();
+
+        auto const parked = parkInHealthWait(env, true, OperatingMode::FULL);
+        if (!parked)
+            return;
+
+        // Stopping the store has to break it out of the wait loop, which it
+        // would otherwise never leave: the gap is never filled in and the
+        // validated ledger index never advances to reach the circuit breaker.
+        //
+        // stop() joins the store's thread, so its return is the
+        // synchronisation point here. rendezvous() afterwards is only a
+        // cross-check, and cannot block: the store is parked in the health
+        // check that gates a rotation, so Stopping there merely leaves
+        // readyToRotate false, and run() falls through to the top of its loop,
+        // where it clears working_ and notifies before returning on stop_.
+        store.stop();
+        BEAST_EXPECT(store.rendezvous());
+        BEAST_EXPECTS(
+            store.getLastRotated() == parked->lastRotated, std::to_string(store.getLastRotated()));
+    }
+
+    // The two tests below cover the health check that run() performs between the
+    // stages of a rotation it has already committed to, which is a different
+    // decision from the one that gates the rotation in the first place: giving
+    // up here means abandoning work in progress. run() makes it at four points
+    // -- after clearing prior ledgers, after copying the validated ledger, after
+    // freshening the caches, and after clearing them -- with the same three-way
+    // switch each time, and parkMidRotation() parks the store at the first of
+    // them.
+    void
+    testHealthWaitExpiredMidRotation()
+    {
+        testcase("healthWait circuit breaker mid-rotation");
+
+        using namespace test::jtx;
+
+        auto logs = std::make_unique<StoreLogs>();
+        auto* const log = logs.get();
+        Env env{*this, envconfig(slowOnlineDelete), std::move(logs), beast::Severity::Trace};
+
+        auto& lm = env.app().getLedgerMaster();
+        auto& store = env.app().getSHAMapStore();
+
+        auto const parked = parkMidRotation(env, *log);
+        if (!parked)
+            return;
+
+        // Advance the validated ledger index past the circuit breaker. The store
+        // has had no successful health check since the gap appeared, so once the
+        // index has moved max_waiting_ledgers on from the last one that did
+        // succeed, it abandons the rotation instead of waiting for the gap
+        // forever. Nothing here fills the gap in.
+        for (int i = 0; i < kMinWaitingLedgers; ++i)
+        {
+            env.close();
+            BEAST_EXPECT(!lm.haveLedger(parked->gap));
+        }
+
+        // Abandoning the rotation returns the store to waiting for work, so it
+        // reports itself idle -- but with lastRotated left where it started,
+        // unlike the completed rotation parkMidRotation() drove first.
+        BEAST_EXPECT(syncStore(env));
+        BEAST_EXPECTS(
+            store.getLastRotated() == parked->lastRotated, std::to_string(store.getLastRotated()));
+        BEAST_EXPECT(log->count(kExpired) > 0);
+        BEAST_EXPECTS(log->count(kFinished) == 1, std::to_string(log->count(kFinished)));
+        BEAST_EXPECT(!lm.haveLedger(parked->gap));
+    }
+
+    void
+    testHealthWaitStopMidRotation()
+    {
+        testcase("healthWait stop mid-rotation");
+
+        using namespace test::jtx;
+
+        auto logs = std::make_unique<StoreLogs>();
+        auto* const log = logs.get();
+        Env env{*this, envconfig(slowOnlineDelete), std::move(logs), beast::Severity::Trace};
+
+        auto& store = env.app().getSHAMapStore();
+
+        auto const parked = parkMidRotation(env, *log);
+        if (!parked)
+            return;
+
+        // Stopping has to break the store out of the rotation, which it would
+        // otherwise never leave: the gap is never filled in and the validated
+        // ledger index never advances to reach the circuit breaker. Note that
+        // being stopped outranks being healthy -- the health check reports it
+        // even when nothing is wrong with the server -- so this does not depend
+        // on the store still being parked when stop() lands.
+        //
+        // stop() joins the store's thread, so its return is the synchronisation
+        // point. Deliberately do not call the untimed rendezvous() afterwards:
+        // run() returns without clearing working_, so it would block forever.
+        store.stop();
+        BEAST_EXPECTS(
+            store.getLastRotated() == parked->lastRotated, std::to_string(store.getLastRotated()));
+        // The rotation was abandoned rather than completed, and the circuit
+        // breaker was not what abandoned it.
+        BEAST_EXPECTS(log->count(kFinished) == 1, std::to_string(log->count(kFinished)));
+        BEAST_EXPECTS(log->count(kExpired) == 0, std::to_string(log->count(kExpired)));
+    }
+
     void
     run() override
     {
+        testConfig();
         testClear();
         testAutomatic();
         testCanDelete();
         testRotate();
         testLedgerGaps();
+        testHealthWaitState();
+        testHealthWaitGapLevels();
+        testHealthWaitDisconnected();
+        testHealthWaitStop();
+        testHealthWaitExpiredMidRotation();
+        testHealthWaitStopMidRotation();
     }
 };
 
diff --git a/src/test/app/Sponsor_test.cpp b/src/test/app/Sponsor_test.cpp
index 593edfe0a4..22b5d0bcdc 100644
--- a/src/test/app/Sponsor_test.cpp
+++ b/src/test/app/Sponsor_test.cpp
@@ -376,11 +376,11 @@ public:
     }
 
     void
-    testSingleSigning()
+    testSingleSigning(FeatureBitset features)
     {
         testcase("Single signing");
         using namespace test::jtx;
-        Env env{*this, testableAmendments()};
+        Env env{*this, features};
         Account const alice("alice");
         Account const sponsor("sponsor");
         Account const invalid("invalid");
@@ -415,11 +415,11 @@ public:
     }
 
     void
-    testMultiSigning()
+    testMultiSigning(FeatureBitset features)
     {
         testcase("Multi signing");
         using namespace test::jtx;
-        Env env{*this, testableAmendments()};
+        Env env{*this, features};
         Account const alice("alice");
         Account const bob("bob");
         Account const sponsor("sponsor");
@@ -1163,6 +1163,25 @@ public:
                     sponsor::SponseeAcc(alice),
                     Ter(temMALFORMED));
             }
+
+            // Post-fixCleanup3_5_0, a zero ObjectID is malformed.
+            // Pre-fixCleanup3_5_0 path is unreachable so it is not testable.
+            if (features[fixCleanup3_5_0])
+            {
+                uint256 const zeroObjectID{};
+
+                env(sponsor::transfer(alice, tfSponsorshipEnd, zeroObjectID), Ter(temMALFORMED));
+
+                env(sponsor::transfer(alice, tfSponsorshipCreate, zeroObjectID),
+                    sponsor::As(sponsor, spfSponsorReserve),
+                    Sig(sfSponsorSignature, sponsor),
+                    Ter(temMALFORMED));
+
+                env(sponsor::transfer(alice, tfSponsorshipReassign, zeroObjectID),
+                    sponsor::As(sponsor, spfSponsorReserve),
+                    Sig(sfSponsorSignature, sponsor),
+                    Ter(temMALFORMED));
+            }
         }
 
         {
@@ -5467,13 +5486,12 @@ public:
         using namespace test::jtx;
         using namespace std::chrono_literals;
 
-        // Finishing a self-escrow (source == destination) whose trust line
-        // was deleted while the escrow was outstanding auto-creates the line,
-        // and the outcome of that reserve check depends on whether the escrow
-        // reserve is released before delivery (Sponsor) or after (legacy).
-        // With the source's balance in the one-increment window
-        // [reserve(1), reserve(2)), the legacy order requires reserve(2) and
-        // fails, while the Sponsor order requires reserve(1) and succeeds.
+        // Finishing a self-escrow (source == destination) whose trust line was
+        // deleted while the escrow was outstanding auto-creates the line. With
+        // the source's balance in the one-increment window
+        // [reserve(1), reserve(2)), the finish succeeds only when the escrow
+        // reserve is released before delivery, which either featureSponsor or
+        // fixCleanup3_4_0 does.
         auto runTest = [&](FeatureBitset features, TER expected) {
             Account const alice("alice");
             Account const gw("gw");
@@ -5538,11 +5556,9 @@ public:
             }
         };
 
-        // Pre-amendment: legacy order — the escrow still counts against the
-        // reserve while the auto-created line is checked.
-        runTest(testableAmendments() - featureSponsor, tecNO_LINE_INSUF_RESERVE);
-
-        // Post-amendment: the escrow reserve is recycled into the new line.
+        runTest(testableAmendments() - featureSponsor - fixCleanup3_4_0, tecNO_LINE_INSUF_RESERVE);
+        runTest(testableAmendments() - featureSponsor, tesSUCCESS);
+        runTest(testableAmendments() - fixCleanup3_4_0, tesSUCCESS);
         runTest(testableAmendments(), tesSUCCESS);
     }
 
@@ -5678,8 +5694,12 @@ protected:
         testInvalidSponsorshipSet();
         testPseudoAccountSponsorship();
 
-        testSingleSigning();
-        testMultiSigning();
+        // The signing prefix of an alternate signature field changes with
+        // fixCleanup3_4_0, so sign and verify under both rule sets.
+        testSingleSigning(jtx::testableAmendments());
+        testSingleSigning(jtx::testableAmendments() - fixCleanup3_4_0);
+        testMultiSigning(jtx::testableAmendments());
+        testMultiSigning(jtx::testableAmendments() - fixCleanup3_4_0);
 
         testInvalidSponsorField();
 
diff --git a/src/test/app/invariants/InvariantsMPT_test.cpp b/src/test/app/invariants/InvariantsMPT_test.cpp
index 4692463baa..91984f2021 100644
--- a/src/test/app/invariants/InvariantsMPT_test.cpp
+++ b/src/test/app/invariants/InvariantsMPT_test.cpp
@@ -967,6 +967,75 @@ class InvariantsMPT_test : public InvariantsBase
                 });
         }
 
+        // LoanSet / VaultWithdraw MayAuthorizeMpt caps (fixCleanup3_4_0):
+        // LoanSet allows at most two creates and no deletes; VaultWithdraw
+        // allows at most one of each. Fabricate one extra mutation so a
+        // too-loose cap would miss these.
+        {
+            auto const insertHolderTokens =
+                [](Account const& issuer, Account const& holder, ApplyContext& ac, int n) {
+                    auto const sle = ac.view().peek(keylet::account(issuer.id()));
+                    if (!sle)
+                        return false;
+                    auto seq = sle->getFieldU32(sfSequence);
+                    for (int i = 0; i < n; ++i)
+                    {
+                        MPTIssue const mpt{makeMptID(seq + i, issuer)};
+                        auto sleNew =
+                            std::make_shared<SLE>(keylet::mptoken(mpt.getMptID(), holder));
+                        (*sleNew)[sfAccount] = holder.id();
+                        (*sleNew)[sfMPTokenIssuanceID] = mpt.getMptID();
+                        ac.view().insert(sleNew);
+                    }
+                    return true;
+                };
+
+            std::array<std::pair<xrpl::TxType, std::uint8_t>, 2> const createOverCap{
+                {{ttLOAN_SET, 3}, {ttVAULT_WITHDRAW, 2}}};
+            for (auto const& [txnType, nTokens] : createOverCap)
+            {
+                doInvariantCheck(
+                    {{"MPT authorize succeeded but created/deleted bad number mptokens"}},
+                    [&](Account const& a1, Account const& a2, ApplyContext& ac) {
+                        return insertHolderTokens(a1, a2, ac, nTokens);
+                    },
+                    XRPAmount{},
+                    STTx{txnType, [](STObject&) {}},
+                    {tecINVARIANT_FAILED, tefINVARIANT_FAILED});
+            }
+
+            MPTID id;
+            auto const precloseTwoHolders = [&id](Account const& a1, Account const& a2, Env& env) {
+                Account const gw("gw");
+                env.fund(XRP(1'000), gw);
+                MPTTester const mpt({.env = env, .issuer = gw, .holders = {a1, a2}});
+                id = mpt.issuanceID();
+                return true;
+            };
+            std::array<std::pair<xrpl::TxType, std::uint8_t>, 2> const deleteOverCap{
+                {{ttLOAN_SET, 1}, {ttVAULT_WITHDRAW, 2}}};
+            for (auto const& [txnType, nTokens] : deleteOverCap)
+            {
+                doInvariantCheck(
+                    {{"MPT authorize succeeded but created/deleted bad number mptokens"}},
+                    [&](Account const& a1, Account const& a2, ApplyContext& ac) {
+                        std::array const holders{a1, a2};
+                        for (int i = 0; i < nTokens; ++i)
+                        {
+                            auto sle = ac.view().peek(keylet::mptoken(id, holders[i]));
+                            if (!sle)
+                                return false;
+                            ac.view().erase(sle);
+                        }
+                        return true;
+                    },
+                    XRPAmount{},
+                    STTx{txnType, [](STObject&) {}},
+                    {tecINVARIANT_FAILED, tefINVARIANT_FAILED},
+                    precloseTwoHolders);
+            }
+        }
+
         // sfReferenceHolding can only be set on creation by VaultCreate. A
         // non-VaultCreate transaction that creates an MPTokenIssuance with
         // sfReferenceHolding present must trip the invariant.
diff --git a/src/test/app/invariants/InvariantsVault_test.cpp b/src/test/app/invariants/InvariantsVault_test.cpp
index dcf783a1b5..e264b91cb1 100644
--- a/src/test/app/invariants/InvariantsVault_test.cpp
+++ b/src/test/app/invariants/InvariantsVault_test.cpp
@@ -1224,33 +1224,51 @@ class InvariantsVault_test : public InvariantsBase
 
         // ttLOAN_PAY success post-conditions. A loan left with payments still
         // remaining after a successful payment must show that payment in its
-        // balance and schedule: PrincipalOutstanding and PaymentRemaining both
-        // strictly decrease, and NextPaymentDueDate advances by a positive
-        // multiple of PaymentInterval. Each case seeds the same loan, then applies
+        // balance and schedule: neither PrincipalOutstanding nor
+        // TotalValueOutstanding may increase, at least one of them must
+        // strictly decrease, PaymentRemaining must strictly decrease, and
+        // NextPaymentDueDate must advance by a positive multiple of
+        // PaymentInterval. Each failing case seeds the same loan, then applies
         // an after-image that breaks exactly one of those conditions.
         {
             struct Case
             {
                 Number principal;
+                Number totalValue;
                 std::uint32_t remaining;
                 std::uint32_t dueDate;
                 std::string expected;
             };
             auto const cases = std::to_array<Case>({
                 {.principal = Number(100),
+                 .totalValue = Number(150),
                  .remaining = 1,
                  .dueDate = 110,
-                 .expected = "loan pay must strictly decrease PrincipalOutstanding"},
+                 .expected = "loan pay must decrease PrincipalOutstanding or "
+                             "TotalValueOutstanding"},
+                {.principal = Number(110),
+                 .totalValue = Number(150),
+                 .remaining = 1,
+                 .dueDate = 110,
+                 .expected = "loan pay must not increase PrincipalOutstanding"},
                 {.principal = Number(50),
+                 .totalValue = Number(160),
+                 .remaining = 1,
+                 .dueDate = 110,
+                 .expected = "loan pay must not increase TotalValueOutstanding"},
+                {.principal = Number(50),
+                 .totalValue = Number(150),
                  .remaining = 2,
                  .dueDate = 110,
                  .expected = "loan pay must decrease PaymentRemaining"},
                 {.principal = Number(50),
+                 .totalValue = Number(150),
                  .remaining = 1,
                  .dueDate = 100,
                  .expected = "loan pay must advance NextPaymentDueDate"},
                 // Advanced, but not by a whole number of payment intervals.
                 {.principal = Number(50),
+                 .totalValue = Number(150),
                  .remaining = 1,
                  .dueDate = 105,
                  .expected = "loan pay must advance NextPaymentDueDate"},
@@ -1291,6 +1309,7 @@ class InvariantsVault_test : public InvariantsBase
                 if (!BEAST_EXPECT(sleLoan))
                     continue;
                 sleLoan->at(sfPrincipalOutstanding) = c.principal;
+                sleLoan->at(sfTotalValueOutstanding) = c.totalValue;
                 sleLoan->setFieldU32(sfPaymentRemaining, c.remaining);
                 sleLoan->setFieldU32(sfNextPaymentDueDate, c.dueDate);
                 ac.view().update(sleLoan);
@@ -1303,6 +1322,65 @@ class InvariantsVault_test : public InvariantsBase
                 BEAST_EXPECT(result == tecINVARIANT_FAILED);
                 BEAST_EXPECT(sink.messages().str().contains(c.expected));
             }
+
+            // Principal may stick while TotalValueOutstanding falls. This
+            // after-image is only a Loan mutation, so other (vault) invariants
+            // still fail under Full scope; ValidLoan itself must not.
+            {
+                Env env{*this, all_};
+                Account const a1{"A1"};
+                Account const a2{"A2"};
+                env.fund(XRP(1000), a1, a2);
+                auto const keys = createClosedXrpBroker(a1, env);
+                if (!keys)
+                {
+                    fail();
+                }
+                else
+                {
+                    auto const& brokerKeylet = keys->second;
+                    OpenView ov{*env.current()};
+                    auto const loanKeylet =
+                        keylet::loan(brokerKeylet.key, SeqProxy::rawSequence(1));
+                    {
+                        auto sleLoan = makeLoanSle(brokerKeylet.key, 1, a2.id());
+                        sleLoan->at(sfPrincipalOutstanding) = Number(100);
+                        sleLoan->at(sfTotalValueOutstanding) = Number(150);
+                        sleLoan->at(sfPaymentInterval) = 10u;
+                        sleLoan->setFieldU32(sfPaymentRemaining, 2);
+                        sleLoan->setFieldU32(sfNextPaymentDueDate, 100);
+                        ov.rawInsert(sleLoan);
+                    }
+
+                    STTx const tx{
+                        ttLOAN_PAY, [](STObject& t) { t.setFieldAmount(sfAmount, XRPAmount(50)); }};
+                    test::StreamSink sink{beast::Severity::Warning};
+                    beast::Journal const jlog{sink};
+                    ApplyContext ac{
+                        env.app(), ov, tx, tesSUCCESS, env.current()->fees().base, TapNone, jlog};
+                    CurrentTransactionRulesGuard const rulesGuard(ov.rules());
+
+                    auto sleLoan = ac.view().peek(loanKeylet);
+                    if (BEAST_EXPECT(sleLoan))
+                    {
+                        sleLoan->at(sfPrincipalOutstanding) = Number(100);
+                        sleLoan->at(sfTotalValueOutstanding) = Number(140);
+                        sleLoan->setFieldU32(sfPaymentRemaining, 1);
+                        sleLoan->setFieldU32(sfNextPaymentDueDate, 110);
+                        ac.view().update(sleLoan);
+
+                        auto transactor = makeTransactor(ac);
+                        if (BEAST_EXPECT(transactor))
+                        {
+                            std::ignore = transactor->checkInvariants(
+                                tesSUCCESS, XRPAmount{}, Transactor::InvariantScope::Full);
+                            auto const logs = sink.messages().str();
+                            BEAST_EXPECT(!logs.contains("Invariant failed: Loan"));
+                            BEAST_EXPECT(!logs.contains("loan pay"));
+                        }
+                    }
+                }
+            }
         }
 
         // ttLOAN_MANAGE (default): the write-off is rounded downward at the
diff --git a/src/test/app/lending/LendingHelpers_test.cpp b/src/test/app/lending/LendingHelpers_test.cpp
index 96adfd5254..c509469de9 100644
--- a/src/test/app/lending/LendingHelpers_test.cpp
+++ b/src/test/app/lending/LendingHelpers_test.cpp
@@ -1482,9 +1482,9 @@ class LendingHelpers_test : public beast::unit_test::Suite
     }
 
     void
-    testAccrualLoanOriginationDeltas()
+    testInstantRecognitionLoanOriginationDeltas()
     {
-        using namespace xrpl::accrual;
+        using namespace xrpl::instant_recognition;
 
         struct TestCase
         {
@@ -1504,7 +1504,7 @@ class LendingHelpers_test : public beast::unit_test::Suite
 
         for (auto const& tc : testCases)
         {
-            testcase("accrual::loanOriginationDeltas: " + tc.name);
+            testcase("instant_recognition::loanOriginationDeltas: " + tc.name);
 
             auto const deltas = loanOriginationDeltas(tc.principalRequested, tc.interestDue);
             BEAST_EXPECTS(
@@ -1540,9 +1540,9 @@ class LendingHelpers_test : public beast::unit_test::Suite
     }
 
     void
-    testAccrualLoanOriginationExceedsVaultMaximum()
+    testInstantRecognitionLoanOriginationExceedsVaultMaximum()
     {
-        using namespace xrpl::accrual;
+        using namespace xrpl::instant_recognition;
 
         struct TestCase
         {
@@ -1578,7 +1578,7 @@ class LendingHelpers_test : public beast::unit_test::Suite
 
         for (auto const& tc : testCases)
         {
-            testcase("accrual::loanOriginationExceedsVaultMaximum: " + tc.name);
+            testcase("instant_recognition::loanOriginationExceedsVaultMaximum: " + tc.name);
             BEAST_EXPECT(
                 loanOriginationExceedsVaultMaximum(
                     tc.vaultMaximum, tc.vaultTotal, tc.interestDue) == tc.expected);
@@ -1620,12 +1620,12 @@ class LendingHelpers_test : public beast::unit_test::Suite
     }
 
     void
-    testAccrualLoanVaultExposure()
+    testInstantRecognitionLoanVaultExposure()
     {
-        testcase("accrual::loanVaultExposure");
+        testcase("instant_recognition::loanVaultExposure");
 
         auto sle = makeLoanSle(Number{1'000}, Number{800}, Number{50});
-        BEAST_EXPECT(xrpl::accrual::loanVaultExposure(sle) == Number{950});
+        BEAST_EXPECT(xrpl::instant_recognition::loanVaultExposure(sle) == Number{950});
     }
 
     void
@@ -1642,7 +1642,7 @@ class LendingHelpers_test : public beast::unit_test::Suite
     {
         // principalPaid, interestPaid, feePaid, valueChange are all distinct
         // and nonzero, with a nonzero valueChange simulating a late-payment
-        // penalty, so Accrual's formula is meaningfully exercised.
+        // penalty, so InstantRecognition's formula is meaningfully exercised.
         LoanPaymentParts const parts{
             .principalPaid = Number{100},
             .interestPaid = Number{20},
@@ -1650,8 +1650,8 @@ class LendingHelpers_test : public beast::unit_test::Suite
             .feePaid = Number{3}};
 
         {
-            testcase("accrual::loanPaymentDeltas: nonzero valueChange");
-            auto const deltas = xrpl::accrual::loanPaymentDeltas(parts);
+            testcase("instant_recognition::loanPaymentDeltas: nonzero valueChange");
+            auto const deltas = xrpl::instant_recognition::loanPaymentDeltas(parts);
             BEAST_EXPECT(deltas.assetsTotalDelta == parts.valueChange);
             BEAST_EXPECT(
                 deltas.debtTotalDelta ==
@@ -1680,11 +1680,11 @@ class LendingHelpers_test : public beast::unit_test::Suite
         {
             testcase(
                 "loanOriginationDeltas dispatcher: amendment enabled, legacy vault picks "
-                "Accrual");
+                "InstantRecognition");
             Env const env{*this};
             auto const deltas = loanOriginationDeltas(legacyVault, principalRequested, interestDue);
             auto const expected =
-                xrpl::accrual::loanOriginationDeltas(principalRequested, interestDue);
+                xrpl::instant_recognition::loanOriginationDeltas(principalRequested, interestDue);
             BEAST_EXPECT(deltas.assetsTotalDelta == expected.assetsTotalDelta);
             BEAST_EXPECT(deltas.debtTotalDelta == expected.debtTotalDelta);
         }
@@ -1709,7 +1709,7 @@ class LendingHelpers_test : public beast::unit_test::Suite
 
         Number const vaultMaximum{1'000};
         Number const vaultTotal{900};
-        // Exceeds Accrual's headroom (100), but must never trip CashBasis.
+        // Exceeds InstantRecognition's headroom (100), but must never trip CashBasis.
         Number const interestDue{101};
 
         auto const legacyVault = makeVaultSle(std::nullopt, vaultMaximum, vaultTotal);
@@ -1718,11 +1718,11 @@ class LendingHelpers_test : public beast::unit_test::Suite
         {
             testcase(
                 "loanOriginationExceedsVaultMaximum dispatcher: amendment enabled, legacy vault "
-                "picks Accrual");
+                "picks InstantRecognition");
             Env const env{*this};
             BEAST_EXPECT(
                 loanOriginationExceedsVaultMaximum(legacyVault, vaultTotal, interestDue) ==
-                xrpl::accrual::loanOriginationExceedsVaultMaximum(
+                xrpl::instant_recognition::loanOriginationExceedsVaultMaximum(
                     vaultMaximum, vaultTotal, interestDue));
         }
 
@@ -1746,11 +1746,14 @@ class LendingHelpers_test : public beast::unit_test::Suite
         auto const cashBasisVault = makeVaultSle(VaultVersion::CashBasis);
 
         {
-            testcase("loanVaultExposure dispatcher: amendment enabled, legacy vault picks Accrual");
+            testcase(
+                "loanVaultExposure dispatcher: amendment enabled, legacy vault picks "
+                "InstantRecognition");
             Env const env{*this};
             auto sle = makeLoanSle(Number{1'000}, Number{800}, Number{50});
             BEAST_EXPECT(
-                loanVaultExposure(legacyVault, sle) == xrpl::accrual::loanVaultExposure(sle));
+                loanVaultExposure(legacyVault, sle) ==
+                xrpl::instant_recognition::loanVaultExposure(sle));
         }
 
         {
@@ -1780,10 +1783,12 @@ class LendingHelpers_test : public beast::unit_test::Suite
         auto const cashBasisVault = makeVaultSle(VaultVersion::CashBasis);
 
         {
-            testcase("loanPaymentDeltas dispatcher: amendment enabled, legacy vault picks Accrual");
+            testcase(
+                "loanPaymentDeltas dispatcher: amendment enabled, legacy vault picks "
+                "InstantRecognition");
             Env const env{*this};
             auto const deltas = loanPaymentDeltas(legacyVault, parts);
-            auto const expected = xrpl::accrual::loanPaymentDeltas(parts);
+            auto const expected = xrpl::instant_recognition::loanPaymentDeltas(parts);
             BEAST_EXPECT(deltas.assetsTotalDelta == expected.assetsTotalDelta);
             BEAST_EXPECT(deltas.debtTotalDelta == expected.debtTotalDelta);
         }
@@ -1999,10 +2004,10 @@ public:
         testComputeInterestAndFeeParts();
         testCanApplyToBrokerCover();
 
-        testAccrualLoanOriginationDeltas();
+        testInstantRecognitionLoanOriginationDeltas();
         testCashBasisLoanOriginationDeltas();
-        testAccrualLoanOriginationExceedsVaultMaximum();
-        testAccrualLoanVaultExposure();
+        testInstantRecognitionLoanOriginationExceedsVaultMaximum();
+        testInstantRecognitionLoanVaultExposure();
         testCashBasisLoanVaultExposure();
         testLoanPaymentDeltas();
         testLoanOriginationDeltasDispatcher();
diff --git a/src/test/app/lending/LoanBroker_test.cpp b/src/test/app/lending/LoanBroker_test.cpp
index 5b3ea854f8..3bcda42c7e 100644
--- a/src/test/app/lending/LoanBroker_test.cpp
+++ b/src/test/app/lending/LoanBroker_test.cpp
@@ -2968,126 +2968,6 @@ class LoanBroker_test : public beast::unit_test::Suite
         runTestCases(all_ - fixCleanup3_2_0);
     }
 
-    void
-    testCredentialPinsPseudoAccount()
-    {
-        using namespace test::jtx;
-        using namespace loan_broker;
-
-        // A credential issued to a LoanBroker pseudo-account can't be accepted
-        // or deleted by it, so it stays pinned in the pseudo-account's owner
-        // directory and blocks LoanBrokerDelete with tecHAS_OBLIGATIONS. A pin
-        // created before the cure activates is removed by LoanBrokerDelete once
-        // it does.
-        Account const alice{"alice"};  // vault & broker owner
-        Account const attacker{"attacker"};
-        char const credType[] = "FN36";
-
-        Env env{*this, all_ - fixCleanup3_3_0 - fixCleanup3_4_0};
-        env.fund(XRP(1'000'000), alice, attacker);
-        env.close();
-
-        Vault const vault{env};
-        auto [vtx, vkeylet] = vault.create({.owner = alice, .asset = xrpIssue()});
-        env(vtx);
-        env.close();
-        BEAST_EXPECT(env.le(vkeylet));
-
-        auto const brokerKeylet =
-            keylet::loanBroker(alice.id(), SeqProxy::rawSequence(env.seq(alice)));
-        env(set(alice.id(), vkeylet.key));
-        env.close();
-
-        auto const broker = env.le(brokerKeylet);
-        BEAST_EXPECT(broker);
-        Account const pseudo{"broker pseudo-account", broker->at(sfAccount)};
-        env.memoize(pseudo);
-
-        testcase("Credential pins broker pseudo-account");
-        env(credentials::create(pseudo, attacker, credType));
-        env.close();
-
-        auto const credKey = credentials::keylet(pseudo, attacker, credType);
-        BEAST_EXPECT(env.le(credKey));
-        BEAST_EXPECT(ownerCount(env, attacker) == 1);
-
-        env(del(alice.id(), brokerKeylet.key), Ter(tecHAS_OBLIGATIONS));
-        env.close();
-
-        env.enableFeature(fixCleanup3_4_0);
-        env.close();
-
-        // The pre-existing pin no longer blocks deletion; the credential is
-        // cleaned up and the issuer's owner count is restored.
-        testcase("LoanBrokerDelete removes pinned credential");
-        env(del(alice.id(), brokerKeylet.key));
-        env.close();
-
-        BEAST_EXPECT(!env.le(credKey));
-        BEAST_EXPECT(!env.le(brokerKeylet));
-        BEAST_EXPECT(!env.le(keylet::account(pseudo.id())));
-        BEAST_EXPECT(ownerCount(env, attacker) == 0);
-    }
-
-    void
-    testCredentialPinOverflow()
-    {
-        using namespace test::jtx;
-        using namespace loan_broker;
-        testcase("Credential pin cleanup is bounded (tecINCOMPLETE)");
-
-        // A pseudo-account can be pinned with more credentials than one
-        // transaction is allowed to clean up. LoanBrokerDelete then removes
-        // them a bounded batch at a time, returning tecINCOMPLETE until the
-        // last batch.
-        Account const alice{"alice"};
-        Account const attacker{"attacker"};
-
-        Env env{*this, all_ - fixCleanup3_3_0 - fixCleanup3_4_0};
-        env.fund(XRP(10'000'000), alice, attacker);
-        env.close();
-
-        Vault const vault{env};
-        auto [vtx, vkeylet] = vault.create({.owner = alice, .asset = xrpIssue()});
-        env(vtx);
-        env.close();
-        BEAST_EXPECT(env.le(vkeylet));
-
-        auto const brokerKeylet =
-            keylet::loanBroker(alice.id(), SeqProxy::rawSequence(env.seq(alice)));
-        env(set(alice.id(), vkeylet.key));
-        env.close();
-
-        auto const broker = env.le(brokerKeylet);
-        BEAST_EXPECT(broker);
-        Account const pseudo{"broker pseudo-account", broker->at(sfAccount)};
-        env.memoize(pseudo);
-
-        // Pin more than one cleanup batch's worth of credentials.
-        std::uint16_t const count = kMaxDeletablePseudoAccountCredentials + 3;
-        for (std::uint16_t i = 0; i < count; ++i)
-            env(credentials::create(pseudo, attacker, std::to_string(i)));
-        env.close();
-        BEAST_EXPECT(ownerCount(env, attacker) == count);
-
-        env.enableFeature(fixCleanup3_4_0);
-        env.close();
-
-        // First delete removes one bounded batch and reports it isn't finished.
-        env(del(alice.id(), brokerKeylet.key), Ter(tecINCOMPLETE));
-        env.close();
-        BEAST_EXPECT(env.le(brokerKeylet));  // broker still exists
-        auto const remaining = ownerCount(env, attacker);
-        BEAST_EXPECT(remaining > 0 && remaining < count);
-
-        // Second delete finishes the cleanup and removes the broker.
-        env(del(alice.id(), brokerKeylet.key));
-        env.close();
-        BEAST_EXPECT(!env.le(brokerKeylet));
-        BEAST_EXPECT(!env.le(keylet::account(pseudo.id())));
-        BEAST_EXPECT(ownerCount(env, attacker) == 0);
-    }
-
 public:
     void
     run() override
@@ -3106,8 +2986,6 @@ public:
 
         testDisabled();
         testLifecycle();
-        testCredentialPinsPseudoAccount();
-        testCredentialPinOverflow();
         testInvalidLoanBrokerDelete();
         testInvalidLoanBrokerSet();
         testRequireAuth();
diff --git a/src/test/app/lending/LoanCashBasis_test.cpp b/src/test/app/lending/LoanCashBasis_test.cpp
index e238838306..f9f5948db9 100644
--- a/src/test/app/lending/LoanCashBasis_test.cpp
+++ b/src/test/app/lending/LoanCashBasis_test.cpp
@@ -39,13 +39,13 @@ namespace xrpl::test {
 // amendment. They are called once, directly, from
 // runAmendmentIndependent() -- not looped through
 // runAmendmentSensitive()/amendmentCombinations(), since doing so would
-// require re-deriving whole-life-specific expected values for ~15
+// require re-deriving instant-recognition-specific expected values for ~15
 // unrelated regression tests.
 class LoanCashBasis_test : public LoanTestBase
 {
 private:
     // 1. LoanSet origination: Vault.AssetsTotal/LoanBroker.DebtTotal deltas,
-    // and the AssetsMaximum/DebtMaximum guards. Accrual AssetsMaximum still
+    // and the AssetsMaximum/DebtMaximum guards. Instant-recognition AssetsMaximum still
     // requires headroom for interestDue; cash-basis AssetsMaximum does not,
     // because origination does not credit interest into AssetsTotal.
     void
@@ -147,16 +147,16 @@ private:
 
             BEAST_EXPECTS(
                 assetsTotalDelta == interestDue,
-                "whole-life origination must add interestDue to AssetsTotal; delta=" +
+                "instant-recognition origination must add interestDue to AssetsTotal; delta=" +
                     to_string(assetsTotalDelta) + " interestDue=" + to_string(interestDue));
             BEAST_EXPECTS(
                 debtTotalDelta == principalOutstanding + interestDue,
-                "whole-life origination must add principal+interest to DebtTotal; delta=" +
+                "instant-recognition origination must add principal+interest to DebtTotal; delta=" +
                     to_string(debtTotalDelta));
         }
 
         // AssetsMaximum guard checks interestDue headroom only under
-        // whole-life accounting; DebtMaximum guard also varies by model.
+        // instant interest recognition; DebtMaximum guard also varies by model.
         auto runVaultGuard = [&](FeatureBitset features, Number const& slack, TER expected) {
             Env env(*this, features);
 
@@ -217,7 +217,8 @@ private:
 
         Number const oneDrop = xrpAsset(1).value();
         {
-            testcase("whole-life: LoanSet AssetsMaximum guard checks interestDue headroom");
+            testcase(
+                "instant-recognition: LoanSet AssetsMaximum guard checks interestDue headroom");
             // Guard rejects when there's not quite enough headroom for the
             // interest.
             runVaultGuard(all_, interestDueCash - oneDrop, tecLIMIT_EXCEEDED);
@@ -230,19 +231,19 @@ private:
             // Even far less headroom than interestDue still succeeds, since
             // cash-basis origination never adds interest to AssetsTotal.
             runVaultGuard(all_ | featureLendingProtocolV1_1, oneDrop, tesSUCCESS);
-            // Fully subscribed: AssetsTotal == AssetsMaximum. Accrual preclaim
+            // Fully subscribed: AssetsTotal == AssetsMaximum. Instant-recognition preclaim
             // used to refuse this; origination must still succeed because it
             // does not change AssetsTotal.
             runVaultGuard(all_ | featureLendingProtocolV1_1, Number{0}, tesSUCCESS);
         }
 
         // DebtMaximum guard: cash-basis projects principal-only DebtTotal;
-        // whole-life projects principal + interestDue.
+        // instant recognition projects principal + interestDue.
         for (auto const cashBasis : {true, false})
         {
             testcase(
                 std::string("LoanSet DebtMaximum guard (") +
-                (cashBasis ? "cash-basis)" : "whole-life)"));
+                (cashBasis ? "cash-basis)" : "instant-recognition)"));
             auto const features = cashBasis ? all_ | featureLendingProtocolV1_1 : all_;
             Number const newDebtTotal =
                 principalOutstandingCash + (cashBasis ? Number{} : interestDueCash);
@@ -254,9 +255,9 @@ private:
     // 2. LoanPay: regular, late, overpayment, and full-payment types.
     // Assert Vault.AssetsTotal/LoanBroker.DebtTotal deltas match
     // interestPaid/principalPaid under cash-basis, and cross-check the
-    // amendment-disabled run's deltas against the documented whole-life
+    // amendment-disabled run's deltas against the documented instant-recognition
     // formula (AssetsTotal += valueChange; DebtTotal mirrors the loan's own
-    // TotalValueOutstanding delta exactly, since whole-life debt recognition
+    // TotalValueOutstanding delta exactly, since instant-recognition debt recognition
     // tracks total loan value).
     void
     testCashBasisLoanPay()
@@ -360,7 +361,7 @@ private:
                 .totalValueDelta = totalValueAfter - totalValueBefore};
         };
 
-        // Compares the disabled (whole-life) and enabled (cash-basis) runs
+        // Compares the disabled (instant-recognition) and enabled (cash-basis) runs
         // of the same payment scenario, and asserts the documented
         // relationships between them.
         auto checkScenario = [&](std::string const& label,
@@ -381,12 +382,12 @@ private:
             // does.
             BEAST_EXPECTS(
                 off.debtTotalDelta == off.totalValueDelta,
-                "whole-life DebtTotal delta must mirror TotalValueOutstanding delta; "
+                "instant-recognition DebtTotal delta must mirror TotalValueOutstanding delta; "
                 "debtTotalDelta=" +
                     to_string(off.debtTotalDelta) +
                     " totalValueDelta=" + to_string(off.totalValueDelta));
 
-            // Derive interestPaid from the whole-life run's independent
+            // Derive interestPaid from the instant-recognition run's independent
             // ledger deltas:
             //   assetsTotalDelta_off == valueChange
             //   debtTotalDelta_off == valueChange - (principalPaid + interestPaid)
@@ -423,10 +424,11 @@ private:
 
             // Regular, on-time payments never change the loan's value beyond
             // normal amortization (production asserts valueChange == 0), so
-            // AssetsTotal must be unaffected in the whole-life run.
+            // AssetsTotal must be unaffected in the instant-recognition run.
             BEAST_EXPECTS(
                 off.assetsTotalDelta == beast::kZero,
-                "regular on-time payment must not change AssetsTotal under whole-life; delta=" +
+                "regular on-time payment must not change AssetsTotal under instant recognition; "
+                "delta=" +
                     to_string(off.assetsTotalDelta));
 
             checkScenario("regular payment", off, on);
@@ -932,14 +934,15 @@ private:
     }
 
     // 3b. LEVersion regression: a Vault created before featureLendingProtocolV1_1
-    // activates (LEVersion absent) must keep whole-life (accrual) accounting
+    // activates (LEVersion absent) must keep instant interest recognition
     // forever, even after the amendment is later enabled -- the switch is
     // per-Vault (LEVersion == VaultVersion::CashBasis), not a single global amendment
     // flag.
     void
-    testLegacyVaultKeepsAccrualAfterAmendmentEnabled()
+    testLegacyVaultKeepsInstantRecognitionAfterAmendmentEnabled()
     {
-        testcase("LEVersion: legacy vault keeps accrual after amendment enabled");
+        testcase(
+            "LEVersion: legacy vault keeps instant interest recognition after amendment enabled");
 
         using namespace jtx;
         using namespace loan;
@@ -977,7 +980,7 @@ private:
         }
 
         // Now enable the amendment -- production dispatch must still treat
-        // this specific Vault as accrual-basis, since its LEVersion is
+        // this specific Vault as instant interest recognition, since its LEVersion is
         // (and remains) absent.
         env.enableFeature(featureLendingProtocolV1_1);
         env.close();
@@ -997,7 +1000,7 @@ private:
         auto const loanSequence = brokerBeforeLoan->at(sfLoanSequence);
         auto const loanKeylet = keylet::loan(broker.brokerID, SeqProxy::rawSequence(loanSequence));
 
-        // ---- LoanSet origination: whole-life formulas expected ----
+        // ---- LoanSet origination: instant-recognition formulas expected ----
         auto const vaultBeforeSet = env.le(broker.vaultKeylet());
         auto const brokerBeforeSet = env.le(broker.brokerKeylet());
         BEAST_EXPECT(vaultBeforeSet && brokerBeforeSet);
@@ -1034,7 +1037,7 @@ private:
         LoanState const state = getCurrentState(env, broker, loanKeylet);
         env.close();
 
-        // ---- LoanPay: whole-life formulas expected ----
+        // ---- LoanPay: instant-recognition formulas expected ----
         auto const vaultBeforePay = env.le(broker.vaultKeylet());
         auto const brokerBeforePay = env.le(broker.brokerKeylet());
         auto const loanBeforePay = env.le(loanKeylet);
@@ -1059,7 +1062,7 @@ private:
             Number(brokerAfterPay->at(sfDebtTotal)) - debtTotalBeforePay;
         Number const totalValueDeltaPay = totalValueAfterPay - totalValueBeforePay;
 
-        // A regular, on-time payment has valueChange == 0, so whole-life
+        // A regular, on-time payment has valueChange == 0, so instant-recognition
         // AssetsTotal is untouched and DebtTotal mirrors TotalValueOutstanding.
         BEAST_EXPECTS(
             assetsTotalDeltaPay == beast::kZero,
@@ -1071,7 +1074,7 @@ private:
             "debtTotalDelta=" +
                 to_string(debtTotalDeltaPay) + " totalValueDelta=" + to_string(totalValueDeltaPay));
 
-        // ---- LoanManage: impair, then default -- whole-life exposure expected ----
+        // ---- LoanManage: impair, then default -- instant-recognition exposure expected ----
         auto const loanBeforeImpair = env.le(loanKeylet);
         BEAST_EXPECT(loanBeforeImpair);
         Number const totalValueBeforeImpair = loanBeforeImpair->at(sfTotalValueOutstanding);
@@ -1110,7 +1113,7 @@ private:
 
         BEAST_EXPECTS(
             debtTotalDeltaDefault == -expectedExposure,
-            "legacy vault default must reduce DebtTotal by whole-life exposure; delta=" +
+            "legacy vault default must reduce DebtTotal by instant-recognition exposure; delta=" +
                 to_string(debtTotalDeltaDefault) + " expected=" + to_string(expectedExposure));
         BEAST_EXPECTS(
             lossDeltaDefault == -expectedExposure,
@@ -1131,7 +1134,7 @@ private:
     // entirely under the amendment, with independently hand-computed
     // expected AssetsTotal/DebtTotal/LossUnrealized/CoverAvailable values at
     // each step. 0% interest keeps the arithmetic exact and tractable; the
-    // divergence from whole-life accounting is already covered directly by
+    // divergence from instant interest recognition is already covered directly by
     // testCashBasisLoanSetOrigination/LoanPay/LoanManage above, so this test
     // focuses purely on an independent, from-scratch trajectory check.
     void
@@ -1270,7 +1273,7 @@ public:
         testVaultSetWhileAssetsTotalExceedsMaximum();
         testCashBasisLoanSetAfterInterestExceedsCap();
         testCashBasisLoanManage();
-        testLegacyVaultKeepsAccrualAfterAmendmentEnabled();
+        testLegacyVaultKeepsInstantRecognitionAfterAmendmentEnabled();
         testCashBasisEndToEndTrajectory();
     }
 };
diff --git a/src/test/app/lending/LoanLifecycle_test.cpp b/src/test/app/lending/LoanLifecycle_test.cpp
index dae6f6ce16..45420529c6 100644
--- a/src/test/app/lending/LoanLifecycle_test.cpp
+++ b/src/test/app/lending/LoanLifecycle_test.cpp
@@ -205,8 +205,14 @@ private:
         if (!BEAST_EXPECT(!createJson.isMember(jss::Signers)))
             counterpartyJson[sfSigners] = createJson[sfSigners];
 
-        // The duplicated signature works
-        createJson = env.json(createJson, Json(sfCounterpartySignature, counterpartyJson));
+        // The duplicated signature does not work: the counterparty signs a
+        // different prefix than the account.
+        env(env.json(createJson, Json(sfCounterpartySignature, counterpartyJson)),
+            Ter(telENV_RPC_FAILED));
+
+        // Signing the counterparty field itself works, even though the lender
+        // is both the borrower and the counterparty.
+        createJson = env.json(createJson, Sig(sfCounterpartySignature, lender));
         env(createJson);
 
         env.close();
diff --git a/src/test/app/lending/LoanMisc_test.cpp b/src/test/app/lending/LoanMisc_test.cpp
index c5a7d54311..7c4db3e2bf 100644
--- a/src/test/app/lending/LoanMisc_test.cpp
+++ b/src/test/app/lending/LoanMisc_test.cpp
@@ -113,21 +113,26 @@ private:
             txJson[sfTransactionType] = "AccountSet";
             txJson[sfAccount] = borrower.human();
 
-            auto const borrowerSignParams = [&]() {
-                json::Value params{json::ValueType::Object};
-                params[jss::passphrase] = borrowerPass;
-                params[jss::key_type] = "ed25519";
-                params[jss::signature_target] = "Destination";
-                params[jss::tx_json] = txJson;
-                return params;
-            }();
-            auto const jSignBorrower = env.rpc("json", "sign", to_string(borrowerSignParams));
-            BEAST_EXPECT(
-                jSignBorrower.isMember(jss::result) &&
-                jSignBorrower[jss::result].isMember(jss::error) &&
-                jSignBorrower[jss::result][jss::error] == "invalidParams" &&
-                jSignBorrower[jss::result].isMember(jss::error_message) &&
-                jSignBorrower[jss::result][jss::error_message] == "Destination");
+            // "Destination" is not an inner object at all. "Book" is one, but
+            // it holds no transaction signature, so it is not a target either.
+            for (char const* target : {"Destination", "Book", "Signer"})
+            {
+                auto const borrowerSignParams = [&]() {
+                    json::Value params{json::ValueType::Object};
+                    params[jss::passphrase] = borrowerPass;
+                    params[jss::key_type] = "ed25519";
+                    params[jss::signature_target] = target;
+                    params[jss::tx_json] = txJson;
+                    return params;
+                }();
+                auto const jSignBorrower = env.rpc("json", "sign", to_string(borrowerSignParams));
+                BEAST_EXPECT(
+                    jSignBorrower.isMember(jss::result) &&
+                    jSignBorrower[jss::result].isMember(jss::error) &&
+                    jSignBorrower[jss::result][jss::error] == "invalidParams" &&
+                    jSignBorrower[jss::result].isMember(jss::error_message) &&
+                    jSignBorrower[jss::result][jss::error_message] == target);
+            }
         }
         {
             testcase("RPC LoanSet - sign and submit borrower initiated");
diff --git a/src/test/app/lending/LoanRounding_test.cpp b/src/test/app/lending/LoanRounding_test.cpp
index ded1c816a2..4a2063ed77 100644
--- a/src/test/app/lending/LoanRounding_test.cpp
+++ b/src/test/app/lending/LoanRounding_test.cpp
@@ -415,6 +415,9 @@ private:
     // The test pays one period at a time across three LoanPay
     // transactions and verifies the loan completes (paymentRemaining=0)
     // with totals matching the loan's economics (1 principal + 2 interest).
+    // Also run under featureLendingProtocolV1_1: ValidLoan must allow the
+    // two sticking pays (TVO falls, PO does not) and the final clear
+    // (PaymentRemaining 0, NextPaymentDueDate 0).
     void
     testIntegerScalePrincipalSticks(FeatureBitset features)
     {
@@ -446,28 +449,19 @@ private:
         env(pay(issuer, borrower, asset(10'000)));
         env.close();
 
-        Vault const vault{env};
-        auto [vaultTx, vaultKeylet] = vault.create({.owner = lender, .asset = asset});
-        env(vaultTx);
-        env.close();
+        // createVaultAndBroker promotes the vault to ClosedEnded under
+        // featureLendingProtocolV1_1 (LoanBrokerSet rejects open-ended).
+        BrokerParameters const params{
+            .vaultDeposit = Number{5'000},
+            .debtMax = Number{100},
+            .coverRateMin = TenthBips32{0},
+            .coverDeposit = 0,
+            .managementFeeRate = TenthBips16{0},
+            .coverRateLiquidation = TenthBips32{0}};
+        BrokerInfo const broker = createVaultAndBroker(env, asset, lender, params);
 
-        env(vault.deposit({.depositor = lender, .id = vaultKeylet.key, .amount = asset(5'000)}));
-        env.close();
-
-        auto const brokerKeylet =
-            keylet::loanBroker(lender.id(), SeqProxy::rawSequence(env.seq(lender)));
-        env(loan_broker::set(lender, vaultKeylet.key),
-            loan_broker::kDebtMaximum(Number{100}),
-            Fee(env.current()->fees().base * 2));
-        env.close();
-
-        auto const brokerStateBefore = env.le(brokerKeylet);
-        if (!BEAST_EXPECT(brokerStateBefore))
-            return;
-        auto const loanSequence = brokerStateBefore->at(sfLoanSequence);
-        auto const loanKeylet = keylet::loan(brokerKeylet.key, SeqProxy::rawSequence(loanSequence));
-
-        env(loan::set(borrower, brokerKeylet.key, Number{1}),
+        auto const loanKeylet = nextLoanKeylet(env, broker);
+        env(loan::set(borrower, broker.brokerID, Number{1}),
             Sig(sfCounterpartySignature, lender),
             loan::kInterestRate(TenthBips32{50'000}),
             loan::kPaymentTotal(3),
@@ -499,6 +493,8 @@ private:
             BEAST_EXPECT(sle->at(sfPrincipalOutstanding) == expectedPO[i]);
             BEAST_EXPECT(sle->at(sfTotalValueOutstanding) == expectedTVO[i]);
             BEAST_EXPECT(sle->at(sfPaymentRemaining) == expectedRemaining[i]);
+            if (expectedRemaining[i] == 0)
+                BEAST_EXPECT(sle->at(~sfNextPaymentDueDate).value_or(0) == 0);
         }
 
         // Borrower paid 3 total regardless of fee split (1 principal + 2
@@ -1226,6 +1222,9 @@ private:
         testBugVaultWithdrawDustVsAssetsTotal(all_ - fixCleanup3_4_0);
         testBugVaultWithdrawDustVsAssetsTotal(all_);
         testBugInterestDueDeltaCrash();
+        // all_ excludes V1.1; amendmentCombinations never pairs it with the
+        // sticking schedule. Run that combination explicitly.
+        testIntegerScalePrincipalSticks(all_ | featureLendingProtocolV1_1);
     }
 
     // Tests run under each entry in amendmentCombinations().
diff --git a/src/test/app/lending/LoanSecurity_test.cpp b/src/test/app/lending/LoanSecurity_test.cpp
index 463273e227..54c972b505 100644
--- a/src/test/app/lending/LoanSecurity_test.cpp
+++ b/src/test/app/lending/LoanSecurity_test.cpp
@@ -5,6 +5,7 @@
 #include <test/jtx/amount.h>
 #include <test/jtx/fee.h>
 #include <test/jtx/noop.h>
+#include <test/jtx/sponsor.h>
 #include <test/jtx/ter.h>
 #include <test/jtx/txflags.h>
 #include <test/jtx/vault.h>
@@ -1090,9 +1091,74 @@ private:
         }
     }
 
+    // Every signature on a transaction covered the same bytes before
+    // fixCleanup3_4_0, so a signature could be moved from the role that made
+    // it into another role. Here the lender signs a LoanSet as the
+    // counterparty, and the borrower copies that signature into the
+    // SponsorSignature, making the lender pay the fee without the lender ever
+    // agreeing to sponsor it.
+    void
+    testSignatureCopiedBetweenRoles(bool fixEnabled)
+    {
+        testcase(
+            std::string("Counterparty signature copied into the sponsor slot") +
+            (fixEnabled ? "" : " (pre-amendment)"));
+
+        using namespace jtx;
+        using namespace loan;
+
+        Env env(*this, fixEnabled ? all_ : all_ - fixCleanup3_4_0);
+        BEAST_EXPECT(env.enabled(fixCleanup3_4_0) == fixEnabled);
+
+        Account const lender{"lender"};
+        Account const borrower{"borrower"};
+
+        env.fund(XRP(100'000'000), lender, borrower);
+        env.close();
+
+        PrettyAsset const xrpAsset{xrpIssue(), 1'000'000};
+        auto const broker = createVaultAndBroker(env, xrpAsset, lender);
+
+        auto const feeAmt = XRP(1);
+
+        // The lender agrees to the loan by signing the Counterparty slot of a
+        // LoanSet that names the lender as the fee sponsor. The lender signs
+        // nothing else.
+        auto loanSet = env.json(
+            set(borrower, broker.brokerID, broker.asset(Number{1, 3}).value()),
+            sponsor::As(lender, spfSponsorFee),
+            Sig(sfCounterpartySignature, lender),
+            Fee(feeAmt));
+
+        // The borrower copies the lender's signature into the sponsor slot.
+        loanSet[sfSponsorSignature.jsonName] = loanSet[sfCounterpartySignature.jsonName];
+
+        auto const lenderBalance = env.balance(lender);
+        auto const borrowerBalance = env.balance(borrower);
+
+        env(loanSet, Ter(fixEnabled ? TER{telENV_RPC_FAILED} : TER{tesSUCCESS}));
+        env.close();
+
+        if (fixEnabled)
+        {
+            // The copied signature does not verify in the sponsor slot, so
+            // nothing happens at all.
+            BEAST_EXPECT(env.balance(lender) == lenderBalance);
+            BEAST_EXPECT(env.balance(borrower) == borrowerBalance);
+        }
+        else
+        {
+            // The lender paid the fee, and the borrower got the loan.
+            BEAST_EXPECT(env.balance(lender) == lenderBalance - feeAmt);
+            BEAST_EXPECT(env.balance(borrower).value() > borrowerBalance.value());
+        }
+    }
+
     void
     runAmendmentIndependent()
     {
+        testSignatureCopiedBetweenRoles(true);
+        testSignatureCopiedBetweenRoles(false);
         testRIPD3901();
         testImpairmentPaymentDateUnchanged();
         testImpairmentPaymentDatePreAmendment();
diff --git a/src/test/app/lending/LoanSet_test.cpp b/src/test/app/lending/LoanSet_test.cpp
index 5eea6f83fe..469c1662ad 100644
--- a/src/test/app/lending/LoanSet_test.cpp
+++ b/src/test/app/lending/LoanSet_test.cpp
@@ -22,6 +22,7 @@
 #include <xrpl/protocol/LedgerFormats.h>
 #include <xrpl/protocol/Protocol.h>
 #include <xrpl/protocol/SField.h>
+#include <xrpl/protocol/SeqProxy.h>
 #include <xrpl/protocol/TER.h>
 #include <xrpl/protocol/TxFlags.h>
 #include <xrpl/protocol/Units.h>
@@ -597,6 +598,105 @@ private:
             nullptr);
     }
 
+    void
+    testLoanSetOriginationFeeTwoMptCreates(FeatureBitset features)
+    {
+        using namespace jtx;
+        using namespace loan;
+
+        bool const fix340Enabled = features[fixCleanup3_4_0];
+        testcase << "LoanSet: borrower and broker owner missing MPToken"
+                 << (fix340Enabled ? "" : " pre-fixCleanup3_4_0");
+
+        Account const issuer{"issuer"};
+        Account const lender{"lender"};
+        Account const borrower{"borrower"};
+
+        Env env(*this, features);
+        env.fund(XRP(1'000'000), issuer, lender, borrower);
+        env.close();
+
+        MPTTester mptt{env, issuer, kMptInitNoFund};
+        mptt.create({.flags = tfMPTCanTransfer | tfMPTCanLock});
+        env.close();
+        PrettyAsset const asset = mptt.issuanceID();
+        mptt.authorize({.account = lender});
+        mptt.authorize({.account = borrower});
+        env.close();
+
+        env(pay(issuer, lender, asset(10'000'000)));
+        env.close();
+
+        auto const broker = createVaultAndBroker(env, asset, lender);
+
+        // Delete borrower's asset MPToken.
+        mptt.authorize({.account = borrower, .flags = tfMPTUnauthorize});
+        env.close();
+
+        // Pay out and delete the broker owner's asset MPToken.
+        auto const lenderMPToken = keylet::mptoken(mptt.issuanceID(), lender);
+        auto const sleLenderMPT = env.le(lenderMPToken);
+        if (!BEAST_EXPECT(sleLenderMPT))
+            return;
+        env(pay(lender, issuer, asset(sleLenderMPT->at(sfMPTAmount))));
+        env.close();
+        mptt.authorize({.account = lender, .flags = tfMPTUnauthorize});
+        env.close();
+
+        auto const borrowerMPToken = keylet::mptoken(mptt.issuanceID(), borrower);
+        auto const brokerKeylet = keylet::loanBroker(broker.brokerID);
+        auto const sleBrokerBefore = env.le(brokerKeylet);
+        if (!BEAST_EXPECT(sleBrokerBefore))
+            return;
+        auto const loanSequence = sleBrokerBefore->at(sfLoanSequence);
+        auto const debtTotalBefore = sleBrokerBefore->at(sfDebtTotal);
+        auto const loanKeylet = keylet::loan(broker.brokerID, SeqProxy::rawSequence(loanSequence));
+
+        auto const sleVaultBefore = env.le(keylet::vault(broker.vaultID));
+        if (!BEAST_EXPECT(sleVaultBefore))
+            return;
+        auto const assetsAvailableBefore = sleVaultBefore->at(sfAssetsAvailable);
+
+        env(set(borrower, broker.brokerID, asset(1'000).value()),
+            kLoanOriginationFee(asset(1).value()),
+            kCounterparty(lender),
+            Sig(sfCounterpartySignature, lender),
+            Fee(env.current()->fees().base * 5),
+            Ter{fix340Enabled ? TER{tesSUCCESS} : TER{tecINVARIANT_FAILED}});
+        env.close();
+
+        auto const sleBorrowerAfter = env.le(borrowerMPToken);
+        auto const sleLenderAfter = env.le(lenderMPToken);
+        auto const sleLoanAfter = env.le(loanKeylet);
+        auto const sleBrokerAfter = env.le(brokerKeylet);
+        auto const sleVaultAfter = env.le(keylet::vault(broker.vaultID));
+        if (!BEAST_EXPECT(sleVaultAfter))
+            return;
+        if (fix340Enabled)
+        {
+            if (!BEAST_EXPECT(sleBorrowerAfter && sleLenderAfter && sleLoanAfter && sleBrokerAfter))
+                return;
+            BEAST_EXPECT(sleBorrowerAfter->at(sfMPTAmount) == 999);
+            BEAST_EXPECT(sleLenderAfter->at(sfMPTAmount) == 1);
+            BEAST_EXPECT(sleLoanAfter->at(sfPrincipalOutstanding) == Number{1'000});
+            BEAST_EXPECT(sleBrokerAfter->at(sfLoanSequence) == loanSequence + 1);
+            BEAST_EXPECT(
+                sleVaultAfter->at(sfAssetsAvailable) == assetsAvailableBefore - Number{1'000});
+        }
+        else
+        {
+            // The whole transaction must roll back.
+            BEAST_EXPECT(!sleBorrowerAfter);
+            BEAST_EXPECT(!sleLenderAfter);
+            BEAST_EXPECT(!sleLoanAfter);
+            if (!BEAST_EXPECT(sleBrokerAfter))
+                return;
+            BEAST_EXPECT(sleBrokerAfter->at(sfLoanSequence) == loanSequence);
+            BEAST_EXPECT(sleBrokerAfter->at(sfDebtTotal) == debtTotalBefore);
+            BEAST_EXPECT(sleVaultAfter->at(sfAssetsAvailable) == assetsAvailableBefore);
+        }
+    }
+
     // LoanSet in a closed-ended vault — phase gating and maturity bound.
     void
     testLoanSetClosedEnded()
@@ -838,6 +938,8 @@ public:
 
         testLoanSetClosedEnded();
         testLoanSetExistingLineAfterIssuerClearsDefaultRipple();
+        testLoanSetOriginationFeeTwoMptCreates(all_);
+        testLoanSetOriginationFeeTwoMptCreates(all_ - fixCleanup3_4_0);
     }
 };
 
diff --git a/src/test/app/lending/LoanTestBase.h b/src/test/app/lending/LoanTestBase.h
index 13dffb6b9e..ab74ab6811 100644
--- a/src/test/app/lending/LoanTestBase.h
+++ b/src/test/app/lending/LoanTestBase.h
@@ -85,7 +85,7 @@ protected:
     //
     // featureLendingProtocolV1_1 is excluded from the default set: it changes
     // Vault/LoanBroker accounting (AssetsTotal/DebtTotal/LossUnrealized), and
-    // most of this file's tests assert whole-life-specific expected values
+    // most of this file's tests assert instant-interest-recognition-specific expected values
     // for those fields. Tests that specifically exercise the amendment opt
     // it back in explicitly (e.g. `all_ | featureLendingProtocolV1_1`).
     FeatureBitset const all_{jtx::testableAmendments() - featureLendingProtocolV1_1};
diff --git a/src/test/app/lending/LoanValidation_test.cpp b/src/test/app/lending/LoanValidation_test.cpp
index 169a02c462..566633b690 100644
--- a/src/test/app/lending/LoanValidation_test.cpp
+++ b/src/test/app/lending/LoanValidation_test.cpp
@@ -6,7 +6,6 @@
 #include <test/jtx/envconfig.h>
 #include <test/jtx/fee.h>
 #include <test/jtx/flags.h>
-#include <test/jtx/jtx_json.h>
 #include <test/jtx/mpt.h>
 #include <test/jtx/pay.h>
 #include <test/jtx/sponsor.h>
@@ -522,15 +521,13 @@ private:
         auto const loanSetFee = Fee(env.current()->fees().base * 2);
         Number const principalRequest{1, 3};
 
-        auto createJson = env.json(set(lender, broker.brokerID, principalRequest), Fee(loanSetFee));
-
-        json::Value counterpartyJson{json::ValueType::Object};
-        counterpartyJson[sfTxnSignature] = createJson[sfTxnSignature];
-        counterpartyJson[sfSigningPubKey] = createJson[sfSigningPubKey];
-        if (!BEAST_EXPECT(!createJson.isMember(jss::Signers)))
-            counterpartyJson[sfSigners] = createJson[sfSigners];
-
-        createJson = env.json(createJson, Json(sfCounterpartySignature, counterpartyJson));
+        // The lender is both the borrower and the counterparty here, but the
+        // two roles sign different bytes, so each signature must be made for
+        // the field it goes into.
+        auto const createJson = env.json(
+            set(lender, broker.brokerID, principalRequest),
+            Sig(sfCounterpartySignature, lender),
+            Fee(loanSetFee));
         env(createJson);
 
         env.close();
diff --git a/src/test/app/tx/apply_test.cpp b/src/test/app/tx/apply_test.cpp
index 8f71d47fcf..39289a6264 100644
--- a/src/test/app/tx/apply_test.cpp
+++ b/src/test/app/tx/apply_test.cpp
@@ -1,12 +1,23 @@
 // Copyright (c) 2020 Dev Null Productions
 
+#include <test/jtx/Account.h>
 #include <test/jtx/Env.h>
+#include <test/jtx/JTx.h>
+#include <test/jtx/TestHelpers.h>
+#include <test/jtx/amount.h>
+#include <test/jtx/fee.h>
+#include <test/jtx/noop.h>
+#include <test/jtx/sig.h>
+#include <test/jtx/sponsor.h>
 
 #include <xrpl/basics/Slice.h>
 #include <xrpl/basics/StringUtilities.h>
 #include <xrpl/beast/unit_test/suite.h>
+#include <xrpl/protocol/Feature.h>
+#include <xrpl/protocol/SField.h>
 #include <xrpl/protocol/STTx.h>
 #include <xrpl/protocol/Serializer.h>
+#include <xrpl/protocol/TxFlags.h>
 #include <xrpl/tx/apply.h>
 
 #include <functional>
@@ -22,6 +33,136 @@ public:
     {
         testcase("Require Fully Canonical Signature");
         testFullyCanonicalSigs();
+        testRoleSignatureCacheIsEraSpecific();
+        testForcedValidityIgnoresPrefixEra();
+    }
+
+    // forceValidity means the caller verified nothing and wants the result
+    // trusted, so it has to hold in both prefix eras. If it marked only the
+    // ordinary slot, a role-signature transaction would still be verified
+    // under pre-fix rules, defeating the cluster path and the configurations
+    // that turn signature checks off.
+    void
+    testForcedValidityIgnoresPrefixEra()
+    {
+        testcase("Forced validity ignores the prefix era");
+
+        using namespace test::jtx;
+
+        Env preFix{*this, testableAmendments() - fixCleanup3_4_0};
+        Env postFix{*this, testableAmendments()};
+        auto const preFixRules = preFix.current()->rules();
+
+        Account const alice{"alice"};
+        Account const sponsor{"sponsor"};
+        postFix.fund(XRP(10'000), alice, sponsor);
+        postFix.close();
+
+        // Signed under the post-fix rules, so this signature does not verify
+        // under the pre-fix prefix. Only the forced verdict can make the check
+        // below pass.
+        auto const jt = postFix.jt(
+            noop(alice),
+            Fee(XRP(1)),
+            sponsor::As(sponsor, spfSponsorFee),
+            Sig(sfSponsorSignature, sponsor));
+        if (!BEAST_EXPECT(jt.stx))
+            return;
+
+        // A router that has never seen this transaction, so the only cached
+        // state is what forceValidity writes.
+        auto& router = preFix.app().getHashRouter();
+        forceValidity(router, jt.stx->getTransactionID(), Validity::SigGoodOnly);
+        BEAST_EXPECT(checkValidity(router, *jt.stx, preFixRules).first != Validity::SigBad);
+    }
+
+    // A signature verdict reached under one prefix era must not be honored in
+    // the other, because the two eras require the sponsor signature to cover
+    // different bytes. Each direction below uses one HashRouter and differs
+    // only in the rules, which is what the flag ledger looks like in practice:
+    // relay and submit verify against the validated rules, which lag the open
+    // ledger rules that preflight2 verifies against, so one transaction gets
+    // checked under both prefixes at the same time.
+    void
+    testRoleSignatureCacheIsEraSpecific()
+    {
+        testcase("Role signature cache is era specific");
+
+        using namespace test::jtx;
+
+        Env preFix{*this, testableAmendments() - fixCleanup3_4_0};
+        Env postFix{*this, testableAmendments()};
+        auto const preFixRules = preFix.current()->rules();
+        auto const postFixRules = postFix.current()->rules();
+
+        Account const alice{"alice"};
+        Account const sponsor{"sponsor"};
+        Account const counterparty{"counterparty"};
+        for (auto* env : {&preFix, &postFix})
+        {
+            env->fund(XRP(10'000), alice, sponsor, counterparty);
+            env->close();
+        }
+
+        // Both directions for a transaction whose role signature sits in the
+        // field that makeTx signs. makeTx builds the transaction in the Env it
+        // is given, so the role signature carries that era's prefix.
+        auto checkBothDirections = [&](std::function<JTx(test::jtx::Env&)> const& makeTx) {
+            // Direction 1: a good verdict under the old prefix must not let a
+            // signature moved between roles survive the amendment.
+            {
+                auto const jt = makeTx(preFix);
+                if (!BEAST_EXPECT(jt.stx))
+                    return;
+
+                auto& router = preFix.app().getHashRouter();
+                BEAST_EXPECT(checkValidity(router, *jt.stx, preFixRules).first == Validity::Valid);
+
+                // Same router, asked again under the post-fix rules. The Valid
+                // verdict above was reached under the old prefix and must not
+                // be reused, or a signature moved between roles would survive
+                // the amendment.
+                BEAST_EXPECT(
+                    checkValidity(router, *jt.stx, postFixRules).first == Validity::SigBad);
+            }
+
+            // Direction 2: a bad verdict under the old prefix must not condemn
+            // a transaction that the new prefixes accept. A node whose
+            // validated rules still lag the open ledger will run this check
+            // pre-fix first and reject a correctly new-prefix-signed
+            // transaction; the post-fix check must then verify it afresh
+            // instead of reusing the pre-fix verdict.
+            {
+                auto const jt = makeTx(postFix);
+                if (!BEAST_EXPECT(jt.stx))
+                    return;
+
+                auto& router = postFix.app().getHashRouter();
+                BEAST_EXPECT(checkValidity(router, *jt.stx, preFixRules).first == Validity::SigBad);
+                BEAST_EXPECT(checkValidity(router, *jt.stx, postFixRules).first == Validity::Valid);
+            }
+        };
+
+        // sfSponsorSignature, which uses the SPN and SPM prefixes.
+        checkBothDirections([&](Env& env) {
+            return env.jt(
+                noop(alice),
+                Fee(XRP(1)),
+                sponsor::As(sponsor, spfSponsorFee),
+                Sig(sfSponsorSignature, sponsor));
+        });
+
+        // sfCounterpartySignature, which uses its own prefixes, CPT and CPM,
+        // and only appears on a LoanSet. The transaction does not have to be
+        // applicable: checkValidity verifies signatures without consulting the
+        // ledger, so a placeholder LoanBrokerID is enough.
+        checkBothDirections([&](Env& env) {
+            return env.jt(
+                loan::set(alice, uint256{1}, Number{1}),
+                loan::kCounterparty(counterparty),
+                Fee(XRP(1)),
+                Sig(sfCounterpartySignature, counterparty));
+        });
     }
 
     void
diff --git a/src/test/app/vault/VaultBugs_test.cpp b/src/test/app/vault/VaultBugs_test.cpp
index 5b6e756e59..43f2b0354c 100644
--- a/src/test/app/vault/VaultBugs_test.cpp
+++ b/src/test/app/vault/VaultBugs_test.cpp
@@ -7,6 +7,7 @@
 #include <test/jtx/credentials.h>
 #include <test/jtx/fee.h>
 #include <test/jtx/flags.h>
+#include <test/jtx/mpt.h>
 #include <test/jtx/pay.h>
 #include <test/jtx/permissioned_domains.h>
 #include <test/jtx/sig.h>
@@ -1355,117 +1356,6 @@ private:
         }
     }
 
-    void
-    testCredentialPinsPseudoAccount()
-    {
-        using namespace test::jtx;
-
-        // A credential issued to a vault pseudo-account can't be accepted or
-        // deleted by it (pseudo-accounts can't sign), so it stays pinned in the
-        // pseudo-account's owner directory and blocks VaultDelete with
-        // tecHAS_OBLIGATIONS. A pin created before the cure activates is removed
-        // by VaultDelete once it does.
-        Account const owner{"owner"};
-        Account const attacker{"attacker"};
-        char const credType[] = "FN36";
-
-        Env env{*this, all_ - fixCleanup3_3_0 - fixCleanup3_4_0};
-        env.fund(XRP(1'000'000), owner, attacker);
-        env.close();
-
-        Vault const vault{env};
-        PrettyAsset const asset = xrpIssue();
-        auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
-        env(tx);
-        env.close();
-
-        auto const vaultSle = env.le(keylet);
-        BEAST_EXPECT(vaultSle);
-        Account const pseudo{"vault pseudo-account", vaultSle->at(sfAccount)};
-        env.memoize(pseudo);
-
-        // The pseudo-account owns the share issuance; the pin must not change
-        // its owner count (an unaccepted credential is owned by the issuer).
-        auto const pseudoOwnerCount = ownerCount(env, pseudo);
-
-        testcase("Credential pins vault pseudo-account");
-        env(credentials::create(pseudo, attacker, credType));
-        env.close();
-
-        auto const credKey = credentials::keylet(pseudo, attacker, credType);
-        BEAST_EXPECT(env.le(credKey));
-        BEAST_EXPECT(ownerCount(env, attacker) == 1);
-        BEAST_EXPECT(ownerCount(env, pseudo) == pseudoOwnerCount);
-
-        // The pin blocks deletion of an otherwise-empty vault.
-        env(vault.del({.owner = owner, .id = keylet.key}), Ter(tecHAS_OBLIGATIONS));
-        env.close();
-
-        env.enableFeature(fixCleanup3_4_0);
-        env.close();
-
-        // The pre-existing pin no longer blocks deletion; the credential is
-        // cleaned up and the issuer's owner count is restored.
-        testcase("VaultDelete removes pinned credential");
-        env(vault.del({.owner = owner, .id = keylet.key}));
-        env.close();
-
-        BEAST_EXPECT(!env.le(credKey));
-        BEAST_EXPECT(!env.le(keylet));
-        BEAST_EXPECT(!env.le(::xrpl::keylet::account(pseudo.id())));
-        BEAST_EXPECT(ownerCount(env, attacker) == 0);
-    }
-
-    void
-    testCredentialPinOverflow()
-    {
-        using namespace test::jtx;
-        testcase("Credential pin cleanup is bounded (tecINCOMPLETE)");
-
-        // A pseudo-account can be pinned with more credentials than one
-        // transaction is allowed to clean up. VaultDelete then removes them a
-        // bounded batch at a time, returning tecINCOMPLETE until the last batch.
-        Account const owner{"owner"};
-        Account const attacker{"attacker"};
-
-        Env env{*this, all_ - fixCleanup3_3_0 - fixCleanup3_4_0};
-        env.fund(XRP(10'000'000), owner, attacker);
-        env.close();
-
-        Vault const vault{env};
-        auto [tx, keylet] = vault.create({.owner = owner, .asset = xrpIssue()});
-        env(tx);
-        env.close();
-        auto const vaultSle = env.le(keylet);
-        BEAST_EXPECT(vaultSle);
-        Account const pseudo{"vault pseudo-account", vaultSle->at(sfAccount)};
-        env.memoize(pseudo);
-
-        // Pin more than one cleanup batch's worth of credentials.
-        std::uint16_t const count = kMaxDeletablePseudoAccountCredentials + 3;
-        for (std::uint16_t i = 0; i < count; ++i)
-            env(credentials::create(pseudo, attacker, std::to_string(i)));
-        env.close();
-        BEAST_EXPECT(ownerCount(env, attacker) == count);
-
-        env.enableFeature(fixCleanup3_4_0);
-        env.close();
-
-        // First delete removes one bounded batch and reports it isn't finished.
-        env(vault.del({.owner = owner, .id = keylet.key}), Ter(tecINCOMPLETE));
-        env.close();
-        BEAST_EXPECT(env.le(keylet));  // vault still exists
-        auto const remaining = ownerCount(env, attacker);
-        BEAST_EXPECT(remaining > 0 && remaining < count);
-
-        // Second delete finishes the cleanup and removes the vault.
-        env(vault.del({.owner = owner, .id = keylet.key}));
-        env.close();
-        BEAST_EXPECT(!env.le(keylet));
-        BEAST_EXPECT(!env.le(::xrpl::keylet::account(pseudo.id())));
-        BEAST_EXPECT(ownerCount(env, attacker) == 0);
-    }
-
     struct ImpairedLoanVault
     {
         test::jtx::Account issuer;
@@ -1677,6 +1567,491 @@ private:
         }
     }
 
+    // Bug: a fully impaired vault may pay zero assets for a share burn.
+    // Sending zero MPT is a no-op, so the vault pseudo-account's asset
+    // MPToken is never written and ValidVault, which only records deltas for
+    // created, modified or deleted entries, sees no vault delta at all.
+    //
+    // Pre-fixCleanup3_4_0 that alone makes the withdrawal impossible:
+    // zeroDeltaIsLegitimate is gated on the amendment, so the absent vault
+    // delta fails "withdrawal must change vault balance". Every pre-amendment
+    // arm below dies there, before any destination-side check runs.
+    //
+    // The destination side differs per arm, and only the vault-delta return
+    // hides that pre-amendment. With Alice's asset MPToken already present
+    // nothing touches it, so she has no delta either. With it missing,
+    // doWithdraw still called addEmptyHolding for a self-destination on a
+    // zero payout and created her MPToken at amount 0; a created MPToken is
+    // recorded even at zero, so she arrives with a present-and-zero delta,
+    // which for an integral MPT asset the destination check would reject if
+    // it were reached.
+    //
+    // ValidMPTIssuance: pre-fixCleanup3_4_0, a VaultWithdraw that both
+    // creates and deletes an MPToken fails. Post-fixCleanup3_4_0 that is
+    // allowed.
+
+    //
+    // Post-fixCleanup3_4_0, doWithdraw skips addEmptyHolding on a zero
+    // payout and zeroDeltaIsLegitimate lets the vault-delta and
+    // missing-recipient-delta checks accept the transfer. A present
+    // destination delta of zero is still rejected.
+    void
+    testBugMptZeroWithdrawMissingHolding()
+    {
+        using namespace test::jtx;
+        using namespace loan_broker;
+        using namespace loan;
+        using namespace std::chrono_literals;
+
+        auto runScenario = [this](
+                               FeatureBitset features,
+                               bool removeAssetToken,
+                               bool withdrawAllAliceShares,
+                               TER expected) {
+            testcase(
+                std::string{"bug: MPT vault zero-value withdraw "} +
+                (removeAssetToken ? "without asset MPToken" : "with asset MPToken") +
+                (withdrawAllAliceShares ? ", Alice's last share" : ", Alice has leftover shares") +
+                (features[fixCleanup3_4_0] ? " (post-fixCleanup3_4_0)" : " (pre-fixCleanup3_4_0)"));
+
+            Env env(*this, features);
+
+            Account const issuer{"issuer"};
+            Account const owner{"owner"};
+            Account const alice{"alice"};
+            Account const bob{"bob"};
+            Account const borrower{"borrower"};
+
+            env.fund(XRP(100'000), issuer, owner, alice, bob, borrower);
+            env.close();
+
+            MPTTester mptt{env, issuer, kMptInitNoFund};
+            mptt.create({.flags = tfMPTCanTransfer});
+            PrettyAsset const asset = mptt.issuanceID();
+            mptt.authorize({.account = owner});
+            mptt.authorize({.account = alice});
+            mptt.authorize({.account = bob});
+            mptt.authorize({.account = borrower});
+            env.close();
+
+            env(pay(issuer, alice, asset(2)));
+            env(pay(issuer, bob, asset(8)));
+            env.close();
+
+            Vault const vault{env};
+            auto const [createTx, vaultKeylet, subscriptionDate] = vault.createClosedEnded(
+                {.owner = owner, .asset = asset, .subscriptionOffset = 60s});
+            env(createTx);
+            env.close();
+
+            env(vault.deposit({.depositor = alice, .id = vaultKeylet.key, .amount = asset(2)}));
+            env(vault.deposit({.depositor = bob, .id = vaultKeylet.key, .amount = asset(8)}));
+            env.close();
+
+            vault.closePastSubscription(subscriptionDate);
+
+            auto const brokerKeylet =
+                keylet::loanBroker(owner.id(), SeqProxy::rawSequence(env.seq(owner)));
+            env(set(owner, vaultKeylet.key));
+            env.close();
+
+            auto const sleBroker = env.le(brokerKeylet);
+            if (!BEAST_EXPECT(sleBroker))
+                return;
+            auto const loanKeylet = keylet::loan(
+                brokerKeylet.key, SeqProxy::rawSequence(sleBroker->at(sfLoanSequence)));
+
+            env(set(borrower, brokerKeylet.key, asset(10).value()),
+                kInterestRate(percentageToTenthBips(0)),
+                kGracePeriod(60),
+                kPaymentInterval(120),
+                kPaymentTotal(10),
+                Sig(sfCounterpartySignature, owner),
+                Fee(env.current()->fees().base * 2),
+                Ter(tesSUCCESS));
+            env.close();
+
+            auto const loanBefore = env.le(loanKeylet);
+            if (!BEAST_EXPECT(loanBefore))
+                return;
+            std::uint32_t const dueDate = loanBefore->at(sfNextPaymentDueDate);
+            env.close(NetClock::time_point{NetClock::duration{dueDate}} + 1s);
+
+            env(manage(owner, loanKeylet.key, tfLoanImpair), Ter(tesSUCCESS));
+            env.close();
+
+            auto const vaultImpaired = env.le(vaultKeylet);
+            if (!BEAST_EXPECT(vaultImpaired))
+                return;
+            BEAST_EXPECT(vaultImpaired->at(sfAssetsAvailable) == asset(0).value());
+            BEAST_EXPECT(vaultImpaired->at(sfAssetsTotal) == vaultImpaired->at(sfLossUnrealized));
+            Number const totalBefore = vaultImpaired->at(sfAssetsTotal);
+            Number const lossBefore = vaultImpaired->at(sfLossUnrealized);
+
+            MPTID const shareId = vaultImpaired->at(sfShareMPTID);
+            auto const issuanceBefore = env.le(keylet::mptokenIssuance(shareId));
+            if (!BEAST_EXPECT(issuanceBefore))
+                return;
+            std::uint64_t const outstandingBefore =
+                issuanceBefore->getFieldU64(sfOutstandingAmount);
+
+            auto const tokenAlice = env.le(keylet::mptoken(shareId, alice.id()));
+            if (!BEAST_EXPECT(tokenAlice))
+                return;
+            std::uint64_t const sharesBefore = tokenAlice->getFieldU64(sfMPTAmount);
+            BEAST_EXPECT(sharesBefore == 2);
+            std::uint64_t const sharesToRedeem = withdrawAllAliceShares ? sharesBefore : 1;
+            STAmount const redeemShares{MPTIssue{shareId}, Number(sharesToRedeem)};
+
+            auto const assetTokenKeylet = keylet::mptoken(mptt.issuanceID(), alice.id());
+            if (removeAssetToken)
+            {
+                mptt.authorize({.account = alice, .flags = tfMPTUnauthorize});
+                env.close();
+                BEAST_EXPECT(!env.le(assetTokenKeylet));
+            }
+            else
+            {
+                auto const existing = env.le(assetTokenKeylet);
+                if (!BEAST_EXPECT(existing))
+                    return;
+                BEAST_EXPECT(existing->getFieldU64(sfMPTAmount) == 0);
+            }
+
+            std::uint32_t const redemptionDate = vaultImpaired->at(sfRedemptionDate);
+            env.close(NetClock::time_point{NetClock::duration{redemptionDate}} + 1s);
+
+            env(vault.withdraw({.depositor = alice, .id = vaultKeylet.key, .amount = redeemShares}),
+                Ter(expected));
+            env.close();
+            if (expected != tesSUCCESS)
+                return;
+
+            if (removeAssetToken)
+            {
+                BEAST_EXPECT(!env.le(assetTokenKeylet));
+            }
+            else
+            {
+                auto const assetAfter = env.le(assetTokenKeylet);
+                if (!BEAST_EXPECT(assetAfter))
+                    return;
+                BEAST_EXPECT(assetAfter->getFieldU64(sfMPTAmount) == 0);
+            }
+
+            auto const shareAfter = env.le(keylet::mptoken(shareId, alice.id()));
+            if (withdrawAllAliceShares)
+            {
+                BEAST_EXPECT(!shareAfter);
+            }
+            else if (BEAST_EXPECT(shareAfter))
+            {
+                BEAST_EXPECT(shareAfter->getFieldU64(sfMPTAmount) == sharesBefore - sharesToRedeem);
+            }
+
+            auto const vaultAfter = env.le(vaultKeylet);
+            if (!BEAST_EXPECT(vaultAfter))
+                return;
+            BEAST_EXPECT(vaultAfter->at(sfAssetsTotal) == totalBefore);
+            BEAST_EXPECT(vaultAfter->at(sfLossUnrealized) == lossBefore);
+            BEAST_EXPECT(vaultAfter->at(sfAssetsAvailable) == asset(0).value());
+
+            auto const issuanceAfter = env.le(keylet::mptokenIssuance(shareId));
+            if (!BEAST_EXPECT(issuanceAfter))
+                return;
+            BEAST_EXPECT(
+                issuanceAfter->getFieldU64(sfOutstandingAmount) ==
+                outstandingBefore - sharesToRedeem);
+        };
+
+        runScenario(
+            all_, false /* removeAssetToken */, false /* withdrawAllAliceShares */, tesSUCCESS);
+        runScenario(
+            all_, false /* removeAssetToken */, true /* withdrawAllAliceShares */, tesSUCCESS);
+        runScenario(
+            all_, true /* removeAssetToken */, false /* withdrawAllAliceShares */, tesSUCCESS);
+        runScenario(
+            all_, true /* removeAssetToken */, true /* withdrawAllAliceShares */, tesSUCCESS);
+        runScenario(
+            all_ - fixCleanup3_4_0,
+            false /* removeAssetToken */,
+            false /* withdrawAllAliceShares */,
+            tecINVARIANT_FAILED);
+        runScenario(
+            all_ - fixCleanup3_4_0,
+            false /* removeAssetToken */,
+            true /* withdrawAllAliceShares */,
+            tecINVARIANT_FAILED);
+        runScenario(
+            all_ - fixCleanup3_4_0,
+            true /* removeAssetToken */,
+            false /* withdrawAllAliceShares */,
+            tecINVARIANT_FAILED);
+        runScenario(
+            all_ - fixCleanup3_4_0,
+            true /* removeAssetToken */,
+            true /* withdrawAllAliceShares */,
+            tecINVARIANT_FAILED);
+    }
+
+    // IOU analogue of the missing-MPToken case above. Alice removes her
+    // zero-balance trust line after depositing, then burns one unit from her
+    // scaled share balance after the vault is fully impaired. Bob's share
+    // balance keeps this out of the sole-shareholder loss-waiver and
+    // final-outstanding-share paths. A zero payout must not recreate Alice's
+    // unsolicited trust line.
+    void
+    testBugIouZeroWithdrawMissingTrustLine()
+    {
+        using namespace test::jtx;
+        using namespace loan_broker;
+        using namespace loan;
+        using namespace std::chrono_literals;
+
+        Env env(*this, all_);
+
+        Account const issuer{"issuer"};
+        Account const owner{"owner"};
+        Account const alice{"alice"};
+        Account const bob{"bob"};
+        Account const borrower{"borrower"};
+
+        env.fund(XRP(100'000), issuer, owner, alice, bob, borrower);
+        env.close();
+        env(fset(issuer, asfDefaultRipple));
+        env.close();
+
+        PrettyAsset const asset = issuer["USD"];
+        env.trust(asset(100), owner);
+        env.trust(asset(100), alice);
+        env.trust(asset(100), bob);
+        env.trust(asset(100), borrower);
+        env.close();
+
+        env(pay(issuer, alice, asset(2)));
+        env(pay(issuer, bob, asset(8)));
+        env.close();
+
+        Vault const vault{env};
+        auto const [createTx, vaultKeylet, subscriptionDate] =
+            vault.createClosedEnded({.owner = owner, .asset = asset, .subscriptionOffset = 60s});
+        env(createTx);
+        env.close();
+
+        env(vault.deposit({.depositor = alice, .id = vaultKeylet.key, .amount = asset(2)}));
+        env(vault.deposit({.depositor = bob, .id = vaultKeylet.key, .amount = asset(8)}));
+        env.close();
+
+        auto const assetLine = keylet::trustLine(alice, asset.raw().get<Issue>());
+        if (!BEAST_EXPECT(env.le(assetLine)))
+            return;
+        env.trust(asset(0), alice);
+        env.close();
+        BEAST_EXPECT(!env.le(assetLine));
+
+        vault.closePastSubscription(subscriptionDate);
+
+        auto const brokerKeylet =
+            keylet::loanBroker(owner.id(), SeqProxy::rawSequence(env.seq(owner)));
+        env(set(owner, vaultKeylet.key));
+        env.close();
+
+        auto const sleBroker = env.le(brokerKeylet);
+        if (!BEAST_EXPECT(sleBroker))
+            return;
+        auto const loanKeylet =
+            keylet::loan(brokerKeylet.key, SeqProxy::rawSequence(sleBroker->at(sfLoanSequence)));
+
+        env(set(borrower, brokerKeylet.key, asset(10).value()),
+            kInterestRate(percentageToTenthBips(0)),
+            kGracePeriod(60),
+            kPaymentInterval(120),
+            kPaymentTotal(10),
+            Sig(sfCounterpartySignature, owner),
+            Fee(env.current()->fees().base * 2),
+            Ter(tesSUCCESS));
+        env.close();
+
+        auto const loanBefore = env.le(loanKeylet);
+        if (!BEAST_EXPECT(loanBefore))
+            return;
+        std::uint32_t const dueDate = loanBefore->at(sfNextPaymentDueDate);
+        env.close(NetClock::time_point{NetClock::duration{dueDate}} + 1s);
+
+        env(manage(owner, loanKeylet.key, tfLoanImpair), Ter(tesSUCCESS));
+        env.close();
+
+        auto const vaultImpaired = env.le(vaultKeylet);
+        if (!BEAST_EXPECT(vaultImpaired))
+            return;
+        BEAST_EXPECT(vaultImpaired->at(sfAssetsAvailable) == asset(0).value());
+        BEAST_EXPECT(vaultImpaired->at(sfAssetsTotal) == vaultImpaired->at(sfLossUnrealized));
+        Number const totalBefore = vaultImpaired->at(sfAssetsTotal);
+        Number const lossBefore = vaultImpaired->at(sfLossUnrealized);
+
+        MPTID const shareId = vaultImpaired->at(sfShareMPTID);
+        auto const tokenAlice = env.le(keylet::mptoken(shareId, alice.id()));
+        if (!BEAST_EXPECT(tokenAlice))
+            return;
+        std::uint64_t const sharesBefore = tokenAlice->getFieldU64(sfMPTAmount);
+        // Default IOU vault scale is 6, so 2 USD mints 2e6 shares. Redeem one
+        // leftover share; do not require 1:1 like the MPT case.
+        BEAST_EXPECT(sharesBefore > 1);
+        STAmount const redeemShares{MPTIssue{shareId}, Number(1)};
+
+        std::uint32_t const redemptionDate = vaultImpaired->at(sfRedemptionDate);
+        env.close(NetClock::time_point{NetClock::duration{redemptionDate}} + 1s);
+
+        env(vault.withdraw({.depositor = alice, .id = vaultKeylet.key, .amount = redeemShares}),
+            Ter(tesSUCCESS));
+        env.close();
+
+        // A regression in the View guard would recreate this line even though
+        // no asset value was paid.
+        BEAST_EXPECT(!env.le(assetLine));
+
+        auto const shareAfter = env.le(keylet::mptoken(shareId, alice.id()));
+        if (!BEAST_EXPECT(shareAfter))
+            return;
+        BEAST_EXPECT(shareAfter->getFieldU64(sfMPTAmount) == sharesBefore - 1);
+
+        auto const vaultAfter = env.le(vaultKeylet);
+        if (!BEAST_EXPECT(vaultAfter))
+            return;
+        BEAST_EXPECT(vaultAfter->at(sfAssetsTotal) == totalBefore);
+        BEAST_EXPECT(vaultAfter->at(sfLossUnrealized) == lossBefore);
+        BEAST_EXPECT(vaultAfter->at(sfAssetsAvailable) == asset(0).value());
+    }
+
+    // Same zero-payout withdrawal as testBugMptZeroWithdrawMissingHolding, but
+    // the vault asset is XRP. addEmptyHolding is a no-op for native assets.
+    // Sequence processing still touches the sender AccountRoot; a sponsored
+    // fee leaves that XRP balance economically unchanged. After the
+    // sponsored-withdraw fee-payer fix, deltaAssetsForParty collapses that
+    // economically-zero XRP delta to absence, so tesSUCCESS takes the
+    // missing-recipient-delta arm gated by zeroDeltaIsLegitimate. This test
+    // covers that live SUCCESS path. Pre-fixCleanup3_4_0 still fails the
+    // invariant.
+    void
+    testBugXrpZeroWithdrawSponsoredFee()
+    {
+        using namespace test::jtx;
+        using namespace loan_broker;
+        using namespace loan;
+        using namespace std::chrono_literals;
+
+        auto runScenario = [this](FeatureBitset features, TER expected) {
+            testcase(
+                std::string{"bug: XRP vault zero-value withdraw with sponsored fee"} +
+                (features[fixCleanup3_4_0] ? " (post-fixCleanup3_4_0)" : " (pre-fixCleanup3_4_0)"));
+
+            Env env(*this, features);
+
+            Account const owner{"owner"};
+            Account const alice{"alice"};
+            Account const bob{"bob"};
+            Account const borrower{"borrower"};
+            Account const sponsor{"sponsor"};
+
+            env.fund(XRP(100'000), owner, alice, bob, borrower, sponsor);
+            env.close();
+
+            PrettyAsset const asset{xrpIssue()};
+            Vault const vault{env};
+            auto const [createTx, vaultKeylet, subscriptionDate] = vault.createClosedEnded(
+                {.owner = owner, .asset = asset, .subscriptionOffset = 60s});
+            env(createTx);
+            env.close();
+
+            env(vault.deposit({.depositor = alice, .id = vaultKeylet.key, .amount = asset(2)}));
+            env(vault.deposit({.depositor = bob, .id = vaultKeylet.key, .amount = asset(8)}));
+            env.close();
+
+            vault.closePastSubscription(subscriptionDate);
+
+            auto const brokerKeylet =
+                keylet::loanBroker(owner.id(), SeqProxy::rawSequence(env.seq(owner)));
+            env(set(owner, vaultKeylet.key));
+            env.close();
+
+            auto const sleBroker = env.le(brokerKeylet);
+            if (!BEAST_EXPECT(sleBroker))
+                return;
+            auto const loanKeylet = keylet::loan(
+                brokerKeylet.key, SeqProxy::rawSequence(sleBroker->at(sfLoanSequence)));
+
+            env(set(borrower, brokerKeylet.key, asset(10).value()),
+                kInterestRate(percentageToTenthBips(0)),
+                kGracePeriod(60),
+                kPaymentInterval(120),
+                kPaymentTotal(10),
+                Sig(sfCounterpartySignature, owner),
+                Fee(env.current()->fees().base * 2),
+                Ter(tesSUCCESS));
+            env.close();
+
+            auto const loanBefore = env.le(loanKeylet);
+            if (!BEAST_EXPECT(loanBefore))
+                return;
+            std::uint32_t const dueDate = loanBefore->at(sfNextPaymentDueDate);
+            env.close(NetClock::time_point{NetClock::duration{dueDate}} + 1s);
+
+            env(manage(owner, loanKeylet.key, tfLoanImpair), Ter(tesSUCCESS));
+            env.close();
+
+            auto const vaultImpaired = env.le(vaultKeylet);
+            if (!BEAST_EXPECT(vaultImpaired))
+                return;
+            BEAST_EXPECT(vaultImpaired->at(sfAssetsAvailable) == asset(0).value());
+            BEAST_EXPECT(vaultImpaired->at(sfAssetsTotal) == vaultImpaired->at(sfLossUnrealized));
+            Number const totalBefore = vaultImpaired->at(sfAssetsTotal);
+            Number const lossBefore = vaultImpaired->at(sfLossUnrealized);
+
+            MPTID const shareId = vaultImpaired->at(sfShareMPTID);
+            auto const tokenAlice = env.le(keylet::mptoken(shareId, alice.id()));
+            if (!BEAST_EXPECT(tokenAlice))
+                return;
+            std::uint64_t const sharesBefore = tokenAlice->getFieldU64(sfMPTAmount);
+            BEAST_EXPECT(sharesBefore == 2);
+            STAmount const redeemShares{MPTIssue{shareId}, Number(1)};
+
+            std::uint32_t const redemptionDate = vaultImpaired->at(sfRedemptionDate);
+            env.close(NetClock::time_point{NetClock::duration{redemptionDate}} + 1s);
+
+            auto const aliceBalanceBefore = env.balance(alice);
+            auto const sponsorBalanceBefore = env.balance(sponsor);
+            auto const fee = env.current()->fees().base;
+
+            env(vault.withdraw({.depositor = alice, .id = vaultKeylet.key, .amount = redeemShares}),
+                Fee(fee),
+                sponsor::As(sponsor, spfSponsorFee),
+                Sig(sfSponsorSignature, sponsor),
+                Ter(expected));
+            env.close();
+
+            BEAST_EXPECT(env.balance(sponsor) == sponsorBalanceBefore - fee);
+            BEAST_EXPECT(env.balance(alice) == aliceBalanceBefore);
+
+            if (expected != tesSUCCESS)
+                return;
+
+            auto const shareAfter = env.le(keylet::mptoken(shareId, alice.id()));
+            if (!BEAST_EXPECT(shareAfter))
+                return;
+            BEAST_EXPECT(shareAfter->getFieldU64(sfMPTAmount) == sharesBefore - 1);
+
+            auto const vaultAfter = env.le(vaultKeylet);
+            if (!BEAST_EXPECT(vaultAfter))
+                return;
+            BEAST_EXPECT(vaultAfter->at(sfAssetsTotal) == totalBefore);
+            BEAST_EXPECT(vaultAfter->at(sfLossUnrealized) == lossBefore);
+            BEAST_EXPECT(vaultAfter->at(sfAssetsAvailable) == asset(0).value());
+        };
+
+        runScenario(all_, tesSUCCESS);
+        runScenario(all_ - fixCleanup3_4_0, tecINVARIANT_FAILED);
+    }
+
     // addEmptyHolding() used to check isGlobalFrozen(issuer) and
     // !lsfDefaultRipple before the "line already exists" tecDUPLICATE
     // short circuit. doWithdraw() calls addEmptyHolding() for a
@@ -2377,12 +2752,13 @@ public:
         testBugVaultDepositOvercreditsAcrossScaleBoundary();
         testBugVaultLockedByPartialWithdraw();
         testVaultDepositNegativeBalanceFromOppositeLimit();
-        testCredentialPinsPseudoAccount();
-        testCredentialPinOverflow();
         testBug6LimitBypassWithShares();
         testBugClawbackRoundTripOvershoot();
         testBugWithdrawRoundTripOvershoot();
         testBugClawbackAfterLoanImpair();
+        testBugMptZeroWithdrawMissingHolding();
+        testBugIouZeroWithdrawMissingTrustLine();
+        testBugXrpZeroWithdrawSponsoredFee();
         testBugSelfWithdrawAfterIssuerClearsDefaultRipple();
         testBugSponsoredWithdrawZeroDeltaMisclassifiedAsSecondRecipient();
         testBugSponsorAsDestinationFeeMisappliedToPayout();
diff --git a/src/test/app/vault/VaultClosedEnded_test.cpp b/src/test/app/vault/VaultClosedEnded_test.cpp
index 5ed242f8a4..6909a1bffa 100644
--- a/src/test/app/vault/VaultClosedEnded_test.cpp
+++ b/src/test/app/vault/VaultClosedEnded_test.cpp
@@ -699,9 +699,9 @@ private:
         env.close();
 
         // A real loan is originated during Investment (permitted only in this phase). Zero-interest
-        // one-payment schedule keeps AssetsTotal unchanged (both accrual and cash-basis
-        // accounting recognise no interest at origination); AssetsAvailable drops by the loan
-        // principal.
+        // one-payment schedule keeps AssetsTotal unchanged (both instant interest recognition and
+        // cash-basis accounting recognise no interest at origination); AssetsAvailable drops by
+        // the loan principal.
         env(loan::set(borrower, brokerKeylet.key, XRP(60).value()),
             loan::kInterestRate(TenthBips32(0)),
             kGracePeriod(60),
diff --git a/src/test/app/vault/VaultLifecycle_test.cpp b/src/test/app/vault/VaultLifecycle_test.cpp
index ce91ca857a..8d7afe67f2 100644
--- a/src/test/app/vault/VaultLifecycle_test.cpp
+++ b/src/test/app/vault/VaultLifecycle_test.cpp
@@ -795,6 +795,86 @@ private:
             },
             {.requireAuth = false});
 
+        auto const redeemAllNoAssetMpt = [this](TER expected) {
+            return [this, expected](
+                       Env& env,
+                       Account const&,
+                       Account const& owner,
+                       Account const& depositor,
+                       Asset const& asset,
+                       Vault& vault,
+                       MPTTester& mptt) {
+                testcase << "MPT non-owner redeems all shares with no asset MPToken"
+                         << (isTesSuccess(expected) ? "" : " pre-fixCleanup3_4_0");
+
+                auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
+                env(tx);
+                env.close();
+
+                tx = vault.deposit(
+                    {.depositor = depositor,
+                     .id = keylet.key,
+                     .amount = asset(1000)});  // all assets held by depositor
+                env(tx);
+                env.close();
+
+                auto const vaultSle = env.le(keylet);
+                if (!BEAST_EXPECT(vaultSle))
+                    return;
+                auto const shareMPTID = vaultSle->at(sfShareMPTID);
+
+                // Depositor's asset MPToken balance is now zero; delete it.
+                mptt.authorize({.account = depositor, .flags = tfMPTUnauthorize});
+                env.close();
+
+                auto const mptoken = keylet::mptoken(mptt.issuanceID(), depositor);
+
+                auto const shareKeylet = keylet::mptoken(shareMPTID, depositor.id());
+                auto const sleShareBefore = env.le(shareKeylet);
+                if (!BEAST_EXPECT(sleShareBefore))
+                    return;
+                auto const shareAmountBefore = sleShareBefore->at(sfMPTAmount);
+                auto const assetsTotalBefore = vaultSle->at(sfAssetsTotal);
+                auto const assetsAvailableBefore = vaultSle->at(sfAssetsAvailable);
+
+                // Redeeming ALL shares in one transaction both erases the
+                // now-empty share MPToken and re-creates the asset MPToken.
+                tx = vault.withdraw(
+                    {.depositor = depositor, .id = keylet.key, .amount = asset(1000)});
+                env(tx, Ter{expected});
+                env.close();
+
+                auto const sleAsset = env.le(mptoken);
+                auto const sleShare = env.le(shareKeylet);
+                auto const vaultAfter = env.le(keylet);
+                if (!BEAST_EXPECT(vaultAfter))
+                    return;
+                if (isTesSuccess(expected))
+                {
+                    if (!BEAST_EXPECT(sleAsset))
+                        return;
+                    BEAST_EXPECT(sleAsset->at(sfMPTAmount) == 1000);
+                    BEAST_EXPECT(!sleShare);
+                    BEAST_EXPECT(vaultAfter->at(sfAssetsTotal) == beast::kZero);
+                    BEAST_EXPECT(vaultAfter->at(sfAssetsAvailable) == beast::kZero);
+                }
+                else
+                {
+                    BEAST_EXPECT(!sleAsset);
+                    if (!BEAST_EXPECT(sleShare))
+                        return;
+                    BEAST_EXPECT(sleShare->at(sfMPTAmount) == shareAmountBefore);
+                    BEAST_EXPECT(vaultAfter->at(sfAssetsTotal) == assetsTotalBefore);
+                    BEAST_EXPECT(vaultAfter->at(sfAssetsAvailable) == assetsAvailableBefore);
+                }
+            };
+        };
+
+        testCase(redeemAllNoAssetMpt(tesSUCCESS), {.requireAuth = false});
+        testCase(
+            redeemAllNoAssetMpt(tecINVARIANT_FAILED),
+            {.requireAuth = false, .features = testableAmendments() - fixCleanup3_4_0});
+
         auto const [acctReserve, incReserve] = [this]() -> std::pair<int, int> {
             Env const env{*this, testableAmendments()};
             return {
diff --git a/src/test/basics/PerfLog_test.cpp b/src/test/basics/PerfLog_test.cpp
index f7679dc488..5e790810f7 100644
--- a/src/test/basics/PerfLog_test.cpp
+++ b/src/test/basics/PerfLog_test.cpp
@@ -1,9 +1,7 @@
 #include <test/jtx/Env.h>
-#include <test/jtx/TestHelpers.h>
 #include <test/jtx/envconfig.h>
 
-#include <xrpld/rpc/detail/Handler.h>
-
+#include <xrpl/basics/StringUtilities.h>
 #include <xrpl/basics/random.h>
 #include <xrpl/beast/unit_test/suite.h>
 #include <xrpl/beast/utility/Journal.h>
@@ -16,6 +14,7 @@
 #include <xrpl/protocol/jss.h>
 
 #include <algorithm>
+#include <array>
 #include <chrono>
 #include <cstdint>
 #include <filesystem>
@@ -26,7 +25,9 @@
 #include <memory>
 #include <ostream>
 #include <random>
+#include <ranges>
 #include <string>
+#include <string_view>
 #include <system_error>
 #include <thread>
 #include <utility>
@@ -42,6 +43,21 @@ class PerfLog_test : public beast::unit_test::Suite
 
     using path = std::filesystem::path;
 
+    // The method names to count. PerfLog treats them as opaque keys, so these are
+    // made up rather than taken from the dispatch table: this test then needs no
+    // knowledge of the RPC layer, and does not change shape when a method is
+    // added or removed.
+    //
+    // String literals because PerfLog reads them back as C strings, which is what
+    // NullTerminatedView requires, and they must outlive the PerfLog. Sorted,
+    // because the counters are reported in sorted order.
+    static constexpr std::array kMethodNames{
+        NullTerminatedView{"method_a"},
+        NullTerminatedView{"method_b"},
+        NullTerminatedView{"method_c"},
+        NullTerminatedView{"method_d"},
+        NullTerminatedView{"method_e"}};
+
     // We're only using Env for its Journal.  That Journal gives better
     // coverage in unit tests.
     test::jtx::Env env_{*this, test::jtx::envconfig(), nullptr, beast::Severity::Disabled};
@@ -114,7 +130,7 @@ class PerfLog_test : public beast::unit_test::Suite
         {
             perf::PerfLog::Setup const setup{
                 .perfLog = withFile == WithFile::No ? "" : logFile(), .logInterval = logInterval()};
-            return perf::makePerfLog(setup, app, j, [this]() {
+            return perf::makePerfLog(setup, app, kMethodNames, j, [this]() {
                 signalStop();
                 return;
             });
@@ -310,9 +326,11 @@ public:
         auto perfLog{fixture.perfLog(withFile)};
         perfLog->start();
 
-        // Get the all the labels we can use for RPC interfaces without
-        // causing an assert.
-        std::vector<char const*> labels = test::jtx::makeVector(xrpl::rpc::getHandlerNames());
+        // The only labels the RPC interface accepts: those the PerfLog was
+        // constructed with, since rpcStart() reaches UNREACHABLE for any other.
+        // Copied into a vector because they are shuffled below, then paired
+        // positionally with the request ids.
+        auto labels = std::ranges::to<std::vector>(kMethodNames);
         std::shuffle(labels.begin(), labels.end(), defaultPrng());
 
         // Get two IDs to associate with each label.  Errors tend to happen at
@@ -347,7 +365,7 @@ public:
             for (auto& label : labels)
             {
                 // Expect every label in labels to have the same contents.
-                json::Value const& counter{countersJson[label]};
+                json::Value const& counter{countersJson[std::string{label}]};
                 BEAST_EXPECT(counter[jss::duration_us] == "0");
                 BEAST_EXPECT(counter[jss::errored] == "0");
                 BEAST_EXPECT(counter[jss::finished] == "0");
@@ -370,7 +388,7 @@ public:
             std::uint64_t prevDur = std::numeric_limits<std::uint64_t>::max();
             for (int i = 0; i < currents.size(); ++i)
             {
-                BEAST_EXPECT(currents[i].name == labels[i / 2]);
+                BEAST_EXPECT(currents[i].name == labels[i / 2].view());
                 BEAST_EXPECT(prevDur > currents[i].dur);
                 prevDur = currents[i].dur;
             }
@@ -404,7 +422,7 @@ public:
             // their durations with the appropriate labels.
             {
                 // The first label is special.  It should have "errored" : "0".
-                json::Value const& first = rpc[labels[0]];
+                json::Value const& first = rpc[std::string{labels[0]}];
                 BEAST_EXPECT(first[jss::duration_us] != "0");
                 BEAST_EXPECT(first[jss::errored] == "0");
                 BEAST_EXPECT(first[jss::finished] == "1");
@@ -415,7 +433,7 @@ public:
             std::uint64_t prevDur = std::numeric_limits<std::uint64_t>::max();
             for (int i = 1; i < labels.size(); ++i)
             {
-                json::Value const& counter{rpc[labels[i]]};
+                json::Value const& counter{rpc[std::string{labels[i]}]};
                 std::uint64_t const dur{jsonToUInt64(counter[jss::duration_us])};
                 BEAST_EXPECT(dur != 0 && dur < prevDur);
                 prevDur = dur;
@@ -447,7 +465,7 @@ public:
             BEAST_EXPECT(only.size() == 2);
             BEAST_EXPECT(only.isObject());
             BEAST_EXPECT(only[jss::duration_us] != "0");
-            BEAST_EXPECT(only[jss::method] == labels[0]);
+            BEAST_EXPECT(only[jss::method] == std::string{labels[0]});
         };
 
         // Validate the final state of the PerfLog.
@@ -1012,6 +1030,35 @@ public:
         }
     }
 
+    // makePerfLog() copies the range of names it is given, so only the names have
+    // to outlive the PerfLog. Here the range does not: it is destroyed before the
+    // counters are read. Retaining it instead is a use-after-free, which a
+    // sanitizer build reports directly and which otherwise surfaces as a failed
+    // assertion or a Debug-mode heap-corruption abort, not a silent pass.
+    void
+    testCallerRangeNeedNotOutlive()
+    {
+        testcase("Caller's range need not outlive the PerfLog");
+
+        Fixture const fixture{env_.app(), j_};
+
+        std::unique_ptr<perf::PerfLog> perfLog;
+        {
+            std::vector<NullTerminatedView> const names{kMethodNames.begin(), kMethodNames.end()};
+            perf::PerfLog::Setup const setup{.perfLog = "", .logInterval = fixture.logInterval()};
+            perfLog = perf::makePerfLog(setup, env_.app(), names, j_, []() {});
+        }
+
+        perfLog->start();
+        perfLog->rpcStart(kMethodNames[0], 1);
+        perfLog->rpcFinish(kMethodNames[0], 1);
+
+        // Reads the retained names, which is where a dangling range would surface.
+        json::Value const counters{perfLog->countersJson()[jss::rpc]};
+        BEAST_EXPECT(counters.isMember(std::string{kMethodNames[0].view()}));
+        perfLog->stop();
+    }
+
     void
     run() override
     {
@@ -1024,6 +1071,7 @@ public:
         testInvalidID(WithFile::Yes);
         testRotate(WithFile::No);
         testRotate(WithFile::Yes);
+        testCallerRangeNeedNotOutlive();
     }
 };
 
diff --git a/src/test/core/Workers_test.cpp b/src/test/core/Workers_test.cpp
index fe3820b84a..6824b94769 100644
--- a/src/test/core/Workers_test.cpp
+++ b/src/test/core/Workers_test.cpp
@@ -9,6 +9,7 @@
 #include <memory>
 #include <mutex>
 #include <string>
+#include <string_view>
 
 namespace xrpl {
 
@@ -21,17 +22,17 @@ namespace perf {
 class PerfLogTest : public PerfLog
 {
     void
-    rpcStart(std::string const& method, std::uint64_t requestId) override
+    rpcStart(std::string_view method, std::uint64_t requestId) override
     {
     }
 
     void
-    rpcFinish(std::string const& method, std::uint64_t requestId) override
+    rpcFinish(std::string_view method, std::uint64_t requestId) override
     {
     }
 
     void
-    rpcError(std::string const& method, std::uint64_t dur) override
+    rpcError(std::string_view method, std::uint64_t requestId) override
     {
     }
 
diff --git a/src/test/jtx/ConfidentialTransfer.h b/src/test/jtx/ConfidentialTransfer.h
index 465bac03db..21e1929902 100644
--- a/src/test/jtx/ConfidentialTransfer.h
+++ b/src/test/jtx/ConfidentialTransfer.h
@@ -3,28 +3,19 @@
 #include <test/jtx/Account.h>
 #include <test/jtx/Env.h>
 #include <test/jtx/mpt.h>
-#include <test/jtx/vault.h>
 
 #include <xrpl/basics/Buffer.h>
-#include <xrpl/basics/Slice.h>
 #include <xrpl/basics/base_uint.h>
 #include <xrpl/basics/contract.h>
-#include <xrpl/basics/strHex.h>
 #include <xrpl/beast/unit_test/suite.h>
 #include <xrpl/protocol/ConfidentialTransfer.h>
 #include <xrpl/protocol/Protocol.h>
 #include <xrpl/protocol/TER.h>
 #include <xrpl/protocol/TxFlags.h>
 
-#include <utility/mpt_utility.h>
-
-#include <secp256k1.h>
-#include <secp256k1_mpt.h>
-
 #include <array>
 #include <cstddef>
 #include <cstdint>
-#include <cstring>
 #include <functional>
 #include <optional>
 #include <stdexcept>
@@ -54,156 +45,66 @@ protected:
         return *value;
     }
 
-    // Offset where the bulletproof begins in a send proof blob.
-    // Proof layout: [compact_sigma | bulletproof]
-    static constexpr size_t kBulletproofOffset = kEcSendProofLength - kEcDoubleBulletproofLength;
-
-    // Generate a forged aggregated bulletproof (double bulletproof) for
-    // the given values and blinding factors. Used to test that splicing
-    // a bulletproof claiming a different remaining balance is rejected.
-    // secp256k1 convention: returns 1 on success, 0 on failure.
-    static Buffer
-    getForgedBulletproof(
-        std::array<uint64_t, 2> const& values,
-        std::array<Buffer, 2> const& blindingFactors,
-        uint256 const& contextHash)
+    // Creates the MPT issuance on the given Env, authorizes and funds each
+    // holder, generates keys for the issuer, holders and optional auditor,
+    // registers the issuer/auditor keys, and converts part of each holder's
+    // balance to a confidential balance.
+    struct ConfidentialEnv
     {
-        auto* const ctx = mpt_secp256k1_context();
-
-        secp256k1_pubkey h;
-        secp256k1_mpt_get_h_generator(ctx, &h);
-
-        Buffer proof(kEcDoubleBulletproofLength);
-        size_t proofLen = kEcDoubleBulletproofLength;
-
-        unsigned char blindings[64];
-        std::memcpy(blindings, blindingFactors[0].data(), 32);
-        std::memcpy(blindings + 32, blindingFactors[1].data(), 32);
-
-        if (secp256k1_bulletproof_prove_agg(
-                ctx,
-                proof.data(),
-                &proofLen,
-                values.data(),
-                blindings,
-                2,
-                &h,
-                contextHash.data()) == 0)
-            Throw<std::runtime_error>("Failed to generate forged bulletproof");
-
-        return proof;
-    }
-
-    // Generate a forged single bulletproof for a single value and blinding factor.
-    // Used to test ConvertBack overdraft prevention via bulletproof verification.
-    static Buffer
-    getForgedSingleBulletproof(
-        uint64_t value,
-        Buffer const& blindingFactor,
-        uint256 const& contextHash)
-    {
-        auto* const ctx = mpt_secp256k1_context();
-
-        secp256k1_pubkey h;
-        secp256k1_mpt_get_h_generator(ctx, &h);
-
-        Buffer proof(kEcSingleBulletproofLength);
-        size_t proofLen = kEcSingleBulletproofLength;
-
-        if (secp256k1_bulletproof_prove_agg(
-                ctx,
-                proof.data(),
-                &proofLen,
-                &value,
-                blindingFactor.data(),
-                1,  // m = 1 (single bulletproof)
-                &h,
-                contextHash.data()) == 0)
-            Throw<std::runtime_error>("Failed to generate forged single bulletproof");
-
-        return proof;
-    }
-
-    // Get a bad ciphertext with valid structure but cryptographic invalid for
-    // testing purposes. For preflight test purposes.
-    static Buffer const&
-    getBadCiphertext()
-    {
-        static Buffer const kBadCiphertext = []() {
-            Buffer buf(kEcGamalEncryptedTotalLength);
-            std::memset(buf.data(), 0xFF, kEcGamalEncryptedTotalLength);
-
-            buf.data()[0] = kEcCompressedPrefixEvenY;
-            buf.data()[kEcCiphertextComponentLength] = kEcCompressedPrefixEvenY;
-            return buf;
-        }();
-
-        return kBadCiphertext;
-    }
-
-    // Get a trivial buffer that is structurally and mathematically valid, but
-    // contains invalid data that does not match the ledger state. For preclaim
-    // test purposes.
-    static Buffer const&
-    getTrivialCiphertext()
-    {
-        static Buffer const kTrivialCiphertext = []() {
-            Buffer buf(kEcGamalEncryptedTotalLength);
-            std::memset(buf.data(), 0, kEcGamalEncryptedTotalLength);
-
-            buf.data()[0] = kEcCompressedPrefixEvenY;
-            buf.data()[kEcCiphertextComponentLength] = kEcCompressedPrefixEvenY;
-
-            buf.data()[kEcCiphertextComponentLength - 1] = 0x01;
-            buf.data()[kEcGamalEncryptedTotalLength - 1] = 0x01;
-
-            return buf;
-        }();
-
-        return kTrivialCiphertext;
-    }
-
-    // Returns a valid compressed EC point (33 bytes) that can pass preflight
-    // validation but contains invalid data for preclaim test purposes.
-    static Buffer const&
-    getTrivialCommitment()
-    {
-        static Buffer const kTrivialCommitment = []() {
-            Buffer buf(kEcPedersenCommitmentLength);
-            std::memset(buf.data(), 0, kEcPedersenCommitmentLength);
-
-            buf.data()[0] = kEcCompressedPrefixEvenY;
-            // Set last byte to make it a valid x-coordinate on the curve
-            buf.data()[kEcPedersenCommitmentLength - 1] = 0x01;
-
-            return buf;
-        }();
-
-        return kTrivialCommitment;
-    }
-
-    static std::string
-    getTrivialSendProofHex()
-    {
-        Buffer buf(kEcSendProofLength);
-        std::memset(buf.data(), 0, kEcSendProofLength);
-
-        for (std::size_t i = 0; i < kEcSendProofLength; i += kEcCiphertextComponentLength)
+        // Per-holder configuration: the account, how much MPT to fund it
+        // with, and how much of that to convert to a confidential balance.
+        struct HolderInit
         {
-            buf.data()[i] = kEcCompressedPrefixEvenY;
-            if (i + kEcCiphertextComponentLength - 1 < kEcSendProofLength)
-                buf.data()[i + kEcCiphertextComponentLength - 1] = 0x01;
-        }
+            test::jtx::Account account;
+            std::uint64_t payAmount = 1000;
+            std::uint64_t convertAmount = 100;
+        };
 
-        return strHex(buf);
-    }
+        test::jtx::MPTTester mpt;
+
+        ConfidentialEnv(
+            test::jtx::Env& env,
+            test::jtx::Account const& issuer,
+            std::vector<HolderInit> const& holders,
+            std::uint32_t flags = tfMPTCanLock | tfMPTCanHoldConfidentialBalance | tfMPTCanTransfer,
+            std::optional<test::jtx::Account> auditor = std::nullopt);
+
+    private:
+        static std::vector<test::jtx::Account>
+        extractAccounts(std::vector<HolderInit> const& holders);
+    };
+
+    // Create an issuance that can hold confidential balances, with the listed
+    // holders funded and authorized, and a key pair generated for the issuer,
+    // every holder, and every extra key owner. The keys are
+    // generated but not registered.
+    static void
+    setupConfidentialIssuance(
+        test::jtx::MPTTester& mpt,
+        test::jtx::Account const& issuer,
+        std::vector<test::jtx::Account> const& holders,
+        std::vector<test::jtx::Account> const& keyOwners = {},
+        std::uint32_t flags = tfMPTCanTransfer | tfMPTCanHoldConfidentialBalance);
+
+    // Set up an MPT environment suitable for batch testing.
+    // alice is issuer; bob has 'bobAmt' in confidential spending; carol has
+    // 'carolAmt' in confidential spending; dave is initialised with pubkey but
+    // zero spending/inbox.
+    static void
+    setupBatchEnv(
+        test::jtx::MPTTester& mpt,
+        test::jtx::Account const& alice,
+        test::jtx::Account const& bob,
+        test::jtx::Account const& carol,
+        test::jtx::Account const& dave,
+        std::uint64_t bobAmt,
+        std::uint64_t carolAmt);
 
     // Helper struct to encapsulate common setup for integration tests.
     struct ConfidentialSendSetup
     {
         // Constants
         uint64_t sendAmount;
-        size_t nRecipients;
         uint32_t version;
 
         // Blinding factors
@@ -243,55 +144,7 @@ protected:
             test::jtx::Account const& dest,
             test::jtx::Account const& issuer,
             uint64_t amount,
-            std::optional<std::reference_wrapper<test::jtx::Account const>> auditor = std::nullopt)
-            : sendAmount(amount)
-            , nRecipients(auditor ? 4 : 3)
-            , version(mpt.getMPTokenVersion(sender))
-            , blindingFactor(generateBlindingFactor())
-            , amountBlindingFactor(blindingFactor)
-            , balanceBlindingFactor(generateBlindingFactor())
-            , senderAmt(mpt.encryptAmount(sender, amount, blindingFactor))
-            , destAmt(mpt.encryptAmount(dest, amount, blindingFactor))
-            , issuerAmt(mpt.encryptAmount(issuer, amount, blindingFactor))
-            , auditorAmt(
-                  auditor ? std::optional<Buffer>(
-                                mpt.encryptAmount(auditor->get(), amount, blindingFactor))
-                          : std::nullopt)
-            , amountCommitment(mpt.getPedersenCommitment(amount, amountBlindingFactor))
-            , senderPubKey(requireOptional(mpt.getPubKey(sender), "Missing sender public key"))
-            , destPubKey(requireOptional(mpt.getPubKey(dest), "Missing destination public key"))
-            , issuerPubKey(requireOptional(mpt.getPubKey(issuer), "Missing issuer public key"))
-            , auditorPubKey(auditor ? mpt.getPubKey(auditor->get()) : std::nullopt)
-            , prevSpending(requireOptional(
-                  mpt.getDecryptedBalance(sender, test::jtx::MPTTester::holderEncryptedSpending),
-                  "Missing sender spending balance"))
-            , prevEncryptedSpending(requireOptional(
-                  mpt.getEncryptedBalance(sender, test::jtx::MPTTester::holderEncryptedSpending),
-                  "Missing sender encrypted spending balance"))
-            , balanceCommitment(mpt.getPedersenCommitment(prevSpending, balanceBlindingFactor))
-        {
-            recipients.push_back({
-                .publicKey = Slice(senderPubKey),
-                .encryptedAmount = senderAmt,
-            });
-            recipients.push_back({
-                .publicKey = Slice(destPubKey),
-                .encryptedAmount = destAmt,
-            });
-            recipients.push_back({
-                .publicKey = Slice(issuerPubKey),
-                .encryptedAmount = issuerAmt,
-            });
-            if (auditor)
-            {
-                recipients.push_back({
-                    .publicKey =
-                        Slice(requireOptionalRef(auditorPubKey, "Missing auditor public key")),
-                    .encryptedAmount =
-                        requireOptionalRef(auditorAmt, "Missing auditor encrypted amount"),
-                });
-            }
-        }
+            std::optional<std::reference_wrapper<test::jtx::Account const>> auditor = std::nullopt);
 
         // Generate proof with current account sequence
         std::optional<Buffer>
@@ -299,206 +152,89 @@ protected:
             test::jtx::MPTTester& mpt,
             test::jtx::Env& env,
             test::jtx::Account const& sender,
-            test::jtx::Account const& dest) const
-        {
-            auto const ctxHash = getSendContextHash(
-                sender.id(), mpt.issuanceID(), env.seq(sender), dest.id(), version);
-
-            return mpt.getConfidentialSendProof(
-                sender,
-                sendAmount,
-                recipients,
-                blindingFactor,
-                ctxHash,
-                {
-                    .pedersenCommitment = amountCommitment,
-                    .amt = sendAmount,
-                    .encryptedAmt = senderAmt,
-                    .blindingFactor = amountBlindingFactor,
-                },
-                {
-                    .pedersenCommitment = balanceCommitment,
-                    .amt = prevSpending,
-                    .encryptedAmt = prevEncryptedSpending,
-                    .blindingFactor = balanceBlindingFactor,
-                });
-        }
+            test::jtx::Account const& dest) const;
 
         [[nodiscard]] test::jtx::MPTConfidentialSend
         sendArgs(
             test::jtx::Account const& sender,
             test::jtx::Account const& dest,
             Buffer const& proof,
-            std::optional<TER> err = std::nullopt) const
-        {
-            return {
-                .account = sender,
-                .dest = dest,
-                .amt = sendAmount,
-                .proof = strHex(proof),
-                .senderEncryptedAmt = senderAmt,
-                .destEncryptedAmt = destAmt,
-                .issuerEncryptedAmt = issuerAmt,
-                .auditorEncryptedAmt = auditorAmt,
-                .amountCommitment = amountCommitment,
-                .balanceCommitment = balanceCommitment,
-                .err = err,
-            };
-        }
+            std::optional<TER> err = std::nullopt) const;
     };
 
-    // Helper that wraps the boilerplate setup: Env + MPT creation, funding, key
-    // generation, and seeding each holder with a confidential balance.
-    // The caller supplies the issuer and any number of holders.
-    struct ConfidentialEnv
-    {
-        // Per-holder configuration: the account, how much MPT to fund it
-        // with, and how much of that to convert to a confidential balance.
-        struct HolderInit
-        {
-            test::jtx::Account account;
-            std::uint64_t payAmount = 1000;
-            std::uint64_t convertAmount = 100;
-        };
+    // Get a bad ciphertext with valid structure but cryptographic invalid for
+    // testing purposes. For preflight test purposes.
+    static Buffer const&
+    getBadCiphertext();
 
-        test::jtx::MPTTester mpt;
+    // Get a trivial buffer that is structurally and mathematically valid, but
+    // contains invalid data that does not match the ledger state. For preclaim
+    // test purposes.
+    static Buffer const&
+    getTrivialCiphertext();
 
-        ConfidentialEnv(
-            test::jtx::Env& env,
-            test::jtx::Account const& issuer,
-            std::vector<HolderInit> const& holders,
-            std::uint32_t flags = tfMPTCanLock | tfMPTCanHoldConfidentialBalance | tfMPTCanTransfer,
-            std::optional<test::jtx::Account> auditor = std::nullopt)
-            : mpt{env, issuer, {.holders = extractAccounts(holders), .auditor = auditor}}
-        {
-            mpt.create({.ownerCount = 1, .flags = flags});
+    // Returns a valid compressed EC point (33 bytes) that can pass preflight
+    // validation but contains invalid data for preclaim test purposes.
+    static Buffer const&
+    getTrivialCommitment();
 
-            for (auto const& h : holders)
-            {
-                mpt.authorize({.account = h.account});
-                if ((flags & tfMPTRequireAuth) != 0)
-                    mpt.authorize({.account = issuer, .holder = h.account});
-                mpt.pay(issuer, h.account, h.payAmount);
-            }
+    // Returns a hex-encoded send proof of the correct length filled with
+    // placeholder data. It passes the proof length check in preflight but
+    // fails proof verification.
+    static std::string
+    getTrivialSendProofHex();
 
-            mpt.generateKeyPair(issuer);
-            for (auto const& h : holders)
-                mpt.generateKeyPair(h.account);
-            if (auditor)
-                mpt.generateKeyPair(requireOptionalRef(auditor, "Missing auditor"));
+    // Offset where the bulletproof begins in a send proof blob.
+    // Proof layout: [compact_sigma | bulletproof]
+    static constexpr size_t kBulletproofOffset = kEcSendProofLength - kEcDoubleBulletproofLength;
 
-            mpt.set({
-                .account = issuer,
-                .issuerPubKey = mpt.getPubKey(issuer),
-                .auditorPubKey = auditor
-                    ? mpt.getPubKey(requireOptionalRef(auditor, "Missing auditor"))
-                    : std::optional<Buffer>{},
-            });
+    // Generate a forged aggregated bulletproof (double bulletproof) for
+    // the given values and blinding factors. Used to test that splicing
+    // a bulletproof claiming a different remaining balance is rejected.
+    static Buffer
+    getForgedBulletproof(
+        std::array<uint64_t, 2> const& values,
+        std::array<Buffer, 2> const& blindingFactors,
+        uint256 const& contextHash);
 
-            for (auto const& h : holders)
-            {
-                mpt.convert({
-                    .account = h.account,
-                    .amt = h.convertAmount,
-                    .holderPubKey = mpt.getPubKey(h.account),
-                });
-                mpt.mergeInbox({.account = h.account});
-            }
-        }
+    // Generate a forged single bulletproof for a single value and blinding factor.
+    // Used to test ConvertBack overdraft prevention via bulletproof verification.
+    static Buffer
+    getForgedSingleBulletproof(
+        uint64_t value,
+        Buffer const& blindingFactor,
+        uint256 const& contextHash);
 
-    private:
-        static std::vector<test::jtx::Account>
-        extractAccounts(std::vector<HolderInit> const& holders)
-        {
-            std::vector<test::jtx::Account> accounts;
-            accounts.reserve(holders.size());
-            for (auto const& h : holders)
-                accounts.push_back(h.account);
-            return accounts;
-        }
-    };
-
-    // Set up an MPT environment suitable for batch testing.
-    // alice is issuer; bob has 'bobAmt' in confidential spending; carol has
-    // 'carolAmt' in confidential spending; dave is initialised with pubkey but
-    // zero spending/inbox.
-    static void
-    setupBatchEnv(
+    // Forges a ConvertBack proof (compact sigma + single bulletproof) whose
+    // sigma component claims claimedBalance (which may be wrong) while binding
+    // to the real pedersen commitment and to the encrypted spending balance
+    // already on the ledger. The bulletproof component is built from the real
+    // remaining balance (realBalance - amt) so it stays honest.
+    // mpt_get_convert_back_proof validates its inputs before proving, so it
+    // cannot be used to build such an inconsistent proof.
+    static Buffer
+    getForgedConvertBackProof(
         test::jtx::MPTTester& mpt,
-        test::jtx::Account const& alice,
-        test::jtx::Account const& bob,
-        test::jtx::Account const& carol,
-        test::jtx::Account const& dave,
-        std::uint64_t bobAmt,
-        std::uint64_t carolAmt)
-    {
-        using namespace test::jtx;
-        mpt.create({
-            .ownerCount = 1,
-            .flags = tfMPTCanTransfer | tfMPTCanLock | tfMPTCanHoldConfidentialBalance,
-        });
-        mpt.authorize({.account = bob});
-        mpt.authorize({.account = carol});
-        mpt.authorize({.account = dave});
+        test::jtx::Account const& holder,
+        uint64_t claimedBalance,
+        uint64_t realBalance,
+        uint64_t amt,
+        Buffer const& pedersenCommitment,
+        Buffer const& encryptedSpendingBalance,
+        Buffer const& pcBlindingFactor,
+        uint256 const& contextHash);
 
-        if (bobAmt > 0)
-            mpt.pay(alice, bob, bobAmt);
-        if (carolAmt > 0)
-            mpt.pay(alice, carol, carolAmt);
-
-        mpt.generateKeyPair(alice);
-        mpt.generateKeyPair(bob);
-        mpt.generateKeyPair(carol);
-        mpt.generateKeyPair(dave);
-
-        mpt.set({
-            .account = alice,
-            .issuerPubKey = mpt.getPubKey(alice),
-        });
-
-        if (bobAmt > 0)
-        {
-            mpt.convert({
-                .account = bob,
-                .amt = bobAmt,
-                .holderPubKey = mpt.getPubKey(bob),
-            });
-            mpt.mergeInbox({.account = bob});
-        }
-        else
-        {
-            mpt.convert({
-                .account = bob,
-                .amt = 0,
-                .holderPubKey = mpt.getPubKey(bob),
-            });
-        }
-
-        if (carolAmt > 0)
-        {
-            mpt.convert({
-                .account = carol,
-                .amt = carolAmt,
-                .holderPubKey = mpt.getPubKey(carol),
-            });
-            mpt.mergeInbox({.account = carol});
-        }
-        else
-        {
-            mpt.convert({
-                .account = carol,
-                .amt = 0,
-                .holderPubKey = mpt.getPubKey(carol),
-            });
-        }
-
-        // dave: register pubkey only (0 spending/inbox)
-        mpt.convert({
-            .account = dave,
-            .amt = 0,
-            .holderPubKey = mpt.getPubKey(dave),
-        });
-    }
+    // Forges a ConfidentialMPTSend proof (compact sigma + double bulletproof)
+    // for setup.sendAmount against setup's real balance commitment/ciphertext.
+    // mpt_get_confidential_send_proof does not allow to build a proof whose amount
+    // exceeds the sender's claimed balance.
+    static Buffer
+    getForgedSendProof(
+        test::jtx::MPTTester& mpt,
+        test::jtx::Env& env,
+        test::jtx::Account const& sender,
+        test::jtx::Account const& dest,
+        ConfidentialSendSetup const& setup);
 };
 
 }  // namespace xrpl
diff --git a/src/test/jtx/PeerStub.h b/src/test/jtx/PeerStub.h
new file mode 100644
index 0000000000..cabe94f351
--- /dev/null
+++ b/src/test/jtx/PeerStub.h
@@ -0,0 +1,185 @@
+#pragma once
+
+#include <xrpld/overlay/Message.h>
+#include <xrpld/overlay/Peer.h>
+
+#include <xrpl/basics/base_uint.h>
+#include <xrpl/beast/net/IPEndpoint.h>
+#include <xrpl/json/json_value.h>
+#include <xrpl/protocol/KeyType.h>
+#include <xrpl/protocol/PublicKey.h>
+#include <xrpl/protocol/SecretKey.h>
+
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <optional>
+#include <string>
+
+namespace xrpl::test {
+
+/**
+ * A `Peer` whose every method is a no-op returning a default.
+ *
+ * Derive from this and override only the methods a test cares about. Adding a
+ * method to `Peer` then costs one stub here, not one per double.
+ *
+ * The id and the node public key are real, because the code under test routes
+ * and deduplicates on both.
+ */
+class PeerStub : public Peer
+{
+public:
+    /**
+     * @param id  The connection id reported by `id()`.
+     */
+    explicit PeerStub(id_t id = 0)
+        : id_(id), nodePublicKey_(derivePublicKey(KeyType::Ed25519, randomSecretKey()))
+    {
+    }
+
+    ~PeerStub() override = default;
+
+    void
+    send(std::shared_ptr<Message> const&) override
+    {
+    }
+
+    [[nodiscard]] beast::ip::Endpoint
+    getRemoteAddress() const override
+    {
+        return {};
+    }
+
+    void
+    sendTxQueue() override
+    {
+    }
+
+    void
+    addTxQueue(uint256 const&) override
+    {
+    }
+
+    void
+    removeTxQueue(uint256 const&) override
+    {
+    }
+
+    void
+    charge(resource::Charge const&, std::string const&) override
+    {
+    }
+
+    [[nodiscard]] id_t
+    id() const override
+    {
+        return id_;
+    }
+
+    [[nodiscard]] bool
+    cluster() const override
+    {
+        return false;
+    }
+
+    [[nodiscard]] bool
+    isHighLatency() const override
+    {
+        return false;
+    }
+
+    [[nodiscard]] int
+    getScore(bool) const override
+    {
+        return 0;
+    }
+
+    [[nodiscard]] PublicKey const&
+    getNodePublic() const override
+    {
+        return nodePublicKey_;
+    }
+
+    json::Value
+    json() override
+    {
+        return {};
+    }
+
+    [[nodiscard]] bool
+    supportsFeature(ProtocolFeature) const override
+    {
+        return false;
+    }
+
+    [[nodiscard]] std::optional<std::size_t>
+    publisherListSequence(PublicKey const&) const override
+    {
+        return {};
+    }
+
+    void
+    setPublisherListSequence(PublicKey const&, std::size_t const) override
+    {
+    }
+
+    [[nodiscard]] std::string const&
+    fingerprint() const override
+    {
+        return fingerprint_;
+    }
+
+    [[nodiscard]] uint256
+    getClosedLedgerHash() const override
+    {
+        return {};
+    }
+
+    [[nodiscard]] bool
+    hasLedger(uint256 const&, std::uint32_t) const override
+    {
+        return false;
+    }
+
+    void
+    ledgerRange(std::uint32_t&, std::uint32_t&) const override
+    {
+    }
+
+    [[nodiscard]] bool
+    hasTxSet(uint256 const&) const override
+    {
+        return false;
+    }
+
+    void
+    cycleStatus() override
+    {
+    }
+
+    bool
+    hasRange(std::uint32_t, std::uint32_t) override
+    {
+        return false;
+    }
+
+    [[nodiscard]] bool
+    compressionEnabled() const override
+    {
+        return false;
+    }
+
+    [[nodiscard]] bool
+    txReduceRelayEnabled() const override
+    {
+        return false;
+    }
+
+private:
+    id_t const id_;
+    PublicKey const nodePublicKey_;
+    std::string const fingerprint_;
+};
+
+}  // namespace xrpl::test
diff --git a/src/test/jtx/TestHelpers.h b/src/test/jtx/TestHelpers.h
index 801c3627b8..382a6fe333 100644
--- a/src/test/jtx/TestHelpers.h
+++ b/src/test/jtx/TestHelpers.h
@@ -43,7 +43,6 @@
 #include <memory>
 #include <mutex>
 #include <optional>
-#include <ranges>
 #include <source_location>
 #include <string>
 #include <tuple>
@@ -316,13 +315,6 @@ auto const kData = JTxFieldWrapper<BlobField>(sfData);
 
 auto const kAmount = JTxFieldWrapper<StAmountField>(sfAmount);
 
-template <std::ranges::range Input>
-auto
-makeVector(Input const& input)
-{
-    return std::vector(std::ranges::begin(input), std::ranges::end(input));
-}
-
 // Functions used in debugging
 json::Value
 getAccountOffers(Env& env, AccountID const& acct, bool current = false);
diff --git a/src/test/jtx/impl/ConfidentialTransfer.cpp b/src/test/jtx/impl/ConfidentialTransfer.cpp
new file mode 100644
index 0000000000..0bc98778f6
--- /dev/null
+++ b/src/test/jtx/impl/ConfidentialTransfer.cpp
@@ -0,0 +1,587 @@
+#include <test/jtx/ConfidentialTransfer.h>
+
+#include <test/jtx/Account.h>
+#include <test/jtx/Env.h>
+#include <test/jtx/mpt.h>
+
+#include <xrpl/basics/Buffer.h>
+#include <xrpl/basics/Slice.h>
+#include <xrpl/basics/base_uint.h>
+#include <xrpl/basics/contract.h>
+#include <xrpl/basics/strHex.h>
+#include <xrpl/protocol/ConfidentialTransfer.h>
+#include <xrpl/protocol/Protocol.h>
+#include <xrpl/protocol/TER.h>
+#include <xrpl/protocol/TxFlags.h>
+
+#include <utility/mpt_utility.h>
+
+#include <secp256k1.h>
+#include <secp256k1_mpt.h>
+
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <functional>
+#include <optional>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+namespace xrpl {
+
+ConfidentialTransferTestBase::ConfidentialEnv::ConfidentialEnv(
+    test::jtx::Env& env,
+    test::jtx::Account const& issuer,
+    std::vector<HolderInit> const& holders,
+    std::uint32_t flags,
+    std::optional<test::jtx::Account> auditor)
+    : mpt{env, issuer, {.holders = extractAccounts(holders), .auditor = auditor}}
+{
+    mpt.create({.ownerCount = 1, .flags = flags});
+
+    for (auto const& h : holders)
+    {
+        mpt.authorize({.account = h.account});
+        if ((flags & tfMPTRequireAuth) != 0)
+            mpt.authorize({.account = issuer, .holder = h.account});
+        mpt.pay(issuer, h.account, h.payAmount);
+    }
+
+    mpt.generateKeyPair(issuer);
+    for (auto const& h : holders)
+        mpt.generateKeyPair(h.account);
+    if (auditor)
+        mpt.generateKeyPair(requireOptionalRef(auditor, "Missing auditor"));
+
+    mpt.set({
+        .account = issuer,
+        .issuerPubKey = mpt.getPubKey(issuer),
+        .auditorPubKey = auditor ? mpt.getPubKey(requireOptionalRef(auditor, "Missing auditor"))
+                                 : std::optional<Buffer>{},
+    });
+
+    for (auto const& h : holders)
+    {
+        mpt.convert({
+            .account = h.account,
+            .amt = h.convertAmount,
+            .holderPubKey = mpt.getPubKey(h.account),
+        });
+        mpt.mergeInbox({.account = h.account});
+    }
+}
+
+std::vector<test::jtx::Account>
+ConfidentialTransferTestBase::ConfidentialEnv::extractAccounts(
+    std::vector<HolderInit> const& holders)
+{
+    std::vector<test::jtx::Account> accounts;
+    accounts.reserve(holders.size());
+    for (auto const& h : holders)
+        accounts.push_back(h.account);
+    return accounts;
+}
+
+void
+ConfidentialTransferTestBase::setupConfidentialIssuance(
+    test::jtx::MPTTester& mpt,
+    test::jtx::Account const& issuer,
+    std::vector<test::jtx::Account> const& holders,
+    std::vector<test::jtx::Account> const& keyOwners,
+    std::uint32_t flags)
+{
+    using namespace test::jtx;
+    mpt.create({
+        .ownerCount = 1,
+        .flags = flags,
+    });
+
+    for (auto const& holder : holders)
+    {
+        mpt.authorize({.account = holder});
+        mpt.pay(issuer, holder, 100);
+        mpt.generateKeyPair(holder);
+    }
+
+    mpt.generateKeyPair(issuer);
+    for (auto const& keyOwner : keyOwners)
+        mpt.generateKeyPair(keyOwner);
+}
+
+void
+ConfidentialTransferTestBase::setupBatchEnv(
+    test::jtx::MPTTester& mpt,
+    test::jtx::Account const& alice,
+    test::jtx::Account const& bob,
+    test::jtx::Account const& carol,
+    test::jtx::Account const& dave,
+    std::uint64_t bobAmt,
+    std::uint64_t carolAmt)
+{
+    using namespace test::jtx;
+    mpt.create({
+        .ownerCount = 1,
+        .flags = tfMPTCanTransfer | tfMPTCanLock | tfMPTCanHoldConfidentialBalance,
+    });
+    mpt.authorize({.account = bob});
+    mpt.authorize({.account = carol});
+    mpt.authorize({.account = dave});
+
+    if (bobAmt > 0)
+        mpt.pay(alice, bob, bobAmt);
+    if (carolAmt > 0)
+        mpt.pay(alice, carol, carolAmt);
+
+    mpt.generateKeyPair(alice);
+    mpt.generateKeyPair(bob);
+    mpt.generateKeyPair(carol);
+    mpt.generateKeyPair(dave);
+
+    mpt.set({
+        .account = alice,
+        .issuerPubKey = mpt.getPubKey(alice),
+    });
+
+    if (bobAmt > 0)
+    {
+        mpt.convert({
+            .account = bob,
+            .amt = bobAmt,
+            .holderPubKey = mpt.getPubKey(bob),
+        });
+        mpt.mergeInbox({.account = bob});
+    }
+    else
+    {
+        mpt.convert({
+            .account = bob,
+            .amt = 0,
+            .holderPubKey = mpt.getPubKey(bob),
+        });
+    }
+
+    if (carolAmt > 0)
+    {
+        mpt.convert({
+            .account = carol,
+            .amt = carolAmt,
+            .holderPubKey = mpt.getPubKey(carol),
+        });
+        mpt.mergeInbox({.account = carol});
+    }
+    else
+    {
+        mpt.convert({
+            .account = carol,
+            .amt = 0,
+            .holderPubKey = mpt.getPubKey(carol),
+        });
+    }
+
+    // dave: register pubkey only (0 spending/inbox)
+    mpt.convert({
+        .account = dave,
+        .amt = 0,
+        .holderPubKey = mpt.getPubKey(dave),
+    });
+}
+
+ConfidentialTransferTestBase::ConfidentialSendSetup::ConfidentialSendSetup(
+    test::jtx::MPTTester& mpt,
+    test::jtx::Account const& sender,
+    test::jtx::Account const& dest,
+    test::jtx::Account const& issuer,
+    uint64_t amount,
+    std::optional<std::reference_wrapper<test::jtx::Account const>> auditor)
+    : sendAmount(amount)
+    , version(mpt.getMPTokenVersion(sender))
+    , blindingFactor(generateBlindingFactor())
+    , amountBlindingFactor(blindingFactor)
+    , balanceBlindingFactor(generateBlindingFactor())
+    , senderAmt(mpt.encryptAmount(sender, amount, blindingFactor))
+    , destAmt(mpt.encryptAmount(dest, amount, blindingFactor))
+    , issuerAmt(mpt.encryptAmount(issuer, amount, blindingFactor))
+    , auditorAmt(
+          auditor ? std::optional<Buffer>(mpt.encryptAmount(auditor->get(), amount, blindingFactor))
+                  : std::nullopt)
+    , amountCommitment(mpt.getPedersenCommitment(amount, amountBlindingFactor))
+    , senderPubKey(requireOptional(mpt.getPubKey(sender), "Missing sender public key"))
+    , destPubKey(requireOptional(mpt.getPubKey(dest), "Missing destination public key"))
+    , issuerPubKey(requireOptional(mpt.getPubKey(issuer), "Missing issuer public key"))
+    , auditorPubKey(auditor ? mpt.getPubKey(auditor->get()) : std::nullopt)
+    , prevSpending(requireOptional(
+          mpt.getDecryptedBalance(sender, test::jtx::MPTTester::holderEncryptedSpending),
+          "Missing sender spending balance"))
+    , prevEncryptedSpending(requireOptional(
+          mpt.getEncryptedBalance(sender, test::jtx::MPTTester::holderEncryptedSpending),
+          "Missing sender encrypted spending balance"))
+    , balanceCommitment(mpt.getPedersenCommitment(prevSpending, balanceBlindingFactor))
+{
+    recipients.push_back({
+        .publicKey = Slice(senderPubKey),
+        .encryptedAmount = senderAmt,
+    });
+    recipients.push_back({
+        .publicKey = Slice(destPubKey),
+        .encryptedAmount = destAmt,
+    });
+    recipients.push_back({
+        .publicKey = Slice(issuerPubKey),
+        .encryptedAmount = issuerAmt,
+    });
+    if (auditor)
+    {
+        recipients.push_back({
+            .publicKey = Slice(requireOptionalRef(auditorPubKey, "Missing auditor public key")),
+            .encryptedAmount = requireOptionalRef(auditorAmt, "Missing auditor encrypted amount"),
+        });
+    }
+}
+
+std::optional<Buffer>
+ConfidentialTransferTestBase::ConfidentialSendSetup::generateProof(
+    test::jtx::MPTTester& mpt,
+    test::jtx::Env& env,
+    test::jtx::Account const& sender,
+    test::jtx::Account const& dest) const
+{
+    auto const ctxHash =
+        getSendContextHash(sender.id(), mpt.issuanceID(), env.seq(sender), dest.id(), version);
+
+    return mpt.getConfidentialSendProof(
+        sender,
+        sendAmount,
+        recipients,
+        blindingFactor,
+        ctxHash,
+        {
+            .pedersenCommitment = amountCommitment,
+            .amt = sendAmount,
+            .encryptedAmt = senderAmt,
+            .blindingFactor = amountBlindingFactor,
+        },
+        {
+            .pedersenCommitment = balanceCommitment,
+            .amt = prevSpending,
+            .encryptedAmt = prevEncryptedSpending,
+            .blindingFactor = balanceBlindingFactor,
+        });
+}
+
+test::jtx::MPTConfidentialSend
+ConfidentialTransferTestBase::ConfidentialSendSetup::sendArgs(
+    test::jtx::Account const& sender,
+    test::jtx::Account const& dest,
+    Buffer const& proof,
+    std::optional<TER> err) const
+{
+    return {
+        .account = sender,
+        .dest = dest,
+        .amt = sendAmount,
+        .proof = strHex(proof),
+        .senderEncryptedAmt = senderAmt,
+        .destEncryptedAmt = destAmt,
+        .issuerEncryptedAmt = issuerAmt,
+        .auditorEncryptedAmt = auditorAmt,
+        .amountCommitment = amountCommitment,
+        .balanceCommitment = balanceCommitment,
+        .err = err,
+    };
+}
+
+Buffer const&
+ConfidentialTransferTestBase::getBadCiphertext()
+{
+    static Buffer const kBadCiphertext = []() {
+        Buffer buf(kEcGamalEncryptedTotalLength);
+        std::memset(buf.data(), 0xFF, kEcGamalEncryptedTotalLength);
+
+        buf.data()[0] = kEcCompressedPrefixEvenY;
+        buf.data()[kEcCiphertextComponentLength] = kEcCompressedPrefixEvenY;
+        return buf;
+    }();
+
+    return kBadCiphertext;
+}
+
+Buffer const&
+ConfidentialTransferTestBase::getTrivialCiphertext()
+{
+    static Buffer const kTrivialCiphertext = []() {
+        Buffer buf(kEcGamalEncryptedTotalLength);
+        std::memset(buf.data(), 0, kEcGamalEncryptedTotalLength);
+
+        buf.data()[0] = kEcCompressedPrefixEvenY;
+        buf.data()[kEcCiphertextComponentLength] = kEcCompressedPrefixEvenY;
+
+        buf.data()[kEcCiphertextComponentLength - 1] = 0x01;
+        buf.data()[kEcGamalEncryptedTotalLength - 1] = 0x01;
+
+        return buf;
+    }();
+
+    return kTrivialCiphertext;
+}
+
+Buffer const&
+ConfidentialTransferTestBase::getTrivialCommitment()
+{
+    static Buffer const kTrivialCommitment = []() {
+        Buffer buf(kEcPedersenCommitmentLength);
+        std::memset(buf.data(), 0, kEcPedersenCommitmentLength);
+
+        buf.data()[0] = kEcCompressedPrefixEvenY;
+        // Set last byte to make it a valid x-coordinate on the curve
+        buf.data()[kEcPedersenCommitmentLength - 1] = 0x01;
+
+        return buf;
+    }();
+
+    return kTrivialCommitment;
+}
+
+std::string
+ConfidentialTransferTestBase::getTrivialSendProofHex()
+{
+    Buffer buf(kEcSendProofLength);
+    std::memset(buf.data(), 0, kEcSendProofLength);
+
+    for (std::size_t i = 0; i < kEcSendProofLength; i += kEcCiphertextComponentLength)
+    {
+        buf.data()[i] = kEcCompressedPrefixEvenY;
+        if (i + kEcCiphertextComponentLength - 1 < kEcSendProofLength)
+            buf.data()[i + kEcCiphertextComponentLength - 1] = 0x01;
+    }
+
+    return strHex(buf);
+}
+
+Buffer
+ConfidentialTransferTestBase::getForgedBulletproof(
+    std::array<uint64_t, 2> const& values,
+    std::array<Buffer, 2> const& blindingFactors,
+    uint256 const& contextHash)
+{
+    auto* const ctx = mpt_secp256k1_context();
+
+    secp256k1_pubkey h;
+    secp256k1_mpt_get_h_generator(ctx, &h);
+
+    Buffer proof(kEcDoubleBulletproofLength);
+    size_t proofLen = kEcDoubleBulletproofLength;
+
+    unsigned char blindings[64];
+    std::memcpy(blindings, blindingFactors[0].data(), 32);
+    std::memcpy(blindings + 32, blindingFactors[1].data(), 32);
+
+    if (secp256k1_bulletproof_prove_agg(
+            ctx, proof.data(), &proofLen, values.data(), blindings, 2, &h, contextHash.data()) == 0)
+        Throw<std::runtime_error>("Failed to generate forged bulletproof");
+
+    return proof;
+}
+
+Buffer
+ConfidentialTransferTestBase::getForgedSingleBulletproof(
+    uint64_t value,
+    Buffer const& blindingFactor,
+    uint256 const& contextHash)
+{
+    auto* const ctx = mpt_secp256k1_context();
+
+    secp256k1_pubkey h;
+    secp256k1_mpt_get_h_generator(ctx, &h);
+
+    Buffer proof(kEcSingleBulletproofLength);
+    size_t proofLen = kEcSingleBulletproofLength;
+
+    if (secp256k1_bulletproof_prove_agg(
+            ctx,
+            proof.data(),
+            &proofLen,
+            &value,
+            blindingFactor.data(),
+            1,  // m = 1 (single bulletproof)
+            &h,
+            contextHash.data()) == 0)
+        Throw<std::runtime_error>("Failed to generate forged single bulletproof");
+
+    return proof;
+}
+
+Buffer
+ConfidentialTransferTestBase::getForgedConvertBackProof(
+    test::jtx::MPTTester& mpt,
+    test::jtx::Account const& holder,
+    uint64_t claimedBalance,
+    uint64_t realBalance,
+    uint64_t amt,
+    Buffer const& pedersenCommitment,
+    Buffer const& encryptedSpendingBalance,
+    Buffer const& pcBlindingFactor,
+    uint256 const& contextHash)
+{
+    if (pedersenCommitment.size() != kCompressedEcPointLength)
+        Throw<std::runtime_error>("getForgedConvertBackProof: bad pedersenCommitment length");
+    if (encryptedSpendingBalance.size() != kEcGamalEncryptedTotalLength)
+    {
+        Throw<std::runtime_error>("getForgedConvertBackProof: bad encryptedSpendingBalance length");
+    }
+    if (amt > realBalance)
+        Throw<std::runtime_error>("getForgedConvertBackProof: amt exceeds realBalance");
+
+    auto* const ctx = mpt_secp256k1_context();
+    auto const holderPubKey = requireOptional(mpt.getPubKey(holder), "Missing holder pubkey");
+    auto const holderPrivKey = requireOptional(mpt.getPrivKey(holder), "Missing holder privkey");
+
+    secp256k1_pubkey pkHolder;
+    if (secp256k1_ec_pubkey_parse(ctx, &pkHolder, holderPubKey.data(), kCompressedEcPointLength) !=
+        1)
+        Throw<std::runtime_error>("Failed to parse holder's public key");
+
+    secp256k1_pubkey pcB;
+    if (secp256k1_ec_pubkey_parse(ctx, &pcB, pedersenCommitment.data(), kCompressedEcPointLength) !=
+        1)
+        Throw<std::runtime_error>("Failed to parse pedersen commitment");
+
+    secp256k1_pubkey b1, b2;
+    if (secp256k1_ec_pubkey_parse(
+            ctx, &b1, encryptedSpendingBalance.data(), kCompressedEcPointLength) != 1 ||
+        secp256k1_ec_pubkey_parse(
+            ctx,
+            &b2,
+            encryptedSpendingBalance.data() + kCompressedEcPointLength,
+            kCompressedEcPointLength) != 1)
+        Throw<std::runtime_error>("Failed to parse balance ciphertext");
+
+    Buffer sigmaProof(SECP256K1_COMPACT_CONVERTBACK_PROOF_SIZE);
+    if (secp256k1_compact_convertback_prove(
+            ctx,
+            sigmaProof.data(),
+            claimedBalance,
+            holderPrivKey.data(),
+            pcBlindingFactor.data(),
+            &pkHolder,
+            &b1,
+            &b2,
+            &pcB,
+            contextHash.data()) != 1)
+        Throw<std::runtime_error>("Failed to generate convertback sigma proof");
+
+    auto const forgedBulletproof =
+        getForgedSingleBulletproof(realBalance - amt, pcBlindingFactor, contextHash);
+
+    Buffer proof(kEcConvertBackProofLength);
+    std::memcpy(proof.data(), sigmaProof.data(), SECP256K1_COMPACT_CONVERTBACK_PROOF_SIZE);
+    std::memcpy(
+        proof.data() + SECP256K1_COMPACT_CONVERTBACK_PROOF_SIZE,
+        forgedBulletproof.data(),
+        kEcSingleBulletproofLength);
+
+    return proof;
+}
+
+Buffer
+ConfidentialTransferTestBase::getForgedSendProof(
+    test::jtx::MPTTester& mpt,
+    test::jtx::Env& env,
+    test::jtx::Account const& sender,
+    test::jtx::Account const& dest,
+    ConfidentialSendSetup const& setup)
+{
+    auto* const ctx = mpt_secp256k1_context();
+
+    secp256k1_pubkey c1;
+    std::vector<secp256k1_pubkey> c2Vec(setup.recipients.size());
+    std::vector<secp256k1_pubkey> pkVec(setup.recipients.size());
+    for (std::size_t i = 0; i < setup.recipients.size(); ++i)
+    {
+        auto const& r = setup.recipients[i];
+        if (i == 0 &&
+            secp256k1_ec_pubkey_parse(
+                ctx, &c1, r.encryptedAmount.data(), kCompressedEcPointLength) != 1)
+            Throw<std::runtime_error>("Failed to parse C1");
+        if (secp256k1_ec_pubkey_parse(
+                ctx,
+                &c2Vec[i],
+                r.encryptedAmount.data() + kCompressedEcPointLength,
+                kCompressedEcPointLength) != 1)
+            Throw<std::runtime_error>("Failed to parse C2");
+        if (secp256k1_ec_pubkey_parse(
+                ctx, &pkVec[i], r.publicKey.data(), kCompressedEcPointLength) != 1)
+            Throw<std::runtime_error>("Failed to parse recipient pubkey");
+    }
+
+    secp256k1_pubkey pkSender, pcAmount, pcBalance, b1, b2;
+    if (secp256k1_ec_pubkey_parse(
+            ctx, &pkSender, setup.senderPubKey.data(), kCompressedEcPointLength) != 1 ||
+        secp256k1_ec_pubkey_parse(
+            ctx, &pcAmount, setup.amountCommitment.data(), kCompressedEcPointLength) != 1 ||
+        secp256k1_ec_pubkey_parse(
+            ctx, &pcBalance, setup.balanceCommitment.data(), kCompressedEcPointLength) != 1 ||
+        secp256k1_ec_pubkey_parse(
+            ctx, &b1, setup.prevEncryptedSpending.data(), kCompressedEcPointLength) != 1 ||
+        secp256k1_ec_pubkey_parse(
+            ctx,
+            &b2,
+            setup.prevEncryptedSpending.data() + kCompressedEcPointLength,
+            kCompressedEcPointLength) != 1)
+        Throw<std::runtime_error>("Failed to parse commitments/ciphertext");
+
+    Buffer const senderPrivKey = requireOptional(mpt.getPrivKey(sender), "Missing sender privkey");
+    auto const ctxHash = getSendContextHash(
+        sender.id(), mpt.issuanceID(), env.seq(sender), dest.id(), setup.version);
+
+    Buffer sigmaProof(SECP256K1_COMPACT_STANDARD_PROOF_SIZE);
+    if (secp256k1_compact_standard_prove(
+            ctx,
+            sigmaProof.data(),
+            setup.sendAmount,
+            setup.prevSpending,
+            setup.blindingFactor.data(),
+            senderPrivKey.data(),
+            setup.balanceBlindingFactor.data(),
+            setup.recipients.size(),
+            &c1,
+            c2Vec.data(),
+            pkVec.data(),
+            &pcAmount,
+            &pkSender,
+            &pcBalance,
+            &b1,
+            &b2,
+            ctxHash.data()) != 1)
+        Throw<std::runtime_error>("Failed to generate sigma proof");
+
+    // Wraps (mod 2^64) for overdrafts, unlike the ledger's own homomorphic
+    // commitment subtraction (mod the curve order) — that mismatch is
+    // exactly what makes the forged proof fail verification.
+    // Computed without a wrapping `uint64` subtract: Clang UBSan treats
+    // unsigned overflow as fatal (see incrementConfidentialVersion).
+    std::uint64_t const remaining = setup.sendAmount <= setup.prevSpending
+        ? setup.prevSpending - setup.sendAmount
+        : ~setup.sendAmount + setup.prevSpending + 1;
+
+    Buffer negAmountBf(kEcBlindingFactorLength);
+    Buffer remainingBf(kEcBlindingFactorLength);
+    secp256k1_mpt_scalar_negate(negAmountBf.data(), setup.amountBlindingFactor.data());
+    secp256k1_mpt_scalar_add(
+        remainingBf.data(), setup.balanceBlindingFactor.data(), negAmountBf.data());
+
+    auto const forgedBulletproof = getForgedBulletproof(
+        {setup.sendAmount, remaining}, {setup.amountBlindingFactor, remainingBf}, ctxHash);
+
+    Buffer combinedProof(kEcSendProofLength);
+    std::memcpy(combinedProof.data(), sigmaProof.data(), SECP256K1_COMPACT_STANDARD_PROOF_SIZE);
+    std::memcpy(
+        combinedProof.data() + SECP256K1_COMPACT_STANDARD_PROOF_SIZE,
+        forgedBulletproof.data(),
+        kEcDoubleBulletproofLength);
+
+    return combinedProof;
+}
+
+}  // namespace xrpl
diff --git a/src/test/jtx/impl/mpt.cpp b/src/test/jtx/impl/mpt.cpp
index 2743084beb..16e108c597 100644
--- a/src/test/jtx/impl/mpt.cpp
+++ b/src/test/jtx/impl/mpt.cpp
@@ -42,8 +42,10 @@
 #include <cstddef>
 #include <cstdint>
 #include <cstring>
+#include <filesystem>
 #include <functional>
 #include <optional>
+#include <source_location>
 #include <stdexcept>
 #include <string>
 #include <unordered_map>
@@ -63,14 +65,23 @@ constexpr std::uint64_t kElGamalDecryptRangeHigh = 3000;
  *
  * @param opt The optional to unwrap.
  * @param what Description used in the thrown exception if opt is empty.
+ * @param loc The call site to report in the thrown exception, defaulting to
+ *            the immediate caller.
  * @return A const reference to the contained value.
  */
 template <class T>
 [[nodiscard]] T const&
-requireValue(std::optional<T> const& opt, char const* what)
+requireValue(
+    std::optional<T> const& opt,
+    char const* what,
+    std::source_location const& loc = std::source_location::current())
 {
     if (!opt)
-        Throw<std::logic_error>(what);
+    {
+        Throw<std::logic_error>(
+            std::string(what) + " must be present (called from " +
+            std::string(loc.function_name()) + ")");
+    }
     return *opt;
 }
 
@@ -92,24 +103,114 @@ makePedersenParams(PedersenProofParams const& params)
     return res;
 }
 
+/**
+ * @brief Sets sfAccount on jv to the given account.
+ *
+ * @param jv The JSON object to set the field on.
+ * @param account The account to set. Throws if not present.
+ * @return The resolved account.
+ */
+Account const&
+setAccountField(json::Value& jv, std::optional<Account> const& account)
+{
+    Account const& act = requireValue(account, "account");
+    jv[sfAccount] = act.human();
+    return act;
+}
+
+/**
+ * @brief Sets sfDestination on jv to the given account.
+ *
+ * @param jv The JSON object to set the field on.
+ * @param dest The destination account to set. Throws if not present.
+ * @return The resolved account.
+ */
+Account const&
+setDestinationField(json::Value& jv, std::optional<Account> const& dest)
+{
+    Account const& act = requireValue(dest, "dest");
+    jv[sfDestination] = act.human();
+    return act;
+}
+
+/**
+ * @brief Sets sfZKProof to the given proof if present, otherwise to a
+ *        zero-filled placeholder of the given length.
+ *
+ * @param jv The JSON object to set the field on.
+ * @param proof The real proof to use, if generated.
+ * @param dummyLen The length of the placeholder buffer to use when proof is not set.
+ */
+void
+setProofOrDummy(json::Value& jv, std::optional<Buffer> const& proof, std::size_t dummyLen)
+{
+    jv[sfZKProof.jsonName] = strHex(proof ? *proof : gMakeZeroBuffer(dummyLen));
+}
+
+/**
+ * @brief Looks up an account's key at a given key epoch.
+ *
+ * @param keys accounts' history of keys, indexed by key epoch.
+ * @param account The account whose key is being looked up.
+ * @param epoch The key epoch, or std::nullopt for the account's latest key.
+ * @return The key, or std::nullopt if the account has no key at that epoch.
+ */
+[[nodiscard]] std::optional<Buffer>
+keyAtEpoch(
+    std::unordered_map<AccountID, std::vector<Buffer>> const& keys,
+    AccountID const& account,
+    std::optional<std::uint32_t> epoch)
+{
+    auto const it = keys.find(account);
+    if (it == keys.end() || it->second.empty())
+        return std::nullopt;
+
+    if (!epoch)
+        return it->second.back();
+
+    if (*epoch >= it->second.size())
+        return std::nullopt;
+
+    return it->second[*epoch];
+}
+
+}  // namespace
+
+namespace {
+// Renders the check's own construction site (usually in mpt.cpp) so it can be
+// embedded as the "reason" alongside the test call site reported as file/line.
+std::string
+checkSiteReason(std::source_location const& checkLoc)
+{
+    return std::string("check ") + std::filesystem::path{checkLoc.file_name()}.filename().string() +
+        "(" + std::to_string(checkLoc.line()) + ")";
+}
 }  // namespace
 
 void
 MptFlags::operator()(Env& env) const
 {
-    env.test.expect(tester_.checkFlags(flags_, holder_));
+    env.test.expect(
+        tester_.checkFlags(flags_, holder_),
+        checkSiteReason(checkLoc_),
+        testLoc_.file_name(),
+        testLoc_.line());
 }
 
 void
 MptBalance::operator()(Env& env) const
 {
-    env.test.expect(amount_ == tester_.getBalance(account_));
+    env.test.expect(
+        amount_ == tester_.getBalance(account_),
+        checkSiteReason(checkLoc_),
+        testLoc_.file_name(),
+        testLoc_.line());
 }
 
 void
 RequireAny::operator()(Env& env) const
 {
-    env.test.expect(cb_());
+    env.test.expect(cb_(), checkSiteReason(checkLoc_), testLoc_.file_name(), testLoc_.line());
 }
 
 std::unordered_map<std::string, Account>
@@ -125,7 +226,7 @@ MPTTester::makeHolders(std::vector<Account> const& holders)
     return accounts;
 }
 
-MPTTester::MPTTester(Env& env, Account issuer, MPTInit const& arg)
+MPTTester::MPTTester(Env& env, Account issuer, MPTInit const& arg, std::source_location const& loc)
     : env_(env)
     , issuer_(std::move(issuer))
     , holders_(makeHolders(arg.holders))
@@ -157,7 +258,7 @@ MPTTester::MPTTester(Env& env, Account issuer, MPTInit const& arg)
             env_.require(Owners(*arg.auditor, 0));
     }
     if (arg.create)
-        create(*arg.create);
+        create(*arg.create, loc);
 }
 
 MPTTester::MPTTester(
@@ -192,7 +293,7 @@ makeMPTCreate(MPTInitDef const& arg)
         .authHolder = arg.authHolder};
 }
 
-MPTTester::MPTTester(MPTInitDef const& arg)
+MPTTester::MPTTester(MPTInitDef const& arg, std::source_location const& loc)
     : MPTTester{
           arg.env,
           arg.issuer,
@@ -201,7 +302,8 @@ MPTTester::MPTTester(MPTInitDef const& arg)
               .fund = arg.fund,
               .close = arg.close,
               .create = makeMPTCreate(arg),
-          }}
+          },
+          loc}
 {
 }
 
@@ -238,7 +340,7 @@ MPTTester::createJV(MPTCreate const& arg)
 }
 
 void
-MPTTester::create(MPTCreate const& arg)
+MPTTester::create(MPTCreate const& arg, std::source_location const& loc)
 {
     if (id_)
         Throw<std::runtime_error>("MPT can't be reused");
@@ -251,30 +353,30 @@ MPTTester::create(MPTCreate const& arg)
          .metadata = arg.metadata,
          .immutableFlags = arg.immutableFlags,
          .domainID = arg.domainID});
-    if (!isTesSuccess(submit(arg, jv)))
+    if (!isTesSuccess(submit(arg, {jv, loc})))
     {
         // Verify issuance doesn't exist
         env_.require(RequireAny(
-            [&]() -> bool { return env_.le(keylet::mptokenIssuance(*id_)) == nullptr; }));
+            [&]() -> bool { return env_.le(keylet::mptokenIssuance(*id_)) == nullptr; }, loc));
 
         id_.reset();
     }
     else
     {
-        env_.require(MptFlags(*this, arg.flags.value_or(0)));
+        env_.require(MptFlags(*this, arg.flags.value_or(0), std::nullopt, loc));
         auto authAndPay = [&](auto const& accts, auto const&& getAcct) {
             for (auto const& it : accts)
             {
-                authorize({.account = getAcct(it)});
+                authorize({.account = getAcct(it)}, loc);
                 if ((arg.flags.value_or(0) & tfMPTRequireAuth) && arg.authHolder)
-                    authorize({.account = issuer_, .holder = getAcct(it)});
+                    authorize({.account = issuer_, .holder = getAcct(it)}, loc);
                 if (arg.pay && arg.pay->first.empty())
-                    pay(issuer_, getAcct(it), arg.pay->second);
+                    pay(issuer_, getAcct(it), arg.pay->second, std::nullopt, std::nullopt, loc);
             }
             if (arg.pay)
             {
                 for (auto const& p : arg.pay->first)
-                    pay(issuer_, p, arg.pay->second);
+                    pay(issuer_, p, arg.pay->second, std::nullopt, std::nullopt, loc);
             }
         };
         if (arg.authorize)
@@ -316,13 +418,13 @@ MPTTester::destroyJV(MPTDestroy const& arg)
 }
 
 void
-MPTTester::destroy(MPTDestroy const& arg)
+MPTTester::destroy(MPTDestroy const& arg, std::source_location const& loc)
 {
     if (!arg.id && !id_)
         Throw<std::runtime_error>("MPT has not been created");
     json::Value const jv =
         destroyJV({.issuer = arg.issuer ? arg.issuer : issuer_, .id = arg.id ? arg.id : id_});
-    submit(arg, jv);
+    submit(arg, {jv, loc});
 }
 
 Account const&
@@ -350,7 +452,7 @@ MPTTester::authorizeJV(MPTAuthorize const& arg)
 }
 
 void
-MPTTester::authorize(MPTAuthorize const& arg)
+MPTTester::authorize(MPTAuthorize const& arg, std::source_location const& loc)
 {
     if (!arg.id && !id_)
         Throw<std::runtime_error>("MPT has not been created");
@@ -359,7 +461,7 @@ MPTTester::authorize(MPTAuthorize const& arg)
         .holder = arg.holder,
         .id = arg.id ? arg.id : id_,
     });
-    if (auto const result = submit(arg, jv); isTesSuccess(result))
+    if (auto const result = submit(arg, {jv, loc}); isTesSuccess(result))
     {
         // Issuer authorizes
         if (!arg.account || *arg.account == issuer_)
@@ -368,12 +470,12 @@ MPTTester::authorize(MPTAuthorize const& arg)
             // issuer un-authorizes the holder
             if (arg.flags.value_or(0) == tfMPTUnauthorize)
             {
-                env_.require(MptFlags(*this, flags, arg.holder));
+                env_.require(MptFlags(*this, flags, arg.holder, loc));
                 // issuer authorizes the holder
             }
             else
             {
-                env_.require(MptFlags(*this, flags | lsfMPTAuthorized, arg.holder));
+                env_.require(MptFlags(*this, flags | lsfMPTAuthorized, arg.holder, loc));
             }
         }
         // Holder authorizes
@@ -381,13 +483,17 @@ MPTTester::authorize(MPTAuthorize const& arg)
         {
             auto const flags = getFlags(arg.account);
             // holder creates a token
-            env_.require(MptFlags(*this, flags, arg.account));
-            env_.require(MptBalance(*this, *arg.account, 0));
+            env_.require(MptFlags(*this, flags, arg.account, loc));
+            env_.require(MptBalance(*this, *arg.account, 0, loc));
         }
         else
         {
             // Verify that the MPToken doesn't exist.
-            forObject([&](SLEP const& sle) { return env_.test.BEAST_EXPECT(!sle); }, arg.account);
+            forObject(
+                [&](SLEP const& sle) {
+                    return env_.test.expect(!sle, "", loc.file_name(), loc.line());
+                },
+                arg.account);
         }
     }
     else if (
@@ -396,27 +502,31 @@ MPTTester::authorize(MPTAuthorize const& arg)
         if (result == tecDUPLICATE)
         {
             // Verify that MPToken already exists
-            env_.require(RequireAny([&]() -> bool {
-                return env_.le(keylet::mptoken(*id_, arg.account->id())) != nullptr;
-            }));
+            env_.require(RequireAny(
+                [&]() -> bool {
+                    return env_.le(keylet::mptoken(*id_, arg.account->id())) != nullptr;
+                },
+                loc));
         }
         else
         {
             // Verify MPToken doesn't exist if holder failed authorizing(unless
             // it already exists)
-            env_.require(RequireAny([&]() -> bool {
-                return env_.le(keylet::mptoken(*id_, arg.account->id())) == nullptr;
-            }));
+            env_.require(RequireAny(
+                [&]() -> bool {
+                    return env_.le(keylet::mptoken(*id_, arg.account->id())) == nullptr;
+                },
+                loc));
         }
     }
 }
 
 void
-MPTTester::authorizeHolders(Holders const& holders)
+MPTTester::authorizeHolders(Holders const& holders, std::source_location const& loc)
 {
     for (auto const& holder : holders)
     {
-        authorize({.account = holder});
+        authorize({.account = holder}, loc);
     }
 }
 
@@ -464,7 +574,7 @@ MPTTester::setJV(MPTSet const& arg)
 }
 
 void
-MPTTester::set(MPTSet const& arg)
+MPTTester::set(MPTSet const& arg, std::source_location const& loc)
 {
     if (!arg.id && !id_)
         Throw<std::runtime_error>("MPT has not been created");
@@ -479,7 +589,7 @@ MPTTester::set(MPTSet const& arg)
          .domainID = arg.domainID,
          .issuerPubKey = arg.issuerPubKey,
          .auditorPubKey = arg.auditorPubKey});
-    if (submit(arg, jv) == tesSUCCESS && arg.flags.value_or(0) != 0u)
+    if (submit(arg, {jv, loc}) == tesSUCCESS && arg.flags.value_or(0) != 0u)
     {
         auto require = [&](std::optional<Account> const& holder, bool unchanged) {
             auto flags = getFlags(holder);
@@ -505,7 +615,7 @@ MPTTester::set(MPTSet const& arg)
                     }
                 }
             }
-            env_.require(MptFlags(*this, flags, holder));
+            env_.require(MptFlags(*this, flags, holder, loc));
         };
         if (arg.account)
             require(std::nullopt, arg.holder.has_value());
@@ -514,43 +624,48 @@ MPTTester::set(MPTSet const& arg)
 
         if (arg.issuerPubKey)
         {
-            env_.require(RequireAny([&]() -> bool {
-                return forObject([&](SLEP const& sle) -> bool {
-                    if (sle)
-                    {
-                        auto const issuerPubKey = getPubKey(issuer_);
-                        if (!issuerPubKey)
+            env_.require(RequireAny(
+                [&]() -> bool {
+                    return forObject([&](SLEP const& sle) -> bool {
+                        if (sle)
                         {
-                            Throw<std::runtime_error>("MPTTester::set: issuer's pubkey is not set");
-                        }
+                            auto const issuerPubKey = getPubKey(issuer_);
+                            if (!issuerPubKey)
+                            {
+                                Throw<std::runtime_error>(
+                                    "MPTTester::set: issuer's pubkey is not set");
+                            }
 
-                        return strHex((*sle)[sfIssuerEncryptionKey]) == strHex(*issuerPubKey);
-                    }
-                    return false;
-                });
-            }));
+                            return strHex((*sle)[sfIssuerEncryptionKey]) == strHex(*issuerPubKey);
+                        }
+                        return false;
+                    });
+                },
+                loc));
         }
         if (arg.auditorPubKey)
         {
-            env_.require(RequireAny([&]() -> bool {
-                return forObject([&](SLEP const& sle) -> bool {
-                    if (sle)
-                    {
-                        if (!auditor_.has_value())
-                            Throw<std::runtime_error>("MPTTester::set: auditor is not set");
-
-                        auto const auditorPubKey = getPubKey(*auditor_);
-                        if (!auditorPubKey)
+            env_.require(RequireAny(
+                [&]() -> bool {
+                    return forObject([&](SLEP const& sle) -> bool {
+                        if (sle)
                         {
-                            Throw<std::runtime_error>(
-                                "MPTTester::set: auditor's pubkey is not set");
-                        }
+                            if (!auditor_.has_value())
+                                Throw<std::runtime_error>("MPTTester::set: auditor is not set");
 
-                        return strHex((*sle)[sfAuditorEncryptionKey]) == strHex(*auditorPubKey);
-                    }
-                    return false;
-                });
-            }));
+                            auto const auditorPubKey = getPubKey(*auditor_);
+                            if (!auditorPubKey)
+                            {
+                                Throw<std::runtime_error>(
+                                    "MPTTester::set: auditor's pubkey is not set");
+                            }
+
+                            return strHex((*sle)[sfAuditorEncryptionKey]) == strHex(*auditorPubKey);
+                        }
+                        return false;
+                    });
+                },
+                loc));
         }
     }
 }
@@ -648,13 +763,73 @@ MPTTester::checkImmutableFlags(std::uint32_t expectedFlags) const
     });
 }
 
+[[nodiscard]] bool
+MPTTester::checkKeyEpochs(
+    std::optional<std::uint32_t> issuerKeyEpoch,
+    std::optional<std::uint32_t> auditorKeyEpoch) const
+{
+    return forObject([&](SLEP const& sle) -> bool {
+        return (*sle)[~sfIssuerKeyEpoch] == issuerKeyEpoch &&
+            (*sle)[~sfAuditorKeyEpoch] == auditorKeyEpoch;
+    });
+}
+
+[[nodiscard]] bool
+MPTTester::checkMirrorEpochs(
+    Account const& holder,
+    std::optional<std::uint32_t> issuerKeyMirrorEpoch,
+    std::optional<std::uint32_t> auditorKeyMirrorEpoch) const
+{
+    return forObject(
+        [&](SLEP const& sle) -> bool {
+            return (*sle)[~sfIssuerKeyMirrorEpoch] == issuerKeyMirrorEpoch &&
+                (*sle)[~sfAuditorKeyMirrorEpoch] == auditorKeyMirrorEpoch;
+        },
+        holder);
+}
+
+[[nodiscard]] std::optional<std::uint32_t>
+MPTTester::getMirrorEpoch(Account const& holder, SF_UINT32 const& field) const
+{
+    std::optional<std::uint32_t> epoch;
+    forObject(
+        [&](SLEP const& sle) -> bool {
+            epoch = (*sle)[~field];
+            return true;
+        },
+        holder);
+    return epoch;
+}
+
+[[nodiscard]] bool
+MPTTester::checkEncryptionKeys(
+    std::optional<Account> const& issuerKeyOwner,
+    std::optional<Account> const& auditorKeyOwner) const
+{
+    auto const matches =
+        [this](SLEP const& sle, SF_VL const& field, std::optional<Account> const& owner) {
+            if (!owner)
+                return !sle->isFieldPresent(field);
+
+            auto const expected = getPubKey(*owner);
+            return expected && sle->isFieldPresent(field) &&
+                strHex((*sle)[field]) == strHex(*expected);
+        };
+
+    return forObject([&](SLEP const& sle) -> bool {
+        return matches(sle, sfIssuerEncryptionKey, issuerKeyOwner) &&
+            matches(sle, sfAuditorEncryptionKey, auditorKeyOwner);
+    });
+}
+
 void
 MPTTester::pay(
     Account const& src,
     Account const& dest,
     std::int64_t amount,
     std::optional<TER> err,
-    std::optional<std::vector<std::string>> credentials)
+    std::optional<std::vector<std::string>> credentials,
+    std::source_location const& loc)
 {
     if (!id_)
         Throw<std::runtime_error>("MPT has not been created");
@@ -665,13 +840,15 @@ MPTTester::pay(
     if (credentials)
     {
         env_(
-            jtx::pay(src, dest, mpt(amount)),
+            WithSourceLocation<json::Value>{jtx::pay(src, dest, mpt(amount)), loc},
             Ter(err.value_or(tesSUCCESS)),
             credentials::Ids(*credentials));
     }
     else
     {
-        env_(jtx::pay(src, dest, mpt(amount)), Ter(err.value_or(tesSUCCESS)));
+        env_(
+            WithSourceLocation<json::Value>{jtx::pay(src, dest, mpt(amount)), loc},
+            Ter(err.value_or(tesSUCCESS)));
     }
 
     if (!isTesSuccess(env_.ter()))
@@ -680,23 +857,23 @@ MPTTester::pay(
         env_.close();
     if (src == issuer_)
     {
-        env_.require(MptBalance(*this, src, srcAmt + amount));
-        env_.require(MptBalance(*this, dest, destAmt + amount));
+        env_.require(MptBalance(*this, src, srcAmt + amount, loc));
+        env_.require(MptBalance(*this, dest, destAmt + amount, loc));
     }
     else if (dest == issuer_)
     {
-        env_.require(MptBalance(*this, src, srcAmt - amount));
-        env_.require(MptBalance(*this, dest, destAmt - amount));
+        env_.require(MptBalance(*this, src, srcAmt - amount, loc));
+        env_.require(MptBalance(*this, dest, destAmt - amount, loc));
     }
     else
     {
         STAmount const saAmount = {*id_, amount};
         auto const actual = multiply(saAmount, transferRate(*env_.current(), *id_)).mpt().value();
         // Sender pays the transfer fee if any
-        env_.require(MptBalance(*this, src, srcAmt - actual));
-        env_.require(MptBalance(*this, dest, destAmt + amount));
+        env_.require(MptBalance(*this, src, srcAmt - actual, loc));
+        env_.require(MptBalance(*this, dest, destAmt + amount, loc));
         // Outstanding amount is reduced by the transfer fee if any
-        env_.require(MptBalance(*this, issuer_, outstandingAmt - (actual - amount)));
+        env_.require(MptBalance(*this, issuer_, outstandingAmt - (actual - amount), loc));
     }
 }
 
@@ -705,20 +882,23 @@ MPTTester::claw(
     Account const& issuer,
     Account const& holder,
     std::int64_t amount,
-    std::optional<TER> err)
+    std::optional<TER> err,
+    std::source_location const& loc)
 {
     if (!id_)
         Throw<std::runtime_error>("MPT has not been created");
     auto const issuerAmt = getBalance(issuer);
     auto const holderAmt = getBalance(holder);
-    env_(jtx::claw(issuer, mpt(amount), holder), Ter(err.value_or(tesSUCCESS)));
+    env_(
+        WithSourceLocation<json::Value>{jtx::claw(issuer, mpt(amount), holder), loc},
+        Ter(err.value_or(tesSUCCESS)));
     if (!isTesSuccess(env_.ter()))
         amount = 0;
     if (close_)
         env_.close();
 
-    env_.require(MptBalance(*this, issuer, issuerAmt - std::min(holderAmt, amount)));
-    env_.require(MptBalance(*this, holder, holderAmt - std::min(holderAmt, amount)));
+    env_.require(MptBalance(*this, issuer, issuerAmt - std::min(holderAmt, amount), loc));
+    env_.require(MptBalance(*this, holder, holderAmt - std::min(holderAmt, amount), loc));
 }
 
 PrettyAmount
@@ -917,7 +1097,7 @@ MPTTester::getPedersenCommitment(std::uint64_t const amount, Buffer const& peder
     return buf;
 }
 
-Buffer
+std::optional<Buffer>
 MPTTester::getConvertBackProof(
     Account const& holder,
     std::uint64_t const amount,
@@ -929,13 +1109,13 @@ MPTTester::getConvertBackProof(
 
     auto const sleMptoken = env_.le(keylet::mptoken(issuanceID(), holder.id()));
     if (!sleMptoken || !sleMptoken->isFieldPresent(sfConfidentialBalanceSpending))
-        return gMakeZeroBuffer(kExpectedProofLength);
+        return std::nullopt;
 
     auto const holderPubKey = getPubKey(holder);
     auto const holderPrivKey = getPrivKey(holder);
 
     if (!holderPubKey || !holderPrivKey)
-        return gMakeZeroBuffer(kExpectedProofLength);
+        return std::nullopt;
 
     auto const pedersenParams = makePedersenParams(pcParams);
     Buffer proof(kExpectedProofLength);
@@ -947,7 +1127,7 @@ MPTTester::getConvertBackProof(
             amount,
             &pedersenParams,
             proof.data()) != 0)
-        return gMakeZeroBuffer(kExpectedProofLength);
+        return std::nullopt;
 
     return proof;
 }
@@ -958,33 +1138,32 @@ MPTTester::getEncryptedBalance(Account const& account, EncryptedBalanceType opti
     if (!id_)
         Throw<std::runtime_error>("MPT has not been created");
 
-    if (auto const sle = env_.le(keylet::mptoken(*id_, account.id())))
+    auto const sle = env_.le(keylet::mptoken(*id_, account.id()));
+    if (!sle)
+        return {};
+
+    SField const* field = nullptr;
+    switch (option)
     {
-        if (option == holderEncryptedInbox && sle->isFieldPresent(sfConfidentialBalanceInbox))
-        {
-            return Buffer(
-                (*sle)[sfConfidentialBalanceInbox].data(),
-                (*sle)[sfConfidentialBalanceInbox].size());
-        }
-        if (option == holderEncryptedSpending && sle->isFieldPresent(sfConfidentialBalanceSpending))
-        {
-            return Buffer(
-                (*sle)[sfConfidentialBalanceSpending].data(),
-                (*sle)[sfConfidentialBalanceSpending].size());
-        }
-        if (option == issuerEncryptedBalance && sle->isFieldPresent(sfIssuerEncryptedBalance))
-        {
-            return Buffer(
-                (*sle)[sfIssuerEncryptedBalance].data(), (*sle)[sfIssuerEncryptedBalance].size());
-        }
-        if (option == auditorEncryptedBalance && sle->isFieldPresent(sfAuditorEncryptedBalance))
-        {
-            return Buffer(
-                (*sle)[sfAuditorEncryptedBalance].data(), (*sle)[sfAuditorEncryptedBalance].size());
-        }
+        case holderEncryptedInbox:
+            field = &sfConfidentialBalanceInbox;
+            break;
+        case holderEncryptedSpending:
+            field = &sfConfidentialBalanceSpending;
+            break;
+        case issuerEncryptedBalance:
+            field = &sfIssuerEncryptedBalance;
+            break;
+        case auditorEncryptedBalance:
+            field = &sfAuditorEncryptedBalance;
+            break;
     }
 
-    return {};
+    if (field == nullptr || !sle->isFieldPresent(*field))
+        return {};
+
+    auto const blob = sle->getFieldVL(*field);
+    return Buffer(blob.data(), blob.size());
 }
 
 std::uint32_t
@@ -1001,6 +1180,33 @@ MPTTester::getFlags(std::optional<Account> const& holder) const
     return flags;
 }
 
+void
+MPTTester::setIssuanceIdField(json::Value& jv, std::optional<MPTID> const& id) const
+{
+    if (id)
+    {
+        jv[sfMPTokenIssuanceID] = to_string(*id);
+    }
+    else if (id_)
+    {
+        jv[sfMPTokenIssuanceID] = to_string(*id_);
+    }
+    else
+    {
+        Throw<std::runtime_error>("MPT has not been created");
+    }
+}
+
+std::uint32_t
+MPTTester::ticketOrSeq(
+    std::optional<std::uint32_t> const& ticketSeq,
+    std::optional<Account> const& account) const
+{
+    if (ticketSeq)
+        return *ticketSeq;
+    return env_.seq(requireValue(account, "account"));
+}
+
 MPT
 MPTTester::operator[](std::string const& name) const
 {
@@ -1018,47 +1224,37 @@ void
 MPTTester::fillConversionCiphertexts(
     T const& arg,
     json::Value& jv,
-    Buffer& holderCiphertext,
-    Buffer& issuerCiphertext,
-    std::optional<Buffer>& auditorCiphertext,
-    Buffer& blindingFactor) const
+    Account const& account,
+    std::uint64_t const amount) const
 {
-    blindingFactor = arg.blindingFactor ? *arg.blindingFactor : generateBlindingFactor();
+    Buffer const blindingFactor =
+        arg.blindingFactor ? *arg.blindingFactor : generateBlindingFactor();
+    jv[sfBlindingFactor.jsonName] = strHex(blindingFactor);
 
     // Handle Holder
-    if (arg.holderEncryptedAmt)
-    {
-        holderCiphertext = *arg.holderEncryptedAmt;
-    }
-    else
-    {
-        holderCiphertext = encryptAmount(
-            requireValue(arg.account, "account"), requireValue(arg.amt, "amt"), blindingFactor);
-    }
+    Buffer const holderCiphertext = arg.holderEncryptedAmt
+        ? *arg.holderEncryptedAmt
+        : encryptAmount(account, amount, blindingFactor);
 
     jv[sfHolderEncryptedAmount.jsonName] = strHex(holderCiphertext);
 
     // Handle Issuer
-    if (arg.issuerEncryptedAmt)
-    {
-        issuerCiphertext = *arg.issuerEncryptedAmt;
-    }
-    else
-    {
-        issuerCiphertext = encryptAmount(issuer_, requireValue(arg.amt, "amt"), blindingFactor);
-    }
+    Buffer const issuerCiphertext = arg.issuerEncryptedAmt
+        ? *arg.issuerEncryptedAmt
+        : encryptAmount(issuer_, amount, blindingFactor);
 
     jv[sfIssuerEncryptedAmount.jsonName] = strHex(issuerCiphertext);
 
     // Handle Auditor
+    std::optional<Buffer> auditorCiphertext;
     if (arg.auditorEncryptedAmt)
     {
         auditorCiphertext = *arg.auditorEncryptedAmt;
     }
     else if (auditor_.has_value() && arg.fillAuditorEncryptedAmt.value_or(false))
     {
-        auditorCiphertext = encryptAmount(
-            requireValue(auditor_, "auditor"), requireValue(arg.amt, "amt"), blindingFactor);
+        auditorCiphertext =
+            encryptAmount(requireValue(auditor_, "auditor"), amount, blindingFactor);
     }
 
     // Update auditor JSON only if ciphertext exists
@@ -1067,174 +1263,138 @@ MPTTester::fillConversionCiphertexts(
 }
 
 void
-MPTTester::convert(MPTConvert const& arg)
+MPTTester::convert(MPTConvert const& arg, std::source_location const& loc)
 {
-    json::Value jv;
-    if (arg.account)
-    {
-        jv[sfAccount] = arg.account->human();
-    }
-    else
-    {
-        Throw<std::runtime_error>("Account not specified");
-    }
+    json::Value const jv = convertJV(arg, ticketOrSeq(arg.ticketSeq, arg.account));
 
-    jv[jss::TransactionType] = jss::ConfidentialMPTConvert;
-    if (arg.id)
-    {
-        jv[sfMPTokenIssuanceID] = to_string(*arg.id);
-    }
-    else
-    {
-        if (!id_)
-            Throw<std::runtime_error>("MPT has not been created");
-        jv[sfMPTokenIssuanceID] = to_string(*id_);
-    }
+    Account const& account = requireValue(arg.account, "account");
+    auto const amt = requireValue(arg.amt, "amt");
 
-    if (arg.amt)
-        jv[sfMPTAmount.jsonName] = std::to_string(*arg.amt);
-    if (arg.holderPubKey)
-        jv[sfHolderEncryptionKey.jsonName] = strHex(*arg.holderPubKey);
-
-    Buffer holderCiphertext;
-    Buffer issuerCiphertext;
-    std::optional<Buffer> auditorCiphertext;
-    Buffer blindingFactor;
-
-    fillConversionCiphertexts(
-        arg, jv, holderCiphertext, issuerCiphertext, auditorCiphertext, blindingFactor);
-
-    jv[sfBlindingFactor.jsonName] = strHex(blindingFactor);
-    if (arg.proof)
-    {
-        jv[sfZKProof.jsonName] = *arg.proof;
-    }
-    else if (arg.fillSchnorrProof.value_or(arg.holderPubKey.has_value()))
-    {
-        // whether to automatically generate and attach a Schnorr proof:
-        // if fillSchnorrProof is explicitly set, follow its value;
-        // otherwise, default to generating the proof only if holder pub key is
-        // present.
-        auto const seq = arg.ticketSeq.value_or(env_.seq(*arg.account));
-        auto const contextHash =
-            getConvertContextHash(requireValue(arg.account, "account").id(), issuanceID(), seq);
-
-        auto const proof = getSchnorrProof(*arg.account, contextHash);
-        if (proof)
-        {
-            jv[sfZKProof.jsonName] = strHex(*proof);
-        }
-        else
-        {
-            jv[sfZKProof.jsonName] = strHex(gMakeZeroBuffer(kEcSchnorrProofLength));
-        }
-    }
-
-    auto const holderAmt = getBalance(*arg.account);
+    auto const holderAmt = getBalance(account);
     auto const prevConfidentialOutstanding = getIssuanceConfidentialBalance();
 
-    auto const prevInboxBalance = getDecryptedBalance(*arg.account, holderEncryptedInbox);
-    auto const prevSpendingBalance = getDecryptedBalance(*arg.account, holderEncryptedSpending);
-    auto const prevIssuerBalance = getDecryptedBalance(*arg.account, issuerEncryptedBalance);
+    auto const prevInboxBalance = getDecryptedBalance(account, holderEncryptedInbox);
+    auto const prevSpendingBalance = getDecryptedBalance(account, holderEncryptedSpending);
+    auto const prevIssuerBalance = getDecryptedBalance(account, issuerEncryptedBalance);
 
     if (!prevInboxBalance || !prevSpendingBalance || !prevIssuerBalance)
         Throw<std::runtime_error>("Failed to get Pre-convert balance");
 
+    // The auditor mirror is only touched if the transaction carries an auditor
+    // ciphertext, which mirrors the condition convertJV fills it under.
+    bool const hasAuditorAmt =
+        arg.auditorEncryptedAmt || (auditor_ && arg.fillAuditorEncryptedAmt.value_or(false));
+
     std::optional<uint64_t> prevAuditorBalance;
-    if (arg.auditorEncryptedAmt || auditor_)
+    if (hasAuditorAmt)
     {
-        prevAuditorBalance = getDecryptedBalance(*arg.account, auditorEncryptedBalance);
+        prevAuditorBalance = getDecryptedBalance(account, auditorEncryptedBalance);
         if (!prevAuditorBalance)
             Throw<std::runtime_error>("Failed to get Pre-convert balance");
     }
 
     auto const prevOutstanding = getIssuanceOutstandingBalance();
 
-    if (submit(arg, jv) == tesSUCCESS)
+    if (submit(arg, {jv, loc}) == tesSUCCESS)
     {
         auto const postConfidentialOutstanding = getIssuanceConfidentialBalance();
         auto const postOutstanding = getIssuanceOutstandingBalance();
-        env_.require(MptBalance(
-            *this, requireValue(arg.account, "account"), holderAmt - requireValue(arg.amt, "amt")));
-        env_.require(RequireAny([&]() -> bool {
-            return prevOutstanding && postOutstanding && *prevOutstanding == *postOutstanding;
-        }));
-        env_.require(RequireAny([&]() -> bool {
-            return prevConfidentialOutstanding + *arg.amt == postConfidentialOutstanding;
-        }));
+        env_.require(MptBalance(*this, account, holderAmt - amt, loc));
+        env_.require(RequireAny(
+            [&]() -> bool {
+                return prevOutstanding && postOutstanding && *prevOutstanding == *postOutstanding;
+            },
+            loc));
+        env_.require(RequireAny(
+            [&]() -> bool {
+                return prevConfidentialOutstanding + amt == postConfidentialOutstanding;
+            },
+            loc));
 
-        env_.require(RequireAny([&]() -> bool {
-            return getEncryptedBalance(*arg.account, holderEncryptedInbox).has_value();
-        }));
-        env_.require(RequireAny([&]() -> bool {
-            return getEncryptedBalance(*arg.account, holderEncryptedSpending).has_value();
-        }));
-        env_.require(RequireAny([&]() -> bool {
-            return getEncryptedBalance(*arg.account, issuerEncryptedBalance).has_value();
-        }));
+        env_.require(RequireAny(
+            [&]() -> bool {
+                return getEncryptedBalance(account, holderEncryptedInbox).has_value();
+            },
+            loc));
+        env_.require(RequireAny(
+            [&]() -> bool {
+                return getEncryptedBalance(account, holderEncryptedSpending).has_value();
+            },
+            loc));
+        env_.require(RequireAny(
+            [&]() -> bool {
+                return getEncryptedBalance(account, issuerEncryptedBalance).has_value();
+            },
+            loc));
 
-        auto const postInboxBalance = getDecryptedBalance(*arg.account, holderEncryptedInbox);
-        auto const postIssuerBalance = getDecryptedBalance(*arg.account, issuerEncryptedBalance);
-        auto const postSpendingBalance = getDecryptedBalance(*arg.account, holderEncryptedSpending);
+        auto const postInboxBalance = getDecryptedBalance(account, holderEncryptedInbox);
+        auto const postIssuerBalance = getDecryptedBalance(account, issuerEncryptedBalance);
+        auto const postSpendingBalance = getDecryptedBalance(account, holderEncryptedSpending);
 
         if (!postInboxBalance || !postIssuerBalance || !postSpendingBalance)
             Throw<std::runtime_error>("Failed to get post-convert balance");
 
-        if (arg.auditorEncryptedAmt || auditor_)
+        if (hasAuditorAmt)
         {
-            auto const postAuditorBalance =
-                getDecryptedBalance(*arg.account, auditorEncryptedBalance);
+            auto const postAuditorBalance = getDecryptedBalance(account, auditorEncryptedBalance);
 
             if (!postAuditorBalance)
                 Throw<std::runtime_error>("Failed to get post-convert auditor balance");
 
-            env_.require(RequireAny([&]() -> bool {
-                return getEncryptedBalance(*arg.account, auditorEncryptedBalance).has_value();
-            }));
+            env_.require(RequireAny(
+                [&]() -> bool {
+                    return getEncryptedBalance(account, auditorEncryptedBalance).has_value();
+                },
+                loc));
 
             // auditor's encrypted balance is updated correctly
             env_.require(RequireAny(
-                [&]() -> bool { return *prevAuditorBalance + *arg.amt == *postAuditorBalance; }));
+                [&]() -> bool { return *prevAuditorBalance + amt == *postAuditorBalance; }, loc));
         }
         // spending balance should not change
-        env_.require(
-            RequireAny([&]() -> bool { return *postSpendingBalance == *prevSpendingBalance; }));
+        env_.require(RequireAny(
+            [&]() -> bool { return *postSpendingBalance == *prevSpendingBalance; }, loc));
 
         // issuer's encrypted balance is updated correctly
         env_.require(RequireAny(
-            [&]() -> bool { return *prevIssuerBalance + *arg.amt == *postIssuerBalance; }));
+            [&]() -> bool { return *prevIssuerBalance + amt == *postIssuerBalance; }, loc));
 
         // holder's inbox balance is updated correctly
         env_.require(RequireAny(
-            [&]() -> bool { return *prevInboxBalance + *arg.amt == *postInboxBalance; }));
+            [&]() -> bool { return *prevInboxBalance + amt == *postInboxBalance; }, loc));
 
         // sum of holder's inbox and spending balance should equal to issuer's
         // encrypted balance
-        env_.require(RequireAny([&]() -> bool {
-            return *postInboxBalance + *postSpendingBalance == *postIssuerBalance;
-        }));
+        env_.require(RequireAny(
+            [&]() -> bool {
+                return *postInboxBalance + *postSpendingBalance == *postIssuerBalance;
+            },
+            loc));
 
         if (arg.holderPubKey)
         {
-            env_.require(RequireAny([&]() -> bool {
-                return forObject(
-                    [&](SLEP const& sle) -> bool {
-                        if (sle)
-                        {
-                            auto const holderPubKey = getPubKey(*arg.account);
-                            if (!holderPubKey)
+            env_.require(RequireAny(
+                [&]() -> bool {
+                    return forObject(
+                        [&](SLEP const& sle) -> bool {
+                            if (sle)
                             {
-                                Throw<std::runtime_error>(
-                                    "MPTTester::convert: holder's pubkey is "
-                                    "not set");
-                            }
+                                auto const holderPubKey = getPubKey(account);
+                                if (!holderPubKey)
+                                {
+                                    Throw<std::runtime_error>(
+                                        "MPTTester::convert: holder's pubkey is "
+                                        "not set");
+                                }
 
-                            return strHex((*sle)[sfHolderEncryptionKey]) == strHex(*holderPubKey);
-                        }
-                        return false;
-                    },
-                    arg.account);
-            }));
+                                return strHex((*sle)[sfHolderEncryptionKey]) ==
+                                    strHex(*holderPubKey);
+                            }
+                            return false;
+                        },
+                        account);
+                },
+                loc));
         }
     }
 }
@@ -1243,41 +1403,17 @@ json::Value
 MPTTester::convertJV(MPTConvert const& arg, std::uint32_t seq)
 {
     json::Value jv;
-    if (arg.account)
-    {
-        jv[sfAccount] = arg.account->human();
-    }
-    else
-    {
-        Throw<std::runtime_error>("Account not specified");
-    }
+    Account const& account = setAccountField(jv, arg.account);
 
     jv[jss::TransactionType] = jss::ConfidentialMPTConvert;
-    if (arg.id)
-    {
-        jv[sfMPTokenIssuanceID] = to_string(*arg.id);
-    }
-    else
-    {
-        if (!id_)
-            Throw<std::runtime_error>("MPT has not been created");
-        jv[sfMPTokenIssuanceID] = to_string(*id_);
-    }
+    setIssuanceIdField(jv, arg.id);
 
-    if (arg.amt)
-        jv[sfMPTAmount.jsonName] = std::to_string(*arg.amt);
+    auto const amt = requireValue(arg.amt, "amt");
+    jv[sfMPTAmount.jsonName] = std::to_string(amt);
     if (arg.holderPubKey)
         jv[sfHolderEncryptionKey.jsonName] = strHex(*arg.holderPubKey);
 
-    Buffer holderCiphertext;
-    Buffer issuerCiphertext;
-    std::optional<Buffer> auditorCiphertext;
-    Buffer blindingFactor;
-
-    fillConversionCiphertexts(
-        arg, jv, holderCiphertext, issuerCiphertext, auditorCiphertext, blindingFactor);
-
-    jv[sfBlindingFactor.jsonName] = strHex(blindingFactor);
+    fillConversionCiphertexts(arg, jv, account, amt);
 
     if (arg.proof)
     {
@@ -1285,356 +1421,151 @@ MPTTester::convertJV(MPTConvert const& arg, std::uint32_t seq)
     }
     else if (arg.fillSchnorrProof.value_or(arg.holderPubKey.has_value()))
     {
-        auto const contextHash =
-            getConvertContextHash(requireValue(arg.account, "account").id(), issuanceID(), seq);
-        auto const proof = getSchnorrProof(*arg.account, contextHash);
-        if (proof)
-        {
-            jv[sfZKProof.jsonName] = strHex(*proof);
-        }
-        else
-        {
-            jv[sfZKProof.jsonName] = strHex(gMakeZeroBuffer(kEcSchnorrProofLength));
-        }
+        auto const contextHash = getConvertContextHash(account.id(), issuanceID(), seq);
+        setProofOrDummy(jv, getSchnorrProof(account, contextHash), kEcSchnorrProofLength);
     }
 
     return jv;
 }
 
 void
-MPTTester::send(MPTConfidentialSend const& arg)
+MPTTester::send(MPTConfidentialSend const& arg, std::source_location const& loc)
 {
-    json::Value jv;
-    jv[jss::TransactionType] = jss::ConfidentialMPTSend;
+    json::Value const jv = sendJV(arg, ticketOrSeq(arg.ticketSeq, arg.account));
 
-    if (arg.account)
-    {
-        jv[sfAccount] = arg.account->human();
-    }
-    else
-    {
-        Throw<std::runtime_error>("Account not specified");
-    }
-
-    if (arg.dest)
-    {
-        jv[sfDestination] = arg.dest->human();
-    }
-    else
-    {
-        Throw<std::runtime_error>("Destination not specified");
-    }
-
-    if (!arg.amt)
-        Throw<std::runtime_error>("Amount not specified for testing purposes");
-
-    if (arg.id)
-    {
-        jv[sfMPTokenIssuanceID] = to_string(*arg.id);
-    }
-    else
-    {
-        if (!id_)
-            Throw<std::runtime_error>("MPT has not been created");
-        jv[sfMPTokenIssuanceID] = to_string(*id_);
-    }
-
-    Buffer const blindingFactor =
-        arg.blindingFactor ? *arg.blindingFactor : generateBlindingFactor();
-
-    // fill in the encrypted amounts if not provided
-    auto const senderAmt = arg.senderEncryptedAmt
-        ? *arg.senderEncryptedAmt
-        : encryptAmount(*arg.account, *arg.amt, blindingFactor);
-    auto const destAmt = arg.destEncryptedAmt ? *arg.destEncryptedAmt
-                                              : encryptAmount(*arg.dest, *arg.amt, blindingFactor);
-    auto const issuerAmt = arg.issuerEncryptedAmt
-        ? *arg.issuerEncryptedAmt
-        : encryptAmount(issuer_, *arg.amt, blindingFactor);
-
-    std::optional<Buffer> auditorAmt;
-    if (arg.auditorEncryptedAmt)
-    {
-        auditorAmt = arg.auditorEncryptedAmt;
-    }
-    else if (auditor_.has_value() && arg.fillAuditorEncryptedAmt.value_or(false))
-    {
-        auditorAmt = encryptAmount(
-            requireValue(auditor_, "auditor"), requireValue(arg.amt, "amt"), blindingFactor);
-    }
-
-    jv[sfSenderEncryptedAmount] = strHex(senderAmt);
-    jv[sfDestinationEncryptedAmount] = strHex(destAmt);
-    jv[sfIssuerEncryptedAmount] = strHex(issuerAmt);
-    if (auditorAmt)
-        jv[sfAuditorEncryptedAmount] = strHex(*auditorAmt);
-
-    if (arg.credentials)
-    {
-        auto& arr(jv[sfCredentialIDs.jsonName] = json::ValueType::Array);
-        for (auto const& hash : *arg.credentials)
-            arr.append(hash);
-    }
+    Account const& account = requireValue(arg.account, "account");
+    Account const& dest = requireValue(arg.dest, "dest");
+    auto const amt = requireValue(arg.amt, "amt");
 
     // Version counters before send
-    auto const prevSenderVersion = getMPTokenVersion(*arg.account);
-    auto const prevDestVersion = getMPTokenVersion(*arg.dest);
+    auto const prevSenderVersion = getMPTokenVersion(account);
+    auto const prevDestVersion = getMPTokenVersion(dest);
 
     // Sender's previous confidential state
-    auto const prevSenderInbox = getDecryptedBalance(*arg.account, holderEncryptedInbox);
-    auto const prevSenderSpending = getDecryptedBalance(*arg.account, holderEncryptedSpending);
-    auto const prevSenderIssuer = getDecryptedBalance(*arg.account, issuerEncryptedBalance);
-    auto const prevSenderInboxEncrypted = getEncryptedBalance(*arg.account, holderEncryptedInbox);
-    auto const prevSenderSpendingEncrypted =
-        getEncryptedBalance(*arg.account, holderEncryptedSpending);
-    auto const prevSenderIssuerEncrypted =
-        getEncryptedBalance(*arg.account, issuerEncryptedBalance);
+    auto const prevSenderInbox = getDecryptedBalance(account, holderEncryptedInbox);
+    auto const prevSenderSpending = getDecryptedBalance(account, holderEncryptedSpending);
+    auto const prevSenderIssuer = getDecryptedBalance(account, issuerEncryptedBalance);
     if (!prevSenderInbox || !prevSenderSpending || !prevSenderIssuer)
         Throw<std::runtime_error>("Failed to get Pre-send balance");
 
     std::optional<uint64_t> prevSenderAuditor;
-    auto const prevSenderAuditorEncrypted =
-        getEncryptedBalance(*arg.account, auditorEncryptedBalance);
     if (arg.auditorEncryptedAmt || auditor_)
     {
-        prevSenderAuditor = getDecryptedBalance(*arg.account, auditorEncryptedBalance);
+        prevSenderAuditor = getDecryptedBalance(account, auditorEncryptedBalance);
         if (!prevSenderAuditor)
             Throw<std::runtime_error>("Failed to get Pre-send balance");
     }
 
     // Destination's previous confidential state
-    auto const prevDestInbox = getDecryptedBalance(*arg.dest, holderEncryptedInbox);
-    auto const prevDestSpending = getDecryptedBalance(*arg.dest, holderEncryptedSpending);
-    auto const prevDestIssuer = getDecryptedBalance(*arg.dest, issuerEncryptedBalance);
-    auto const prevDestInboxEncrypted = getEncryptedBalance(*arg.dest, holderEncryptedInbox);
-    auto const prevDestSpendingEncrypted = getEncryptedBalance(*arg.dest, holderEncryptedSpending);
-    auto const prevDestIssuerEncrypted = getEncryptedBalance(*arg.dest, issuerEncryptedBalance);
+    auto const prevDestInbox = getDecryptedBalance(dest, holderEncryptedInbox);
+    auto const prevDestSpending = getDecryptedBalance(dest, holderEncryptedSpending);
+    auto const prevDestIssuer = getDecryptedBalance(dest, issuerEncryptedBalance);
     if (!prevDestInbox || !prevDestSpending || !prevDestIssuer)
         Throw<std::runtime_error>("Failed to get Pre-send balance");
 
     std::optional<uint64_t> prevDestAuditor;
-    auto const prevDestAuditorEncrypted = getEncryptedBalance(*arg.dest, auditorEncryptedBalance);
     if (arg.auditorEncryptedAmt || auditor_)
     {
-        prevDestAuditor = getDecryptedBalance(*arg.dest, auditorEncryptedBalance);
+        prevDestAuditor = getDecryptedBalance(dest, auditorEncryptedBalance);
         if (!prevDestAuditor)
             Throw<std::runtime_error>("Failed to get Pre-send balance");
     }
 
-    // Fill in the commitment if not provided
-    // The amount commitment must use the same blinding factor as the ElGamal
-    // encryption. The sigma proof links the two, so using different randomness
-    // for each would cause proof verification to fail.
-    Buffer amountCommitment, balanceCommitment;
-    if (arg.amountCommitment)
-    {
-        amountCommitment = *arg.amountCommitment;
-    }
-    else
-    {
-        amountCommitment = getPedersenCommitment(*arg.amt, blindingFactor);
-    }
-
-    jv[sfAmountCommitment] = strHex(amountCommitment);
-
-    auto const balanceBlindingFactor = generateBlindingFactor();
-    if (arg.balanceCommitment)
-    {
-        balanceCommitment = *arg.balanceCommitment;
-    }
-    else
-    {
-        balanceCommitment = getPedersenCommitment(*prevSenderSpending, balanceBlindingFactor);
-    }
-
-    jv[sfBalanceCommitment] = strHex(balanceCommitment);
-
-    // Fill in the proof if not provided
-    if (arg.proof)
-    {
-        jv[sfZKProof] = *arg.proof;
-    }
-    else
-    {
-        auto const version = getMPTokenVersion(*arg.account);
-        auto const seq = arg.ticketSeq.value_or(env_.seq(*arg.account));
-        auto const ctxHash = getSendContextHash(
-            requireValue(arg.account, "account").id(),
-            issuanceID(),
-            seq,
-            requireValue(arg.dest, "dest").id(),
-            version);
-
-        std::vector<ConfidentialRecipient> recipients;
-
-        auto const senderPubKey = getPubKey(*arg.account);
-        auto const destPubKey = getPubKey(*arg.dest);
-        auto const issuerPubKey = getPubKey(issuer_);
-
-        // If a key is missing, we skip adding the recipient. This intentionally
-        // causes proof generation to fail, triggering the dummy proof fallback.
-        if (senderPubKey)
-        {
-            recipients.push_back({
-                .publicKey = Slice(*senderPubKey),
-                .encryptedAmount = senderAmt,
-            });
-        }
-        if (destPubKey)
-        {
-            recipients.push_back({
-                .publicKey = Slice(*destPubKey),
-                .encryptedAmount = destAmt,
-            });
-        }
-        if (issuerPubKey)
-        {
-            recipients.push_back({
-                .publicKey = Slice(*issuerPubKey),
-                .encryptedAmount = issuerAmt,
-            });
-        }
-
-        std::optional<Buffer> auditorPubKey;
-        if (auditorAmt)
-        {
-            if (!auditor_)
-                Throw<std::runtime_error>("Auditor not registered");
-
-            auditorPubKey = getPubKey(*auditor_);
-            if (auditorPubKey)
-            {
-                recipients.push_back({
-                    .publicKey = Slice(*auditorPubKey),
-                    .encryptedAmount = *auditorAmt,
-                });
-            }
-        }
-
-        std::optional<Buffer> proof;
-
-        // Skip proof generation if encrypted balance is missing (e.g.,
-        // feature disabled), when the sender and destination are the same
-        // (malformed case causing pcm to be zero), or when spending balance
-        // is 0
-        if (arg.account != arg.dest && prevSenderSpendingEncrypted && *prevSenderSpending > 0)
-        {
-            proof = getConfidentialSendProof(
-                *arg.account,
-                *arg.amt,
-                recipients,
-                blindingFactor,
-                ctxHash,
-                {
-                    .pedersenCommitment = amountCommitment,
-                    .amt = *arg.amt,
-                    .encryptedAmt = senderAmt,
-                    .blindingFactor = blindingFactor,
-                },
-                {
-                    .pedersenCommitment = balanceCommitment,
-                    .amt = *prevSenderSpending,
-                    .encryptedAmt = *prevSenderSpendingEncrypted,
-                    .blindingFactor = balanceBlindingFactor,
-                });
-        }
-
-        if (proof)
-        {
-            jv[sfZKProof.jsonName] = strHex(*proof);
-        }
-        else
-        {
-            jv[sfZKProof.jsonName] = strHex(gMakeZeroBuffer(kEcSendProofLength));
-        }
-    }
-
-    auto const senderPubAmt = getBalance(*arg.account);
-    auto const destPubAmt = getBalance(*arg.dest);
+    auto const senderPubAmt = getBalance(account);
+    auto const destPubAmt = getBalance(dest);
     auto const prevCOA = getIssuanceConfidentialBalance();
     auto const prevOA = getIssuanceOutstandingBalance();
 
-    if (submit(arg, jv) == tesSUCCESS)
+    if (submit(arg, {jv, loc}) == tesSUCCESS)
     {
         auto const postCOA = getIssuanceConfidentialBalance();
         auto const postOA = getIssuanceOutstandingBalance();
 
         // Sender's post confidential state
-        auto const postSenderInbox = getDecryptedBalance(*arg.account, holderEncryptedInbox);
-        auto const postSenderSpending = getDecryptedBalance(*arg.account, holderEncryptedSpending);
-        auto const postSenderIssuer = getDecryptedBalance(*arg.account, issuerEncryptedBalance);
+        auto const postSenderInbox = getDecryptedBalance(account, holderEncryptedInbox);
+        auto const postSenderSpending = getDecryptedBalance(account, holderEncryptedSpending);
+        auto const postSenderIssuer = getDecryptedBalance(account, issuerEncryptedBalance);
 
         if (!postSenderInbox || !postSenderSpending || !postSenderIssuer)
             Throw<std::runtime_error>("Failed to get Post-send balance");
 
         // Destination's post confidential state
-        auto const postDestInbox = getDecryptedBalance(*arg.dest, holderEncryptedInbox);
-        auto const postDestSpending = getDecryptedBalance(*arg.dest, holderEncryptedSpending);
-        auto const postDestIssuer = getDecryptedBalance(*arg.dest, issuerEncryptedBalance);
+        auto const postDestInbox = getDecryptedBalance(dest, holderEncryptedInbox);
+        auto const postDestSpending = getDecryptedBalance(dest, holderEncryptedSpending);
+        auto const postDestIssuer = getDecryptedBalance(dest, issuerEncryptedBalance);
 
         if (!postDestInbox || !postDestSpending || !postDestIssuer)
             Throw<std::runtime_error>("Failed to get Post-send balance");
 
         // Public balances unchanged
-        env_.require(MptBalance(*this, *arg.account, senderPubAmt));
-        env_.require(MptBalance(*this, *arg.dest, destPubAmt));
+        env_.require(MptBalance(*this, account, senderPubAmt, loc));
+        env_.require(MptBalance(*this, dest, destPubAmt, loc));
 
         // OA and COA unchanged
-        env_.require(RequireAny([&]() -> bool { return prevOA && postOA && *prevOA == *postOA; }));
-        env_.require(RequireAny([&]() -> bool { return prevCOA == postCOA; }));
+        env_.require(
+            RequireAny([&]() -> bool { return prevOA && postOA && *prevOA == *postOA; }, loc));
+        env_.require(RequireAny([&]() -> bool { return prevCOA == postCOA; }, loc));
 
         // Verify sender changes
-        env_.require(RequireAny([&]() -> bool {
-            return *prevSenderSpending >= *arg.amt &&
-                *postSenderSpending == *prevSenderSpending - *arg.amt;
-        }));
-        env_.require(RequireAny([&]() -> bool { return postSenderInbox == prevSenderInbox; }));
-        env_.require(RequireAny([&]() -> bool {
-            return *prevSenderIssuer >= *arg.amt &&
-                *postSenderIssuer == *prevSenderIssuer - *arg.amt;
-        }));
+        env_.require(RequireAny(
+            [&]() -> bool {
+                return *prevSenderSpending >= amt &&
+                    *postSenderSpending == *prevSenderSpending - amt;
+            },
+            loc));
+        env_.require(RequireAny([&]() -> bool { return postSenderInbox == prevSenderInbox; }, loc));
+        env_.require(RequireAny(
+            [&]() -> bool {
+                return *prevSenderIssuer >= amt && *postSenderIssuer == *prevSenderIssuer - amt;
+            },
+            loc));
 
         // Verify destination changes
         env_.require(
-            RequireAny([&]() -> bool { return *postDestInbox == *prevDestInbox + *arg.amt; }));
-        env_.require(RequireAny([&]() -> bool { return *postDestSpending == *prevDestSpending; }));
+            RequireAny([&]() -> bool { return *postDestInbox == *prevDestInbox + amt; }, loc));
         env_.require(
-            RequireAny([&]() -> bool { return *postDestIssuer == *prevDestIssuer + *arg.amt; }));
+            RequireAny([&]() -> bool { return *postDestSpending == *prevDestSpending; }, loc));
+        env_.require(
+            RequireAny([&]() -> bool { return *postDestIssuer == *prevDestIssuer + amt; }, loc));
 
         // Cross checks
         env_.require(RequireAny(
-            [&]() -> bool { return *postSenderInbox + *postSenderSpending == *postSenderIssuer; }));
+            [&]() -> bool { return *postSenderInbox + *postSenderSpending == *postSenderIssuer; },
+            loc));
         env_.require(RequireAny(
-            [&]() -> bool { return *postDestInbox + *postDestSpending == *postDestIssuer; }));
+            [&]() -> bool { return *postDestInbox + *postDestSpending == *postDestIssuer; }, loc));
 
         // Version: sender increments by 1; receiver version is unchanged by incoming sends
         env_.require(RequireAny(
-            [&]() -> bool { return getMPTokenVersion(*arg.account) == prevSenderVersion + 1; }));
+            [&]() -> bool { return getMPTokenVersion(account) == prevSenderVersion + 1; }, loc));
         env_.require(
-            RequireAny([&]() -> bool { return getMPTokenVersion(*arg.dest) == prevDestVersion; }));
+            RequireAny([&]() -> bool { return getMPTokenVersion(dest) == prevDestVersion; }, loc));
 
         if (arg.auditorEncryptedAmt || auditor_)
         {
-            auto const postSenderAuditor =
-                getDecryptedBalance(*arg.account, auditorEncryptedBalance);
-            auto const postDestAuditor = getDecryptedBalance(*arg.dest, auditorEncryptedBalance);
+            auto const postSenderAuditor = getDecryptedBalance(account, auditorEncryptedBalance);
+            auto const postDestAuditor = getDecryptedBalance(dest, auditorEncryptedBalance);
             if (!postSenderAuditor || !postDestAuditor)
                 Throw<std::runtime_error>("Failed to get Post-send balance");
 
-            env_.require(RequireAny([&]() -> bool {
-                return *postSenderAuditor == *postSenderIssuer &&
-                    *postDestAuditor == *postDestIssuer;
-            }));
+            env_.require(RequireAny(
+                [&]() -> bool {
+                    return *postSenderAuditor == *postSenderIssuer &&
+                        *postDestAuditor == *postDestIssuer;
+                },
+                loc));
 
             // verify sender
-            env_.require(RequireAny([&]() -> bool {
-                return prevSenderAuditor >= *arg.amt &&
-                    *postSenderAuditor == *prevSenderAuditor - *arg.amt;
-            }));
+            env_.require(RequireAny(
+                [&]() -> bool {
+                    return *prevSenderAuditor >= amt &&
+                        *postSenderAuditor == *prevSenderAuditor - amt;
+                },
+                loc));
 
             // verify dest
             env_.require(RequireAny(
-                [&]() -> bool { return *postDestAuditor == *prevDestAuditor + *arg.amt; }));
+                [&]() -> bool { return *postDestAuditor == *prevDestAuditor + amt; }, loc));
         }
     }
 }
@@ -1648,49 +1579,21 @@ MPTTester::sendJV(
     json::Value jv;
     jv[jss::TransactionType] = jss::ConfidentialMPTSend;
 
-    if (arg.account)
-    {
-        jv[sfAccount] = arg.account->human();
-    }
-    else
-    {
-        Throw<std::runtime_error>("Account not specified");
-    }
+    Account const& account = setAccountField(jv, arg.account);
+    Account const& dest = setDestinationField(jv, arg.dest);
+    auto const amt = requireValue(arg.amt, "amt");
 
-    if (arg.dest)
-    {
-        jv[sfDestination] = arg.dest->human();
-    }
-    else
-    {
-        Throw<std::runtime_error>("Destination not specified");
-    }
-
-    if (!arg.amt)
-        Throw<std::runtime_error>("Amount not specified for testing purposes");
-
-    if (arg.id)
-    {
-        jv[sfMPTokenIssuanceID] = to_string(*arg.id);
-    }
-    else
-    {
-        if (!id_)
-            Throw<std::runtime_error>("MPT has not been created");
-        jv[sfMPTokenIssuanceID] = to_string(*id_);
-    }
+    setIssuanceIdField(jv, arg.id);
 
     Buffer const blindingFactor =
         arg.blindingFactor ? *arg.blindingFactor : generateBlindingFactor();
 
-    auto const senderAmt = arg.senderEncryptedAmt
-        ? *arg.senderEncryptedAmt
-        : encryptAmount(*arg.account, *arg.amt, blindingFactor);
-    auto const destAmt = arg.destEncryptedAmt ? *arg.destEncryptedAmt
-                                              : encryptAmount(*arg.dest, *arg.amt, blindingFactor);
-    auto const issuerAmt = arg.issuerEncryptedAmt
-        ? *arg.issuerEncryptedAmt
-        : encryptAmount(issuer_, *arg.amt, blindingFactor);
+    auto const senderAmt = arg.senderEncryptedAmt ? *arg.senderEncryptedAmt
+                                                  : encryptAmount(account, amt, blindingFactor);
+    auto const destAmt =
+        arg.destEncryptedAmt ? *arg.destEncryptedAmt : encryptAmount(dest, amt, blindingFactor);
+    auto const issuerAmt = arg.issuerEncryptedAmt ? *arg.issuerEncryptedAmt
+                                                  : encryptAmount(issuer_, amt, blindingFactor);
 
     std::optional<Buffer> auditorAmt;
     if (arg.auditorEncryptedAmt)
@@ -1699,8 +1602,7 @@ MPTTester::sendJV(
     }
     else if (auditor_.has_value() && arg.fillAuditorEncryptedAmt.value_or(false))
     {
-        auditorAmt = encryptAmount(
-            requireValue(auditor_, "auditor"), requireValue(arg.amt, "amt"), blindingFactor);
+        auditorAmt = encryptAmount(requireValue(auditor_, "auditor"), amt, blindingFactor);
     }
 
     jv[sfSenderEncryptedAmount] = strHex(senderAmt);
@@ -1727,12 +1629,12 @@ MPTTester::sendJV(
     }
     else
     {
-        auto const ledgerSpending = getDecryptedBalance(*arg.account, holderEncryptedSpending);
+        auto const ledgerSpending = getDecryptedBalance(account, holderEncryptedSpending);
         if (!ledgerSpending)
             Throw<std::runtime_error>("Failed to get sender spending balance");
         prevSenderSpending = *ledgerSpending;
-        prevEncryptedSenderSpending = getEncryptedBalance(*arg.account, holderEncryptedSpending);
-        version = getMPTokenVersion(*arg.account);
+        prevEncryptedSenderSpending = getEncryptedBalance(account, holderEncryptedSpending);
+        version = getMPTokenVersion(account);
     }
 
     // The amount commitment must use the same blinding factor as the tx ElGamal
@@ -1744,7 +1646,7 @@ MPTTester::sendJV(
     }
     else
     {
-        amountCommitment = getPedersenCommitment(*arg.amt, blindingFactor);
+        amountCommitment = getPedersenCommitment(amt, blindingFactor);
     }
 
     jv[sfAmountCommitment] = strHex(amountCommitment);
@@ -1767,17 +1669,13 @@ MPTTester::sendJV(
     }
     else
     {
-        auto const ctxHash = getSendContextHash(
-            requireValue(arg.account, "account").id(),
-            issuanceID(),
-            seq,
-            requireValue(arg.dest, "dest").id(),
-            version);
+        auto const ctxHash =
+            getSendContextHash(account.id(), issuanceID(), seq, dest.id(), version);
 
         std::vector<ConfidentialRecipient> recipients;
 
-        auto const senderPubKey = getPubKey(*arg.account);
-        auto const destPubKey = getPubKey(*arg.dest);
+        auto const senderPubKey = getPubKey(account);
+        auto const destPubKey = getPubKey(dest);
         auto const issuerPubKey = getPubKey(issuer_);
 
         if (senderPubKey)
@@ -1820,17 +1718,17 @@ MPTTester::sendJV(
         std::optional<Buffer> proof;
 
         // Skip proof generation when spending balance is 0
-        if (arg.account != arg.dest && prevEncryptedSenderSpending && prevSenderSpending > 0)
+        if (prevEncryptedSenderSpending && prevSenderSpending > 0)
         {
             proof = getConfidentialSendProof(
-                *arg.account,
-                *arg.amt,
+                account,
+                amt,
                 recipients,
                 blindingFactor,
                 ctxHash,
                 {
                     .pedersenCommitment = amountCommitment,
-                    .amt = *arg.amt,
+                    .amt = amt,
                     .encryptedAmt = senderAmt,
                     .blindingFactor = blindingFactor,
                 },
@@ -1842,14 +1740,7 @@ MPTTester::sendJV(
                 });
         }
 
-        if (proof)
-        {
-            jv[sfZKProof.jsonName] = strHex(*proof);
-        }
-        else
-        {
-            jv[sfZKProof.jsonName] = strHex(gMakeZeroBuffer(kEcSendProofLength));
-        }
+        setProofOrDummy(jv, proof, kEcSendProofLength);
     }
 
     return jv;
@@ -1906,37 +1797,20 @@ computeNextSendChainState(
 }
 
 void
-MPTTester::confidentialClaw(MPTConfidentialClawback const& arg)
+MPTTester::confidentialClaw(MPTConfidentialClawback const& arg, std::source_location const& loc)
 {
     json::Value jv;
     auto const account = arg.account ? *arg.account : issuer_;
     jv[sfAccount] = account.human();
 
-    if (arg.holder)
-    {
-        jv[sfHolder] = arg.holder->human();
-    }
-    else
-    {
-        Throw<std::runtime_error>("Holder not specified");
-    }
+    Account const& holder = requireValue(arg.holder, "holder");
+    jv[sfHolder] = holder.human();
 
     jv[jss::TransactionType] = jss::ConfidentialMPTClawback;
-    if (arg.id)
-    {
-        jv[sfMPTokenIssuanceID] = to_string(*arg.id);
-    }
-    else if (id_)
-    {
-        jv[sfMPTokenIssuanceID] = to_string(*id_);
-    }
-    else
-    {
-        Throw<std::runtime_error>("MPT has not been created");
-    }
+    setIssuanceIdField(jv, arg.id);
 
-    if (arg.amt)
-        jv[sfMPTAmount] = std::to_string(*arg.amt);
+    auto const amt = requireValue(arg.amt, "amt");
+    jv[sfMPTAmount] = std::to_string(amt);
 
     if (arg.proof)
     {
@@ -1945,69 +1819,61 @@ MPTTester::confidentialClaw(MPTConfidentialClawback const& arg)
     else
     {
         auto const seq = arg.ticketSeq ? *arg.ticketSeq : env_.seq(account);
-        auto const contextHash = getClawbackContextHash(
-            account.id(), issuanceID(), seq, requireValue(arg.holder, "holder").id());
+        auto const contextHash =
+            getClawbackContextHash(account.id(), issuanceID(), seq, holder.id());
 
         auto const privKey = getPrivKey(account);
         if (!privKey || privKey->size() != kEcPrivKeyLength)
             Throw<std::runtime_error>("Failed to get clawback private key");
 
-        auto const proof = getClawbackProof(
-            requireValue(arg.holder, "holder"),
-            requireValue(arg.amt, "amt"),
-            requireValue(privKey, "privKey"),
-            contextHash);
+        auto const proof =
+            getClawbackProof(holder, amt, requireValue(privKey, "privKey"), contextHash);
 
-        if (proof)
-        {
-            jv[sfZKProof] = strHex(*proof);
-        }
-        else
-        {
-            jv[sfZKProof] = strHex(gMakeZeroBuffer(kEcClawbackProofLength));
-        }
+        setProofOrDummy(jv, proof, kEcClawbackProofLength);
     }
 
-    auto const holderPubAmt = getBalance(*arg.holder);
+    auto const holderPubAmt = getBalance(holder);
     auto const prevCOA = getIssuanceConfidentialBalance();
     auto const prevOA = getIssuanceOutstandingBalance();
-    auto const prevVersion = getMPTokenVersion(*arg.holder);
+    auto const prevVersion = getMPTokenVersion(holder);
 
-    if (submit(arg, jv) == tesSUCCESS)
+    if (submit(arg, {jv, loc}) == tesSUCCESS)
     {
         auto const postCOA = getIssuanceConfidentialBalance();
         auto const postOA = getIssuanceOutstandingBalance();
-        auto const postVersion = getMPTokenVersion(*arg.holder);
+        auto const postVersion = getMPTokenVersion(holder);
 
         // Verify holder's public balance is unchanged
-        env_.require(MptBalance(*this, *arg.holder, holderPubAmt));
+        env_.require(MptBalance(*this, holder, holderPubAmt, loc));
 
         // Verify COA and OA are reduced correctly
+        env_.require(
+            RequireAny([&]() -> bool { return prevCOA >= amt && postCOA == prevCOA - amt; }, loc));
         env_.require(RequireAny(
-            [&]() -> bool { return prevCOA >= *arg.amt && postCOA == prevCOA - *arg.amt; }));
-        env_.require(RequireAny([&]() -> bool {
-            return prevOA && postOA && *prevOA >= *arg.amt && *postOA == *prevOA - *arg.amt;
-        }));
+            [&]() -> bool {
+                return prevOA && postOA && *prevOA >= amt && *postOA == *prevOA - amt;
+            },
+            loc));
 
         // Verify holder's confidential balances are zeroed out
         env_.require(RequireAny(
-            [&]() -> bool { return getDecryptedBalance(*arg.holder, holderEncryptedInbox) == 0; }));
-        env_.require(RequireAny([&]() -> bool {
-            return getDecryptedBalance(*arg.holder, holderEncryptedSpending) == 0;
-        }));
-        env_.require(RequireAny([&]() -> bool {
-            return getDecryptedBalance(*arg.holder, issuerEncryptedBalance) == 0;
-        }));
-        env_.require(RequireAny([&]() -> bool {
-            return getDecryptedBalance(*arg.holder, auditorEncryptedBalance) == 0;
-        }));
+            [&]() -> bool { return getDecryptedBalance(holder, holderEncryptedInbox) == 0; }, loc));
+        env_.require(RequireAny(
+            [&]() -> bool { return getDecryptedBalance(holder, holderEncryptedSpending) == 0; },
+            loc));
+        env_.require(RequireAny(
+            [&]() -> bool { return getDecryptedBalance(holder, issuerEncryptedBalance) == 0; },
+            loc));
+        env_.require(RequireAny(
+            [&]() -> bool { return getDecryptedBalance(holder, auditorEncryptedBalance) == 0; },
+            loc));
 
         // Verify version is incremented
-        env_.require(RequireAny([&]() -> bool { return postVersion == prevVersion + 1; }));
+        env_.require(RequireAny([&]() -> bool { return postVersion == prevVersion + 1; }, loc));
     }
 }
 
-void
+std::uint32_t
 MPTTester::generateKeyPair(Account const& account)
 {
     unsigned char privKey[kEcPrivKeyLength];
@@ -2025,26 +1891,23 @@ MPTTester::generateKeyPair(Account const& account)
         Throw<std::runtime_error>("failed to serialize public key");
     }
 
-    pubKeys_.insert({account.id(), Buffer{compressedPubKey, kEcPubKeyLength}});
-    privKeys_.insert({account.id(), Buffer{privKey, kEcPrivKeyLength}});
+    auto& pubKeyEpochs = pubKeys_[account.id()];
+    pubKeyEpochs.emplace_back(compressedPubKey, kEcPubKeyLength);
+    privKeys_[account.id()].emplace_back(privKey, kEcPrivKeyLength);
+
+    return static_cast<std::uint32_t>(pubKeyEpochs.size() - 1);
 }
 
 std::optional<Buffer>
-MPTTester::getPubKey(Account const& account) const
+MPTTester::getPubKey(Account const& account, std::optional<std::uint32_t> epoch) const
 {
-    if (auto const it = pubKeys_.find(account.id()); it != pubKeys_.end())
-        return it->second;
-
-    return std::nullopt;
+    return keyAtEpoch(pubKeys_, account.id(), epoch);
 }
 
 std::optional<Buffer>
-MPTTester::getPrivKey(Account const& account) const
+MPTTester::getPrivKey(Account const& account, std::optional<std::uint32_t> epoch) const
 {
-    if (auto const it = privKeys_.find(account.id()); it != privKeys_.end())
-        return it->second;
-
-    return std::nullopt;
+    return keyAtEpoch(privKeys_, account.id(), epoch);
 }
 
 Buffer
@@ -2063,7 +1926,10 @@ MPTTester::encryptAmount(Account const& account, uint64_t const amt, Buffer cons
 }
 
 std::optional<uint64_t>
-MPTTester::decryptAmount(Account const& account, Buffer const& amt) const
+MPTTester::decryptAmount(
+    Account const& account,
+    Buffer const& amt,
+    std::optional<std::uint32_t> epoch) const
 {
     if (amt.size() != kEcGamalEncryptedTotalLength)
         return std::nullopt;
@@ -2072,7 +1938,7 @@ MPTTester::decryptAmount(Account const& account, Buffer const& amt) const
     if (!pair)
         return std::nullopt;
 
-    auto const privKey = getPrivKey(account);
+    auto const privKey = getPrivKey(account, epoch);
     if (!privKey || privKey->size() != kEcPrivKeyLength)
         return std::nullopt;
 
@@ -2104,135 +1970,112 @@ MPTTester::getDecryptedBalance(Account const& account, EncryptedBalanceType bala
 
     Account decryptor = account;
 
+    // A mirror stays encrypted under the key it was written with, so a rotation
+    // leaves it readable only by that generation of the key, not the latest one.
+    std::optional<std::uint32_t> epoch;
+
     if (balanceType == issuerEncryptedBalance)
     {
         decryptor = issuer_;
+        epoch = getMirrorEpoch(account, sfIssuerKeyMirrorEpoch).value_or(0);
     }
     else if (balanceType == auditorEncryptedBalance)
     {
         if (!auditor_)
             return std::nullopt;
         decryptor = *auditor_;
+        epoch = getMirrorEpoch(account, sfAuditorKeyMirrorEpoch).value_or(0);
     }
 
-    return decryptAmount(decryptor, *encryptedAmt);
-};
+    return decryptAmount(decryptor, *encryptedAmt, epoch);
+}
 
 json::Value
 MPTTester::mergeInboxJV(MPTMergeInbox const& arg) const
 {
     json::Value jv;
-    if (arg.account)
-    {
-        jv[sfAccount] = arg.account->human();
-    }
-    else
-    {
-        Throw<std::runtime_error>("Account not specified");
-    }
-    if (arg.id)
-    {
-        jv[sfMPTokenIssuanceID] = to_string(*arg.id);
-    }
-    else
-    {
-        if (!id_)
-            Throw<std::runtime_error>("MPT has not been created");
-        jv[sfMPTokenIssuanceID] = to_string(*id_);
-    }
+    setAccountField(jv, arg.account);
+    setIssuanceIdField(jv, arg.id);
     jv[sfTransactionType] = jss::ConfidentialMPTMergeInbox;
     return jv;
 }
 
 void
-MPTTester::mergeInbox(MPTMergeInbox const& arg)
+MPTTester::mergeInbox(MPTMergeInbox const& arg, std::source_location const& loc)
 {
-    json::Value jv;
-    if (arg.account)
-    {
-        jv[sfAccount] = arg.account->human();
-    }
-    else
-    {
-        Throw<std::runtime_error>("Account not specified");
-    }
-    if (arg.id)
-    {
-        jv[sfMPTokenIssuanceID] = to_string(*arg.id);
-    }
-    else
-    {
-        if (!id_)
-            Throw<std::runtime_error>("MPT has not been created");
-        jv[sfMPTokenIssuanceID] = to_string(*id_);
-    }
+    json::Value const jv = mergeInboxJV(arg);
+    Account const& account = requireValue(arg.account, "account");
 
-    jv[sfTransactionType] = jss::ConfidentialMPTMergeInbox;
-    auto const holderPubAmt = getBalance(*arg.account);
+    auto const holderPubAmt = getBalance(account);
     auto const prevCOA = getIssuanceConfidentialBalance();
     auto const prevOA = getIssuanceOutstandingBalance();
-    auto const prevInboxBalance = getDecryptedBalance(*arg.account, holderEncryptedInbox);
-    auto const prevSpendingBalance = getDecryptedBalance(*arg.account, holderEncryptedSpending);
-    auto const prevIssuerBalance = getDecryptedBalance(*arg.account, issuerEncryptedBalance);
-    auto const prevIssuerEncrypted = getEncryptedBalance(*arg.account, issuerEncryptedBalance);
-    auto const prevAuditorEncrypted = getEncryptedBalance(*arg.account, auditorEncryptedBalance);
-    auto const prevVersion = getMPTokenVersion(*arg.account);
+    auto const prevInboxBalance = getDecryptedBalance(account, holderEncryptedInbox);
+    auto const prevSpendingBalance = getDecryptedBalance(account, holderEncryptedSpending);
+    auto const prevIssuerBalance = getDecryptedBalance(account, issuerEncryptedBalance);
+    auto const prevIssuerEncrypted = getEncryptedBalance(account, issuerEncryptedBalance);
+    auto const prevAuditorEncrypted = getEncryptedBalance(account, auditorEncryptedBalance);
+    auto const prevVersion = getMPTokenVersion(account);
 
     if (!prevInboxBalance || !prevSpendingBalance || !prevIssuerBalance)
         Throw<std::runtime_error>("Failed to get pre-mergeInbox balances");
 
-    if (submit(arg, jv) == tesSUCCESS)
+    if (submit(arg, {jv, loc}) == tesSUCCESS)
     {
         auto const postCOA = getIssuanceConfidentialBalance();
         auto const postOA = getIssuanceOutstandingBalance();
-        auto const postInboxBalance = getDecryptedBalance(*arg.account, holderEncryptedInbox);
-        auto const postSpendingBalance = getDecryptedBalance(*arg.account, holderEncryptedSpending);
-        auto const postIssuerBalance = getDecryptedBalance(*arg.account, issuerEncryptedBalance);
-        auto const postInboxEncrypted = getEncryptedBalance(*arg.account, holderEncryptedInbox);
-        auto const postIssuerEncrypted = getEncryptedBalance(*arg.account, issuerEncryptedBalance);
-        auto const postAuditorEncrypted =
-            getEncryptedBalance(*arg.account, auditorEncryptedBalance);
-        auto const postVersion = getMPTokenVersion(*arg.account);
+        auto const postInboxBalance = getDecryptedBalance(account, holderEncryptedInbox);
+        auto const postSpendingBalance = getDecryptedBalance(account, holderEncryptedSpending);
+        auto const postIssuerBalance = getDecryptedBalance(account, issuerEncryptedBalance);
+        auto const postInboxEncrypted = getEncryptedBalance(account, holderEncryptedInbox);
+        auto const postIssuerEncrypted = getEncryptedBalance(account, issuerEncryptedBalance);
+        auto const postAuditorEncrypted = getEncryptedBalance(account, auditorEncryptedBalance);
+        auto const postVersion = getMPTokenVersion(account);
 
         if (!postInboxBalance || !postSpendingBalance || !postIssuerBalance ||
             !prevIssuerEncrypted || !postInboxEncrypted || !postIssuerEncrypted)
             Throw<std::runtime_error>("Failed to get post-mergeInbox balances");
 
-        env_.require(MptBalance(*this, *arg.account, holderPubAmt));
-        env_.require(RequireAny([&]() -> bool { return prevOA && postOA && *prevOA == *postOA; }));
-        env_.require(RequireAny([&]() -> bool { return prevCOA == postCOA; }));
+        env_.require(MptBalance(*this, account, holderPubAmt, loc));
+        env_.require(
+            RequireAny([&]() -> bool { return prevOA && postOA && *prevOA == *postOA; }, loc));
+        env_.require(RequireAny([&]() -> bool { return prevCOA == postCOA; }, loc));
 
-        env_.require(RequireAny([&]() -> bool {
-            return *postSpendingBalance == *prevInboxBalance + *prevSpendingBalance &&
-                *postInboxBalance == 0;
-        }));
+        env_.require(RequireAny(
+            [&]() -> bool {
+                return *postSpendingBalance == *prevInboxBalance + *prevSpendingBalance &&
+                    *postInboxBalance == 0;
+            },
+            loc));
 
         env_.require(
-            RequireAny([&]() -> bool { return *prevIssuerBalance == *postIssuerBalance; }));
+            RequireAny([&]() -> bool { return *prevIssuerBalance == *postIssuerBalance; }, loc));
 
-        auto const holderPubKey = getPubKey(*arg.account);
+        auto const holderPubKey = getPubKey(account);
         if (!holderPubKey)
             Throw<std::runtime_error>("Failed to get holder public key");
 
         auto const expectedInbox = encryptCanonicalZeroAmount(
-            requireValue(holderPubKey, "holderPubKey"),
-            requireValue(arg.account, "account").id(),
-            issuanceID());
+            requireValue(holderPubKey, "holderPubKey"), account.id(), issuanceID());
         if (!expectedInbox)
             Throw<std::runtime_error>("Failed to get canonical zero encryption");
 
-        env_.require(RequireAny([&]() -> bool { return *postInboxEncrypted == *expectedInbox; }));
         env_.require(
-            RequireAny([&]() -> bool { return *postIssuerEncrypted == *prevIssuerEncrypted; }));
-        env_.require(RequireAny([&]() -> bool {
-            return postAuditorEncrypted.has_value() == prevAuditorEncrypted.has_value() &&
-                (!postAuditorEncrypted || *postAuditorEncrypted == *prevAuditorEncrypted);
-        }));
-        env_.require(RequireAny([&]() -> bool { return postVersion == prevVersion + 1; }));
+            RequireAny([&]() -> bool { return *postInboxEncrypted == *expectedInbox; }, loc));
+        env_.require(RequireAny(
+            [&]() -> bool { return *postIssuerEncrypted == *prevIssuerEncrypted; }, loc));
+        env_.require(RequireAny(
+            [&]() -> bool {
+                return postAuditorEncrypted.has_value() == prevAuditorEncrypted.has_value() &&
+                    (!postAuditorEncrypted || *postAuditorEncrypted == *prevAuditorEncrypted);
+            },
+            loc));
+        env_.require(RequireAny([&]() -> bool { return postVersion == prevVersion + 1; }, loc));
 
-        env_.require(RequireAny([&]() -> bool {
-            return *postSpendingBalance + *postInboxBalance == *postIssuerBalance;
-        }));
+        env_.require(RequireAny(
+            [&]() -> bool {
+                return *postSpendingBalance + *postInboxBalance == *postIssuerBalance;
+            },
+            loc));
     }
 }
 
@@ -2267,169 +2110,92 @@ MPTTester::getMPTokenVersion(Account const account) const
 }
 
 void
-MPTTester::convertBack(MPTConvertBack const& arg)
+MPTTester::convertBack(MPTConvertBack const& arg, std::source_location const& loc)
 {
-    json::Value jv;
-    if (arg.account)
-    {
-        jv[sfAccount] = arg.account->human();
-    }
-    else
-    {
-        Throw<std::runtime_error>("Account not specified");
-    }
+    json::Value const jv = convertBackJV(arg, ticketOrSeq(arg.ticketSeq, arg.account));
 
-    jv[jss::TransactionType] = jss::ConfidentialMPTConvertBack;
-    if (arg.id)
-    {
-        jv[sfMPTokenIssuanceID] = to_string(*arg.id);
-    }
-    else
-    {
-        if (!id_)
-            Throw<std::runtime_error>("MPT has not been created");
-        jv[sfMPTokenIssuanceID] = to_string(*id_);
-    }
+    Account const& account = requireValue(arg.account, "account");
+    auto const amt = requireValue(arg.amt, "amt");
 
-    if (arg.amt)
-        jv[sfMPTAmount.jsonName] = std::to_string(*arg.amt);
-
-    Buffer holderCiphertext;
-    Buffer issuerCiphertext;
-    std::optional<Buffer> auditorCiphertext;
-    Buffer blindingFactor;
-
-    fillConversionCiphertexts(
-        arg, jv, holderCiphertext, issuerCiphertext, auditorCiphertext, blindingFactor);
-
-    jv[sfBlindingFactor] = strHex(blindingFactor);
-
-    auto const prevInboxBalance = getDecryptedBalance(*arg.account, holderEncryptedInbox);
-    auto const prevSpendingBalance = getDecryptedBalance(*arg.account, holderEncryptedSpending);
-    auto const prevIssuerBalance = getDecryptedBalance(*arg.account, issuerEncryptedBalance);
+    auto const prevInboxBalance = getDecryptedBalance(account, holderEncryptedInbox);
+    auto const prevSpendingBalance = getDecryptedBalance(account, holderEncryptedSpending);
+    auto const prevIssuerBalance = getDecryptedBalance(account, issuerEncryptedBalance);
 
     if (!prevInboxBalance || !prevSpendingBalance || !prevIssuerBalance)
         Throw<std::runtime_error>("Failed to get Pre-convertBack balance");
 
-    Buffer pedersenCommitment;
-    Buffer const pcBlindingFactor = generateBlindingFactor();
-    if (arg.pedersenCommitment)
-    {
-        pedersenCommitment = *arg.pedersenCommitment;
-    }
-    else
-    {
-        pedersenCommitment = getPedersenCommitment(*prevSpendingBalance, pcBlindingFactor);
-    }
-
-    jv[sfBalanceCommitment] = strHex(pedersenCommitment);
-
-    if (arg.proof)
-    {
-        jv[sfZKProof.jsonName] = strHex(*arg.proof);
-    }
-    else
-    {
-        auto const version = getMPTokenVersion(*arg.account);
-
-        // if the caller generated ciphertexts themselves, they should also
-        // generate the proof themselves from the blinding factor
-        auto const seq = arg.ticketSeq.value_or(env_.seq(*arg.account));
-        auto const contextHash = getConvertBackContextHash(
-            requireValue(arg.account, "account").id(), issuanceID(), seq, version);
-        auto const prevEncryptedSpendingBalance =
-            getEncryptedBalance(*arg.account, holderEncryptedSpending);
-
-        Buffer proof;
-        // generate a dummy proof if no encrypted amount field, so that other
-        // preflight/preclaim are checked
-        if (!prevEncryptedSpendingBalance)
-        {
-            proof = gMakeZeroBuffer(kEcConvertBackProofLength);
-        }
-        else
-        {
-            proof = getConvertBackProof(
-                *arg.account,
-                requireValue(arg.amt, "amt"),
-                contextHash,
-                {
-                    .pedersenCommitment = pedersenCommitment,
-                    .amt = *prevSpendingBalance,
-                    .encryptedAmt = *prevEncryptedSpendingBalance,
-                    .blindingFactor = pcBlindingFactor,
-                });
-        }
-        jv[sfZKProof] = strHex(proof);
-    }
-
-    auto const holderAmt = getBalance(*arg.account);
+    auto const holderAmt = getBalance(account);
     auto const prevConfidentialOutstanding = getIssuanceConfidentialBalance();
 
     std::optional<uint64_t> prevAuditorBalance;
     if (arg.auditorEncryptedAmt || auditor_)
     {
-        prevAuditorBalance = getDecryptedBalance(*arg.account, auditorEncryptedBalance);
+        prevAuditorBalance = getDecryptedBalance(account, auditorEncryptedBalance);
         if (!prevAuditorBalance)
             Throw<std::runtime_error>("Failed to get Pre-convertBack balance");
     }
 
     auto const prevOutstanding = getIssuanceOutstandingBalance();
-    auto const prevVersion = getMPTokenVersion(*arg.account);
+    auto const prevVersion = getMPTokenVersion(account);
 
-    if (submit(arg, jv) == tesSUCCESS)
+    if (submit(arg, {jv, loc}) == tesSUCCESS)
     {
         auto const postConfidentialOutstanding = getIssuanceConfidentialBalance();
         auto const postOutstanding = getIssuanceOutstandingBalance();
-        auto const postVersion = getMPTokenVersion(*arg.account);
-        env_.require(MptBalance(
-            *this, requireValue(arg.account, "account"), holderAmt + requireValue(arg.amt, "amt")));
-        env_.require(RequireAny([&]() -> bool {
-            return prevOutstanding && postOutstanding && *prevOutstanding == *postOutstanding;
-        }));
-        env_.require(RequireAny([&]() -> bool {
-            return prevConfidentialOutstanding - *arg.amt == postConfidentialOutstanding;
-        }));
+        auto const postVersion = getMPTokenVersion(account);
+        env_.require(MptBalance(*this, account, holderAmt + amt, loc));
+        env_.require(RequireAny(
+            [&]() -> bool {
+                return prevOutstanding && postOutstanding && *prevOutstanding == *postOutstanding;
+            },
+            loc));
+        env_.require(RequireAny(
+            [&]() -> bool {
+                return prevConfidentialOutstanding - amt == postConfidentialOutstanding;
+            },
+            loc));
 
-        auto const postInboxBalance = getDecryptedBalance(*arg.account, holderEncryptedInbox);
-        auto const postIssuerBalance = getDecryptedBalance(*arg.account, issuerEncryptedBalance);
-        auto const postSpendingBalance = getDecryptedBalance(*arg.account, holderEncryptedSpending);
+        auto const postInboxBalance = getDecryptedBalance(account, holderEncryptedInbox);
+        auto const postIssuerBalance = getDecryptedBalance(account, issuerEncryptedBalance);
+        auto const postSpendingBalance = getDecryptedBalance(account, holderEncryptedSpending);
 
         if (!postInboxBalance || !postIssuerBalance || !postSpendingBalance)
             Throw<std::runtime_error>("Failed to get post-convertBack balance");
 
         if (arg.auditorEncryptedAmt || auditor_)
         {
-            auto const postAuditorBalance =
-                getDecryptedBalance(*arg.account, auditorEncryptedBalance);
+            auto const postAuditorBalance = getDecryptedBalance(account, auditorEncryptedBalance);
 
             if (!postAuditorBalance)
                 Throw<std::runtime_error>("Failed to get post-convertBack balance");
 
             // auditor's encrypted balance is updated correctly
             env_.require(RequireAny(
-                [&]() -> bool { return *prevAuditorBalance - *arg.amt == *postAuditorBalance; }));
+                [&]() -> bool { return *prevAuditorBalance - amt == *postAuditorBalance; }, loc));
         }
 
         // inbox balance should not change
-        env_.require(RequireAny([&]() -> bool { return *postInboxBalance == *prevInboxBalance; }));
+        env_.require(
+            RequireAny([&]() -> bool { return *postInboxBalance == *prevInboxBalance; }, loc));
 
         // issuer's encrypted balance is updated correctly
         env_.require(RequireAny(
-            [&]() -> bool { return *prevIssuerBalance - *arg.amt == *postIssuerBalance; }));
+            [&]() -> bool { return *prevIssuerBalance - amt == *postIssuerBalance; }, loc));
 
         // holder's spending balance is updated correctly
         env_.require(RequireAny(
-            [&]() -> bool { return *prevSpendingBalance - *arg.amt == *postSpendingBalance; }));
+            [&]() -> bool { return *prevSpendingBalance - amt == *postSpendingBalance; }, loc));
 
         // holder's confidential balance version is updated correctly
-        env_.require(RequireAny([&]() -> bool { return postVersion == prevVersion + 1; }));
+        env_.require(RequireAny([&]() -> bool { return postVersion == prevVersion + 1; }, loc));
 
         // sum of holder's inbox and spending balance should equal to issuer's
         // encrypted balance
-        env_.require(RequireAny([&]() -> bool {
-            return *postInboxBalance + *postSpendingBalance == *postIssuerBalance;
-        }));
+        env_.require(RequireAny(
+            [&]() -> bool {
+                return *postInboxBalance + *postSpendingBalance == *postIssuerBalance;
+            },
+            loc));
     }
 }
 
@@ -2437,41 +2203,17 @@ json::Value
 MPTTester::convertBackJV(MPTConvertBack const& arg, std::uint32_t seq)
 {
     json::Value jv;
-    if (arg.account)
-    {
-        jv[sfAccount] = arg.account->human();
-    }
-    else
-    {
-        Throw<std::runtime_error>("Account not specified");
-    }
+    Account const& account = setAccountField(jv, arg.account);
 
     jv[jss::TransactionType] = jss::ConfidentialMPTConvertBack;
-    if (arg.id)
-    {
-        jv[sfMPTokenIssuanceID] = to_string(*arg.id);
-    }
-    else
-    {
-        if (!id_)
-            Throw<std::runtime_error>("MPT has not been created");
-        jv[sfMPTokenIssuanceID] = to_string(*id_);
-    }
+    setIssuanceIdField(jv, arg.id);
 
-    if (arg.amt)
-        jv[sfMPTAmount.jsonName] = std::to_string(*arg.amt);
+    auto const amt = requireValue(arg.amt, "amt");
+    jv[sfMPTAmount.jsonName] = std::to_string(amt);
 
-    Buffer holderCiphertext;
-    Buffer issuerCiphertext;
-    std::optional<Buffer> auditorCiphertext;
-    Buffer blindingFactor;
+    fillConversionCiphertexts(arg, jv, account, amt);
 
-    fillConversionCiphertexts(
-        arg, jv, holderCiphertext, issuerCiphertext, auditorCiphertext, blindingFactor);
-
-    jv[sfBlindingFactor] = strHex(blindingFactor);
-
-    auto const prevSpendingBalance = getDecryptedBalance(*arg.account, holderEncryptedSpending);
+    auto const prevSpendingBalance = getDecryptedBalance(account, holderEncryptedSpending);
     if (!prevSpendingBalance)
         Throw<std::runtime_error>("convertBackJV: failed to read spending balance from ledger");
 
@@ -2494,21 +2236,17 @@ MPTTester::convertBackJV(MPTConvertBack const& arg, std::uint32_t seq)
     }
     else
     {
-        auto const version = getMPTokenVersion(*arg.account);
-        auto const prevEncSpending = getEncryptedBalance(*arg.account, holderEncryptedSpending);
-        auto const contextHash = getConvertBackContextHash(
-            requireValue(arg.account, "account").id(), issuanceID(), seq, version);
+        auto const version = getMPTokenVersion(account);
+        auto const prevEncSpending = getEncryptedBalance(account, holderEncryptedSpending);
+        auto const contextHash =
+            getConvertBackContextHash(account.id(), issuanceID(), seq, version);
 
-        Buffer proof;
-        if (!prevEncSpending)
-        {
-            proof = gMakeZeroBuffer(kEcConvertBackProofLength);
-        }
-        else
+        std::optional<Buffer> proof;
+        if (prevEncSpending)
         {
             proof = getConvertBackProof(
-                *arg.account,
-                requireValue(arg.amt, "amt"),
+                account,
+                amt,
                 contextHash,
                 {
                     .pedersenCommitment = pedersenCommitment,
@@ -2518,10 +2256,39 @@ MPTTester::convertBackJV(MPTConvertBack const& arg, std::uint32_t seq)
                 });
         }
 
-        jv[sfZKProof] = strHex(proof);
+        setProofOrDummy(jv, proof, kEcConvertBackProofLength);
     }
 
     return jv;
 }
 
+void
+MPTTester::mirrorUpdate(MPTMirrorUpdate const& arg, std::source_location const& loc)
+{
+    json::Value jv;
+    jv[jss::TransactionType] = jss::ConfidentialMPTMirrorUpdate;
+
+    setAccountField(jv, arg.account);
+    setIssuanceIdField(jv, arg.id);
+
+    if (arg.holder)
+        jv[sfHolder] = arg.holder->human();
+    if (arg.issuerEncryptedAmount)
+        jv[sfIssuerEncryptedAmount] = strHex(*arg.issuerEncryptedAmount);
+    if (arg.auditorEncryptedAmount)
+        jv[sfAuditorEncryptedAmount] = strHex(*arg.auditorEncryptedAmount);
+
+    // Placeholder for proof, the logic will be added in the future
+    if (arg.zkProof)
+    {
+        jv[sfZKProof] = strHex(*arg.zkProof);
+    }
+    else
+    {
+        jv[sfZKProof] = strHex(gMakeZeroBuffer(kEcEqualityProofLength));
+    }
+
+    submit(arg, {jv, loc});
+}
+
 }  // namespace xrpl::test::jtx
diff --git a/src/test/jtx/impl/multisign.cpp b/src/test/jtx/impl/multisign.cpp
index d948042bda..e04e1bb58a 100644
--- a/src/test/jtx/impl/multisign.cpp
+++ b/src/test/jtx/impl/multisign.cpp
@@ -60,10 +60,12 @@ signers(Account const& account, NoneT)
 //------------------------------------------------------------------------------
 
 void
-Msig::operator()(Env& env, JTx& jt) const
+Msig::operator()(Env&, JTx& jt) const
 {
     auto const mySigners = signers;
-    auto callback = [subField = subField, mySigners, &env](Env&, JTx& jtx) {
+    auto callback = [subField = subField, mySigners](Env& env, JTx& jtx) {
+        auto const prefix =
+            signingPrefix(jtx::signatureRole(subField), true, env.current()->rules());
         // Where to put the signature. Supports sfCounterPartySignature and
         // sfSponsorSignature.
         auto& sigObject = subField ? jtx[*subField] : jtx.jv;
@@ -95,7 +97,7 @@ Msig::operator()(Env& env, JTx& jt) const
             jo[jss::Account] = e.acct.human();
             jo[jss::SigningPubKey] = strHex(e.sig.pk().slice());
 
-            Serializer const ss{buildMultiSigningData(*st, e.acct.id())};
+            Serializer const ss{buildMultiSigningData(*st, e.acct.id(), prefix)};
             auto const sig = xrpl::sign(*publicKeyType(e.sig.pk().slice()), e.sig.sk(), ss.slice());
             jo[sfTxnSignature.getJsonName()] = strHex(Slice{sig.data(), sig.size()});
         }
diff --git a/src/test/jtx/impl/sig.cpp b/src/test/jtx/impl/sig.cpp
index e0123073b1..41833c8802 100644
--- a/src/test/jtx/impl/sig.cpp
+++ b/src/test/jtx/impl/sig.cpp
@@ -4,6 +4,8 @@
 #include <test/jtx/JTx.h>
 #include <test/jtx/utility.h>
 
+#include <xrpl/protocol/Sign.h>
+
 namespace xrpl::test::jtx {
 
 void
@@ -17,11 +19,15 @@ Sig::operator()(Env&, JTx& jt) const
     {
         // VFALCO Inefficient pre-C++14
         auto const account = *account_;
-        auto callback = [subField = subField_, account](Env&, JTx& jtx) {
+        auto callback = [subField = subField_, account](Env& env, JTx& jtx) {
             // Where to put the signature. Supports sfCounterPartySignature and sfSponsorSignature.
             auto& sigObject = subField ? jtx[*subField] : jtx.jv;
 
-            jtx::sign(jtx.jv, account, sigObject);
+            jtx::sign(
+                jtx.jv,
+                account,
+                sigObject,
+                signingPrefix(jtx::signatureRole(subField), false, env.current()->rules()));
         };
         if (subField_ == nullptr)
         {
diff --git a/src/test/jtx/impl/utility.cpp b/src/test/jtx/impl/utility.cpp
index c298cee684..6b2c9b69b9 100644
--- a/src/test/jtx/impl/utility.cpp
+++ b/src/test/jtx/impl/utility.cpp
@@ -19,9 +19,11 @@
 #include <xrpl/protocol/STParsedJSON.h>
 #include <xrpl/protocol/SecretKey.h>
 #include <xrpl/protocol/Serializer.h>
+#include <xrpl/protocol/Sign.h>
 #include <xrpl/protocol/XRPAmount.h>
 #include <xrpl/protocol/jss.h>
 
+#include <stdexcept>
 #include <utility>
 #include <vector>
 
@@ -36,12 +38,22 @@ parse(json::Value const& jv)
     return std::move(*p.object);
 }
 
+SignatureRole
+signatureRole(SField const* subField)
+{
+    if (subField == nullptr)
+        return SignatureRole::Transaction;
+    if (auto const role = xrpl::signatureRole(*subField))
+        return *role;
+    Throw<std::runtime_error>(subField->getName() + " does not hold a transaction signature.");
+}
+
 void
-sign(json::Value& jv, Account const& account, json::Value& sigObject)
+sign(json::Value& jv, Account const& account, json::Value& sigObject, HashPrefix prefix)
 {
     sigObject[jss::SigningPubKey] = strHex(account.pk().slice());
     Serializer ss;
-    ss.add32(HashPrefix::TxSign);
+    ss.add32(prefix);
     parse(jv).addWithoutSigningFields(ss);
     auto const sig = xrpl::sign(account.pk(), account.sk(), ss.slice());
     sigObject[jss::TxnSignature] = strHex(Slice{sig.data(), sig.size()});
@@ -66,7 +78,7 @@ fillFee(json::Value& jv, ReadView const& view)
     auto const txType = jv[jss::TransactionType].asString();
     if (txType == jss::ConfidentialMPTConvert || txType == jss::ConfidentialMPTConvertBack ||
         txType == jss::ConfidentialMPTSend || txType == jss::ConfidentialMPTMergeInbox ||
-        txType == jss::ConfidentialMPTClawback)
+        txType == jss::ConfidentialMPTClawback || txType == jss::ConfidentialMPTMirrorUpdate)
     {
         jv[jss::Fee] = to_string(base * (kConfidentialFeeMultiplier + 1));
     }
diff --git a/src/test/jtx/mpt.h b/src/test/jtx/mpt.h
index 35ab7264bd..96af3dac2b 100644
--- a/src/test/jtx/mpt.h
+++ b/src/test/jtx/mpt.h
@@ -20,6 +20,7 @@
 #include <xrpl/protocol/AccountID.h>
 #include <xrpl/protocol/Asset.h>
 #include <xrpl/protocol/ConfidentialTransfer.h>
+#include <xrpl/protocol/SField.h>
 #include <xrpl/protocol/TER.h>
 #include <xrpl/protocol/TxFlags.h>
 #include <xrpl/protocol/UintTypes.h>
@@ -31,6 +32,7 @@
 #include <cstring>
 #include <functional>
 #include <optional>
+#include <source_location>
 #include <stdexcept>
 #include <string>
 #include <unordered_map>
@@ -74,13 +76,19 @@ private:
     MPTTester& tester_;
     std::uint32_t flags_;
     std::optional<Account> holder_;
+    // Test call site (forwarded from the MPTTester method).
+    std::source_location testLoc_;
+    // The site where this check object was constructed (usually in mpt.cpp).
+    std::source_location checkLoc_;
 
 public:
     MptFlags(
         MPTTester& tester,
         std::uint32_t flags,
-        std::optional<Account> const& holder = std::nullopt)
-        : tester_(tester), flags_(flags), holder_(holder)
+        std::optional<Account> const& holder = std::nullopt,
+        std::source_location const& testLoc = std::source_location::current(),
+        std::source_location const& checkLoc = std::source_location::current())
+        : tester_(tester), flags_(flags), holder_(holder), testLoc_(testLoc), checkLoc_(checkLoc)
     {
     }
 
@@ -97,10 +105,23 @@ private:
     MPTTester const& tester_;
     Account const& account_;
     std::int64_t const amount_;
+    // Test call site (forwarded from the MPTTester method).
+    std::source_location testLoc_;
+    // The site where this check object was constructed (usually in mpt.cpp).
+    std::source_location checkLoc_;
 
 public:
-    MptBalance(MPTTester& tester, Account const& account, std::int64_t amount)
-        : tester_(tester), account_(account), amount_(amount)
+    MptBalance(
+        MPTTester& tester,
+        Account const& account,
+        std::int64_t amount,
+        std::source_location const& testLoc = std::source_location::current(),
+        std::source_location const& checkLoc = std::source_location::current())
+        : tester_(tester)
+        , account_(account)
+        , amount_(amount)
+        , testLoc_(testLoc)
+        , checkLoc_(checkLoc)
     {
     }
 
@@ -115,9 +136,17 @@ class RequireAny
 {
 private:
     std::function<bool()> cb_;
+    // Test call site (forwarded from the MPTTester method).
+    std::source_location testLoc_;
+    // The site where this check object was constructed (usually in mpt.cpp).
+    std::source_location checkLoc_;
 
 public:
-    RequireAny(std::function<bool()> const& cb) : cb_(cb)
+    RequireAny(
+        std::function<bool()> const& cb,
+        std::source_location const& testLoc = std::source_location::current(),
+        std::source_location const& checkLoc = std::source_location::current())
+        : cb_(cb), testLoc_(testLoc), checkLoc_(checkLoc)
     {
     }
 
@@ -361,6 +390,24 @@ struct MPTConfidentialClawback
     std::optional<TER> err = std::nullopt;
 };
 
+/**
+ * @brief Arguments for building a ConfidentialMPTMirrorUpdate test transaction.
+ */
+struct MPTMirrorUpdate
+{
+    std::optional<Account> account = std::nullopt;
+    std::optional<Account> holder = std::nullopt;
+    std::optional<MPTID> id = std::nullopt;
+    std::optional<Buffer> issuerEncryptedAmount = std::nullopt;
+    std::optional<Buffer> auditorEncryptedAmount = std::nullopt;
+    std::optional<Buffer> zkProof = std::nullopt;
+    std::optional<XRPAmount> fee = std::nullopt;
+    std::optional<std::uint32_t> flags = std::nullopt;
+    std::optional<std::uint32_t> ownerCount = std::nullopt;
+    std::optional<std::uint32_t> holderCount = std::nullopt;
+    std::optional<TER> err = std::nullopt;
+};
+
 /**
  * @brief Stores the parameters that are exclusively used to generate a
  * Pedersen linkage proof.
@@ -451,8 +498,10 @@ class MPTTester
     std::optional<Account> const auditor_;
     std::optional<MPTID> id_;
     bool close_;
-    std::unordered_map<AccountID, Buffer> pubKeys_;
-    std::unordered_map<AccountID, Buffer> privKeys_;
+    // Keys generated for each account. Buffer vector's index is the key epoch: index 0 is
+    // the initial pair and each rotation appends.
+    std::unordered_map<AccountID, std::vector<Buffer>> pubKeys_;
+    std::unordered_map<AccountID, std::vector<Buffer>> privKeys_;
 
 public:
     enum class EncryptedBalanceType {
@@ -467,8 +516,14 @@ public:
     static constexpr auto holderEncryptedSpending = EncryptedBalanceType::HolderEncryptedSpending;
     static constexpr auto auditorEncryptedBalance = EncryptedBalanceType::AuditorEncryptedBalance;
 
-    MPTTester(Env& env, Account issuer, MPTInit const& constr = {});
-    MPTTester(MPTInitDef const& constr);
+    MPTTester(
+        Env& env,
+        Account issuer,
+        MPTInit const& constr = {},
+        std::source_location const& loc = std::source_location::current());
+    MPTTester(
+        MPTInitDef const& constr,
+        std::source_location const& loc = std::source_location::current());
     MPTTester(
         Env& env,
         Account issuer,
@@ -478,34 +533,44 @@ public:
     operator MPT() const;
 
     void
-    create(MPTCreate const& arg = MPTCreate{});
+    create(
+        MPTCreate const& arg = MPTCreate{},
+        std::source_location const& loc = std::source_location::current());
 
     static json::Value
     createJV(MPTCreate const& arg = MPTCreate{});
 
     void
-    destroy(MPTDestroy const& arg = MPTDestroy{});
+    destroy(
+        MPTDestroy const& arg = MPTDestroy{},
+        std::source_location const& loc = std::source_location::current());
 
     static json::Value
     destroyJV(MPTDestroy const& arg = MPTDestroy{});
 
     void
-    authorize(MPTAuthorize const& arg = MPTAuthorize{});
+    authorize(
+        MPTAuthorize const& arg = MPTAuthorize{},
+        std::source_location const& loc = std::source_location::current());
 
     static json::Value
     authorizeJV(MPTAuthorize const& arg = MPTAuthorize{});
 
     void
-    authorizeHolders(Holders const& holders);
+    authorizeHolders(
+        Holders const& holders,
+        std::source_location const& loc = std::source_location::current());
 
     void
-    set(MPTSet const& set = {});
+    set(MPTSet const& set = {}, std::source_location const& loc = std::source_location::current());
 
     static json::Value
     setJV(MPTSet const& set = {});
 
     void
-    convert(MPTConvert const& arg = MPTConvert{});
+    convert(
+        MPTConvert const& arg = MPTConvert{},
+        std::source_location const& loc = std::source_location::current());
 
     /**
      * @brief Build a confidential convert JV without submitting it.
@@ -519,13 +584,17 @@ public:
     convertJV(MPTConvert const& arg, std::uint32_t seq);
 
     void
-    mergeInbox(MPTMergeInbox const& arg = MPTMergeInbox{});
+    mergeInbox(
+        MPTMergeInbox const& arg = MPTMergeInbox{},
+        std::source_location const& loc = std::source_location::current());
 
     [[nodiscard]] json::Value
     mergeInboxJV(MPTMergeInbox const& arg = MPTMergeInbox{}) const;
 
     void
-    send(MPTConfidentialSend const& arg = MPTConfidentialSend{});
+    send(
+        MPTConfidentialSend const& arg = MPTConfidentialSend{},
+        std::source_location const& loc = std::source_location::current());
 
     /**
      * @brief Build a confidential send JV.
@@ -563,7 +632,9 @@ public:
     chainAfterSend(Account const& sender, std::uint64_t sendAmt, json::Value const& jv) const;
 
     void
-    convertBack(MPTConvertBack const& arg = MPTConvertBack{});
+    convertBack(
+        MPTConvertBack const& arg = MPTConvertBack{},
+        std::source_location const& loc = std::source_location::current());
 
     /**
      * @brief Build a confidential convertBack JV without submitting it.
@@ -579,7 +650,14 @@ public:
     convertBackJV(MPTConvertBack const& arg, std::uint32_t seq);
 
     void
-    confidentialClaw(MPTConfidentialClawback const& arg = MPTConfidentialClawback{});
+    confidentialClaw(
+        MPTConfidentialClawback const& arg = MPTConfidentialClawback{},
+        std::source_location const& loc = std::source_location::current());
+
+    void
+    mirrorUpdate(
+        MPTMirrorUpdate const& arg = MPTMirrorUpdate{},
+        std::source_location const& loc = std::source_location::current());
 
     [[nodiscard]] bool
     checkDomainID(std::optional<uint256> expected) const;
@@ -612,6 +690,30 @@ public:
     [[nodiscard]] bool
     checkImmutableFlags(std::uint32_t expectedFlags) const;
 
+    // Checks both key epochs on the issuance. Pass std::nullopt for an epoch
+    // that is expected to be absent, which means the key is never rotated.
+    [[nodiscard]] bool
+    checkKeyEpochs(
+        std::optional<std::uint32_t> issuerKeyEpoch,
+        std::optional<std::uint32_t> auditorKeyEpoch) const;
+
+    // Checks both mirror epochs on a holder's MPToken. Pass std::nullopt for an
+    // epoch that is expected to be absent, which means the mirror was written
+    // under the issuance's epoch 0 key.
+    [[nodiscard]] bool
+    checkMirrorEpochs(
+        Account const& holder,
+        std::optional<std::uint32_t> issuerKeyMirrorEpoch,
+        std::optional<std::uint32_t> auditorKeyMirrorEpoch) const;
+
+    // Checks that the issuance carries the encryption keys of the given
+    // accounts. Pass std::nullopt for a key that is expected to be absent,
+    // which means the key is never registered.
+    [[nodiscard]] bool
+    checkEncryptionKeys(
+        std::optional<Account> const& issuerKeyOwner,
+        std::optional<Account> const& auditorKeyOwner) const;
+
     [[nodiscard]] Account const&
     issuer() const
     {
@@ -625,14 +727,16 @@ public:
         Account const& dest,
         std::int64_t amount,
         std::optional<TER> err = std::nullopt,
-        std::optional<std::vector<std::string>> credentials = std::nullopt);
+        std::optional<std::vector<std::string>> credentials = std::nullopt,
+        std::source_location const& loc = std::source_location::current());
 
     void
     claw(
         Account const& issuer,
         Account const& holder,
         std::int64_t amount,
-        std::optional<TER> err = std::nullopt);
+        std::optional<TER> err = std::nullopt,
+        std::source_location const& loc = std::source_location::current());
 
     [[nodiscard]] PrettyAmount
     mpt(std::int64_t amount) const;
@@ -663,20 +767,31 @@ public:
 
     operator Asset() const;
 
-    void
+    // Generates the account's next key pair and returns the key epoch it landed
+    // at, leaving the earlier ones retrievable.
+    std::uint32_t
     generateKeyPair(Account const& account);
 
+    // Returns the account's public key at the given key epoch, or its latest key when
+    // no epoch is given.
     [[nodiscard]] std::optional<Buffer>
-    getPubKey(Account const& account) const;
+    getPubKey(Account const& account, std::optional<std::uint32_t> epoch = std::nullopt) const;
 
+    // Returns the account's private key at the given key epoch, or its latest key when
+    // no epoch is given.
     [[nodiscard]] std::optional<Buffer>
-    getPrivKey(Account const& account) const;
+    getPrivKey(Account const& account, std::optional<std::uint32_t> epoch = std::nullopt) const;
 
     [[nodiscard]] Buffer
     encryptAmount(Account const& account, uint64_t const amt, Buffer const& blindingFactor) const;
 
+    // Decrypts with the account's key at the given key epoch, or its latest key
+    // when no epoch is given.
     [[nodiscard]] std::optional<uint64_t>
-    decryptAmount(Account const& account, Buffer const& amt) const;
+    decryptAmount(
+        Account const& account,
+        Buffer const& amt,
+        std::optional<std::uint32_t> epoch = std::nullopt) const;
 
     [[nodiscard]] std::optional<uint64_t>
     getDecryptedBalance(Account const& account, EncryptedBalanceType balanceType) const;
@@ -704,7 +819,7 @@ public:
         PedersenProofParams const& amountParams,
         PedersenProofParams const& balanceParams) const;
 
-    [[nodiscard]] Buffer
+    [[nodiscard]] std::optional<Buffer>
     getConvertBackProof(
         Account const& holder,
         std::uint64_t const amount,
@@ -730,9 +845,13 @@ private:
         std::function<bool(SLEP const& sle)> const& cb,
         std::optional<Account> const& holder = std::nullopt) const;
 
+    // Reads one of the holder's mirror key epochs off their MPToken.
+    [[nodiscard]] std::optional<std::uint32_t>
+    getMirrorEpoch(Account const& holder, SF_UINT32 const& field) const;
+
     template <typename A>
     TER
-    submit(A const& arg, json::Value jv)
+    submit(A const& arg, WithSourceLocation<json::Value> jv)
     {
         auto const expectedFlags = Txflags(arg.flags.value_or(0));
         auto const expectedTer = Ter(arg.err.value_or(tesSUCCESS));
@@ -740,7 +859,7 @@ private:
         if constexpr (requires { arg.fee; })
         {
             if (arg.fee)
-                jv[jss::Fee] = to_string(*arg.fee);
+                jv.value[jss::Fee] = to_string(*arg.fee);
         }
 
         std::optional<std::uint32_t> ticketSeq;
@@ -799,15 +918,28 @@ private:
     [[nodiscard]] std::uint32_t
     getFlags(std::optional<Account> const& holder) const;
 
+    /**
+     * @brief Sets sfMPTokenIssuanceID on jv, falling back to id_ if arg's id is
+     *        not set.
+     *
+     * @param jv The JSON object to set the field on.
+     * @param id The explicit issuance ID override from the caller, if any.
+     */
+    void
+    setIssuanceIdField(json::Value& jv, std::optional<MPTID> const& id) const;
+
+    [[nodiscard]] std::uint32_t
+    ticketOrSeq(
+        std::optional<std::uint32_t> const& ticketSeq,
+        std::optional<Account> const& account) const;
+
     template <typename T>
     void
     fillConversionCiphertexts(
         T const& arg,
         json::Value& jv,
-        Buffer& holderCiphertext,
-        Buffer& issuerCiphertext,
-        std::optional<Buffer>& auditorCiphertext,
-        Buffer& blindingFactor) const;
+        Account const& account,
+        std::uint64_t const amount) const;
 };
 
 }  // namespace xrpl::test::jtx
diff --git a/src/test/jtx/utility.h b/src/test/jtx/utility.h
index 289afec8b3..5a37abd920 100644
--- a/src/test/jtx/utility.h
+++ b/src/test/jtx/utility.h
@@ -5,7 +5,10 @@
 #include <xrpl/beast/utility/Journal.h>
 #include <xrpl/json/json_value.h>
 #include <xrpl/ledger/ReadView.h>
+#include <xrpl/protocol/HashPrefix.h>
+#include <xrpl/protocol/SField.h>
 #include <xrpl/protocol/STObject.h>
+#include <xrpl/protocol/Sign.h>
 
 #include <stdexcept>
 #include <string>
@@ -33,12 +36,29 @@ struct ParseError : std::logic_error
 STObject
 parse(json::Value const& jv);
 
+/**
+ * The role that signs into an optional signature subfield.
+ *
+ * @param subField The signature field, or nullptr for the transaction's own
+ * signature. Throws if the field does not hold a transaction signature.
+ */
+SignatureRole
+signatureRole(SField const* subField);
+
 /**
  * Sign automatically into a specific Json field of the jv object.
+ *
+ * @param prefix Prefix to insert before the serialized transaction when
+ * hashing. Use signingPrefix to get the prefix that matches the field that
+ * holds sigObject.
  * @note This only works on accounts with multi-signing off.
  */
 void
-sign(json::Value& jv, Account const& account, json::Value& sigObject);
+sign(
+    json::Value& jv,
+    Account const& account,
+    json::Value& sigObject,
+    HashPrefix prefix = HashPrefix::TxSign);
 
 /**
  * Sign automatically.
diff --git a/src/test/overlay/CapturePeer.h b/src/test/overlay/CapturePeer.h
new file mode 100644
index 0000000000..28a26d01e7
--- /dev/null
+++ b/src/test/overlay/CapturePeer.h
@@ -0,0 +1,252 @@
+#pragma once
+
+#include <test/jtx/Env.h>
+
+#include <xrpld/app/main/Application.h>
+#include <xrpld/overlay/Message.h>
+#include <xrpld/overlay/Peer.h>
+#include <xrpld/overlay/detail/OverlayImpl.h>
+#include <xrpld/overlay/detail/PeerImp.h>
+#include <xrpld/overlay/detail/ProtocolVersion.h>
+
+#include <xrpl/basics/contract.h>
+#include <xrpl/basics/make_SSLContext.h>
+#include <xrpl/beast/net/IPEndpoint.h>
+#include <xrpl/peerfinder/Slot.h>
+#include <xrpl/protocol/KeyType.h>
+#include <xrpl/protocol/PublicKey.h>
+#include <xrpl/protocol/SecretKey.h>
+#include <xrpl/resource/Charge.h>
+#include <xrpl/resource/Consumer.h>
+#include <xrpl/server/Handoff.h>
+
+#include <boost/asio/ip/address.hpp>
+#include <boost/asio/ip/address_v4.hpp>
+#include <boost/asio/ip/tcp.hpp>
+#include <boost/asio/ssl/context.hpp>
+#include <boost/beast/core/tcp_stream.hpp>
+#include <boost/beast/ssl/ssl_stream.hpp>
+
+#include <cstdint>
+#include <memory>
+#include <optional>
+#include <stdexcept>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace xrpl::test {
+
+/**
+ * A real `PeerImp` that captures the messages it would have sent.
+ *
+ * Only `send` and `run` are overridden, so `onMessage` runs production code.
+ * Derive from this to reach a `protected` `PeerImp` member.
+ */
+class CapturePeer : public PeerImp
+{
+public:
+    using MiddleType = boost::beast::tcp_stream;
+    using StreamType = boost::beast::ssl_stream<MiddleType>;
+    using SocketType = boost::asio::ip::tcp::socket;
+
+    /**
+     * Takes `PeerImp`'s two rvalue-reference parameters by value instead, so a
+     * derived double can inherit this constructor without a never-moved-from
+     * warning.
+     *
+     * @param app      The application owning the peer.
+     * @param id       The connection id, unique among the overlay's peers.
+     * @param slot     The peer finder slot; must be seated.
+     * @param request  The handshake request.
+     * @param publicKey  The peer's node public key.
+     * @param protocol   The negotiated protocol version.
+     * @param consumer   The resource manager endpoint for the peer.
+     * @param streamPtr  The connection's ssl stream.
+     * @param overlay    The overlay to register with.
+     */
+    CapturePeer(
+        Application& app,
+        Peer::id_t id,
+        std::shared_ptr<peer_finder::Slot> const& slot,
+        http_request_type request,
+        PublicKey const& publicKey,
+        ProtocolVersion protocol,
+        resource::Consumer consumer,
+        std::unique_ptr<StreamType> streamPtr,
+        OverlayImpl& overlay)
+        : PeerImp(
+              app,
+              id,
+              slot,
+              std::move(request),
+              publicKey,
+              protocol,
+              consumer,  // copy-only, so `std::move` would be a copy anyway
+              std::move(streamPtr),
+              overlay)
+    {
+    }
+
+    ~CapturePeer() override = default;
+
+    /**
+     * Does nothing, so the peer stays registered. The real `run()` reaches
+     * `PeerImp::doAccept`, which fails on an unconnected socket and detaches.
+     */
+    void
+    run() override
+    {
+    }
+
+    /**
+     * Captures the message instead of writing it, so replies are observable.
+     */
+    void
+    send(std::shared_ptr<Message> const& m) override
+    {
+        sent_.push_back(m);
+    }
+
+    /**
+     * @return Every message sent to this peer, in order.
+     */
+    std::vector<std::shared_ptr<Message>> const&
+    sent() const
+    {
+        return sent_;
+    }
+
+    /**
+     * @return The most recent message sent, or null if there was none.
+     */
+    std::shared_ptr<Message>
+    lastSent() const
+    {
+        return sent_.empty() ? nullptr : sent_.back();
+    }
+
+    /**
+     * Reads the accumulated charge without draining it through `charge()`.
+     *
+     * @return The charge accumulated on the peer so far.
+     */
+    resource::Charge
+    feeCharge() const
+    {
+        return currentFeeCharge();
+    }
+
+private:
+    std::vector<std::shared_ptr<Message>> sent_;
+};
+
+namespace detail {
+
+// `inline` so the functions below name one entity across translation units.
+inline constexpr std::uint16_t kCapturePeerPort = 51235;
+
+/**
+ * Non-template, so all `makeCapturePeer` instantiations share one counter. A
+ * per-instantiation counter would give two peer types the same id, and
+ * `addActive` would silently drop the second from `ids_`.
+ *
+ * @return The next unused connection id.
+ */
+inline Peer::id_t
+nextCapturePeerId()
+{
+    static Peer::id_t id{0};
+    return ++id;
+}
+
+/**
+ * Non-template for the same reason as `nextCapturePeerId`. Each peer needs its
+ * own address, not just its own port: the peer finder caps inbound connections
+ * per address at `ipLimit`, which is at most 2 unless configured.
+ *
+ * @return The next unused remote endpoint.
+ */
+inline beast::ip::Endpoint
+nextCapturePeerRemote()
+{
+    // From 172.2.0.1 upward, so ~900k fit before reaching 172.16/12, where the
+    // peer finder would treat them as private rather than as real inbound.
+    static std::uint32_t next{0xAC020001};
+    return beast::ip::Endpoint(boost::asio::ip::address_v4(next++), kCapturePeerPort);
+}
+
+/**
+ * Outlives every peer, whose stream keeps a reference to it. `PeerImp::charge`
+ * posts a handler holding the peer, so a peer can outlive its caller's scope.
+ *
+ * @return The ssl context every test peer's stream is built on.
+ */
+inline boost::asio::ssl::context&
+capturePeerSslContext()
+{
+    static std::shared_ptr<boost::asio::ssl::context> const kContext{makeSslContext("")};
+    return *kContext;
+}
+
+}  // namespace detail
+
+/**
+ * Build an active `CapturePeer` and register it with the overlay.
+ *
+ * @tparam PeerType  The peer class to build; must derive from `CapturePeer` and
+ *                   inherit its constructor.
+ * @param env      The environment owning the overlay.
+ * @param key      The peer's node public key, or unseated for a fresh random
+ *                 one.
+ * @param request  The handshake request. `PeerImp` reads its `X-Protocol-Ctl`
+ *                 header in the constructor to negotiate features.
+ * @return The peer, already registered with the overlay. Throws if the peer
+ *         finder refused a slot.
+ */
+template <class PeerType = CapturePeer>
+std::shared_ptr<PeerType>
+makeCapturePeer(
+    jtx::Env& env,
+    std::optional<PublicKey> key = std::nullopt,
+    http_request_type request = {})
+{
+    auto& overlay = dynamic_cast<OverlayImpl&>(env.app().getOverlay());
+    auto streamPtr = std::make_unique<CapturePeer::StreamType>(
+        CapturePeer::SocketType(env.app().getIOContext()), detail::capturePeerSslContext());
+
+    beast::ip::Endpoint const local(
+        boost::asio::ip::make_address("172.1.1.1"), detail::kCapturePeerPort);
+    auto const remote = detail::nextCapturePeerRemote();
+
+    auto consumer = overlay.resourceManager().newInboundEndpoint(remote);
+    auto [slot, _] = overlay.peerFinder().newInboundSlot(local, remote);
+
+    // Unseated when the endpoint is already connected or at the per-address
+    // limit. `PeerImp` dereferences the slot, so fail here, not there.
+    if (!slot)
+    {
+        Throw<std::runtime_error>("makeCapturePeer: no slot for " + to_string(remote));
+    }
+
+    if (!key)
+        key = PublicKey(std::get<0>(randomKeyPair(KeyType::Ed25519)));
+
+    auto peer = std::make_shared<PeerType>(
+        env.app(),
+        detail::nextCapturePeerId(),
+        slot,
+        std::move(request),
+        *key,
+        // An unsupported version fails every `supportsFeature` test, so a
+        // version-gated reply would only ever take its legacy branch.
+        newestSupportedProtocolVersion(),
+        consumer,
+        std::move(streamPtr),
+        overlay);
+
+    overlay.addActive(peer);
+    return peer;
+}
+
+}  // namespace xrpl::test
diff --git a/src/test/overlay/ProtocolMessage_test.cpp b/src/test/overlay/ProtocolMessage_test.cpp
new file mode 100644
index 0000000000..08e039f606
--- /dev/null
+++ b/src/test/overlay/ProtocolMessage_test.cpp
@@ -0,0 +1,296 @@
+#include <xrpld/overlay/Compression.h>
+#include <xrpld/overlay/Message.h>
+#include <xrpld/overlay/detail/ProtocolMessage.h>
+
+#include <xrpl/beast/unit_test/suite.h>
+
+#include <boost/asio/buffer.hpp>
+#include <boost/system/errc.hpp>
+
+#include <xrpl.pb.h>
+
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <limits>
+#include <memory>
+#include <optional>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace xrpl::test {
+
+class ProtocolMessage_test : public beast::unit_test::Suite
+{
+    struct TestHandler
+    {
+        bool compression = false;
+        int beginCount = 0;
+        int messageCount = 0;
+        int endCount = 0;
+        int unknownCount = 0;
+        std::uint16_t lastType = 0;
+
+        [[nodiscard]] bool
+        compressionEnabled() const
+        {
+            return compression;
+        }
+
+        void
+        onMessageUnknown(std::uint16_t type)
+        {
+            ++unknownCount;
+            lastType = type;
+        }
+
+        void
+        onMessageBegin(
+            std::uint16_t type,
+            std::shared_ptr<::google::protobuf::Message> const&,
+            std::size_t,
+            std::size_t,
+            bool)
+        {
+            ++beginCount;
+            lastType = type;
+        }
+
+        template <class T>
+        void
+        onMessage(std::shared_ptr<T> const&)
+        {
+            ++messageCount;
+        }
+
+        void
+        onMessageEnd(std::uint16_t, std::shared_ptr<::google::protobuf::Message> const&)
+        {
+            ++endCount;
+        }
+
+        [[nodiscard]] static std::size_t
+        maxManifestsMessageSize()
+        {
+            return std::numeric_limits<std::size_t>::max();
+        }
+    };
+
+    // Wire bytes: `type` (2 bytes) + unknown field tag (2 bytes) + length varint (2 bytes, as these
+    // tests all use unknownFieldSize >= 128).
+    static constexpr std::size_t kPingProtoOverheadWithUnknownLen = 6;
+    static constexpr std::size_t kMinimumPingSizeWithEmptyUnknownField =
+        compression::kHeaderBytes + kPingProtoOverheadWithUnknownLen;
+    static constexpr std::size_t kMinimumPingSizeCompressedWithEmptyUnknownField =
+        compression::kHeaderBytesCompressed + kPingProtoOverheadWithUnknownLen;
+
+    static std::vector<std::uint8_t>
+    makePingBuffer(std::size_t unknownFieldSize, bool compressed = false)
+    {
+        auto ping = protocol::TMPing{};
+        ping.set_type(protocol::TMPing::ptPING);
+        if (unknownFieldSize > 0)
+        {
+            ping.mutable_unknown_fields()->AddLengthDelimited(
+                42, std::string(unknownFieldSize, 'A'));
+        }
+
+        if (!compressed)
+        {
+            auto m = Message{ping, protocol::mtPING};
+            return m.getBuffer(compression::Compressed::Off);
+        }
+
+        // Message::compress() refuses to compress pings (mtPING is not in its
+        // allow-list), so getBuffer(Compressed::On) would just return the
+        // uncompressed bytes. Roll it by hand here to get a compressed
+        // ping message on the wire.
+        auto payload = std::string{};
+        ping.SerializeToString(&payload);
+
+        auto deflated = std::vector<std::uint8_t>{};
+        auto const deflatedSize = compression::compress(
+            payload.data(),
+            payload.size(),
+            [&](std::size_t sz) {
+                deflated.resize(sz);
+                return deflated.data();
+            },
+            compression::Algorithm::LZ4);
+        deflated.resize(deflatedSize);
+
+        auto const type = static_cast<std::uint16_t>(protocol::mtPING);
+        auto buffer = std::vector<std::uint8_t>{};
+        auto pack = [&buffer](std::uint32_t value) {
+            buffer.push_back(static_cast<std::uint8_t>((value >> 24) & 0x0F));
+            buffer.push_back(static_cast<std::uint8_t>((value >> 16) & 0xFF));
+            buffer.push_back(static_cast<std::uint8_t>((value >> 8) & 0xFF));
+            buffer.push_back(static_cast<std::uint8_t>(value & 0xFF));
+        };
+
+        pack(static_cast<std::uint32_t>(deflated.size()));  // compressed payload size
+        buffer.push_back(static_cast<std::uint8_t>((type >> 8) & 0xFF));
+        buffer.push_back(static_cast<std::uint8_t>(type & 0xFF));
+        pack(static_cast<std::uint32_t>(payload.size()));  // uncompressed size
+        buffer[0] |= static_cast<std::uint8_t>(compression::Algorithm::LZ4);
+
+        buffer.insert(buffer.end(), deflated.begin(), deflated.end());
+        return buffer;
+    }
+
+    static std::optional<std::size_t>
+    declaredPingSize(std::vector<std::uint8_t> const& buffer)
+    {
+        auto ec = boost::system::error_code{};
+        auto const seq = std::array<boost::asio::const_buffer, 1>{boost::asio::buffer(buffer)};
+        if (auto const header = xrpl::detail::parseMessageHeader(ec, seq, buffer.size()))
+        {
+            return header->uncompressedSize + header->headerSize;
+        }
+        return std::nullopt;
+    }
+
+    static std::pair<std::size_t, boost::system::error_code>
+    invoke(std::vector<std::uint8_t> const& buffer, TestHandler& handler)
+    {
+        auto const seq = std::array<boost::asio::const_buffer, 1>{boost::asio::buffer(buffer)};
+        auto hint = 0uz;
+        return invokeProtocolMessage(seq, handler, hint);
+    }
+
+    void
+    testOversizedPingRejected()
+    {
+        testcase("oversized ping rejected before dispatch");
+
+        auto runLocalTest = [&](std::size_t size, bool compressed = false) {
+            auto const buffer = makePingBuffer(size, compressed);
+            auto const declared = declaredPingSize(buffer);
+            if (BEAST_EXPECT(declared.has_value()))
+                BEAST_EXPECT(*declared > kMaximumPingMessageSize);
+            BEAST_EXPECT(buffer.size() < kMaximumMessageSize);
+
+            auto handler = TestHandler{};
+            handler.compression = compressed;
+            auto const [bytes, ec] = invoke(buffer, handler);
+
+            BEAST_EXPECT(ec == make_error_code(boost::system::errc::message_size));
+            BEAST_EXPECT(bytes == 0);
+            BEAST_EXPECT(handler.beginCount == 0);
+            BEAST_EXPECT(handler.messageCount == 0);
+            BEAST_EXPECT(handler.endCount == 0);
+        };
+        // Just over the cap, and comfortably over it.
+        runLocalTest(kMaximumPingMessageSize + 1 - kMinimumPingSizeWithEmptyUnknownField);
+        runLocalTest((2 * kMaximumPingMessageSize) - kMinimumPingSizeWithEmptyUnknownField);
+        runLocalTest(
+            kMaximumPingMessageSize + 1 - kMinimumPingSizeCompressedWithEmptyUnknownField, true);
+        runLocalTest(
+            (2 * kMaximumPingMessageSize) - kMinimumPingSizeCompressedWithEmptyUnknownField, true);
+    }
+
+    void
+    testOversizedPingRejectedFromHeaderAlone()
+    {
+        testcase("oversized ping rejected from header alone");
+
+        auto runLocalTest = [&](std::size_t size, bool compressed = false) {
+            auto const full = makePingBuffer(size, compressed);
+            auto const headerSize =
+                compressed ? compression::kHeaderBytesCompressed : compression::kHeaderBytes;
+
+            // Only the header has arrived; the declared payload is still in flight.
+            auto const headerOnly =
+                std::vector<std::uint8_t>{full.begin(), full.begin() + headerSize};
+            BEAST_EXPECT(headerOnly.size() < full.size());
+
+            auto handler = TestHandler{};
+            handler.compression = compressed;
+            auto const [bytes, ec] = invoke(headerOnly, handler);
+
+            BEAST_EXPECT(ec == make_error_code(boost::system::errc::message_size));
+            BEAST_EXPECT(bytes == 0);
+            BEAST_EXPECT(handler.beginCount == 0);
+            BEAST_EXPECT(handler.messageCount == 0);
+            BEAST_EXPECT(handler.endCount == 0);
+        };
+        runLocalTest(kMaximumPingMessageSize + 1 - kMinimumPingSizeWithEmptyUnknownField);
+        runLocalTest((2 * kMaximumPingMessageSize) - kMinimumPingSizeWithEmptyUnknownField);
+        runLocalTest(
+            kMaximumPingMessageSize + 1 - kMinimumPingSizeCompressedWithEmptyUnknownField, true);
+        runLocalTest(
+            (2 * kMaximumPingMessageSize) - kMinimumPingSizeCompressedWithEmptyUnknownField, true);
+    }
+
+    void
+    testNormalPingDispatched()
+    {
+        testcase("normal ping dispatched");
+
+        auto runLocalTest = [&](std::size_t size, bool compressed = false) {
+            auto const buffer = makePingBuffer(size, compressed);
+            auto const declared = declaredPingSize(buffer);
+            if (BEAST_EXPECT(declared.has_value()))
+                BEAST_EXPECT(*declared <= kMaximumPingMessageSize);
+
+            auto handler = TestHandler{};
+            handler.compression = compressed;
+            auto const [bytes, ec] = invoke(buffer, handler);
+
+            BEAST_EXPECT(!ec);
+            BEAST_EXPECT(bytes == buffer.size());
+            BEAST_EXPECT(handler.beginCount == 1);
+            BEAST_EXPECT(handler.messageCount == 1);
+            BEAST_EXPECT(handler.endCount == 1);
+        };
+        runLocalTest(0);
+        runLocalTest(0, true);
+    }
+
+    void
+    testPingWithSmallUnknownFieldDispatched()
+    {
+        testcase("ping with small unknown field still dispatched");
+
+        auto runLocalTest = [&](std::size_t size, bool compressed = false) {
+            auto const buffer = makePingBuffer(size, compressed);
+            auto const declared = declaredPingSize(buffer);
+            if (BEAST_EXPECT(declared.has_value()))
+                BEAST_EXPECT(*declared <= kMaximumPingMessageSize);
+
+            auto handler = TestHandler{};
+            handler.compression = compressed;
+            auto const [bytes, ec] = invoke(buffer, handler);
+
+            BEAST_EXPECT(!ec);
+            BEAST_EXPECT(bytes == buffer.size());
+            BEAST_EXPECT(handler.beginCount == 1);
+            BEAST_EXPECT(handler.messageCount == 1);
+            BEAST_EXPECT(handler.endCount == 1);
+        };
+        // Well under the cap, one byte under it, and exactly at it.
+        runLocalTest((kMaximumPingMessageSize / 2) - kMinimumPingSizeWithEmptyUnknownField);
+        runLocalTest(kMaximumPingMessageSize - 1 - kMinimumPingSizeWithEmptyUnknownField);
+        runLocalTest(kMaximumPingMessageSize - kMinimumPingSizeWithEmptyUnknownField);
+        runLocalTest(
+            (kMaximumPingMessageSize / 2) - kMinimumPingSizeCompressedWithEmptyUnknownField, true);
+        runLocalTest(
+            kMaximumPingMessageSize - 1 - kMinimumPingSizeCompressedWithEmptyUnknownField, true);
+        runLocalTest(
+            kMaximumPingMessageSize - kMinimumPingSizeCompressedWithEmptyUnknownField, true);
+    }
+
+    void
+    run() override
+    {
+        testOversizedPingRejected();
+        testOversizedPingRejectedFromHeaderAlone();
+        testNormalPingDispatched();
+        testPingWithSmallUnknownFieldDispatched();
+    }
+};
+
+BEAST_DEFINE_TESTSUITE(ProtocolMessage, overlay, xrpl);
+
+}  // namespace xrpl::test
diff --git a/src/test/overlay/TMGetLedger_test.cpp b/src/test/overlay/TMGetLedger_test.cpp
new file mode 100644
index 0000000000..eac1a24e24
--- /dev/null
+++ b/src/test/overlay/TMGetLedger_test.cpp
@@ -0,0 +1,135 @@
+#include <test/jtx/Env.h>
+#include <test/overlay/CapturePeer.h>
+
+#include <xrpld/overlay/Compression.h>
+#include <xrpld/overlay/detail/Tuning.h>
+
+#include <xrpl/basics/base_uint.h>
+#include <xrpl/beast/unit_test/suite.h>
+#include <xrpl/resource/Fees.h>
+#include <xrpl/shamap/SHAMapNodeID.h>
+
+#include <xrpl.pb.h>
+
+#include <cstddef>
+#include <memory>
+#include <utility>
+#include <vector>
+
+namespace xrpl::test {
+
+using namespace jtx;
+
+class TMGetLedger_test : public beast::unit_test::Suite
+{
+    /**
+     * Calls the JtLedgerReq-dispatched processor synchronously, so the reply is
+     * visible through `lastSent()`.
+     */
+    class GetLedgerPeer : public CapturePeer
+    {
+    public:
+        using CapturePeer::CapturePeer;
+
+        void
+        runProcessLedgerRequest(
+            std::shared_ptr<protocol::TMGetLedger> const& m,
+            std::vector<SHAMapNodeID> nodeIDs)
+        {
+            processLedgerRequest(m, std::move(nodeIDs));
+        }
+    };
+
+    // Build a well-formed TMGetLedger node request carrying `numNodeIds` node
+    // IDs.
+    static std::shared_ptr<protocol::TMGetLedger>
+    createRequest(std::size_t const numNodeIds)
+    {
+        auto request = std::make_shared<protocol::TMGetLedger>();
+        request->set_itype(protocol::liTX_NODE);
+
+        // A uint256-sized ledger hash, as a well-formed request carries.
+        uint256 const ledgerHash{1};
+        request->set_ledgerhash(ledgerHash.data(), ledgerHash.size());
+
+        // Valid, deserializable SHAMap node IDs.
+        auto const rootNodeId = SHAMapNodeID{}.getRawString();
+        for (std::size_t i = 0; i < numNodeIds; ++i)
+        {
+            request->add_nodeids(rootNodeId);
+        }
+
+        return request;
+    }
+
+    void
+    testNodeIdCountAccepted(std::size_t const numNodeIds, bool const expectRejected)
+    {
+        testcase("Node ID Count Accepted");
+
+        Env env{*this};
+
+        auto peer = makeCapturePeer(env);
+        peer->onMessage(createRequest(numNodeIds));
+
+        // A request outside the accepted node-ID count is charged kFeeInvalidData; one inside
+        // it is not. The JobQueue handler may run concurrently and update the fee in the
+        // accepted case.
+        BEAST_EXPECT(
+            expectRejected ? (peer->feeCharge() == resource::kFeeInvalidData)
+                           : !(peer->feeCharge() == resource::kFeeInvalidData));
+    }
+
+    void
+    testProcessLedgerRequestNodeCount(std::size_t const numNodeIds)
+    {
+        testcase("Process Ledger Request Node Count");
+
+        Env env{*this};
+        env.close();
+
+        auto peer = makeCapturePeer<GetLedgerPeer>(env);
+
+        // Ask for the account-state root node of the closed ledger.
+        auto request = createRequest(numNodeIds);
+        request->clear_ledgerhash();
+        request->set_itype(protocol::liAS_NODE);
+        request->set_ltype(protocol::ltCLOSED);
+
+        peer->runProcessLedgerRequest(request, std::vector<SHAMapNodeID>(numNodeIds));
+
+        auto sentMessage = peer->lastSent();
+        BEAST_EXPECT(sentMessage != nullptr);
+        if (!sentMessage)
+        {
+            return;
+        }
+
+        auto const& buffer = sentMessage->getBuffer(compression::Compressed::Off);
+        BEAST_EXPECT(buffer.size() > 6);
+
+        // Skip the message header (6 bytes: 4 for size, 2 for type).
+        protocol::TMLedgerData reply;
+        BEAST_EXPECT(reply.ParseFromArray(buffer.data() + 6, buffer.size() - 6) == true);
+
+        BEAST_EXPECT(reply.type() == protocol::liAS_NODE);
+        BEAST_EXPECT(reply.nodes_size() > 0);
+        BEAST_EXPECT(reply.nodes_size() <= static_cast<std::size_t>(tuning::kHardMaxReplyNodes));
+    }
+
+    void
+    run() override
+    {
+        auto const limit = static_cast<std::size_t>(tuning::kHardMaxReplyNodes);
+        testNodeIdCountAccepted(limit + 1, true);
+        testNodeIdCountAccepted(limit, false);
+        testNodeIdCountAccepted(limit - 1, false);
+        testProcessLedgerRequestNodeCount(limit + 1);
+        testProcessLedgerRequestNodeCount(limit);
+        testProcessLedgerRequestNodeCount(limit - 1);
+    }
+};
+
+BEAST_DEFINE_TESTSUITE(TMGetLedger, overlay, xrpl);
+
+}  // namespace xrpl::test
diff --git a/src/test/overlay/TMGetObjectByHash_test.cpp b/src/test/overlay/TMGetObjectByHash_test.cpp
index 6c9105164a..1aafd77f2f 100644
--- a/src/test/overlay/TMGetObjectByHash_test.cpp
+++ b/src/test/overlay/TMGetObjectByHash_test.cpp
@@ -1,33 +1,16 @@
 #include <test/jtx/Env.h>
+#include <test/overlay/CapturePeer.h>
 
 #include <xrpld/app/main/Application.h>
 #include <xrpld/overlay/Compression.h>
-#include <xrpld/overlay/Message.h>
-#include <xrpld/overlay/Peer.h>
 #include <xrpld/overlay/detail/OverlayImpl.h>
-#include <xrpld/overlay/detail/PeerImp.h>
-#include <xrpld/overlay/detail/ProtocolVersion.h>
 #include <xrpld/overlay/detail/Tuning.h>
 
 #include <xrpl/basics/Blob.h>
 #include <xrpl/basics/base_uint.h>
-#include <xrpl/basics/make_SSLContext.h>
-#include <xrpl/beast/net/IPEndpoint.h>
 #include <xrpl/beast/unit_test/suite.h>
 #include <xrpl/nodestore/NodeObject.h>
-#include <xrpl/peerfinder/Slot.h>
-#include <xrpl/protocol/KeyType.h>
-#include <xrpl/protocol/PublicKey.h>
-#include <xrpl/protocol/SecretKey.h>
 #include <xrpl/protocol/digest.h>
-#include <xrpl/resource/Consumer.h>
-#include <xrpl/server/Handoff.h>
-
-#include <boost/asio/ip/address.hpp>
-#include <boost/asio/ip/tcp.hpp>
-#include <boost/asio/ssl/context.hpp>
-#include <boost/beast/core/tcp_stream.hpp>
-#include <boost/beast/ssl/ssl_stream.hpp>
 
 #include <xrpl.pb.h>
 
@@ -41,119 +24,30 @@ namespace xrpl::test {
 using namespace jtx;
 
 /**
- * Test for TMGetObjectByHash reply size limiting.
+ * Coverage for the TMGetObjectByHash object-count bound.
  *
- * This verifies the fix that limits TMGetObjectByHash replies to
- * tuning::hardMaxReplyNodes to prevent excessive memory usage and
- * potential DoS attacks from peers requesting large numbers of objects.
+ * A generic query names some number of objects; the number of entries the
+ * reply carries is bounded by tuning::kHardMaxReplyNodes. These cases pin that
+ * bound at and either side of its boundary.
  */
 class TMGetObjectByHash_test : public beast::unit_test::Suite
 {
-    using middle_type = boost::beast::tcp_stream;
-    using stream_type = boost::beast::ssl_stream<middle_type>;
-    using socket_type = boost::asio::ip::tcp::socket;
-    using shared_context = std::shared_ptr<boost::asio::ssl::context>;
     /**
-     * Test peer that captures sent messages for verification.
+     * Calls the JtLedgerReq-dispatched processor synchronously, so the reply is
+     * visible through `sent()`.
      */
-    class PeerTest : public PeerImp
+    class GetObjectPeer : public CapturePeer
     {
     public:
-        PeerTest(
-            Application& app,
-            std::shared_ptr<peer_finder::Slot> const& slot,
-            http_request_type&& request,
-            PublicKey const& publicKey,
-            ProtocolVersion protocol,
-            resource::Consumer consumer,
-            std::unique_ptr<TMGetObjectByHash_test::stream_type>&& streamPtr,
-            OverlayImpl& overlay)
-            : PeerImp(
-                  app,
-                  id++,
-                  slot,
-                  std::move(request),
-                  publicKey,
-                  protocol,
-                  consumer,
-                  std::move(streamPtr),
-                  overlay)
-        {
-        }
+        using CapturePeer::CapturePeer;
 
-        ~PeerTest() override = default;
-
-        void
-        run() override
-        {
-        }
-
-        void
-        send(std::shared_ptr<Message> const& m) override
-        {
-            lastSentMessage_ = m;
-        }
-
-        std::shared_ptr<Message>
-        getLastSentMessage() const
-        {
-            return lastSentMessage_;
-        }
-
-        // Synchronous test access to the JobQueue-dispatched processor.
-        // The production path runs this on JtLedgerReq; tests need a
-        // synchronous entry point to inspect the reply via send().
-        // PeerImp::processGetObjectByHash is `protected` so the derived
-        // test subclass can call it directly.
         void
         runProcessGetObjectByHash(std::shared_ptr<protocol::TMGetObjectByHash> const& m)
         {
             processGetObjectByHash(m);
         }
-
-        static void
-        resetId()
-        {
-            id = 0;
-        }
-
-    private:
-        inline static Peer::id_t id = 0;
-        std::shared_ptr<Message> lastSentMessage_;
     };
 
-    shared_context context_{makeSslContext("")};
-    ProtocolVersion protocolVersion_{1, 7};
-
-    std::shared_ptr<PeerTest>
-    createPeer(jtx::Env& env)
-    {
-        auto& overlay = dynamic_cast<OverlayImpl&>(env.app().getOverlay());
-        boost::beast::http::request<boost::beast::http::dynamic_body> request;
-        auto streamPtr =
-            std::make_unique<stream_type>(socket_type(env.app().getIOContext()), *context_);
-
-        beast::ip::Endpoint const local(boost::asio::ip::make_address("172.1.1.1"), 51235);
-        beast::ip::Endpoint const remote(boost::asio::ip::make_address("172.1.1.2"), 51235);
-
-        PublicKey const key(std::get<0>(randomKeyPair(KeyType::Ed25519)));
-        auto consumer = overlay.resourceManager().newInboundEndpoint(remote);
-        auto [slot, _] = overlay.peerFinder().newInboundSlot(local, remote);
-
-        auto peer = std::make_shared<PeerTest>(
-            env.app(),
-            slot,
-            std::move(request),
-            key,
-            protocolVersion_,
-            consumer,
-            std::move(streamPtr),
-            overlay);
-
-        overlay.addActive(peer);
-        return peer;
-    }
-
     static std::shared_ptr<protocol::TMGetObjectByHash>
     createRequest(size_t const numObjects, Env& env)
     {
@@ -173,7 +67,7 @@ class TMGetObjectByHash_test : public beast::unit_test::Suite
                 NodeObjectType::Ledger, std::move(data), hash, nodeStore.earliestLedgerSeq());
         }
 
-        // Create a request with more objects than hardMaxReplyNodes
+        // Name every stored object in a single generic query.
         auto request = std::make_shared<protocol::TMGetObjectByHash>();
         request->set_type(protocol::TMGetObjectByHash_ObjectType_otLEDGER);
         request->set_query(true);
@@ -188,28 +82,25 @@ class TMGetObjectByHash_test : public beast::unit_test::Suite
     }
 
     /**
-     * Test that reply is limited to hardMaxReplyNodes when more objects
-     * are requested than the limit allows.
+     * Check the object count a generic-query reply carries.
      *
      * `onMessage(TMGetObjectByHash)` dispatches the generic-query path
      * to the JobQueue, so tests invoke the synchronous processor
      * directly via `runProcessGetObjectByHash`.
      */
     void
-    testReplyLimit(size_t const numObjects, int const expectedReplySize)
+    testReplyObjectCount(size_t const numObjects, int const expectedReplySize)
     {
-        testcase("Reply Limit");
+        testcase("Reply Object Count");
 
         Env env(*this);
-        PeerTest::resetId();
-
-        auto peer = createPeer(env);
+        auto peer = makeCapturePeer<GetObjectPeer>(env);
 
         auto request = createRequest(numObjects, env);
         peer->runProcessGetObjectByHash(request);
 
         // Verify that a reply was sent
-        auto sentMessage = peer->getLastSentMessage();
+        auto sentMessage = peer->lastSent();
         BEAST_EXPECT(sentMessage != nullptr);
 
         // Parse the reply message
@@ -220,7 +111,7 @@ class TMGetObjectByHash_test : public beast::unit_test::Suite
         protocol::TMGetObjectByHash reply;
         BEAST_EXPECT(reply.ParseFromArray(buffer.data() + 6, buffer.size() - 6) == true);
 
-        // Verify the reply is limited to expectedReplySize
+        // The reply carries the expected number of objects.
         BEAST_EXPECT(reply.objects_size() == expectedReplySize);
     }
 
@@ -228,9 +119,9 @@ class TMGetObjectByHash_test : public beast::unit_test::Suite
     run() override
     {
         int const limit = static_cast<int>(tuning::kHardMaxReplyNodes);
-        testReplyLimit(limit + 1, limit);
-        testReplyLimit(limit, limit);
-        testReplyLimit(limit - 1, limit - 1);
+        testReplyObjectCount(limit + 1, limit);
+        testReplyObjectCount(limit, limit);
+        testReplyObjectCount(limit - 1, limit - 1);
     }
 };
 
diff --git a/src/test/overlay/TMTransaction_test.cpp b/src/test/overlay/TMTransaction_test.cpp
new file mode 100644
index 0000000000..5a23e25005
--- /dev/null
+++ b/src/test/overlay/TMTransaction_test.cpp
@@ -0,0 +1,45 @@
+#include <test/jtx/Env.h>
+#include <test/jtx/envconfig.h>
+#include <test/overlay/CapturePeer.h>
+
+#include <xrpl/beast/unit_test/suite.h>
+#include <xrpl/resource/Fees.h>
+
+#include <xrpl.pb.h>
+
+#include <memory>
+
+namespace xrpl::test {
+
+using namespace jtx;
+
+class TMTransaction_test : public beast::unit_test::Suite
+{
+    void
+    testFailureDeserializingTransactionIsCharged()
+    {
+        testcase("Undeserializable Transaction Is Charged");
+
+        Env env{*this, envconfig()};
+
+        auto peer = makeCapturePeer(env);
+        auto tx = std::make_shared<protocol::TMTransaction>();
+        tx->set_status(protocol::tsNEW);
+
+        // Bytes that are not a serialized transaction, so deserialization fails.
+        tx->set_rawtransaction("\x01\x02\x03", 3);
+
+        peer->onMessage(tx);
+        BEAST_EXPECT(peer->feeCharge() == resource::kFeeInvalidData);
+    }
+
+    void
+    run() override
+    {
+        testFailureDeserializingTransactionIsCharged();
+    }
+};
+
+BEAST_DEFINE_TESTSUITE(TMTransaction, overlay, xrpl);
+
+}  // namespace xrpl::test
diff --git a/src/test/overlay/TMTransactions_test.cpp b/src/test/overlay/TMTransactions_test.cpp
new file mode 100644
index 0000000000..87c09498f2
--- /dev/null
+++ b/src/test/overlay/TMTransactions_test.cpp
@@ -0,0 +1,82 @@
+#include <test/jtx/CheckMessageLogs.h>
+#include <test/jtx/Env.h>
+#include <test/jtx/envconfig.h>
+#include <test/overlay/CapturePeer.h>
+
+#include <xrpld/overlay/ReduceRelayCommon.h>
+#include <xrpld/overlay/detail/Handshake.h>
+
+#include <xrpl/beast/unit_test/suite.h>
+#include <xrpl/resource/Fees.h>
+#include <xrpl/server/Handoff.h>
+
+#include <xrpl.pb.h>
+
+#include <cstddef>
+#include <memory>
+#include <optional>
+#include <utility>
+
+namespace xrpl::test {
+
+using namespace jtx;
+
+class TMTransactions_test : public beast::unit_test::Suite
+{
+    static std::shared_ptr<protocol::TMTransactions>
+    createRequest(std::size_t const numTransactions)
+    {
+        auto request = std::make_shared<protocol::TMTransactions>();
+        for (std::size_t i = 0; i < numTransactions; ++i)
+        {
+            request->mutable_transactions()->Add(protocol::TMTransaction{});
+        }
+        return request;
+    }
+
+    void
+    testTransactionCountAccepted(std::size_t const numTransactions, bool const expectRejected)
+    {
+        testcase("Transaction Count Accepted");
+
+        static constexpr auto kLimitExceededMessage = "TMTransactions: transaction list too large";
+        auto foundExpectedLog = false;
+        Env env{
+            *this,
+            envconfig(),
+            std::make_unique<CheckMessageLogs>(kLimitExceededMessage, &foundExpectedLog)};
+
+        // `PeerImp` decides `txReduceRelayEnabled()` in its constructor, from
+        // the config and the handshake header, so set this first.
+        env.app().config().txReduceRelayEnable = true;
+        http_request_type request;
+        request.insert("X-Protocol-Ctl", makeFeaturesRequestHeader(false, false, true, false));
+
+        auto peer = makeCapturePeer(env, std::nullopt, std::move(request));
+        peer->onMessage(createRequest(numTransactions));
+
+        auto fee = peer->feeCharge();
+        if (expectRejected)
+        {
+            BEAST_EXPECT(fee == resource::kFeeMalformedRequest);
+            BEAST_EXPECT(foundExpectedLog);
+        }
+        else
+        {
+            BEAST_EXPECT(!foundExpectedLog);
+        }
+    }
+
+    void
+    run() override
+    {
+        auto const limit = reduce_relay::kMaxTxQueueSize;
+        testTransactionCountAccepted(limit + 1, true);
+        testTransactionCountAccepted(limit, false);
+        testTransactionCountAccepted(limit - 1, false);
+    }
+};
+
+BEAST_DEFINE_TESTSUITE(TMTransactions, overlay, xrpl);
+
+}  // namespace xrpl::test
diff --git a/src/test/overlay/cluster_test.cpp b/src/test/overlay/cluster_test.cpp
index 0a51f98594..06df4fb73a 100644
--- a/src/test/overlay/cluster_test.cpp
+++ b/src/test/overlay/cluster_test.cpp
@@ -13,6 +13,7 @@
 
 #include <algorithm>
 #include <chrono>
+#include <cstddef>
 #include <cstdint>
 #include <memory>
 #include <vector>
@@ -96,6 +97,29 @@ public:
             }
         }
 
+        {
+            testcase("Membership: isMember agrees with member");
+
+            // Number of network nodes that also belong to the cluster.
+            std::size_t const overlapCount = 16;
+
+            // Total size of the cluster once padded with non-network nodes.
+            std::size_t const clusterSize = 32;
+
+            std::vector<PublicKey> cluster(network.begin(), network.begin() + overlapCount);
+
+            while (cluster.size() != clusterSize)
+                cluster.push_back(randomNode());
+
+            auto c = create(cluster);
+
+            for (auto const& n : cluster)
+                BEAST_EXPECT(c->isMember(n));
+
+            for (auto const& n : network)
+                BEAST_EXPECT(c->isMember(n) == static_cast<bool>(c->member(n)));
+        }
+
         {
             testcase("Membership: Non-empty cluster and all present");
 
diff --git a/src/test/overlay/overlay_limit_test.cpp b/src/test/overlay/overlay_limit_test.cpp
new file mode 100644
index 0000000000..11bbdc2377
--- /dev/null
+++ b/src/test/overlay/overlay_limit_test.cpp
@@ -0,0 +1,83 @@
+#include <test/jtx/Env.h>
+#include <test/jtx/envconfig.h>
+
+#include <xrpld/app/main/Application.h>
+#include <xrpld/overlay/Overlay.h>
+
+#include <xrpl/beast/unit_test/suite.h>
+#include <xrpl/peerfinder/detail/Tuning.h>
+
+#include <utility>
+
+namespace xrpl::test {
+
+using namespace jtx;
+
+/**
+ * Tests for `Overlay::limit()`, the configured peer allowance reported once
+ * `OverlayImpl::start()` applies the computed `peer_finder::Config`.
+ *
+ * `ApplicationImp::fdRequired()` runs before `OverlayImpl::start()` does, so it
+ * always sees the peer finder manager's default-constructed configuration and
+ * never this value; `Overlay::limit()` instead surfaces through the PeerFinder
+ * property stream and other post-startup callers.
+ *
+ * `jtx::Env` runs standalone, and `ServerHandler` strips the `peer` protocol
+ * from every configured port under `config.standalone()`, so the peer port
+ * declared here is never bound and incoming connections are disabled
+ * throughout; every limit in this suite is an outbound-only allowance. The
+ * inbound cases live alongside `peer_finder::Config::makeConfig`, which takes
+ * the port as a parameter.
+ */
+class OverlayLimit_test : public beast::unit_test::Suite
+{
+    void
+    testLegacyPeersMax()
+    {
+        testcase("Legacy peers_max is reported");
+
+        auto config = jtx::envconfig();
+        config->peersMax = 40;
+
+        Env env(*this, std::move(config));
+        BEAST_EXPECT(env.app().getOverlay().limit() == 40);
+    }
+
+    void
+    testPerDirectionPeerLimits()
+    {
+        testcase("Per-direction peer limits are reported");
+
+        // With incoming connections disabled the 50 inbound slots are dropped
+        // and only the outbound allowance remains, so neither zero (the value
+        // `maxPeers` used to hold in this branch of makeConfig) nor 70 (the
+        // unconditional sum of both directions) is correct.
+        auto config = jtx::envconfig();
+        config->peersInMax = 50;
+        config->peersOutMax = 20;
+
+        Env env(*this, std::move(config));
+        BEAST_EXPECT(env.app().getOverlay().limit() == 20);
+    }
+
+    void
+    testDefaultConfig()
+    {
+        testcase("A default configuration reports the default limit");
+
+        Env env(*this);
+        BEAST_EXPECT(env.app().getOverlay().limit() == peer_finder::tuning::kDefaultMaxPeers);
+    }
+
+    void
+    run() override
+    {
+        testLegacyPeersMax();
+        testPerDirectionPeerLimits();
+        testDefaultConfig();
+    }
+};
+
+BEAST_DEFINE_TESTSUITE(OverlayLimit, overlay, xrpl);
+
+}  // namespace xrpl::test
diff --git a/src/test/overlay/reduce_relay_test.cpp b/src/test/overlay/reduce_relay_test.cpp
index 4091efa0ca..ff3eb51a4d 100644
--- a/src/test/overlay/reduce_relay_test.cpp
+++ b/src/test/overlay/reduce_relay_test.cpp
@@ -1,4 +1,5 @@
 #include <test/jtx/Env.h>
+#include <test/jtx/PeerStub.h>
 #include <test/jtx/envconfig.h>
 
 #include <xrpld/app/main/Application.h>
@@ -12,10 +13,8 @@
 #include <xrpl/basics/base_uint.h>
 #include <xrpl/basics/random.h>
 #include <xrpl/beast/net/IPAddress.h>
-#include <xrpl/beast/net/IPEndpoint.h>
 #include <xrpl/beast/unit_test/suite.h>
 #include <xrpl/beast/utility/Journal.h>
-#include <xrpl/json/json_value.h>
 #include <xrpl/protocol/KeyType.h>
 #include <xrpl/protocol/PublicKey.h>
 #include <xrpl/protocol/SecretKey.h>
@@ -27,7 +26,6 @@
 #include <algorithm>
 #include <cassert>
 #include <chrono>
-#include <cstddef>
 #include <cstdint>
 #include <functional>
 #include <iostream>
@@ -67,16 +65,16 @@ static constexpr std::uint32_t kMaxMessages = 200000;
 /**
  * Simulate two entities - peer directly connected to the server
  * (via squelch in PeerSim) and PeerImp (via Overlay)
+ *
+ * `PeerStub` supplies the rest of the `Peer` interface as no-ops.
  */
-class PeerPartial : public Peer
+class PeerPartial : public PeerStub
 {
 public:
-    PeerPartial() : nodePublicKey(derivePublicKey(KeyType::Ed25519, randomSecretKey()))
-    {
-    }
+    using PeerStub::PeerStub;
+    // Keep the base overload visible; the one below would otherwise hide it.
+    using PeerStub::send;
 
-    PublicKey nodePublicKey;
-    ~PeerPartial() override = default;
     virtual void
     onMessage(MessageSPtr const& m, SquelchCB f) = 0;
     virtual void
@@ -86,111 +84,6 @@ public:
     {
         onMessage(squelch);
     }
-
-    // dummy implementation
-    void
-    send(std::shared_ptr<Message> const& m) override
-    {
-    }
-    [[nodiscard]] beast::ip::Endpoint
-    getRemoteAddress() const override
-    {
-        return {};
-    }
-    void
-    charge(resource::Charge const& fee, std::string const& context = {}) override
-    {
-    }
-    [[nodiscard]] bool
-    cluster() const override
-    {
-        return false;
-    }
-    [[nodiscard]] bool
-    isHighLatency() const override
-    {
-        return false;
-    }
-    [[nodiscard]] int
-    getScore(bool) const override
-    {
-        return 0;
-    }
-    [[nodiscard]] PublicKey const&
-    getNodePublic() const override
-    {
-        return nodePublicKey;
-    }
-    json::Value
-    json() override
-    {
-        return {};
-    }
-    [[nodiscard]] bool
-    supportsFeature(ProtocolFeature f) const override
-    {
-        return false;
-    }
-    [[nodiscard]] std::optional<std::size_t>
-    publisherListSequence(PublicKey const&) const override
-    {
-        return {};
-    }
-    void
-    setPublisherListSequence(PublicKey const&, std::size_t const) override
-    {
-    }
-    [[nodiscard]] uint256
-    getClosedLedgerHash() const override
-    {
-        static uint256 const kHash{};
-        return kHash;
-    }
-    [[nodiscard]] bool
-    hasLedger(uint256 const& hash, std::uint32_t seq) const override
-    {
-        return false;
-    }
-    void
-    ledgerRange(std::uint32_t& minSeq, std::uint32_t& maxSeq) const override
-    {
-    }
-    [[nodiscard]] bool
-    hasTxSet(uint256 const& hash) const override
-    {
-        return false;
-    }
-    void
-    cycleStatus() override
-    {
-    }
-    bool
-    hasRange(std::uint32_t uMin, std::uint32_t uMax) override
-    {
-        return false;
-    }
-    [[nodiscard]] bool
-    compressionEnabled() const override
-    {
-        return false;
-    }
-    [[nodiscard]] bool
-    txReduceRelayEnabled() const override
-    {
-        return false;
-    }
-    void
-    sendTxQueue() override
-    {
-    }
-    void
-    addTxQueue(uint256 const&) override
-    {
-    }
-    void
-    removeTxQueue(uint256 const&) override
-    {
-    }
 };
 
 /**
@@ -466,24 +359,13 @@ class PeerSim : public PeerPartial, public std::enable_shared_from_this<PeerSim>
 {
 public:
     using id_t = Peer::id_t;
-    PeerSim(Overlay& overlay, beast::Journal journal) : overlay_(overlay), squelch_(journal)
+    PeerSim(Overlay& overlay, beast::Journal journal)
+        : PeerPartial(sid++), overlay_(overlay), squelch_(journal)
     {
     }
 
     ~PeerSim() override = default;
 
-    id_t
-    id() const override
-    {
-        return id_;
-    }
-
-    std::string const&
-    fingerprint() const override
-    {
-        return fingerprint_;
-    }
-
     static void
     resetId()
     {
@@ -525,8 +407,6 @@ public:
 
 private:
     inline static id_t sid = 0;
-    std::string fingerprint_;
-    id_t id_{sid++};
     Overlay& overlay_;
     reduce_relay::Squelch<ManualClock> squelch_;
 };
diff --git a/src/test/overlay/tx_reduce_relay_test.cpp b/src/test/overlay/tx_reduce_relay_test.cpp
index 8626d3e19c..e97fba88e5 100644
--- a/src/test/overlay/tx_reduce_relay_test.cpp
+++ b/src/test/overlay/tx_reduce_relay_test.cpp
@@ -1,38 +1,24 @@
 #include <test/jtx/Env.h>
 #include <test/jtx/noop.h>
+#include <test/overlay/CapturePeer.h>
 
 #include <xrpld/app/main/Application.h>
 #include <xrpld/core/Config.h>
-#include <xrpld/overlay/Message.h>
 #include <xrpld/overlay/Peer.h>
 #include <xrpld/overlay/detail/Handshake.h>
 #include <xrpld/overlay/detail/OverlayImpl.h>
 #include <xrpld/overlay/detail/PeerImp.h>
-#include <xrpld/overlay/detail/ProtocolVersion.h>
 
 #include <xrpl/basics/base_uint.h>
-#include <xrpl/basics/make_SSLContext.h>
-#include <xrpl/beast/net/IPEndpoint.h>
 #include <xrpl/beast/unit_test/suite.h>
-#include <xrpl/peerfinder/Slot.h>
 #include <xrpl/protocol/KeyType.h>
 #include <xrpl/protocol/PublicKey.h>
 #include <xrpl/protocol/SecretKey.h>
 #include <xrpl/protocol/Serializer.h>
-#include <xrpl/resource/Consumer.h>
 #include <xrpl/server/Handoff.h>
 
-#include <boost/asio/io_context.hpp>
-#include <boost/asio/ip/address.hpp>
-#include <boost/asio/ip/tcp.hpp>
-#include <boost/asio/ssl/context.hpp>
-#include <boost/beast/core/multi_buffer.hpp>
-#include <boost/beast/core/tcp_stream.hpp>
-#include <boost/beast/ssl/ssl_stream.hpp>
-
 #include <xrpl.pb.h>
 
-#include <cassert>
 #include <cstddef>
 #include <cstdint>
 #include <functional>
@@ -47,13 +33,6 @@ namespace xrpl::test {
 
 class tx_reduce_relay_test : public beast::unit_test::Suite
 {
-public:
-    using socket_type = boost::asio::ip::tcp::socket;
-    using middle_type = boost::beast::tcp_stream;
-    using stream_type = boost::beast::ssl_stream<middle_type>;
-    using shared_context = std::shared_ptr<boost::asio::ssl::context>;
-
-private:
     void
     doTest(std::string const& msg, bool log, std::function<void(bool)> f)
     {
@@ -116,107 +95,83 @@ private:
         });
     }
 
-    class PeerTest : public PeerImp
+    /**
+     * Counts queued transaction hashes. Relayed messages are counted through
+     * the inherited `sent()`.
+     */
+    class TxReducePeer : public CapturePeer
     {
     public:
-        PeerTest(
-            Application& app,
-            std::shared_ptr<peer_finder::Slot> const& slot,
-            http_request_type&& request,
-            PublicKey const& publicKey,
-            ProtocolVersion protocol,
-            resource::Consumer consumer,
-            std::unique_ptr<tx_reduce_relay_test::stream_type>&& streamPtr,
-            OverlayImpl& overlay)
-            : PeerImp(
-                  app,
-                  sid,
-                  slot,
-                  std::move(request),
-                  publicKey,
-                  protocol,
-                  consumer,
-                  std::move(streamPtr),
-                  overlay)
-        {
-            sid++;
-        }
-        ~PeerTest() override = default;
+        using CapturePeer::CapturePeer;
 
         void
-        run() override
+        addTxQueue(uint256 const&) override
         {
+            ++queued_;
         }
-        void
-        send(std::shared_ptr<Message> const&) override
+
+        /**
+         * @return The number of transaction hashes queued for this peer.
+         */
+        std::size_t
+        queued() const
         {
-            sendTx++;
+            return queued_;
         }
-        void
-        addTxQueue(uint256 const& hash) override
-        {
-            queueTx++;
-        }
-        static void
-        init()
-        {
-            queueTx = 0;
-            sendTx = 0;
-            sid = 0;
-        }
-        inline static std::size_t sid = 0;
-        inline static std::uint16_t queueTx = 0;
-        inline static std::uint16_t sendTx = 0;
+
+    private:
+        std::size_t queued_{0};
     };
 
-    std::uint16_t lid_{0};
-    std::uint16_t rid_{1};
-    shared_context context_;
-    ProtocolVersion protocolVersion_;
-    boost::beast::multi_buffer readBuf_;
-
-public:
-    tx_reduce_relay_test() : context_(makeSslContext("")), protocolVersion_{1, 7}
-    {
-    }
-
-private:
+    /**
+     * Build one peer and register it with the overlay.
+     *
+     * The first `nDisabled` peers get no `X-Protocol-Ctl` header, which leaves
+     * tx reduce-relay disabled on them. Built first, they sit at the front of
+     * `peers`, where `testRelay`'s skip set expects them.
+     *
+     * @param env        The environment owning the overlay.
+     * @param peers      Receives the peer; the overlay holds only a weak
+     *                   pointer, so the caller keeps it alive.
+     * @param nDisabled  How many more peers to leave disabled; decremented
+     *                   per peer built.
+     */
     void
-    addPeer(jtx::Env& env, std::vector<std::shared_ptr<PeerTest>>& peers, std::uint16_t& nDisabled)
+    addPeer(
+        jtx::Env& env,
+        std::vector<std::shared_ptr<TxReducePeer>>& peers,
+        std::uint16_t& nDisabled)
     {
         auto& overlay = dynamic_cast<OverlayImpl&>(env.app().getOverlay());
-        boost::beast::http::request<boost::beast::http::dynamic_body> request;
-        (nDisabled == 0)
-            ? request.insert("X-Protocol-Ctl", makeFeaturesRequestHeader(false, false, true, false))
-            : (void)nDisabled--;
-        auto streamPtr = std::make_unique<stream_type>(
-            socket_type(std::forward<boost::asio::io_context&>(env.app().getIOContext())),
-            *context_);
-        beast::ip::Endpoint const local(
-            boost::asio::ip::make_address("172.1.1." + std::to_string(lid_)));
-        beast::ip::Endpoint const remote(
-            boost::asio::ip::make_address("172.1.1." + std::to_string(rid_)));
         PublicKey const key(std::get<0>(randomKeyPair(KeyType::Ed25519)));
-        auto consumer = overlay.resourceManager().newInboundEndpoint(remote);
-        auto [slot, _] = overlay.peerFinder().newInboundSlot(local, remote);
-        auto const peer = std::make_shared<PeerTest>(
-            env.app(),
-            slot,
-            std::move(request),
-            key,
-            protocolVersion_,
-            consumer,
-            std::move(streamPtr),
-            overlay);
+
+        bool const disabled = nDisabled > 0;
+        if (disabled)
+            --nDisabled;
+
+        http_request_type request;
+        if (!disabled)
+            request.insert("X-Protocol-Ctl", makeFeaturesRequestHeader(false, false, true, false));
+
         BEAST_EXPECT(overlay.findPeerByPublicKey(key) == std::shared_ptr<PeerImp>{});
-        overlay.addActive(peer);
+        auto const peer = makeCapturePeer<TxReducePeer>(env, key, std::move(request));
         BEAST_EXPECT(overlay.findPeerByPublicKey(key) == peer);
-        peers.emplace_back(peer);  // overlay stores week ptr to PeerImp
-        lid_ += 2;
-        rid_ += 2;
-        assert(lid_ <= 254);
+        peers.emplace_back(peer);
     }
 
+    /**
+     * Relay one transaction to `nPeers` peers and check the split.
+     *
+     * @param test       The testcase name.
+     * @param txRREnabled  The `tx_enable` config value.
+     * @param nPeers     How many peers to attach to the overlay.
+     * @param nDisabled  How many of those peers have reduce-relay disabled.
+     * @param minPeers   The `tx_min_peers` config value.
+     * @param relayPercentage  The `tx_relay_percentage` config value.
+     * @param expectRelay  The expected number of peers relayed to.
+     * @param expectQueue  The expected number of peers queued for.
+     * @param nSkip      How many of the first-built peers to skip.
+     */
     void
     testRelay(
         std::string const& test,
@@ -227,20 +182,30 @@ private:
         std::uint16_t relayPercentage,
         std::uint16_t expectRelay,
         std::uint16_t expectQueue,
-        std::set<Peer::id_t> const& toSkip = {})
+        std::size_t nSkip = 0)
     {
         testcase(test);
         jtx::Env env(*this);
-        std::vector<std::shared_ptr<PeerTest>> peers;
+        std::vector<std::shared_ptr<TxReducePeer>> peers;
+        // `PeerImp` decides `txReduceRelayEnabled()` in its constructor, from
+        // the config and the handshake header, so set these first.
         env.app().config().txReduceRelayEnable = txRREnabled;
         env.app().config().txReduceRelayMinPeers = minPeers;
         env.app().config().txRelayPercentage = relayPercentage;
-        PeerTest::init();
-        lid_ = 0;
-        rid_ = 0;
         for (int i = 0; i < nPeers; i++)
             addPeer(env, peers, nDisabled);
 
+        // An under-filled skip set would also fail the relay counts below, for
+        // a reason that looks unrelated.
+        if (!BEAST_EXPECT(nSkip <= peers.size()))
+            return;
+
+        // Skip the peers built first, so the skip set overlaps the disabled
+        // peers as the expected counts assume.
+        std::set<Peer::id_t> toSkip;
+        for (std::size_t i = 0; i < nSkip; ++i)
+            toSkip.insert(peers[i]->id());
+
         auto const jtx = env.jt(noop(env.master));
         if (BEAST_EXPECT(jtx.stx))
         {
@@ -251,7 +216,15 @@ private:
             m.set_deferred(false);
             m.set_status(protocol::TransactionStatus::tsNEW);
             env.app().getOverlay().relay(uint256{0}, m, toSkip);
-            BEAST_EXPECT(PeerTest::sendTx == expectRelay && PeerTest::queueTx == expectQueue);
+
+            std::size_t sendTx = 0;
+            std::size_t queueTx = 0;
+            for (auto const& peer : peers)
+            {
+                sendTx += peer->sent().size();
+                queueTx += peer->queued();
+            }
+            BEAST_EXPECT(sendTx == expectRelay && queueTx == expectQueue);
         }
     }
 
@@ -259,12 +232,11 @@ private:
     run() override
     {
         bool const log = false;
-        std::set<Peer::id_t> skip = {0, 1, 2, 3, 4};
         testConfig(log);
         // relay to all peers, no hash queue
         testRelay("feature disabled", false, 10, 0, 10, 25, 10, 0);
         // relay to nPeers - skip (10-5=5)
-        testRelay("feature disabled & skip", false, 10, 0, 10, 25, 5, 0, skip);
+        testRelay("feature disabled & skip", false, 10, 0, 10, 25, 5, 0, 5);
         // relay to all peers because min is greater than nPeers
         testRelay("relay all 1", true, 10, 0, 20, 25, 10, 0);
         // relay to all peers because min + disabled is greater thant nPeers
@@ -275,24 +247,22 @@ private:
         // relay to minPeers + 25% of (nPeers - nPeers) - skip
         // (20+0.25*(60-20)-5=25), queue the rest, skip counts towards relayed
         // (60-25-5=30)
-        testRelay("skip", true, 60, 0, 20, 25, 25, 30, skip);
+        testRelay("skip", true, 60, 0, 20, 25, 25, 30, 5);
         // relay to minPeers + disabled + 25% of (nPeers - minPeers - disabled)
         // (20+10+0.25*(70-20-10)=40), queue the rest (30)
         testRelay("disabled", true, 70, 10, 20, 25, 40, 30);
         // relay to minPeers + disabled-not-in-skip + 25% of (nPeers - minPeers
         // - disabled) (20+5+0.25*(70-20-10)=35), queue the rest, skip counts
         // towards relayed (70-35-5=30))
-        testRelay("disabled & skip", true, 70, 10, 20, 25, 35, 30, skip);
+        testRelay("disabled & skip", true, 70, 10, 20, 25, 35, 30, 5);
         // relay to minPeers + disabled + 25% of (nPeers - minPeers - disabled)
         // - skip (10+5+0.25*(15-10-5)-10=5), queue the rest, skip counts
         // towards relayed (15-5-10=0)
-        skip = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
-        testRelay("disabled & skip, no queue", true, 15, 5, 10, 25, 5, 0, skip);
+        testRelay("disabled & skip, no queue", true, 15, 5, 10, 25, 5, 0, 10);
         // relay to minPeers + disabled + 25% of (nPeers - minPeers - disabled)
         // - skip (10+2+0.25*(20-10-2)-14=0), queue the rest, skip counts
         // towards relayed (20-14=6)
-        skip = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13};
-        testRelay("disabled & skip, no relay", true, 20, 2, 10, 25, 0, 6, skip);
+        testRelay("disabled & skip, no relay", true, 20, 2, 10, 25, 0, 6, 14);
     }
 };
 
diff --git a/src/test/protocol/STTx_test.cpp b/src/test/protocol/STTx_test.cpp
index 777234be83..f310274e56 100644
--- a/src/test/protocol/STTx_test.cpp
+++ b/src/test/protocol/STTx_test.cpp
@@ -1,9 +1,13 @@
+#include <xrpl/basics/Number.h>
 #include <xrpl/basics/Slice.h>
 #include <xrpl/basics/base_uint.h>
+#include <xrpl/basics/safe_cast.h>
+#include <xrpl/basics/strHex.h>
 #include <xrpl/beast/hash/uhash.h>
 #include <xrpl/beast/unit_test/suite.h>
 #include <xrpl/json/to_string.h>  // IWYU pragma: keep
 #include <xrpl/protocol/Feature.h>
+#include <xrpl/protocol/HashPrefix.h>
 #include <xrpl/protocol/KeyType.h>
 #include <xrpl/protocol/PublicKey.h>
 #include <xrpl/protocol/Rules.h>
@@ -11,10 +15,12 @@
 #include <xrpl/protocol/SOTemplate.h>
 #include <xrpl/protocol/STAmount.h>
 #include <xrpl/protocol/STArray.h>
+#include <xrpl/protocol/STNumber.h>
 #include <xrpl/protocol/STObject.h>
 #include <xrpl/protocol/STParsedJSON.h>
 #include <xrpl/protocol/STTx.h>
 #include <xrpl/protocol/SecretKey.h>
+#include <xrpl/protocol/Seed.h>
 #include <xrpl/protocol/Serializer.h>
 #include <xrpl/protocol/Sign.h>
 #include <xrpl/protocol/TxFormats.h>
@@ -24,6 +30,7 @@
 #include <cstdint>
 #include <cstring>
 #include <exception>
+#include <functional>
 #include <memory>
 #include <ostream>
 #include <regex>
@@ -55,6 +62,279 @@ public:
         testSTTx(KeyType::Ed25519);
         testObjectCtorErrors();
         testBatchInnerCtorErrors();
+        testSigningPrefixes();
+        testRoleSignatureBinding();
+        testRoleMultiSignatureBinding();
+    }
+
+    // Rules with no amendments enabled, and rules with only fixCleanup3_4_0
+    // enabled. Rules keep a reference to the presets, so the presets must
+    // outlive the Rules; both are returned together.
+    struct RulesFixture
+    {
+        std::unordered_set<uint256, beast::Uhash<>> const noPresets;
+        std::unordered_set<uint256, beast::Uhash<>> const fixPresets{fixCleanup3_4_0};
+        Rules const legacy{noPresets};
+        Rules const fixed{fixPresets};
+    };
+
+    // A transaction with fixed contents, so its signing data is stable from
+    // run to run.
+    static STTx
+    makeFixedTx()
+    {
+        auto const keypair = generateKeyPair(KeyType::Secp256k1, generateSeed("masterpassphrase"));
+        return STTx(ttACCOUNT_SET, [&keypair](auto& obj) {
+            obj.setAccountID(sfAccount, calcAccountID(keypair.first));
+            obj.setFieldAmount(sfFee, STAmount(10ull));
+            obj.setFieldU32(sfSequence, 1);
+            obj.setFieldVL(sfSigningPubKey, keypair.first.slice());
+        });
+    }
+
+    void
+    testSigningPrefixes()
+    {
+        testcase("signing prefixes");
+
+        // The prefixes are protocol constants. Spell them out so that a typo
+        // in a prefix character fails here, and not in a downstream library.
+        static_assert(safeCast<std::uint32_t>(HashPrefix::TxSign) == 0x53545800);
+        static_assert(safeCast<std::uint32_t>(HashPrefix::TxMultiSign) == 0x534D5400);
+        static_assert(safeCast<std::uint32_t>(HashPrefix::CounterpartyTxSign) == 0x43505400);
+        static_assert(safeCast<std::uint32_t>(HashPrefix::CounterpartyTxMultiSign) == 0x43504D00);
+        static_assert(safeCast<std::uint32_t>(HashPrefix::SponsorTxSign) == 0x53504E00);
+        static_assert(safeCast<std::uint32_t>(HashPrefix::SponsorTxMultiSign) == 0x53504D00);
+
+        RulesFixture const r;
+
+        // Every role gets its own prefix once the fix is enabled.
+        BEAST_EXPECT(
+            signingPrefix(SignatureRole::Transaction, false, r.fixed) == HashPrefix::TxSign);
+        BEAST_EXPECT(
+            signingPrefix(SignatureRole::Transaction, true, r.fixed) == HashPrefix::TxMultiSign);
+        BEAST_EXPECT(
+            signingPrefix(SignatureRole::Counterparty, false, r.fixed) ==
+            HashPrefix::CounterpartyTxSign);
+        BEAST_EXPECT(
+            signingPrefix(SignatureRole::Counterparty, true, r.fixed) ==
+            HashPrefix::CounterpartyTxMultiSign);
+        BEAST_EXPECT(
+            signingPrefix(SignatureRole::Sponsor, false, r.fixed) == HashPrefix::SponsorTxSign);
+        BEAST_EXPECT(
+            signingPrefix(SignatureRole::Sponsor, true, r.fixed) == HashPrefix::SponsorTxMultiSign);
+
+        // Before the fix, every role signs the same bytes.
+        for (auto const role :
+             {SignatureRole::Transaction, SignatureRole::Counterparty, SignatureRole::Sponsor})
+        {
+            BEAST_EXPECT(signingPrefix(role, false, r.legacy) == HashPrefix::TxSign);
+            BEAST_EXPECT(signingPrefix(role, true, r.legacy) == HashPrefix::TxMultiSign);
+        }
+
+        // Each role's field, and each signature field's role, agree.
+        BEAST_EXPECT(signatureField(SignatureRole::Transaction) == nullptr);
+        BEAST_EXPECT(*signatureField(SignatureRole::Counterparty) == sfCounterpartySignature);
+        BEAST_EXPECT(*signatureField(SignatureRole::Sponsor) == sfSponsorSignature);
+        BEAST_EXPECT(signatureRole(sfCounterpartySignature) == SignatureRole::Counterparty);
+        BEAST_EXPECT(signatureRole(sfSponsorSignature) == SignatureRole::Sponsor);
+        BEAST_EXPECT(!signatureRole(sfBook));
+        BEAST_EXPECT(!signatureRole(sfSigner));
+
+        // The bytes signed by an ordinary transaction must not move. Both the
+        // single- and the multi-signing data are pinned, and neither depends
+        // on the amendment.
+        auto const tx = makeFixedTx();
+        for (Rules const& rules : {r.legacy, r.fixed})
+        {
+            Serializer single;
+            single.add32(signingPrefix(SignatureRole::Transaction, false, rules));
+            tx.addWithoutSigningFields(single);
+            // 53545800 STX prefix, 120003 AccountSet, 2400000001 Sequence,
+            // 68400000000000000A Fee, 7321... SigningPubKey, 8114... Account.
+            BEAST_EXPECT(
+                strHex(single.peekData()) ==
+                "53545800"
+                "120003"
+                "2400000001"
+                "68400000000000000A"
+                "73210330E7FC9D56BB25D6893BA3F317AE5BCF33B3291BD63DB32654A313222F7FD020"
+                "8114B5F762798A53D543A014CAF8B297CFF8F2F937E8");
+            BEAST_EXPECT(
+                to_string(single.getSHA512Half()) ==
+                "AB7473EA8D05527A7465229447B0E9B05365C72B87E921762AD30742B253F3E6");
+
+            auto const signer = calcAccountID(
+                generateKeyPair(KeyType::Secp256k1, generateSeed("multisigner")).first);
+            Serializer const multi = buildMultiSigningData(
+                tx, signer, signingPrefix(SignatureRole::Transaction, true, rules));
+
+            // The multi-signing data is the single-signing data with a
+            // different prefix and the signer's account appended.
+            Serializer expected;
+            expected.add32(HashPrefix::TxMultiSign);
+            tx.addWithoutSigningFields(expected);
+            expected.addBitString(signer);
+            BEAST_EXPECT(strHex(multi.peekData()) == strHex(expected.peekData()));
+        }
+    }
+
+    void
+    testRoleSignatureBinding()
+    {
+        testcase("role signature binding");
+
+        RulesFixture const r;
+
+        auto const keypair = generateKeyPair(KeyType::Secp256k1, generateSeed("masterpassphrase"));
+        auto const account = calcAccountID(keypair.first);
+
+        // A transaction signed by its own account, with that signature copied
+        // into an alternate signature field. sfSponsorSignature is a common
+        // field; sfCounterpartySignature is only on a LoanSet.
+        auto makeCopiedSig = [&keypair, &account](SField const& sigField) {
+            bool const counterparty = sigField == sfCounterpartySignature;
+            STTx tx(counterparty ? ttLOAN_SET : ttACCOUNT_SET, [&](auto& obj) {
+                obj.setAccountID(sfAccount, account);
+                obj.setFieldAmount(sfFee, STAmount(10ull));
+                obj.setFieldU32(sfSequence, 1);
+                obj.setFieldVL(sfSigningPubKey, keypair.first.slice());
+                if (counterparty)
+                {
+                    obj.setFieldH256(sfLoanBrokerID, uint256{1});
+                    obj.setFieldNumber(
+                        sfPrincipalRequested, STNumber{sfPrincipalRequested, Number{1}});
+                }
+                else
+                {
+                    obj.setAccountID(sfSponsor, account);
+                    obj.setFieldU32(sfSponsorFlags, 0);
+                }
+            });
+            tx.sign(keypair.first, keypair.second);
+
+            STObject sigObject(sigField);
+            sigObject.setFieldVL(sfSigningPubKey, keypair.first.slice());
+            sigObject.setFieldVL(sfTxnSignature, tx.getSignature());
+
+            // NOLINTNEXTLINE(cppcoreguidelines-slicing)
+            STObject copy{tx};
+            copy.setFieldObject(sigField, sigObject);
+            return STTx{std::move(copy)};
+        };
+
+        for (SField const& sigField :
+             {std::cref(sfCounterpartySignature), std::cref(sfSponsorSignature)})
+        {
+            auto const tx = makeCopiedSig(sigField);
+
+            // Before the fix, the copied signature verifies in the other role.
+            BEAST_EXPECT(tx.checkSign(r.legacy));
+
+            // With the fix, it does not, and the error names the role that
+            // failed so the two role checks cannot be confused.
+            auto const ret = tx.checkSign(r.fixed);
+            BEAST_EXPECT(!ret);
+            if (!ret)
+            {
+                char const* const rolePrefix =
+                    sigField == sfCounterpartySignature ? "Counterparty: " : "Sponsor: ";
+                BEAST_EXPECT(ret.error().starts_with(rolePrefix));
+                BEAST_EXPECT(matches(ret.error().c_str(), "Invalid signature"));
+            }
+        }
+    }
+
+    // Multi-sign analogue of testRoleSignatureBinding. Both the top-level
+    // Signers array and a role slot's Signers array carry the same signer
+    // entry, signed under HashPrefix::TxMultiSign. Before the fix every role
+    // uses that same prefix, so the copied entry verifies in the role slot;
+    // after the fix the role slot verifies against CounterpartyTxMultiSign
+    // (CPM) or SponsorTxMultiSign (SPM) and the entry no longer matches.
+    void
+    testRoleMultiSignatureBinding()
+    {
+        testcase("role multi-signature binding");
+
+        RulesFixture const r;
+
+        auto const acctKp = generateKeyPair(KeyType::Secp256k1, generateSeed("masterpassphrase"));
+        auto const account = calcAccountID(acctKp.first);
+        // The signer must differ from the top-level account so that the
+        // multiSignHelper "account owner may not multisign for themselves"
+        // check passes for the top-level Signers array.
+        auto const signerKp = generateKeyPair(KeyType::Secp256k1, generateSeed("multisigner"));
+        auto const signerId = calcAccountID(signerKp.first);
+
+        auto makeCopiedMultiSig = [&](SField const& sigField) {
+            bool const counterparty = sigField == sfCounterpartySignature;
+            STTx const tx(counterparty ? ttLOAN_SET : ttACCOUNT_SET, [&](auto& obj) {
+                obj.setAccountID(sfAccount, account);
+                obj.setFieldAmount(sfFee, STAmount(10ull));
+                obj.setFieldU32(sfSequence, 1);
+                // Empty SigningPubKey selects the multi-sign path.
+                obj.setFieldVL(sfSigningPubKey, Slice{});
+                if (counterparty)
+                {
+                    obj.setFieldH256(sfLoanBrokerID, uint256{1});
+                    obj.setFieldNumber(
+                        sfPrincipalRequested, STNumber{sfPrincipalRequested, Number{1}});
+                }
+                else
+                {
+                    obj.setAccountID(sfSponsor, account);
+                    obj.setFieldU32(sfSponsorFlags, 0);
+                }
+            });
+
+            // Sign the top-level tx with TxMultiSign, which is what a
+            // multi-signer of the transaction itself would use.
+            Serializer const ss = buildMultiSigningData(tx, signerId, HashPrefix::TxMultiSign);
+            auto const sig = xrpl::sign(signerKp.first, signerKp.second, ss.slice());
+
+            STObject entry(sfSigner);
+            entry.setAccountID(sfAccount, signerId);
+            entry.setFieldVL(sfSigningPubKey, signerKp.first.slice());
+            entry.setFieldVL(sfTxnSignature, sig);
+            STArray signers(sfSigners, 1);
+            signers.pushBack(entry);
+
+            // Attach the Signers array to the top level so its own signature
+            // check succeeds, then copy the identical array into the role
+            // slot. Both arrays carry TxMultiSign-based signatures.
+            // NOLINTNEXTLINE(cppcoreguidelines-slicing)
+            STObject copy{tx};
+            copy.setFieldArray(sfSigners, signers);
+
+            STObject sigObject(sigField);
+            sigObject.setFieldVL(sfSigningPubKey, Slice{});
+            sigObject.setFieldArray(sfSigners, signers);
+            copy.setFieldObject(sigField, sigObject);
+            return STTx{std::move(copy)};
+        };
+
+        for (SField const& sigField :
+             {std::cref(sfCounterpartySignature), std::cref(sfSponsorSignature)})
+        {
+            auto const tx = makeCopiedMultiSig(sigField);
+
+            // Before the fix, both signature checks use TxMultiSign, so the
+            // copied Signers array verifies in the role slot as well.
+            BEAST_EXPECT(tx.checkSign(r.legacy));
+
+            // With the fix, the role slot uses its own multi-sign prefix
+            // (CPM or SPM) and the copied signature no longer verifies. The
+            // error must name the role that failed.
+            auto const ret = tx.checkSign(r.fixed);
+            BEAST_EXPECT(!ret);
+            if (!ret)
+            {
+                char const* const rolePrefix =
+                    sigField == sfCounterpartySignature ? "Counterparty: " : "Sponsor: ";
+                BEAST_EXPECT(ret.error().starts_with(rolePrefix));
+                BEAST_EXPECT(matches(ret.error().c_str(), "Invalid signature"));
+            }
+        }
     }
 
     void
@@ -1555,7 +1835,7 @@ public:
         auto const id2 = calcAccountID(kp2.first);
 
         // Get the stream of the transaction for use in multi-signing.
-        Serializer const s = buildMultiSigningData(txn, id2);
+        Serializer const s = buildMultiSigningData(txn, id2, HashPrefix::TxMultiSign);
 
         auto const saMultiSignature = sign(kp2.first, kp2.second, s.slice());
 
diff --git a/src/test/rpc/Handler_test.cpp b/src/test/rpc/Handler_test.cpp
index be78864cac..16838d3f5a 100644
--- a/src/test/rpc/Handler_test.cpp
+++ b/src/test/rpc/Handler_test.cpp
@@ -1,9 +1,8 @@
 
-#include <test/jtx/TestHelpers.h>
-
 #include <xrpld/rpc/detail/Handler.h>
 
 #include <xrpl/beast/unit_test/suite.h>
+#include <xrpl/protocol/ApiVersion.h>
 
 #include <algorithm>
 #include <array>
@@ -12,7 +11,11 @@
 #include <cmath>
 #include <cstddef>
 #include <iostream>
+#include <iterator>
+#include <optional>
 #include <random>
+#include <string>
+#include <string_view>
 #include <tuple>
 #include <vector>
 // cspell: words stdev
@@ -88,21 +91,50 @@ class Handler_test : public beast::unit_test::Suite
         std::random_device dev;
         std::ranlux48 prng(dev());
 
-        std::vector<char const*> names = test::jtx::makeVector(xrpl::rpc::getHandlerNames());
+        // The lowest version still served. Outside the supported range getHandler()
+        // returns at its bounds check without searching, so the benchmark would
+        // time that check instead of a lookup.
+        constexpr unsigned kVersion = rpc::kApiMinimumSupportedVersion;
+
+        // Only the names that answer at kVersion, so that every timed call does a
+        // whole lookup: a method served from a later version only would not.
+        // Contiguous, so that picking one by index costs nothing.
+        std::vector<std::string_view> names;
+        std::ranges::copy_if(
+            rpc::getHandlerNames(), std::back_inserter(names), [](std::string_view name) {
+                return rpc::getHandler(kVersion, false, name) != nullptr;
+            });
+
+        if (!BEAST_EXPECTS(
+                !names.empty(),
+                "no handler answers at API version " + std::to_string(kVersion) +
+                    ", so there is nothing to measure"))
+            return;
 
         std::uniform_int_distribution<std::size_t> distr{0, names.size() - 1};
 
         std::size_t dummy = 0;
+        std::size_t misses = 0;
         auto const [mean, stdev, n] = time(
             1'000'000,
             [&](std::size_t i) {
-                auto const d = rpc::getHandler(1, false, names[i]);
+                auto const d = rpc::getHandler(kVersion, false, names[i]);
+                if (d == nullptr)
+                {
+                    ++misses;
+                    return;
+                }
                 dummy = dummy + i + (int)d->role;
             },
             [&]() -> std::size_t { return distr(prng); });
 
         std::cout << "mean=" << mean << " stdev=" << stdev << " N=" << n << '\n';
 
+        // Every name answered once already, so a miss here cannot happen.
+        BEAST_EXPECTS(
+            misses == 0,
+            std::to_string(misses) + " of " + std::to_string(n) + " lookups at API version " +
+                std::to_string(kVersion) + " found no handler, so nothing was measured");
         BEAST_EXPECT(dummy != 0);
     }
 
@@ -114,6 +146,125 @@ public:
     }
 };
 
+// Manual: the suite only reports a timing, which says nothing on a CI runner.
+// The table invariants are static_asserts in Handler.cpp.
 BEAST_DEFINE_TESTSUITE_MANUAL(Handler, rpc, xrpl);
 
+// What getHandler() answers, as opposed to how fast it answers. A lookup needs no
+// Application, so these cases run as an automatic suite.
+//
+// The bounds check they cover is unreachable from a request: getAPIVersionNumber()
+// applies the same predicate first, and every caller rejects an invalid version
+// before it asks for a handler. That is why it is checked here directly, and why
+// it is worth checking at all rather than deleting as unreachable.
+class HandlerLookup_test : public beast::unit_test::Suite
+{
+    /**
+     * Find a method that is served at a given API version.
+     *
+     * The name comes from the table, so a case below does not name a method that a
+     * later API version may retire.
+     *
+     * @param version The API version to answer at.
+     * @param betaEnabled Whether the beta API version is enabled.
+     * @return A name that answers, or nullopt if none does.
+     */
+    static std::optional<std::string_view>
+    nameServedAt(unsigned version, bool betaEnabled)
+    {
+        for (std::string_view name : rpc::getHandlerNames())
+        {
+            if (rpc::getHandler(version, betaEnabled, name) != nullptr)
+                return name;
+        }
+
+        return std::nullopt;
+    }
+
+    void
+    testUnservedVersion()
+    {
+        testcase("An unserved API version has no handler");
+
+        // A name the table certainly holds, so that a null answer below can only
+        // come from the version and not from the name.
+        auto const name = nameServedAt(rpc::kApiMinimumSupportedVersion, false);
+        if (!BEAST_EXPECTS(
+                name.has_value(),
+                "no handler answers at API version " +
+                    std::to_string(rpc::kApiMinimumSupportedVersion) +
+                    ", so there is no name to ask about"))
+            return;
+
+        // Below the minimum, which no setting serves.
+        BEAST_EXPECT(
+            rpc::getHandler(rpc::kApiMinimumSupportedVersion - 1, false, *name) == nullptr);
+        BEAST_EXPECT(rpc::getHandler(rpc::kApiMinimumSupportedVersion - 1, true, *name) == nullptr);
+
+        // Above the maximum each setting serves. Both values stay outside the
+        // served range however the version constants move, so neither case can
+        // become vacuous.
+        BEAST_EXPECT(
+            rpc::getHandler(rpc::kApiMaximumSupportedVersion + 1, false, *name) == nullptr);
+        BEAST_EXPECT(rpc::getHandler(rpc::kApiBetaVersion + 1, true, *name) == nullptr);
+    }
+
+    void
+    testBetaVersionGate()
+    {
+        testcase("The beta API version is served only where it is enabled");
+
+        // Between betas the beta version is the maximum supported one, leaving the
+        // two settings nothing to tell apart. Compiled out rather than asserted, so
+        // that the case arms itself again when a later beta version arrives.
+        if constexpr (rpc::kApiBetaVersion > rpc::kApiMaximumSupportedVersion)
+        {
+            auto const name = nameServedAt(rpc::kApiBetaVersion, true);
+            if (!BEAST_EXPECTS(
+                    name.has_value(),
+                    "no handler answers at API version " + std::to_string(rpc::kApiBetaVersion) +
+                        ", so there is nothing for the gate to reject"))
+                return;
+
+            // The handler serves this version, so only the server's own range can
+            // turn the answer into a null one.
+            BEAST_EXPECT(rpc::getHandler(rpc::kApiBetaVersion, true, *name) != nullptr);
+            BEAST_EXPECT(rpc::getHandler(rpc::kApiBetaVersion, false, *name) == nullptr);
+        }
+        else
+        {
+            log << "the beta API version is the maximum supported version, so no gate "
+                   "separates them\n";
+            pass();
+        }
+    }
+
+    void
+    testUnknownMethod()
+    {
+        testcase("An unknown method has no handler");
+
+        constexpr unsigned kVersion = rpc::kApiMinimumSupportedVersion;
+
+        BEAST_EXPECT(rpc::getHandler(kVersion, false, "no such method") == nullptr);
+        BEAST_EXPECT(rpc::getHandler(kVersion, false, "") == nullptr);
+
+        // A method name holds lowercase letters and underscores, so a tilde sorts
+        // after every entry. This runs the search off the end of the table, which
+        // no other case here does.
+        BEAST_EXPECT(rpc::getHandler(kVersion, false, "~") == nullptr);
+    }
+
+public:
+    void
+    run() override
+    {
+        testUnservedVersion();
+        testBetaVersionGate();
+        testUnknownMethod();
+    }
+};
+
+BEAST_DEFINE_TESTSUITE(HandlerLookup, rpc, xrpl);
+
 }  // namespace xrpl::test
diff --git a/src/test/rpc/LedgerRPC_test.cpp b/src/test/rpc/LedgerRPC_test.cpp
index e7c5dd4a80..deb19e3a3f 100644
--- a/src/test/rpc/LedgerRPC_test.cpp
+++ b/src/test/rpc/LedgerRPC_test.cpp
@@ -13,17 +13,21 @@
 #include <test/jtx/ter.h>
 
 #include <xrpld/app/misc/TxQ.h>
+#include <xrpld/rpc/CTID.h>
 
 #include <xrpl/basics/base_uint.h>
 #include <xrpl/beast/unit_test/suite.h>
 #include <xrpl/config/Constants.h>
+#include <xrpl/core/NetworkIDService.h>
 #include <xrpl/json/json_value.h>
 #include <xrpl/json/to_string.h>
 #include <xrpl/protocol/ErrorCodes.h>
+#include <xrpl/protocol/SField.h>
 #include <xrpl/protocol/TER.h>
 #include <xrpl/protocol/TxFlags.h>
 #include <xrpl/protocol/jss.h>
 
+#include <cstdint>
 #include <memory>
 #include <string>
 #include <utility>
@@ -807,6 +811,95 @@ class LedgerRPC_test : public beast::unit_test::Suite
         }
     }
 
+    void
+    testLedgerExpandedTransactionsCTID()
+    {
+        testcase("Expanded Transactions CTID");
+        using namespace test::jtx;
+
+        Env env{*this};
+        Account const alice{"alice"};
+        env.fund(XRP(10000), alice);
+        env.close();
+
+        uint32_t const netID = env.app().getNetworkIDService().getNetworkID();
+
+        // API v2 non-binary: CTID present
+        {
+            json::Value jvParams;
+            jvParams[jss::ledger_index] = "validated";
+            jvParams[jss::transactions] = true;
+            jvParams[jss::expand] = true;
+            jvParams[jss::api_version] = 2;
+            auto const jrr = env.rpc("json", "ledger", to_string(jvParams))[jss::result];
+            BEAST_EXPECT(jrr[jss::status] == "success");
+            auto const& txns = jrr[jss::ledger][jss::transactions];
+            BEAST_EXPECT(txns.isArray() && txns.size() > 0);
+            for (auto const& txn : txns)
+            {
+                BEAST_EXPECT(txn.isMember(jss::ctid));
+                auto const expectedCtid = rpc::encodeCTID(
+                    jrr[jss::ledger][jss::ledger_index].asUInt(),
+                    txn[jss::meta][sfTransactionIndex.jsonName].asUInt(),
+                    netID);
+                // NOLINTBEGIN(bugprone-unchecked-optional-access)
+                if (BEAST_EXPECT(expectedCtid.has_value()))
+                    BEAST_EXPECT(txn[jss::ctid] == expectedCtid.value());
+                // NOLINTEND(bugprone-unchecked-optional-access)
+            }
+        }
+
+        // API v1 non-binary: CTID present
+        {
+            json::Value jvParams;
+            jvParams[jss::ledger_index] = "validated";
+            jvParams[jss::transactions] = true;
+            jvParams[jss::expand] = true;
+            auto const jrr = env.rpc("json", "ledger", to_string(jvParams))[jss::result];
+            BEAST_EXPECT(jrr[jss::status] == "success");
+            auto const& txns = jrr[jss::ledger][jss::transactions];
+            BEAST_EXPECT(txns.isArray() && txns.size() > 0);
+            for (auto const& txn : txns)
+            {
+                BEAST_EXPECT(txn.isMember(jss::ctid));
+            }
+        }
+
+        // Binary expanded: CTID present
+        {
+            json::Value jvParams;
+            jvParams[jss::ledger_index] = "validated";
+            jvParams[jss::transactions] = true;
+            jvParams[jss::expand] = true;
+            jvParams[jss::binary] = true;
+            jvParams[jss::api_version] = 2;
+            auto const jrr = env.rpc("json", "ledger", to_string(jvParams))[jss::result];
+            BEAST_EXPECT(jrr[jss::status] == "success");
+            auto const& txns = jrr[jss::ledger][jss::transactions];
+            BEAST_EXPECT(txns.isArray() && txns.size() > 0);
+            for (auto const& txn : txns)
+            {
+                BEAST_EXPECT(txn.isMember(jss::ctid));
+            }
+        }
+
+        // Non-expanded: transactions are plain hash strings, no CTID
+        {
+            json::Value jvParams;
+            jvParams[jss::ledger_index] = "validated";
+            jvParams[jss::transactions] = true;
+            jvParams[jss::api_version] = 2;
+            auto const jrr = env.rpc("json", "ledger", to_string(jvParams))[jss::result];
+            BEAST_EXPECT(jrr[jss::status] == "success");
+            auto const& txns = jrr[jss::ledger][jss::transactions];
+            BEAST_EXPECT(txns.isArray() && txns.size() > 0);
+            for (auto const& txn : txns)
+            {
+                BEAST_EXPECT(txn.isString());
+            }
+        }
+    }
+
 public:
     void
     run() override
@@ -822,6 +915,7 @@ public:
         testNoQueue();
         testQueue();
         testLedgerAccountsOption();
+        testLedgerExpandedTransactionsCTID();
     }
 };
 
diff --git a/src/test/rpc/NoRippleCheck_test.cpp b/src/test/rpc/NoRippleCheck_test.cpp
index 8e719e6407..3a4ddcf5c4 100644
--- a/src/test/rpc/NoRippleCheck_test.cpp
+++ b/src/test/rpc/NoRippleCheck_test.cpp
@@ -126,9 +126,16 @@ class NoRippleCheck_test : public beast::unit_test::Suite
             params[jss::account] = toBase58(TokenType::NodePrivate, alice.sk());
             params[jss::role] = "user";
             params[jss::ledger] = "current";
+            params[jss::transactions] = true;
             auto const result = env.rpc("json", "noripple_check", to_string(params))[jss::result];
             BEAST_EXPECT(result[jss::error] == "actMalformed");
             BEAST_EXPECT(result[jss::error_message] == "Account malformed.");
+            // The changelog promises malformed-account responses carry
+            // neither `transactions` nor any ledger metadata.
+            BEAST_EXPECT(!result.isMember(jss::transactions));
+            BEAST_EXPECT(!result.isMember(jss::ledger_hash));
+            BEAST_EXPECT(!result.isMember(jss::ledger_index));
+            BEAST_EXPECT(!result.isMember(jss::validated));
         }
 
         {
@@ -194,6 +201,7 @@ class NoRippleCheck_test : public beast::unit_test::Suite
         if (!BEAST_EXPECT(pa.isArray()))
             return;
 
+        BEAST_EXPECT(!result.isMember(jss::transactions));
         if (problems)
         {
             if (!BEAST_EXPECT(pa.size() == 2))
@@ -219,12 +227,12 @@ class NoRippleCheck_test : public beast::unit_test::Suite
         // time.
         params[jss::transactions] = true;
         result = env.rpc("json", "noripple_check", to_string(params))[jss::result];
-        if (!BEAST_EXPECT(result[jss::transactions].isArray()))
-            return;
 
         auto const txs = result[jss::transactions];
         if (problems)
         {
+            if (!BEAST_EXPECT(result[jss::transactions].isArray()))
+                return;
             if (!BEAST_EXPECT(txs.size() == (user ? 1 : 2)))
                 return;
 
diff --git a/src/test/rpc/RPCCall_test.cpp b/src/test/rpc/RPCCall_test.cpp
index ef3213008c..e09d95f99a 100644
--- a/src/test/rpc/RPCCall_test.cpp
+++ b/src/test/rpc/RPCCall_test.cpp
@@ -3,6 +3,9 @@
 #include <test/jtx/utility.h>
 
 #include <xrpld/core/Config.h>
+#include <xrpld/rpc/MethodNames.h>
+#include <xrpld/rpc/RPCCall.h>
+#include <xrpld/rpc/detail/Handler.h>
 
 #include <xrpl/beast/unit_test/suite.h>
 #include <xrpl/json/json_reader.h>
@@ -12,11 +15,14 @@
 
 #include <boost/algorithm/string/replace.hpp>
 
+#include <algorithm>
+#include <array>
 #include <cstdint>
 #include <cstring>
 #include <initializer_list>
 #include <memory>
 #include <string>
+#include <string_view>
 #include <typeinfo>
 #include <vector>
 
@@ -5923,10 +5929,67 @@ public:
         }
     }
 
+    // The command-line table and the dispatch table must agree.
+    //
+    // Forwards: every name the command line accepts must reach a handler at the
+    // version the command-line client requests. Presence in the dispatch table is
+    // not enough: a handler whose API range excludes kApiCommandLineVersion parses
+    // the command and then answers RpcUnknownCommand.
+    //
+    // Backwards: a handler that claims a command-line form must have one, and
+    // one that denies it must not, so that Handler::hasCommandLineForm cannot go
+    // stale.
+    //
+    // Three command-line names are exempt from the forward check because they
+    // are wrappers that forward a caller-supplied method rather than naming one
+    // themselves, so they have no handler of their own.
+    void
+    testCommandLineTableMatchesHandlers()
+    {
+        testcase("Command-line and dispatch tables agree");
+
+        static constexpr std::array kWrappers{
+            rpc::method::kInternal, rpc::method::kJson, rpc::method::kJson2};
+
+        auto const commandLine = commandLineMethodNames();
+        auto const handlers = rpc::getHandlerNames();
+        BEAST_EXPECT(!commandLine.empty());
+        BEAST_EXPECT(!handlers.empty());
+
+        // The command-line client always requests this version, so this is the
+        // only version at which its commands have to be dispatchable. Beta
+        // methods are off: a command must work against a stock server.
+        auto const handlerFor = [](std::string_view name) {
+            return rpc::getHandler(rpc::kApiCommandLineVersion, false, name);
+        };
+
+        for (auto const& name : commandLine)
+        {
+            if (std::ranges::find(kWrappers, name) != kWrappers.end())
+                continue;
+
+            auto const* handler = handlerFor(name);
+            if (BEAST_EXPECTS(handler != nullptr, std::string{name}))
+                BEAST_EXPECTS(handler->hasCommandLineForm, std::string{name});
+        }
+
+        for (auto const& name : handlers)
+        {
+            auto const* handler = handlerFor(name);
+            bool const claimsCommandLine = handler != nullptr && handler->hasCommandLineForm;
+
+            // Both name lists are sorted, so a binary search suffices.
+            BEAST_EXPECTS(
+                claimsCommandLine == std::ranges::binary_search(commandLine, name.view()),
+                std::string{name});
+        }
+    }
+
     void
     run() override
     {
         forAllApiVersions([this](unsigned apiVersion) { testRPCCall(apiVersion); });
+        testCommandLineTableMatchesHandlers();
     }
 };
 
diff --git a/src/tests/libxrpl/CMakeLists.txt b/src/tests/libxrpl/CMakeLists.txt
index 9cbfb8ca10..81f4abc126 100644
--- a/src/tests/libxrpl/CMakeLists.txt
+++ b/src/tests/libxrpl/CMakeLists.txt
@@ -31,6 +31,7 @@ set(test_modules
     consensus
     crypto
     json
+    ledger
     nodestore
     peerfinder
     protocol
diff --git a/src/tests/libxrpl/basics/MallocTrim.cpp b/src/tests/libxrpl/basics/MallocTrim.cpp
index 52151262b0..0f98a156a5 100644
--- a/src/tests/libxrpl/basics/MallocTrim.cpp
+++ b/src/tests/libxrpl/basics/MallocTrim.cpp
@@ -49,7 +49,7 @@ TEST(MallocTrimReport, structure)
 }
 
 #if defined(__GLIBC__) && BOOST_OS_LINUX
-TEST(parseStatmRSSkB, standard_format)
+TEST(ParseStatmRSSkB, standard_format)
 {
     using xrpl::detail::parseStatmRSSkB;
 
@@ -121,7 +121,7 @@ TEST(parseStatmRSSkB, standard_format)
 }
 #endif
 
-TEST(mallocTrim, without_debug_logging)
+TEST(MallocTrim, without_debug_logging)
 {
     beast::Journal const journal{beast::Journal::getNullSink()};
 
@@ -144,7 +144,7 @@ TEST(mallocTrim, without_debug_logging)
 #endif
 }
 
-TEST(mallocTrim, empty_tag)
+TEST(MallocTrim, empty_tag)
 {
     beast::Journal const journal{beast::Journal::getNullSink()};
     MallocTrimReport const report = mallocTrim("", journal);
@@ -157,7 +157,7 @@ TEST(mallocTrim, empty_tag)
 #endif
 }
 
-TEST(mallocTrim, with_debug_logging)
+TEST(MallocTrim, with_debug_logging)
 {
     struct DebugSink : public beast::Journal::Sink
     {
@@ -194,7 +194,7 @@ TEST(mallocTrim, with_debug_logging)
 #endif
 }
 
-TEST(mallocTrim, repeated_calls)
+TEST(MallocTrim, repeated_calls)
 {
     beast::Journal const journal{beast::Journal::getNullSink()};
 
diff --git a/src/tests/libxrpl/basics/RangeSet.cpp b/src/tests/libxrpl/basics/RangeSet.cpp
index 44b13ad581..2e224c79f7 100644
--- a/src/tests/libxrpl/basics/RangeSet.cpp
+++ b/src/tests/libxrpl/basics/RangeSet.cpp
@@ -10,7 +10,7 @@
 
 using namespace xrpl;
 
-TEST(RangeSet, prevMissing)
+TEST(RangeSet, prev_missing)
 {
     // Set will include:
     // [ 0, 5]
@@ -36,7 +36,7 @@ TEST(RangeSet, prevMissing)
     }
 }
 
-TEST(RangeSet, toString)
+TEST(RangeSet, to_string)
 {
     RangeSet<std::uint32_t> set;
     EXPECT_EQ(to_string(set), "empty");
@@ -54,7 +54,7 @@ TEST(RangeSet, toString)
     EXPECT_EQ(to_string(set), "1-2,6");
 }
 
-TEST(RangeSet, fromString)
+TEST(RangeSet, from_string)
 {
     RangeSet<std::uint32_t> set;
 
diff --git a/src/tests/libxrpl/basics/StringUtilities.cpp b/src/tests/libxrpl/basics/StringUtilities.cpp
index 0180e25db0..1859de2cc1 100644
--- a/src/tests/libxrpl/basics/StringUtilities.cpp
+++ b/src/tests/libxrpl/basics/StringUtilities.cpp
@@ -290,7 +290,7 @@ TEST_F(StringUtilitiesTest, to_string)
     EXPECT_EQ(result, "hello");
 }
 
-TEST_F(StringUtilitiesTest, trimWhitespace)
+TEST_F(StringUtilitiesTest, trim_whitespace)
 {
     EXPECT_EQ(trimWhitespace(""), "");
     EXPECT_EQ(trimWhitespace("   "), "");
@@ -303,7 +303,7 @@ TEST_F(StringUtilitiesTest, trimWhitespace)
     EXPECT_EQ(trimWhitespace("  a b\tc  "), "a b\tc");
 }
 
-TEST_F(StringUtilitiesTest, toLower)
+TEST_F(StringUtilitiesTest, to_lower)
 {
     EXPECT_EQ(toLower(""), "");
     EXPECT_EQ(toLower("ABC"), "abc");
@@ -318,7 +318,7 @@ TEST_F(StringUtilitiesTest, toLower)
 // Both helpers are documented as depending only on their input. Guard that by
 // checking the bytes just outside ASCII, which a locale-aware isspace/tolower
 // could classify differently.
-TEST_F(StringUtilitiesTest, trimAndLowerIgnoreLocale)
+TEST_F(StringUtilitiesTest, trim_and_lower_ignore_locale)
 {
     // 0xA0 is NO-BREAK SPACE in Latin-1 and is whitespace to some locales.
     std::string const nbsp("\xA0", 1);
diff --git a/src/tests/libxrpl/basics/base64.cpp b/src/tests/libxrpl/basics/base64.cpp
index d26d23700a..c9f8331c98 100644
--- a/src/tests/libxrpl/basics/base64.cpp
+++ b/src/tests/libxrpl/basics/base64.cpp
@@ -14,7 +14,7 @@ check(std::string const& in, std::string const& out)
     EXPECT_EQ(base64Decode(encoded), in);
 }
 
-TEST(base64, base64)
+TEST(Base64, base64)
 {
     // cspell: disable
     check("", "");
diff --git a/src/tests/libxrpl/basics/base_uint.cpp b/src/tests/libxrpl/basics/base_uint.cpp
index 969705b5b7..4783820205 100644
--- a/src/tests/libxrpl/basics/base_uint.cpp
+++ b/src/tests/libxrpl/basics/base_uint.cpp
@@ -128,7 +128,7 @@ struct BaseUintTest : public ::testing::Test
 
 using BaseUintDeathTest = BaseUintTest;
 
-TEST_F(BaseUintDeathTest, fromRaw_size_mismatch)
+TEST_F(BaseUintDeathTest, from_raw_size_mismatch)
 {
     // ENABLE_VOIDSTAR is a debug build, but does not crash on failed asserts. Rather than twist
     // these tests into knots to make them work, just skip them.
diff --git a/src/tests/libxrpl/basics/contract.cpp b/src/tests/libxrpl/basics/contract.cpp
index 0c6b32a7ad..e9404da78b 100644
--- a/src/tests/libxrpl/basics/contract.cpp
+++ b/src/tests/libxrpl/basics/contract.cpp
@@ -6,7 +6,7 @@
 
 using namespace xrpl;
 
-TEST(contract, contract)
+TEST(Contract, contract)
 {
     try
     {
diff --git a/src/tests/libxrpl/basics/mulDiv.cpp b/src/tests/libxrpl/basics/mulDiv.cpp
index 725bef399e..cdc672a444 100644
--- a/src/tests/libxrpl/basics/mulDiv.cpp
+++ b/src/tests/libxrpl/basics/mulDiv.cpp
@@ -7,7 +7,7 @@
 
 using namespace xrpl;
 
-TEST(mulDiv, mulDiv)
+TEST(MulDiv, mul_div)
 {
     auto const max = std::numeric_limits<std::uint64_t>::max();
     std::uint64_t const max32 = std::numeric_limits<std::uint32_t>::max();
diff --git a/src/tests/libxrpl/basics/scope.cpp b/src/tests/libxrpl/basics/scope.cpp
index dc5623e967..71186d3d90 100644
--- a/src/tests/libxrpl/basics/scope.cpp
+++ b/src/tests/libxrpl/basics/scope.cpp
@@ -6,7 +6,7 @@
 
 using namespace xrpl;
 
-TEST(scope, ScopeExit)
+TEST(Scope, scope_exit)
 {
     // ScopeExit always executes the functor on destruction,
     // unless release() is called
@@ -56,7 +56,7 @@ TEST(scope, ScopeExit)
     EXPECT_EQ(i, 5);
 }
 
-TEST(scope, ScopeFail)
+TEST(Scope, scope_fail)
 {
     // ScopeFail executes the functor on destruction only
     // if an exception is unwinding, unless release() is called
@@ -106,7 +106,7 @@ TEST(scope, ScopeFail)
     EXPECT_EQ(i, 5);
 }
 
-TEST(scope, ScopeSuccess)
+TEST(Scope, scope_success)
 {
     // ScopeSuccess executes the functor on destruction only
     // if an exception is not unwinding, unless release() is called
diff --git a/src/tests/libxrpl/basics/tagged_integer.cpp b/src/tests/libxrpl/basics/tagged_integer.cpp
index 7382527d4d..dc553d4c0f 100644
--- a/src/tests/libxrpl/basics/tagged_integer.cpp
+++ b/src/tests/libxrpl/basics/tagged_integer.cpp
@@ -105,7 +105,7 @@ static_assert(
 
 using TagInt = TaggedInteger<std::int32_t, Tag1>;
 
-TEST(tagged_integer, comparison_operators)
+TEST(TaggedInteger, comparison_operators)
 {
     TagInt const zero(0);
     TagInt const one(1);
@@ -131,7 +131,7 @@ TEST(tagged_integer, comparison_operators)
     EXPECT_FALSE(one <= zero);
 }
 
-TEST(tagged_integer, increment_decrement_operators)
+TEST(TaggedInteger, increment_decrement_operators)
 {
     TagInt const zero(0);
     TagInt const one(1);
@@ -146,7 +146,7 @@ TEST(tagged_integer, increment_decrement_operators)
     EXPECT_EQ(a, zero);
 }
 
-TEST(tagged_integer, arithmetic_operators)
+TEST(TaggedInteger, arithmetic_operators)
 {
     TagInt const a{-2};
     EXPECT_EQ(+a, TagInt{-2});
@@ -166,7 +166,7 @@ TEST(tagged_integer, arithmetic_operators)
     EXPECT_EQ((TagInt{16} >> TagInt{2}), TagInt{4});
 }
 
-TEST(tagged_integer, assignment_operators)
+TEST(TaggedInteger, assignment_operators)
 {
     TagInt a{-2};
     TagInt b{0};
diff --git a/src/tests/libxrpl/crypto/csprng.cpp b/src/tests/libxrpl/crypto/csprng.cpp
index 957f7f5c56..71e20f2ddc 100644
--- a/src/tests/libxrpl/crypto/csprng.cpp
+++ b/src/tests/libxrpl/crypto/csprng.cpp
@@ -6,7 +6,7 @@
 
 using namespace xrpl;
 
-TEST(csprng, get_values)
+TEST(Csprng, get_values)
 {
     auto& engine = cryptoPrng();
     auto randVal = engine();
diff --git a/src/tests/libxrpl/json/Value.cpp b/src/tests/libxrpl/json/Value.cpp
index a58a5df9fd..1aa0756419 100644
--- a/src/tests/libxrpl/json/Value.cpp
+++ b/src/tests/libxrpl/json/Value.cpp
@@ -21,7 +21,7 @@
 
 namespace xrpl {
 
-TEST(json_value, limits)
+TEST(JsonValue, limits)
 {
     using namespace json;
     static_assert(Value::kMinInt == Int(~(UInt(-1) / 2)));
@@ -29,7 +29,7 @@ TEST(json_value, limits)
     static_assert(Value::kMaxUInt == UInt(-1));
 }
 
-TEST(json_value, construct_and_compare_Json_StaticString)
+TEST(JsonValue, construct_and_compare_json_static_string)
 {
     static constexpr char kSample[]{"Contents of a json::StaticString"};
 
@@ -52,7 +52,7 @@ TEST(json_value, construct_and_compare_Json_StaticString)
     EXPECT_NE(kTest3, str);
 }
 
-TEST(json_value, different_types)
+TEST(JsonValue, different_types)
 {
     // Exercise ValueType constructor
     static constexpr json::StaticString kStaticStr{"staticStr"};
@@ -206,7 +206,7 @@ TEST(json_value, different_types)
     }
 }
 
-TEST(json_value, compare_strings)
+TEST(JsonValue, compare_strings)
 {
     auto doCompare = [&](json::Value const& lhs,
                          json::Value const& rhs,
@@ -560,7 +560,7 @@ TEST(json_value, compare_strings)
 #pragma pop_macro("DO_COMPARE")
 }
 
-TEST(json_value, bool)
+TEST(JsonValue, bool)
 {
     EXPECT_FALSE(json::Value());
 
@@ -583,7 +583,7 @@ TEST(json_value, bool)
     EXPECT_TRUE(bool(object));
 }
 
-TEST(json_value, bad_json)
+TEST(JsonValue, bad_json)
 {
     char const* s(R"({"method":"ledger","params":[{"ledger_index":1e300}]})");
 
@@ -607,7 +607,7 @@ parseValue(std::string const& doc)
 
 }  // namespace
 
-TEST(json_value, parse_double_valid)
+TEST(JsonValue, parse_double_valid)
 {
     // 1e300 is large but still representable, so it parses (unlike the out-of-range cases below).
     for (auto const& [text, expected] :
@@ -627,14 +627,14 @@ TEST(json_value, parse_double_valid)
     }
 }
 
-TEST(json_value, parse_double_out_of_range)
+TEST(JsonValue, parse_double_out_of_range)
 {
     // Magnitudes with no finite double representation are rejected.
     for (char const* oor : {"1e400", "-1e400", "0.001e500", "1e-400", "-1e-400", "123e-500"})
         EXPECT_FALSE(parseValue(oor).has_value()) << oor;
 }
 
-TEST(json_value, parse_double_malformed)
+TEST(JsonValue, parse_double_malformed)
 {
     // readNumber() collects any run of digits and '.eE+-' into a single Double
     // token, so these malformed tokens reach decodeDouble. Each has a valid
@@ -644,7 +644,7 @@ TEST(json_value, parse_double_malformed)
         EXPECT_FALSE(parseValue(bad).has_value()) << bad;
 }
 
-TEST(json_value, edge_cases)
+TEST(JsonValue, edge_cases)
 {
     std::uint32_t const maxUInt = std::numeric_limits<std::uint32_t>::max();
     std::int32_t const maxInt = std::numeric_limits<std::int32_t>::max();
@@ -791,7 +791,7 @@ TEST(json_value, edge_cases)
     }
 }
 
-TEST(json_value, copy)
+TEST(JsonValue, copy)
 {
     json::Value v1{2.5};
     EXPECT_TRUE(v1.isDouble());
@@ -812,7 +812,7 @@ TEST(json_value, copy)
     EXPECT_EQ(v1, v2);
 }
 
-TEST(json_value, move)
+TEST(JsonValue, move)
 {
     json::Value v1{2.5};
     EXPECT_TRUE(v1.isDouble());
@@ -831,7 +831,7 @@ TEST(json_value, move)
     EXPECT_NE(v1, v2);  // NOLINT(bugprone-use-after-move)
 }
 
-TEST(json_value, comparisons)
+TEST(JsonValue, comparisons)
 {
     json::Value a, b;
     auto testEquals = [&](std::string const& name) {
@@ -886,7 +886,7 @@ TEST(json_value, comparisons)
     testGreaterThan("big");
 }
 
-TEST(json_value, compact)
+TEST(JsonValue, compact)
 {
     json::Value j;
     json::Reader r;
@@ -909,7 +909,7 @@ TEST(json_value, compact)
     }
 }
 
-TEST(json_value, conversions)
+TEST(JsonValue, conversions)
 {
     // We have json::ValueType::Real but json::Value::asDouble.
     // TODO: What's the thinking here?
@@ -1125,7 +1125,7 @@ TEST(json_value, conversions)
     }
 }
 
-TEST(json_value, access_members)
+TEST(JsonValue, access_members)
 {
     json::Value val;
     EXPECT_EQ(val.type(), json::ValueType::Null);
@@ -1218,7 +1218,7 @@ TEST(json_value, access_members)
     }
 }
 
-TEST(json_value, remove_members)
+TEST(JsonValue, remove_members)
 {
     json::Value val;
     EXPECT_EQ(val.removeMember(std::string("member")).type(), json::ValueType::Null);
@@ -1245,7 +1245,7 @@ TEST(json_value, remove_members)
     EXPECT_EQ(val.size(), 0);
 }
 
-TEST(json_value, iterator)
+TEST(JsonValue, iterator)
 {
     {
         // Iterating an array.
@@ -1331,7 +1331,7 @@ TEST(json_value, iterator)
     }
 }
 
-TEST(json_value, nest_limits)
+TEST(JsonValue, nest_limits)
 {
     json::Reader r;
     {
@@ -1377,7 +1377,7 @@ TEST(json_value, nest_limits)
     }
 }
 
-TEST(json_value, memory_leak)
+TEST(JsonValue, memory_leak)
 {
     // When run with the address sanitizer, this test confirms there is no
     // memory leak with the scenarios below.
diff --git a/src/tests/libxrpl/ledger/AMMEntry.cpp b/src/tests/libxrpl/ledger/AMMEntry.cpp
new file mode 100644
index 0000000000..6013d0f38f
--- /dev/null
+++ b/src/tests/libxrpl/ledger/AMMEntry.cpp
@@ -0,0 +1,25 @@
+#include <xrpl/ledger/entries/AMMEntry.h>
+
+#include <xrpl/protocol/Asset.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/Issue.h>
+
+#include <gtest/gtest.h>
+#include <helpers/IOU.h>
+#include <ledger/EntryTestHelpers.h>
+
+namespace xrpl::test {
+
+TEST(AMMEntryTests, constructors)
+{
+    EntryTestEnv e;
+
+    Asset const xrp{xrpIssue()};
+    Asset const usd{IOU("USD", e.alice).issue()};
+
+    expectKeylet<AMMEntry>(e, keylet::amm(xrp, usd), "amm(asset, asset)", xrp, usd);
+
+    expectKeylet<AMMEntry>(e, keylet::amm(e.someID()), "amm(uint256)", e.someID());
+}
+
+}  // namespace xrpl::test
diff --git a/src/tests/libxrpl/ledger/AccountRootEntry.cpp b/src/tests/libxrpl/ledger/AccountRootEntry.cpp
new file mode 100644
index 0000000000..4c8f18337e
--- /dev/null
+++ b/src/tests/libxrpl/ledger/AccountRootEntry.cpp
@@ -0,0 +1,21 @@
+#include <xrpl/ledger/entries/AccountRootEntry.h>
+
+#include <xrpl/protocol/Indexes.h>
+
+#include <gtest/gtest.h>
+#include <helpers/Account.h>
+#include <ledger/EntryTestHelpers.h>
+
+namespace xrpl::test {
+
+TEST(AccountRootEntryTests, constructors)
+{
+    EntryTestEnv e;
+
+    expectKeylet<AccountRootEntry>(e, keylet::account(e.alice.id()), "account(id)", e.alice.id());
+
+    expectKeylet<AccountRootEntry>(
+        e, keylet::account(Account("nobody").id()), "account(id) absent", Account("nobody").id());
+}
+
+}  // namespace xrpl::test
diff --git a/src/tests/libxrpl/ledger/AmendmentsEntry.cpp b/src/tests/libxrpl/ledger/AmendmentsEntry.cpp
new file mode 100644
index 0000000000..3f296759f3
--- /dev/null
+++ b/src/tests/libxrpl/ledger/AmendmentsEntry.cpp
@@ -0,0 +1,17 @@
+#include <xrpl/ledger/entries/AmendmentsEntry.h>
+
+#include <xrpl/protocol/Indexes.h>
+
+#include <gtest/gtest.h>
+#include <ledger/EntryTestHelpers.h>
+
+namespace xrpl::test {
+
+TEST(AmendmentsEntryTests, constructors)
+{
+    EntryTestEnv e;
+
+    expectKeylet<AmendmentsEntry>(e, keylet::amendments(), "amendments()");
+}
+
+}  // namespace xrpl::test
diff --git a/src/tests/libxrpl/ledger/BridgeEntry.cpp b/src/tests/libxrpl/ledger/BridgeEntry.cpp
new file mode 100644
index 0000000000..6e6a4394f8
--- /dev/null
+++ b/src/tests/libxrpl/ledger/BridgeEntry.cpp
@@ -0,0 +1,41 @@
+#include <xrpl/ledger/entries/BridgeEntry.h>
+
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/Issue.h>
+#include <xrpl/protocol/Keylet.h>
+#include <xrpl/protocol/STXChainBridge.h>
+
+#include <gtest/gtest.h>
+#include <helpers/IOU.h>
+#include <ledger/EntryTestHelpers.h>
+
+namespace xrpl::test {
+
+TEST(BridgeEntryTests, constructors)
+{
+    EntryTestEnv e;
+
+    STXChainBridge const bridge{e.alice.id(), xrpIssue(), e.bob.id(), IOU("USD", e.bob).issue()};
+
+    expectKeylet<BridgeEntry>(
+        e,
+        keylet::bridge(bridge, STXChainBridge::ChainType::Locking),
+        "bridge(bridge, Locking)",
+        bridge,
+        STXChainBridge::ChainType::Locking);
+
+    expectKeylet<BridgeEntry>(
+        e,
+        keylet::bridge(bridge, STXChainBridge::ChainType::Issuing),
+        "bridge(bridge, Issuing)",
+        bridge,
+        STXChainBridge::ChainType::Issuing);
+
+    // The two chain types must not collide, or the assertions above would
+    // pass with chainType ignored entirely.
+    EXPECT_NE(
+        keylet::bridge(bridge, STXChainBridge::ChainType::Locking).key,
+        keylet::bridge(bridge, STXChainBridge::ChainType::Issuing).key);
+}
+
+}  // namespace xrpl::test
diff --git a/src/tests/libxrpl/ledger/CheckEntry.cpp b/src/tests/libxrpl/ledger/CheckEntry.cpp
new file mode 100644
index 0000000000..58f6250b20
--- /dev/null
+++ b/src/tests/libxrpl/ledger/CheckEntry.cpp
@@ -0,0 +1,23 @@
+#include <xrpl/ledger/entries/CheckEntry.h>
+
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/SeqProxy.h>
+
+#include <gtest/gtest.h>
+#include <ledger/EntryTestHelpers.h>
+
+namespace xrpl::test {
+
+TEST(CheckEntryTests, constructors)
+{
+    EntryTestEnv e;
+
+    SeqProxy const seq = SeqProxy::rawSequence(7);
+
+    expectKeylet<CheckEntry>(
+        e, keylet::check(e.alice.id(), seq), "check(id, seq)", e.alice.id(), seq);
+
+    expectKeylet<CheckEntry>(e, keylet::check(e.someID()), "check(uint256)", e.someID());
+}
+
+}  // namespace xrpl::test
diff --git a/src/tests/libxrpl/ledger/CredentialEntry.cpp b/src/tests/libxrpl/ledger/CredentialEntry.cpp
new file mode 100644
index 0000000000..16b877858b
--- /dev/null
+++ b/src/tests/libxrpl/ledger/CredentialEntry.cpp
@@ -0,0 +1,39 @@
+#include <xrpl/ledger/entries/CredentialEntry.h>
+
+#include <xrpl/basics/Slice.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/Keylet.h>
+
+#include <gtest/gtest.h>
+#include <ledger/EntryTestHelpers.h>
+
+#include <string>
+
+namespace xrpl::test {
+
+TEST(CredentialEntryTests, constructors)
+{
+    EntryTestEnv e;
+
+    std::string const credTypeStr = "termsandconditions";
+    Slice const credType = makeSlice(credTypeStr);
+
+    expectKeylet<CredentialEntry>(
+        e,
+        keylet::credential(e.alice.id(), e.bob.id(), credType),
+        "credential(subject, issuer, credType)",
+        e.alice.id(),
+        e.bob.id(),
+        credType);
+
+    expectKeylet<CredentialEntry>(
+        e, keylet::credential(e.someID()), "credential(uint256)", e.someID());
+
+    // Subject and issuer are both AccountIDs, so the assertion above only
+    // has teeth if their order matters.
+    EXPECT_NE(
+        keylet::credential(e.alice.id(), e.bob.id(), credType).key,
+        keylet::credential(e.bob.id(), e.alice.id(), credType).key);
+}
+
+}  // namespace xrpl::test
diff --git a/src/tests/libxrpl/ledger/DIDEntry.cpp b/src/tests/libxrpl/ledger/DIDEntry.cpp
new file mode 100644
index 0000000000..ff0017caad
--- /dev/null
+++ b/src/tests/libxrpl/ledger/DIDEntry.cpp
@@ -0,0 +1,17 @@
+#include <xrpl/ledger/entries/DIDEntry.h>
+
+#include <xrpl/protocol/Indexes.h>
+
+#include <gtest/gtest.h>
+#include <ledger/EntryTestHelpers.h>
+
+namespace xrpl::test {
+
+TEST(DIDEntryTests, constructors)
+{
+    EntryTestEnv e;
+
+    expectKeylet<DIDEntry>(e, keylet::did(e.alice.id()), "did(account)", e.alice.id());
+}
+
+}  // namespace xrpl::test
diff --git a/src/tests/libxrpl/ledger/DelegateEntry.cpp b/src/tests/libxrpl/ledger/DelegateEntry.cpp
new file mode 100644
index 0000000000..3ffc3c73ed
--- /dev/null
+++ b/src/tests/libxrpl/ledger/DelegateEntry.cpp
@@ -0,0 +1,29 @@
+#include <xrpl/ledger/entries/DelegateEntry.h>
+
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/Keylet.h>
+
+#include <gtest/gtest.h>
+#include <ledger/EntryTestHelpers.h>
+
+namespace xrpl::test {
+
+TEST(DelegateEntryTests, constructors)
+{
+    EntryTestEnv e;
+
+    expectKeylet<DelegateEntry>(
+        e,
+        keylet::delegate(e.alice.id(), e.bob.id()),
+        "delegate(account, authorizedAccount)",
+        e.alice.id(),
+        e.bob.id());
+
+    // Both arguments are AccountIDs, so the assertion above only has teeth
+    // if their order matters.
+    EXPECT_NE(
+        keylet::delegate(e.alice.id(), e.bob.id()).key,
+        keylet::delegate(e.bob.id(), e.alice.id()).key);
+}
+
+}  // namespace xrpl::test
diff --git a/src/tests/libxrpl/ledger/DepositPreauthEntry.cpp b/src/tests/libxrpl/ledger/DepositPreauthEntry.cpp
new file mode 100644
index 0000000000..115baa741d
--- /dev/null
+++ b/src/tests/libxrpl/ledger/DepositPreauthEntry.cpp
@@ -0,0 +1,54 @@
+#include <xrpl/ledger/entries/DepositPreauthEntry.h>
+
+#include <xrpl/basics/Slice.h>
+#include <xrpl/protocol/AccountID.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/Keylet.h>
+
+#include <gtest/gtest.h>
+#include <ledger/EntryTestHelpers.h>
+
+#include <set>
+#include <string>
+#include <utility>
+
+namespace xrpl::test {
+
+TEST(DepositPreauthEntryTests, constructors)
+{
+    EntryTestEnv e;
+
+    std::string const credTypeStr = "termsandconditions";
+    std::set<std::pair<AccountID, Slice>> const authCreds{{e.bob.id(), makeSlice(credTypeStr)}};
+
+    expectKeylet<DepositPreauthEntry>(
+        e,
+        keylet::depositPreauth(e.alice.id(), e.bob.id()),
+        "depositPreauth(owner, preauthorized)",
+        e.alice.id(),
+        e.bob.id());
+
+    expectKeylet<DepositPreauthEntry>(
+        e,
+        keylet::depositPreauth(e.alice.id(), authCreds),
+        "depositPreauth(owner, authCreds)",
+        e.alice.id(),
+        authCreds);
+
+    expectKeylet<DepositPreauthEntry>(
+        e, keylet::depositPreauth(e.someID()), "depositPreauth(uint256)", e.someID());
+
+    // Owner and preauthorized are both AccountIDs, so the assertion above
+    // only has teeth if their order matters.
+    EXPECT_NE(
+        keylet::depositPreauth(e.alice.id(), e.bob.id()).key,
+        keylet::depositPreauth(e.bob.id(), e.alice.id()).key);
+
+    // The credential-set overload must not collide with the single-account
+    // one.
+    EXPECT_NE(
+        keylet::depositPreauth(e.alice.id(), authCreds).key,
+        keylet::depositPreauth(e.alice.id(), e.bob.id()).key);
+}
+
+}  // namespace xrpl::test
diff --git a/src/tests/libxrpl/ledger/DirectoryNodeEntry.cpp b/src/tests/libxrpl/ledger/DirectoryNodeEntry.cpp
new file mode 100644
index 0000000000..41349ea427
--- /dev/null
+++ b/src/tests/libxrpl/ledger/DirectoryNodeEntry.cpp
@@ -0,0 +1,28 @@
+#include <xrpl/ledger/entries/DirectoryNodeEntry.h>
+
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/Keylet.h>
+
+#include <gtest/gtest.h>
+#include <ledger/EntryTestHelpers.h>
+
+#include <cstdint>
+
+namespace xrpl::test {
+
+TEST(DirectoryNodeEntryTests, constructors)
+{
+    EntryTestEnv e;
+
+    expectKeylet<DirectoryNodeEntry>(
+        e, keylet::ownerDir(e.alice.id()), "ownerDir(id)", e.alice.id());
+
+    expectKeylet<DirectoryNodeEntry>(
+        e, keylet::page(e.someID(), 3u), "page(root, index)", e.someID(), std::uint64_t{3});
+
+    // The two overloads reach different keylet:: functions; a copy-paste
+    // slip between them would be invisible otherwise.
+    EXPECT_NE(keylet::ownerDir(e.alice.id()).key, keylet::page(e.someID(), 3u).key);
+}
+
+}  // namespace xrpl::test
diff --git a/src/tests/libxrpl/ledger/EntryTestHelpers.h b/src/tests/libxrpl/ledger/EntryTestHelpers.h
new file mode 100644
index 0000000000..d98b40795e
--- /dev/null
+++ b/src/tests/libxrpl/ledger/EntryTestHelpers.h
@@ -0,0 +1,123 @@
+#pragma once
+
+#include <xrpl/basics/base_uint.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/ApplyViewImpl.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/protocol/Keylet.h>
+#include <xrpl/protocol/LedgerHeader.h>
+
+#include <gtest/gtest.h>
+#include <helpers/Account.h>
+#include <helpers/TxTest.h>
+
+#include <string>
+
+namespace xrpl::test {
+
+/**
+ * Scaffolding shared by the per-entry-type suites.
+ *
+ * Each of those suites needs the same three things: a ledger with a few funded
+ * accounts, a throwaway ApplyView that is never applied, and some arbitrary
+ * uint256 to stand in for an object ID. Build one of these per test case --
+ * TxTest construction dominates the runtime of these tests by a wide margin,
+ * and none of the assertions mutate the ledger.
+ */
+class EntryTestEnv
+{
+public:
+    TxTest env;
+    Account const alice{"alice"};
+    Account const bob{"bob"};
+    Account const carol{"carol"};
+
+    EntryTestEnv() : av_(&fundAndClose(), TapNone)
+    {
+    }
+
+    /**
+     * The closed ledger apply() was built over. Nothing here closes another
+     * ledger or submits a transaction afterward, so this and apply() never
+     * diverge.
+     */
+    [[nodiscard]] ReadView const&
+    read() const
+    {
+        return env.getClosedLedger();
+    }
+
+    [[nodiscard]] ApplyView&
+    apply()
+    {
+        return av_;
+    }
+
+    /**
+     * An arbitrary but stable uint256, for the entry constructors that take
+     * an object ID directly. Nothing in the ledger has this key, which is the
+     * point: those overloads should resolve to a non-existent entry.
+     */
+    [[nodiscard]] uint256
+    someID() const
+    {
+        return read().header().parentHash;
+    }
+
+private:
+    // Runs from the av_ member initializer, so it may only touch env and the
+    // accounts -- everything declared above av_.
+    ReadView const&
+    fundAndClose()
+    {
+        env.createAccount(alice, XRP(10'000));
+        env.createAccount(bob, XRP(10'000));
+        env.createAccount(carol, XRP(10'000));
+        env.close();
+        return env.getClosedLedger();
+    }
+
+    ApplyViewImpl av_;
+};
+
+/**
+ * Assert that both flavors of @p Entry built from @p args resolve the ledger
+ * object that @p expected names.
+ *
+ * The entry classes are near identical, so the defect they invite is a
+ * copy-paste one: a constructor that reaches the wrong keylet:: function, or
+ * that transposes two same-typed arguments. Comparing against an independently
+ * spelled-out keylet at the call site catches exactly that.
+ *
+ * @p what names the overload under test, so a failure says which one broke.
+ */
+template <template <typename> class Entry, typename... Args>
+void
+expectKeylet(EntryTestEnv& e, Keylet const& expected, std::string const& what, Args const&... args)
+{
+    bool const present = e.read().read(expected) != nullptr;
+
+    // The writable entry retains its keylet, so it can be inspected whether
+    // or not the entry exists.
+    Entry<ApplyView> const w(args..., e.apply());
+    EXPECT_EQ(w.keylet().key, expected.key) << what << ": writable key";
+    EXPECT_EQ(w.keylet().type, expected.type) << what << ": writable type";
+    EXPECT_EQ(w.exists(), present) << what << ": writable exists";
+
+    // The read-only entry has no keylet of its own -- it derives one from the
+    // SLE, and only when the SLE exists. Its agreement with a direct read
+    // of the expected keylet is what shows it resolved the same key.
+    Entry<ReadView> const r(args..., e.read());
+    EXPECT_EQ(r.exists(), present) << what << ": read-only exists";
+    if (present)
+    {
+        EXPECT_EQ(r.key(), expected.key) << what << ": read-only key";
+    }
+
+    // Not r.type(): for a typed entry that returns kEntryType, so checking it
+    // would just be this same assertion spelled twice.
+    static_assert(Entry<ReadView>::kEntryType == Entry<ApplyView>::kEntryType);
+    EXPECT_EQ(Entry<ReadView>::kEntryType, expected.type) << what << ": kEntryType";
+}
+
+}  // namespace xrpl::test
diff --git a/src/tests/libxrpl/ledger/EscrowEntry.cpp b/src/tests/libxrpl/ledger/EscrowEntry.cpp
new file mode 100644
index 0000000000..2430589641
--- /dev/null
+++ b/src/tests/libxrpl/ledger/EscrowEntry.cpp
@@ -0,0 +1,21 @@
+#include <xrpl/ledger/entries/EscrowEntry.h>
+
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/SeqProxy.h>
+
+#include <gtest/gtest.h>
+#include <ledger/EntryTestHelpers.h>
+
+namespace xrpl::test {
+
+TEST(EscrowEntryTests, constructors)
+{
+    EntryTestEnv e;
+
+    SeqProxy const seq = SeqProxy::rawSequence(11);
+
+    expectKeylet<EscrowEntry>(
+        e, keylet::escrow(e.alice.id(), seq), "escrow(src, seq)", e.alice.id(), seq);
+}
+
+}  // namespace xrpl::test
diff --git a/src/tests/libxrpl/ledger/FeeSettingsEntry.cpp b/src/tests/libxrpl/ledger/FeeSettingsEntry.cpp
new file mode 100644
index 0000000000..b7b8325736
--- /dev/null
+++ b/src/tests/libxrpl/ledger/FeeSettingsEntry.cpp
@@ -0,0 +1,17 @@
+#include <xrpl/ledger/entries/FeeSettingsEntry.h>
+
+#include <xrpl/protocol/Indexes.h>
+
+#include <gtest/gtest.h>
+#include <ledger/EntryTestHelpers.h>
+
+namespace xrpl::test {
+
+TEST(FeeSettingsEntryTests, constructors)
+{
+    EntryTestEnv e;
+
+    expectKeylet<FeeSettingsEntry>(e, keylet::feeSettings(), "feeSettings()");
+}
+
+}  // namespace xrpl::test
diff --git a/src/tests/libxrpl/ledger/LedgerHashesEntry.cpp b/src/tests/libxrpl/ledger/LedgerHashesEntry.cpp
new file mode 100644
index 0000000000..94cb6b1db6
--- /dev/null
+++ b/src/tests/libxrpl/ledger/LedgerHashesEntry.cpp
@@ -0,0 +1,17 @@
+#include <xrpl/ledger/entries/LedgerHashesEntry.h>
+
+#include <xrpl/protocol/Indexes.h>
+
+#include <gtest/gtest.h>
+#include <ledger/EntryTestHelpers.h>
+
+namespace xrpl::test {
+
+TEST(LedgerHashesEntryTests, constructors)
+{
+    EntryTestEnv e;
+
+    expectKeylet<LedgerHashesEntry>(e, keylet::skip(), "skip()");
+}
+
+}  // namespace xrpl::test
diff --git a/src/tests/libxrpl/ledger/LoanBrokerEntry.cpp b/src/tests/libxrpl/ledger/LoanBrokerEntry.cpp
new file mode 100644
index 0000000000..ab0ced00c0
--- /dev/null
+++ b/src/tests/libxrpl/ledger/LoanBrokerEntry.cpp
@@ -0,0 +1,24 @@
+#include <xrpl/ledger/entries/LoanBrokerEntry.h>
+
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/SeqProxy.h>
+
+#include <gtest/gtest.h>
+#include <ledger/EntryTestHelpers.h>
+
+namespace xrpl::test {
+
+TEST(LoanBrokerEntryTests, constructors)
+{
+    EntryTestEnv e;
+
+    SeqProxy const seq = SeqProxy::rawSequence(5);
+
+    expectKeylet<LoanBrokerEntry>(
+        e, keylet::loanBroker(e.alice.id(), seq), "loanBroker(owner, seq)", e.alice.id(), seq);
+
+    expectKeylet<LoanBrokerEntry>(
+        e, keylet::loanBroker(e.someID()), "loanBroker(uint256)", e.someID());
+}
+
+}  // namespace xrpl::test
diff --git a/src/tests/libxrpl/ledger/LoanEntry.cpp b/src/tests/libxrpl/ledger/LoanEntry.cpp
new file mode 100644
index 0000000000..23bc03bc0c
--- /dev/null
+++ b/src/tests/libxrpl/ledger/LoanEntry.cpp
@@ -0,0 +1,29 @@
+#include <xrpl/ledger/entries/LoanEntry.h>
+
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/Keylet.h>
+#include <xrpl/protocol/SeqProxy.h>
+
+#include <gtest/gtest.h>
+#include <ledger/EntryTestHelpers.h>
+
+namespace xrpl::test {
+
+TEST(LoanEntryTests, constructors)
+{
+    EntryTestEnv e;
+
+    SeqProxy const seq = SeqProxy::rawSequence(9);
+
+    expectKeylet<LoanEntry>(
+        e, keylet::loan(e.someID(), seq), "loan(loanBrokerID, loanSeq)", e.someID(), seq);
+
+    expectKeylet<LoanEntry>(e, keylet::loan(e.someID()), "loan(uint256)", e.someID());
+
+    // Both overloads start with the same uint256, so they must not produce
+    // the same key -- otherwise arity is the only thing keeping them apart
+    // and the test proves nothing.
+    EXPECT_NE(keylet::loan(e.someID(), seq).key, keylet::loan(e.someID()).key);
+}
+
+}  // namespace xrpl::test
diff --git a/src/tests/libxrpl/ledger/MPTokenEntry.cpp b/src/tests/libxrpl/ledger/MPTokenEntry.cpp
new file mode 100644
index 0000000000..fe89555c7e
--- /dev/null
+++ b/src/tests/libxrpl/ledger/MPTokenEntry.cpp
@@ -0,0 +1,34 @@
+#include <xrpl/ledger/entries/MPTokenEntry.h>
+
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/UintTypes.h>
+
+#include <gtest/gtest.h>
+#include <ledger/EntryTestHelpers.h>
+
+namespace xrpl::test {
+
+TEST(MPTokenEntryTests, constructors)
+{
+    EntryTestEnv e;
+
+    MPTID const issuanceID = makeMptID(1, e.alice.id());
+
+    expectKeylet<MPTokenEntry>(
+        e,
+        keylet::mptoken(issuanceID, e.bob.id()),
+        "mptoken(MPTID, holder)",
+        issuanceID,
+        e.bob.id());
+
+    expectKeylet<MPTokenEntry>(
+        e,
+        keylet::mptoken(e.someID(), e.bob.id()),
+        "mptoken(issuanceKey, holder)",
+        e.someID(),
+        e.bob.id());
+
+    expectKeylet<MPTokenEntry>(e, keylet::mptoken(e.someID()), "mptoken(uint256)", e.someID());
+}
+
+}  // namespace xrpl::test
diff --git a/src/tests/libxrpl/ledger/MPTokenIssuanceEntry.cpp b/src/tests/libxrpl/ledger/MPTokenIssuanceEntry.cpp
new file mode 100644
index 0000000000..825f75debe
--- /dev/null
+++ b/src/tests/libxrpl/ledger/MPTokenIssuanceEntry.cpp
@@ -0,0 +1,33 @@
+#include <xrpl/ledger/entries/MPTokenIssuanceEntry.h>
+
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/UintTypes.h>
+
+#include <gtest/gtest.h>
+#include <ledger/EntryTestHelpers.h>
+
+#include <cstdint>
+
+namespace xrpl::test {
+
+TEST(MPTokenIssuanceEntryTests, constructors)
+{
+    EntryTestEnv e;
+
+    MPTID const issuanceID = makeMptID(1, e.alice.id());
+
+    expectKeylet<MPTokenIssuanceEntry>(
+        e,
+        keylet::mptokenIssuance(makeMptID(1, e.alice.id())),
+        "mptokenIssuance(seq, issuer)",
+        std::uint32_t{1},
+        e.alice.id());
+
+    expectKeylet<MPTokenIssuanceEntry>(
+        e, keylet::mptokenIssuance(issuanceID), "mptokenIssuance(MPTID)", issuanceID);
+
+    expectKeylet<MPTokenIssuanceEntry>(
+        e, keylet::mptokenIssuance(e.someID()), "mptokenIssuance(uint256)", e.someID());
+}
+
+}  // namespace xrpl::test
diff --git a/src/tests/libxrpl/ledger/NFTokenOfferEntry.cpp b/src/tests/libxrpl/ledger/NFTokenOfferEntry.cpp
new file mode 100644
index 0000000000..2ad676e220
--- /dev/null
+++ b/src/tests/libxrpl/ledger/NFTokenOfferEntry.cpp
@@ -0,0 +1,24 @@
+#include <xrpl/ledger/entries/NFTokenOfferEntry.h>
+
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/SeqProxy.h>
+
+#include <gtest/gtest.h>
+#include <ledger/EntryTestHelpers.h>
+
+namespace xrpl::test {
+
+TEST(NFTokenOfferEntryTests, constructors)
+{
+    EntryTestEnv e;
+
+    SeqProxy const seq = SeqProxy::rawSequence(13);
+
+    expectKeylet<NFTokenOfferEntry>(
+        e, keylet::nftokenOffer(e.alice.id(), seq), "nftokenOffer(owner, seq)", e.alice.id(), seq);
+
+    expectKeylet<NFTokenOfferEntry>(
+        e, keylet::nftokenOffer(e.someID()), "nftokenOffer(uint256)", e.someID());
+}
+
+}  // namespace xrpl::test
diff --git a/src/tests/libxrpl/ledger/NFTokenPageEntry.cpp b/src/tests/libxrpl/ledger/NFTokenPageEntry.cpp
new file mode 100644
index 0000000000..e392cc52af
--- /dev/null
+++ b/src/tests/libxrpl/ledger/NFTokenPageEntry.cpp
@@ -0,0 +1,25 @@
+#include <xrpl/ledger/entries/NFTokenPageEntry.h>
+
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/Keylet.h>
+
+#include <gtest/gtest.h>
+#include <ledger/EntryTestHelpers.h>
+
+namespace xrpl::test {
+
+TEST(NFTokenPageEntryTests, constructors)
+{
+    EntryTestEnv e;
+
+    Keylet const pageMin = keylet::nftokenPageMin(e.alice.id());
+
+    expectKeylet<NFTokenPageEntry>(
+        e,
+        keylet::nftokenPage(pageMin, e.someID()),
+        "nftokenPage(page, token)",
+        pageMin,
+        e.someID());
+}
+
+}  // namespace xrpl::test
diff --git a/src/tests/libxrpl/ledger/NegativeUNLEntry.cpp b/src/tests/libxrpl/ledger/NegativeUNLEntry.cpp
new file mode 100644
index 0000000000..6a15578b3e
--- /dev/null
+++ b/src/tests/libxrpl/ledger/NegativeUNLEntry.cpp
@@ -0,0 +1,17 @@
+#include <xrpl/ledger/entries/NegativeUNLEntry.h>
+
+#include <xrpl/protocol/Indexes.h>
+
+#include <gtest/gtest.h>
+#include <ledger/EntryTestHelpers.h>
+
+namespace xrpl::test {
+
+TEST(NegativeUNLEntryTests, constructors)
+{
+    EntryTestEnv e;
+
+    expectKeylet<NegativeUNLEntry>(e, keylet::negativeUNL(), "negativeUNL()");
+}
+
+}  // namespace xrpl::test
diff --git a/src/tests/libxrpl/ledger/OfferEntry.cpp b/src/tests/libxrpl/ledger/OfferEntry.cpp
new file mode 100644
index 0000000000..17f98b69c2
--- /dev/null
+++ b/src/tests/libxrpl/ledger/OfferEntry.cpp
@@ -0,0 +1,23 @@
+#include <xrpl/ledger/entries/OfferEntry.h>
+
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/SeqProxy.h>
+
+#include <gtest/gtest.h>
+#include <ledger/EntryTestHelpers.h>
+
+namespace xrpl::test {
+
+TEST(OfferEntryTests, constructors)
+{
+    EntryTestEnv e;
+
+    SeqProxy const seq = SeqProxy::rawSequence(3);
+
+    expectKeylet<OfferEntry>(
+        e, keylet::offer(e.alice.id(), seq), "offer(id, seq)", e.alice.id(), seq);
+
+    expectKeylet<OfferEntry>(e, keylet::offer(e.someID()), "offer(uint256)", e.someID());
+}
+
+}  // namespace xrpl::test
diff --git a/src/tests/libxrpl/ledger/OracleEntry.cpp b/src/tests/libxrpl/ledger/OracleEntry.cpp
new file mode 100644
index 0000000000..f467056c1e
--- /dev/null
+++ b/src/tests/libxrpl/ledger/OracleEntry.cpp
@@ -0,0 +1,24 @@
+#include <xrpl/ledger/entries/OracleEntry.h>
+
+#include <xrpl/protocol/Indexes.h>
+
+#include <gtest/gtest.h>
+#include <ledger/EntryTestHelpers.h>
+
+#include <cstdint>
+
+namespace xrpl::test {
+
+TEST(OracleEntryTests, constructors)
+{
+    EntryTestEnv e;
+
+    expectKeylet<OracleEntry>(
+        e,
+        keylet::oracle(e.alice.id(), 7u),
+        "oracle(account, documentID)",
+        e.alice.id(),
+        std::uint32_t{7});
+}
+
+}  // namespace xrpl::test
diff --git a/src/tests/libxrpl/ledger/PayChannelEntry.cpp b/src/tests/libxrpl/ledger/PayChannelEntry.cpp
new file mode 100644
index 0000000000..82dcdb3be8
--- /dev/null
+++ b/src/tests/libxrpl/ledger/PayChannelEntry.cpp
@@ -0,0 +1,33 @@
+#include <xrpl/ledger/entries/PayChannelEntry.h>
+
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/Keylet.h>
+#include <xrpl/protocol/SeqProxy.h>
+
+#include <gtest/gtest.h>
+#include <ledger/EntryTestHelpers.h>
+
+namespace xrpl::test {
+
+TEST(PayChannelEntryTests, constructors)
+{
+    EntryTestEnv e;
+
+    SeqProxy const seq = SeqProxy::rawSequence(4);
+
+    expectKeylet<PayChannelEntry>(
+        e,
+        keylet::payChannel(e.alice.id(), e.bob.id(), seq),
+        "payChannel(src, dst, seq)",
+        e.alice.id(),
+        e.bob.id(),
+        seq);
+
+    // Source and destination are both AccountIDs, so the assertion above
+    // only has teeth if their order matters.
+    EXPECT_NE(
+        keylet::payChannel(e.alice.id(), e.bob.id(), seq).key,
+        keylet::payChannel(e.bob.id(), e.alice.id(), seq).key);
+}
+
+}  // namespace xrpl::test
diff --git a/src/tests/libxrpl/ledger/PermissionedDomainEntry.cpp b/src/tests/libxrpl/ledger/PermissionedDomainEntry.cpp
new file mode 100644
index 0000000000..feb3002c4e
--- /dev/null
+++ b/src/tests/libxrpl/ledger/PermissionedDomainEntry.cpp
@@ -0,0 +1,28 @@
+#include <xrpl/ledger/entries/PermissionedDomainEntry.h>
+
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/SeqProxy.h>
+
+#include <gtest/gtest.h>
+#include <ledger/EntryTestHelpers.h>
+
+namespace xrpl::test {
+
+TEST(PermissionedDomainEntryTests, constructors)
+{
+    EntryTestEnv e;
+
+    SeqProxy const seq = SeqProxy::rawSequence(6);
+
+    expectKeylet<PermissionedDomainEntry>(
+        e,
+        keylet::permissionedDomain(e.alice.id(), seq),
+        "permissionedDomain(account, seq)",
+        e.alice.id(),
+        seq);
+
+    expectKeylet<PermissionedDomainEntry>(
+        e, keylet::permissionedDomain(e.someID()), "permissionedDomain(uint256)", e.someID());
+}
+
+}  // namespace xrpl::test
diff --git a/src/tests/libxrpl/ledger/RippleStateEntry.cpp b/src/tests/libxrpl/ledger/RippleStateEntry.cpp
new file mode 100644
index 0000000000..721dc09157
--- /dev/null
+++ b/src/tests/libxrpl/ledger/RippleStateEntry.cpp
@@ -0,0 +1,43 @@
+#include <xrpl/ledger/entries/RippleStateEntry.h>
+
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/Keylet.h>
+#include <xrpl/protocol/UintTypes.h>
+
+#include <gtest/gtest.h>
+#include <helpers/IOU.h>
+#include <ledger/EntryTestHelpers.h>
+
+namespace xrpl::test {
+
+TEST(RippleStateEntryTests, constructors)
+{
+    EntryTestEnv e;
+
+    IOU const usd("USD", e.alice);
+    Currency const currency = usd.currency();
+
+    expectKeylet<RippleStateEntry>(
+        e,
+        keylet::trustLine(e.alice.id(), e.bob.id(), currency),
+        "trustLine(id0, id1, currency)",
+        e.alice.id(),
+        e.bob.id(),
+        currency);
+
+    expectKeylet<RippleStateEntry>(
+        e,
+        keylet::trustLine(e.bob.id(), usd.issue()),
+        "trustLine(id, issue)",
+        e.bob.id(),
+        usd.issue());
+
+    // Trust lines are deliberately symmetric in their two accounts -- the
+    // keylet canonicalizes them -- so unlike the other two-account entries
+    // there is no transposition to catch here.
+    EXPECT_EQ(
+        keylet::trustLine(e.alice.id(), e.bob.id(), currency).key,
+        keylet::trustLine(e.bob.id(), e.alice.id(), currency).key);
+}
+
+}  // namespace xrpl::test
diff --git a/src/tests/libxrpl/ledger/SLEBase.cpp b/src/tests/libxrpl/ledger/SLEBase.cpp
new file mode 100644
index 0000000000..f721ea760d
--- /dev/null
+++ b/src/tests/libxrpl/ledger/SLEBase.cpp
@@ -0,0 +1,428 @@
+#include <xrpl/ledger/entries/SLEBase.h>
+
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/ApplyViewImpl.h>
+#include <xrpl/ledger/OpenView.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/ledger/entries/AMMEntry.h>  // IWYU pragma: keep
+#include <xrpl/ledger/entries/AccountRootEntry.h>
+#include <xrpl/ledger/entries/AmendmentsEntry.h>       // IWYU pragma: keep
+#include <xrpl/ledger/entries/BridgeEntry.h>           // IWYU pragma: keep
+#include <xrpl/ledger/entries/CheckEntry.h>            // IWYU pragma: keep
+#include <xrpl/ledger/entries/CredentialEntry.h>       // IWYU pragma: keep
+#include <xrpl/ledger/entries/DIDEntry.h>              // IWYU pragma: keep
+#include <xrpl/ledger/entries/DelegateEntry.h>         // IWYU pragma: keep
+#include <xrpl/ledger/entries/DepositPreauthEntry.h>   // IWYU pragma: keep
+#include <xrpl/ledger/entries/DirectoryNodeEntry.h>    // IWYU pragma: keep
+#include <xrpl/ledger/entries/EscrowEntry.h>           // IWYU pragma: keep
+#include <xrpl/ledger/entries/FeeSettingsEntry.h>      // IWYU pragma: keep
+#include <xrpl/ledger/entries/LedgerHashesEntry.h>     // IWYU pragma: keep
+#include <xrpl/ledger/entries/LoanBrokerEntry.h>       // IWYU pragma: keep
+#include <xrpl/ledger/entries/LoanEntry.h>             // IWYU pragma: keep
+#include <xrpl/ledger/entries/MPTokenEntry.h>          // IWYU pragma: keep
+#include <xrpl/ledger/entries/MPTokenIssuanceEntry.h>  // IWYU pragma: keep
+#include <xrpl/ledger/entries/NFTokenOfferEntry.h>     // IWYU pragma: keep
+#include <xrpl/ledger/entries/NFTokenPageEntry.h>      // IWYU pragma: keep
+#include <xrpl/ledger/entries/NegativeUNLEntry.h>      // IWYU pragma: keep
+#include <xrpl/ledger/entries/OfferEntry.h>
+#include <xrpl/ledger/entries/OracleEntry.h>              // IWYU pragma: keep
+#include <xrpl/ledger/entries/PayChannelEntry.h>          // IWYU pragma: keep
+#include <xrpl/ledger/entries/PermissionedDomainEntry.h>  // IWYU pragma: keep
+#include <xrpl/ledger/entries/RippleStateEntry.h>         // IWYU pragma: keep
+#include <xrpl/ledger/entries/SignerListEntry.h>          // IWYU pragma: keep
+#include <xrpl/ledger/entries/SponsorshipEntry.h>         // IWYU pragma: keep
+#include <xrpl/ledger/entries/TicketEntry.h>
+#include <xrpl/ledger/entries/VaultEntry.h>                            // IWYU pragma: keep
+#include <xrpl/ledger/entries/XChainOwnedClaimIDEntry.h>               // IWYU pragma: keep
+#include <xrpl/ledger/entries/XChainOwnedCreateAccountClaimIDEntry.h>  // IWYU pragma: keep
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/LedgerFormats.h>
+#include <xrpl/protocol/SField.h>
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/SeqProxy.h>
+#include <xrpl/protocol/XRPAmount.h>
+#include <xrpl/protocol_autogen/transactions/AccountSet.h>
+
+#include <gtest/gtest.h>
+#include <helpers/Account.h>
+#include <helpers/TxTest.h>
+
+#include <stdexcept>
+#include <tuple>
+#include <type_traits>
+
+namespace xrpl {
+
+// The entry classes have no consumers yet, and an un-instantiated class
+// template is barely type-checked. Instantiate every one explicitly so the
+// compiler actually checks them. Keep this block even once real call sites
+// exist: it is what catches a new ledger entry type being added without its
+// wrapper class, or the wrapper class existing but never actually being used.
+//
+// Driving this off ledger_entries.macro keeps it exhaustive by construction:
+// adding a ledger entry type without adding its entry class stops compiling
+// here, and the static_assert pins each one to the right LedgerEntryType.
+//
+// Keep this loop in one file rather than splitting it across the per-entry
+// *Entry_test.cpp suites. Those are hand-written, so a new ledger entry type
+// would simply have no file there and nothing would complain; this is the only
+// thing making the coverage exhaustive rather than merely extensive.
+
+template class SLEBase<ReadView>;
+template class SLEBase<ApplyView>;
+
+#pragma push_macro("LEDGER_ENTRY")
+#undef LEDGER_ENTRY
+
+#define LEDGER_ENTRY(tag, value, name, ...)                                                    \
+    template class name##Entry<ReadView>;                                                      \
+    template class name##Entry<ApplyView>;                                                     \
+    static_assert(                                                                             \
+        name##Entry<ReadView>::kEntryType == tag && name##Entry<ApplyView>::kEntryType == tag, \
+        #name "Entry must be bound to " #tag);
+
+#include <xrpl/protocol/detail/ledger_entries.macro>
+
+#undef LEDGER_ENTRY
+#pragma pop_macro("LEDGER_ENTRY")
+
+// --- Entry-type safety, checked at compile time. ---
+//
+// The writable -> read-only converting constructor is inherited into every
+// per-type entry, so without the entry-type constraint it will bind any
+// writable entry that slices to SLEBase. These assertions pin down which
+// conversions are legal.
+
+// An entry class for one entry type must never be constructible from another.
+static_assert(
+    !std::is_convertible_v<OfferEntryW, AccountRootEntryR>,
+    "cross-entry-type conversion must not compile");
+static_assert(
+    !std::is_constructible_v<AccountRootEntryR, OfferEntryW>,
+    "cross-entry-type construction must not compile, even explicitly");
+static_assert(
+    !std::is_convertible_v<OfferEntryR, AccountRootEntryR>,
+    "read-only cross-entry-type conversion must not compile");
+
+// Nor from a type-erased writable entry, which carries no static type.
+static_assert(
+    !std::is_convertible_v<WritableSLE, AccountRootEntryR>,
+    "generic -> typed conversion must not compile");
+
+// The intended conversions must keep working: same type writable -> read-only,
+// and typed -> generic widening.
+static_assert(
+    std::is_convertible_v<AccountRootEntryW, AccountRootEntryR>,
+    "same-type writable -> read-only conversion must keep working");
+static_assert(
+    std::is_convertible_v<AccountRootEntryW, ReadOnlySLE>,
+    "typed -> generic widening must keep working");
+
+// Detection idioms for the writable interface. These have to go through a
+// template parameter: a requires-expression over a concrete type is checked
+// eagerly, so spelling the calls out inline would be a hard error rather than
+// the `false` the assertions below want.
+template <typename T>
+concept HasMutableRawSle = requires(T& t) { t.mutableRawSle(); };
+
+template <typename T>
+concept HasApplyView = requires(T& t) { t.applyView(); };
+
+namespace test {
+
+/**
+ * Scaffolding shared by the test cases below: a funded alice, an unfunded bob
+ * (for the entries that need to resolve to nothing), and the TxTest ledger
+ * they live in.
+ */
+class SLEBaseTests : public ::testing::Test
+{
+protected:
+    TxTest env_;
+    Account const alice_{"alice"};
+    Account const bob_{"bob"};
+
+    SLEBaseTests()
+    {
+        env_.createAccount(alice_, XRP(10'000));
+    }
+};
+
+TEST_F(SLEBaseTests, read_only)
+{
+    AccountRootEntryR const absent(bob_.id(), env_.getClosedLedger());
+    EXPECT_FALSE(absent.exists());
+    EXPECT_FALSE(static_cast<bool>(absent));
+    // A typed entry knows its entry type even with nothing to read.
+    EXPECT_EQ(absent.type(), ltACCOUNT_ROOT);
+
+    AccountRootEntryR const present(alice_.id(), env_.getClosedLedger());
+    EXPECT_TRUE(present.exists());
+    EXPECT_TRUE(static_cast<bool>(present));
+    EXPECT_EQ(present.key(), keylet::account(alice_.id()).key);
+    EXPECT_EQ(present.type(), ltACCOUNT_ROOT);
+    EXPECT_EQ(present.keylet().type, ltACCOUNT_ROOT);
+    EXPECT_EQ(present->getType(), ltACCOUNT_ROOT);
+    EXPECT_EQ((*present).getType(), ltACCOUNT_ROOT);
+    EXPECT_EQ(&present.readView(), &env_.getClosedLedger());
+}
+
+TEST_F(SLEBaseTests, adopt_sle)
+{
+    auto const sle = env_.getClosedLedger().read(keylet::account(alice_.id()));
+    ASSERT_NE(sle, nullptr);
+
+    AccountRootEntryR const adopted(sle, env_.getClosedLedger());
+    EXPECT_TRUE(adopted.exists());
+    EXPECT_EQ(adopted.rawSle(), sle);
+    EXPECT_EQ(adopted.key(), keylet::account(alice_.id()).key);
+    EXPECT_EQ(adopted.type(), ltACCOUNT_ROOT);
+    // keylet() reports the SLE's own type, not the entry's static binding, so
+    // it stays truthful in a Release build where the constructor's
+    // entry-type assert is compiled out.
+    EXPECT_EQ(adopted.keylet().type, ltACCOUNT_ROOT);
+
+    // Adopting a null SLE is allowed: the assert only fires on a
+    // type mismatch, and a null pointer has no type to mismatch.
+    AccountRootEntryR const empty(SLE::const_pointer{}, env_.getClosedLedger());
+    EXPECT_FALSE(empty.exists());
+    EXPECT_EQ(empty.type(), ltACCOUNT_ROOT);
+
+    // A generic entry adopting the same SLE has to read the type back.
+    ReadOnlySLE const generic(sle, env_.getClosedLedger());
+    EXPECT_TRUE(generic.exists());
+    EXPECT_EQ(generic.type(), ltACCOUNT_ROOT);
+    EXPECT_EQ(generic.keylet().type, ltACCOUNT_ROOT);
+
+    // There is deliberately no writable equivalent.
+    static_assert(
+        !std::is_constructible_v<AccountRootEntryW, SLE::pointer, ApplyView&>,
+        "writable entries must not be constructible from a bare SLE");
+}
+
+TEST_F(SLEBaseTests, writable_accessors)
+{
+    ApplyViewImpl av(&env_.getClosedLedger(), TapNone);
+    beast::Journal const j{beast::Journal::getNullSink()};
+
+    AccountRootEntryW account(alice_.id(), av, j);
+    EXPECT_TRUE(account.exists());
+    EXPECT_EQ(account.mutableRawSle(), account.rawSle());
+    EXPECT_EQ(&account.applyView(), &av);
+    EXPECT_EQ(&account.readView(), static_cast<ReadView const*>(&av));
+    EXPECT_EQ(&account.journal().sink(), &j.sink());
+
+    // The mutable dereference operators reach the same entry.
+    EXPECT_EQ(account.operator->(), account.rawSle().get());
+    EXPECT_EQ(&*account, account.rawSle().get());
+
+    // Everything handing out mutable access is non-const, so a const
+    // writable entry is as inert as a read-only one.
+    static_assert(HasMutableRawSle<AccountRootEntryW>);
+    static_assert(HasApplyView<AccountRootEntryW>);
+    static_assert(
+        !HasMutableRawSle<AccountRootEntryW const>,
+        "mutableRawSle() must not be callable on a const writable entry");
+    static_assert(
+        !HasApplyView<AccountRootEntryW const>,
+        "applyView() must not be callable on a const writable entry");
+
+    // Read-only entries do not have the writable interface at all.
+    static_assert(
+        !HasMutableRawSle<AccountRootEntryR>,
+        "mutableRawSle() must not exist on a read-only entry");
+    static_assert(
+        !HasApplyView<AccountRootEntryR>, "applyView() must not exist on a read-only entry");
+}
+
+TEST_F(SLEBaseTests, apply_view_context_ctor)
+{
+    ApplyViewImpl av(&env_.getClosedLedger(), TapNone);
+    beast::Journal const j{beast::Journal::getNullSink()};
+
+    transactions::AccountSetBuilder builder{alice_.id()};
+    builder.setSequence(env_.getAccountRoot(alice_.id()).getSequence());
+    builder.setFee(XRPAmount(10));
+    auto const tx = builder.build(alice_.pk(), alice_.sk()).getSTTx();
+    ASSERT_NE(tx, nullptr);
+    ApplyViewContext const ctx{.view = av, .tx = *tx};
+
+    // Delegates to the (Keylet, ApplyView&) constructor; ctx.tx is not
+    // retained, so this must be indistinguishable from building from
+    // ctx.view directly.
+    AccountRootEntryW fromCtx(keylet::account(alice_.id()), ctx, j);
+    EXPECT_TRUE(fromCtx.exists());
+    EXPECT_EQ(&fromCtx.applyView(), &av);
+    EXPECT_EQ(fromCtx.key(), keylet::account(alice_.id()).key);
+
+    AccountRootEntryW const fromView(keylet::account(alice_.id()), av, j);
+    EXPECT_EQ(fromCtx.rawSle(), fromView.rawSle());
+}
+
+TEST_F(SLEBaseTests, writable_lifecycle)
+{
+    // A view we never apply, so nothing here reaches the ledger.
+    ApplyViewImpl av(&env_.getClosedLedger(), TapNone);
+
+    // Entry that does not exist yet: newSLE() -> insert().
+    {
+        TicketEntryW ticket(keylet::ticket(alice_.id(), SeqProxy::rawTicket(1)), av);
+        EXPECT_FALSE(ticket.exists());
+        EXPECT_EQ(ticket.key(), keylet::ticket(alice_.id(), SeqProxy::rawTicket(1)).key);
+        EXPECT_EQ(ticket.type(), ltTICKET);
+        EXPECT_EQ(ticket.keylet().type, ltTICKET);
+
+        ticket.newSLE();
+        EXPECT_TRUE(ticket.exists());
+        ticket.insert();
+        ticket.update();
+
+        // Erasing an entry inserted in this same view drops it outright.
+        ticket.erase();
+        EXPECT_FALSE(ticket.exists());
+    }
+
+    // Entry that already exists: update() is what promotes it from a bare
+    // peek to a real change. ApplyViewImpl::size() counts Insert, Modify and
+    // Erase but not Cache, so it shows the difference: building the entry
+    // only peeks, and the write is invisible to the view until update().
+    {
+        ApplyViewImpl fresh(&env_.getClosedLedger(), TapNone);
+
+        AccountRootEntryW account(alice_.id(), fresh);
+        EXPECT_TRUE(account.exists());
+        EXPECT_EQ(fresh.size(), 0);
+
+        account->setFieldU32(sfSequence, account->getFieldU32(sfSequence) + 1);
+        EXPECT_EQ(fresh.size(), 0);
+
+        account.update();
+        EXPECT_EQ(fresh.size(), 1);
+
+        // update() is idempotent: the entry is already a Modify.
+        account.update();
+        EXPECT_EQ(fresh.size(), 1);
+    }
+
+    // Entry that already exists. ApplyStateTable::erase() keeps holding
+    // this exact SLE and builds the DeletedNode's FinalFields from it, so
+    // the entry must drop its pointer or a later write would silently
+    // land in transaction metadata.
+    {
+        AccountRootEntryW account(alice_.id(), av);
+        EXPECT_TRUE(account.exists());
+
+        account.erase();
+        EXPECT_FALSE(account.exists());
+    }
+}
+
+TEST_F(SLEBaseTests, conversion)
+{
+    ApplyViewImpl av(&env_.getClosedLedger(), TapNone);
+
+    AccountRootEntryW const writable(alice_.id(), av);
+    EXPECT_TRUE(writable.exists());
+
+    AccountRootEntryR const readOnly = writable;
+    EXPECT_TRUE(readOnly.exists());
+    EXPECT_EQ(readOnly.rawSle(), writable.rawSle());
+
+    ReadOnlySLE const generic = writable;
+    EXPECT_TRUE(generic.exists());
+    EXPECT_EQ(generic.rawSle(), writable.rawSle());
+    // A generic entry has to read the type back out of the SLE.
+    EXPECT_EQ(generic.type(), ltACCOUNT_ROOT);
+}
+
+TEST_F(SLEBaseTests, resolve_entry_peeks)
+{
+    // getOpenLedger() is an OpenView, which derives from ReadView but not
+    // from ApplyView, so resolveEntry's dynamic_cast fails and this takes
+    // the plain ReadView::read() path.
+    OpenView const& ledger = env_.getOpenLedger();
+    AccountRootEntryR const overLedger(alice_.id(), ledger);
+    EXPECT_TRUE(overLedger.exists());
+
+    ApplyViewImpl av(&ledger, TapNone);
+
+    // ReadView const& binds an ApplyViewImpl just as happily, and there the
+    // dynamic_cast succeeds, so this one resolves through ApplyView::peek().
+    AccountRootEntryR const readOnly(alice_.id(), av);
+    EXPECT_TRUE(readOnly.exists());
+
+    AccountRootEntryW writable(alice_.id(), av);
+    EXPECT_TRUE(writable.exists());
+
+    // The invariant resolveEntry() exists to hold: one SLE per key per
+    // view. read() would have handed back the base ledger's entry instead,
+    // which is a different object.
+    EXPECT_EQ(readOnly.rawSle(), writable.rawSle());
+    EXPECT_NE(readOnly.rawSle(), overLedger.rawSle());
+
+    // Which is what keeps a read-only entry from going stale: a write
+    // through any other entry over the same view is visible through it.
+    auto const bumped = writable->getFieldU32(sfSequence) + 1;
+    writable->setFieldU32(sfSequence, bumped);
+    EXPECT_EQ(readOnly->getFieldU32(sfSequence), bumped);
+}
+
+TEST_F(SLEBaseTests, throws_on_missing_entry)
+{
+    // A generic read-only entry has no static type to fall back on, so
+    // type() must read it off the (absent) SLE and throw.
+    ReadOnlySLE const absent(keylet::account(bob_.id()), env_.getClosedLedger());
+    EXPECT_FALSE(absent.exists());
+    EXPECT_THROW(std::ignore = absent.type(), std::logic_error);
+
+    // A per-type read-only entry always knows its type, but keylet() and
+    // key() still have to derive the ledger key from the SLE.
+    AccountRootEntryR const missing(bob_.id(), env_.getClosedLedger());
+    EXPECT_FALSE(missing.exists());
+    EXPECT_THROW(std::ignore = missing.key(), std::logic_error);
+    EXPECT_THROW(std::ignore = missing.keylet(), std::logic_error);
+
+    // Dereferencing an absent entry throws rather than handing back a null
+    // pointer for the caller to walk into.
+    EXPECT_THROW(std::ignore = missing.operator->(), std::logic_error);
+    EXPECT_THROW(std::ignore = (*missing).getType(), std::logic_error);
+}
+
+TEST_F(SLEBaseTests, throws_on_missing_writable_entry)
+{
+    // A view we never apply, so nothing here reaches the ledger.
+    ApplyViewImpl av(&env_.getClosedLedger(), TapNone);
+
+    // bob is unfunded, so this resolves to nothing and every operation that
+    // needs an SLE has to throw instead of dereferencing null. These are the
+    // cases a Release build used to walk straight past, back when they were
+    // XRPL_ASSERTs.
+    AccountRootEntryW missing(bob_.id(), av);
+    EXPECT_FALSE(missing.exists());
+
+    EXPECT_THROW(std::ignore = missing.operator->(), std::logic_error);
+    EXPECT_THROW(std::ignore = (*missing).getType(), std::logic_error);
+    EXPECT_THROW(missing.insert(), std::logic_error);
+    EXPECT_THROW(missing.update(), std::logic_error);
+    EXPECT_THROW(missing.erase(), std::logic_error);
+
+    // keylet() and key() are the exception: a writable entry keeps the keylet
+    // it was built from, so they stay valid before newSLE().
+    EXPECT_EQ(missing.key(), keylet::account(bob_.id()).key);
+
+    // newSLE() is the inverse -- it throws when the entry *does* exist,
+    // rather than silently dropping the SLE already held.
+    missing.newSLE();
+    EXPECT_TRUE(missing.exists());
+    EXPECT_THROW(missing.newSLE(), std::logic_error);
+
+    // And once erased, the entry is empty again and throws as before.
+    missing.insert();
+    missing.erase();
+    EXPECT_FALSE(missing.exists());
+    EXPECT_THROW(missing.update(), std::logic_error);
+}
+
+}  // namespace test
+}  // namespace xrpl
diff --git a/src/tests/libxrpl/ledger/SignerListEntry.cpp b/src/tests/libxrpl/ledger/SignerListEntry.cpp
new file mode 100644
index 0000000000..db65af2f02
--- /dev/null
+++ b/src/tests/libxrpl/ledger/SignerListEntry.cpp
@@ -0,0 +1,18 @@
+#include <xrpl/ledger/entries/SignerListEntry.h>
+
+#include <xrpl/protocol/Indexes.h>
+
+#include <gtest/gtest.h>
+#include <ledger/EntryTestHelpers.h>
+
+namespace xrpl::test {
+
+TEST(SignerListEntryTests, constructors)
+{
+    EntryTestEnv e;
+
+    expectKeylet<SignerListEntry>(
+        e, keylet::signerList(e.alice.id()), "signerList(account)", e.alice.id());
+}
+
+}  // namespace xrpl::test
diff --git a/src/tests/libxrpl/ledger/SponsorshipEntry.cpp b/src/tests/libxrpl/ledger/SponsorshipEntry.cpp
new file mode 100644
index 0000000000..735c3e202d
--- /dev/null
+++ b/src/tests/libxrpl/ledger/SponsorshipEntry.cpp
@@ -0,0 +1,29 @@
+#include <xrpl/ledger/entries/SponsorshipEntry.h>
+
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/Keylet.h>
+
+#include <gtest/gtest.h>
+#include <ledger/EntryTestHelpers.h>
+
+namespace xrpl::test {
+
+TEST(SponsorshipEntryTests, constructors)
+{
+    EntryTestEnv e;
+
+    expectKeylet<SponsorshipEntry>(
+        e,
+        keylet::sponsorship(e.alice.id(), e.bob.id()),
+        "sponsorship(sponsor, sponsee)",
+        e.alice.id(),
+        e.bob.id());
+
+    // Sponsor and sponsee are both AccountIDs, so the assertion above only
+    // has teeth if their order matters.
+    EXPECT_NE(
+        keylet::sponsorship(e.alice.id(), e.bob.id()).key,
+        keylet::sponsorship(e.bob.id(), e.alice.id()).key);
+}
+
+}  // namespace xrpl::test
diff --git a/src/tests/libxrpl/ledger/TicketEntry.cpp b/src/tests/libxrpl/ledger/TicketEntry.cpp
new file mode 100644
index 0000000000..fa26b1a937
--- /dev/null
+++ b/src/tests/libxrpl/ledger/TicketEntry.cpp
@@ -0,0 +1,27 @@
+#include <xrpl/ledger/entries/TicketEntry.h>
+
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/SeqProxy.h>
+
+#include <gtest/gtest.h>
+#include <ledger/EntryTestHelpers.h>
+
+namespace xrpl::test {
+
+TEST(TicketEntryTests, constructors)
+{
+    EntryTestEnv e;
+
+    SeqProxy const ticketSeq = SeqProxy::rawTicket(2);
+
+    expectKeylet<TicketEntry>(
+        e,
+        keylet::ticket(e.alice.id(), ticketSeq),
+        "ticket(id, ticketSeq)",
+        e.alice.id(),
+        ticketSeq);
+
+    expectKeylet<TicketEntry>(e, keylet::ticket(e.someID()), "ticket(uint256)", e.someID());
+}
+
+}  // namespace xrpl::test
diff --git a/src/tests/libxrpl/ledger/VaultEntry.cpp b/src/tests/libxrpl/ledger/VaultEntry.cpp
new file mode 100644
index 0000000000..61f24db410
--- /dev/null
+++ b/src/tests/libxrpl/ledger/VaultEntry.cpp
@@ -0,0 +1,23 @@
+#include <xrpl/ledger/entries/VaultEntry.h>
+
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/SeqProxy.h>
+
+#include <gtest/gtest.h>
+#include <ledger/EntryTestHelpers.h>
+
+namespace xrpl::test {
+
+TEST(VaultEntryTests, constructors)
+{
+    EntryTestEnv e;
+
+    SeqProxy const seq = SeqProxy::rawSequence(8);
+
+    expectKeylet<VaultEntry>(
+        e, keylet::vault(e.alice.id(), seq), "vault(owner, seq)", e.alice.id(), seq);
+
+    expectKeylet<VaultEntry>(e, keylet::vault(e.someID()), "vault(uint256)", e.someID());
+}
+
+}  // namespace xrpl::test
diff --git a/src/tests/libxrpl/ledger/XChainOwnedClaimIDEntry.cpp b/src/tests/libxrpl/ledger/XChainOwnedClaimIDEntry.cpp
new file mode 100644
index 0000000000..4145471a27
--- /dev/null
+++ b/src/tests/libxrpl/ledger/XChainOwnedClaimIDEntry.cpp
@@ -0,0 +1,29 @@
+#include <xrpl/ledger/entries/XChainOwnedClaimIDEntry.h>
+
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/Issue.h>
+#include <xrpl/protocol/STXChainBridge.h>
+
+#include <gtest/gtest.h>
+#include <helpers/IOU.h>
+#include <ledger/EntryTestHelpers.h>
+
+#include <cstdint>
+
+namespace xrpl::test {
+
+TEST(XChainOwnedClaimIDEntryTests, constructors)
+{
+    EntryTestEnv e;
+
+    STXChainBridge const bridge{e.alice.id(), xrpIssue(), e.bob.id(), IOU("USD", e.bob).issue()};
+
+    expectKeylet<XChainOwnedClaimIDEntry>(
+        e,
+        keylet::xChainClaimID(bridge, 5u),
+        "xChainClaimID(bridge, seq)",
+        bridge,
+        std::uint64_t{5});
+}
+
+}  // namespace xrpl::test
diff --git a/src/tests/libxrpl/ledger/XChainOwnedCreateAccountClaimIDEntry.cpp b/src/tests/libxrpl/ledger/XChainOwnedCreateAccountClaimIDEntry.cpp
new file mode 100644
index 0000000000..93851deedf
--- /dev/null
+++ b/src/tests/libxrpl/ledger/XChainOwnedCreateAccountClaimIDEntry.cpp
@@ -0,0 +1,35 @@
+#include <xrpl/ledger/entries/XChainOwnedCreateAccountClaimIDEntry.h>
+
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/Issue.h>
+#include <xrpl/protocol/Keylet.h>
+#include <xrpl/protocol/STXChainBridge.h>
+
+#include <gtest/gtest.h>
+#include <helpers/IOU.h>
+#include <ledger/EntryTestHelpers.h>
+
+#include <cstdint>
+
+namespace xrpl::test {
+
+TEST(XChainOwnedCreateAccountClaimIDEntryTests, constructors)
+{
+    EntryTestEnv e;
+
+    STXChainBridge const bridge{e.alice.id(), xrpIssue(), e.bob.id(), IOU("USD", e.bob).issue()};
+
+    expectKeylet<XChainOwnedCreateAccountClaimIDEntry>(
+        e,
+        keylet::xChainCreateAccountClaimID(bridge, 5u),
+        "xChainCreateAccountClaimID(bridge, seq)",
+        bridge,
+        std::uint64_t{5});
+
+    // Must not collide with the plain claim-ID keylet, which takes the same
+    // arguments.
+    EXPECT_NE(
+        keylet::xChainCreateAccountClaimID(bridge, 5u).key, keylet::xChainClaimID(bridge, 5u).key);
+}
+
+}  // namespace xrpl::test
diff --git a/src/tests/libxrpl/peerfinder/PeerFinder.cpp b/src/tests/libxrpl/peerfinder/PeerFinder.cpp
index 3a52bbb5aa..2d98d4385f 100644
--- a/src/tests/libxrpl/peerfinder/PeerFinder.cpp
+++ b/src/tests/libxrpl/peerfinder/PeerFinder.cpp
@@ -1214,6 +1214,9 @@ TEST(PeerFinderConfig, applies_legacy_and_explicit_peer_limits)
          .expectedOut = 10,
          .expectedIn = 0,
          .expectedIpLimit = 1},
+        // A port of zero disables incoming connections, so the configured
+        // inbound limit is dropped and the per-IP inbound limit collapses to
+        // one, exactly as in the legacy private case above.
         {.name = "new in 100/out 10, private",
          .maxPeers = {},
          .maxIn = 100,
@@ -1221,7 +1224,7 @@ TEST(PeerFinderConfig, applies_legacy_and_explicit_peer_limits)
          .port = 0,
          .expectedOut = 10,
          .expectedIn = 0,
-         .expectedIpLimit = 6}};
+         .expectedIpLimit = 1}};
 
     for (auto const& testCase : cases)
     {
@@ -1239,6 +1242,13 @@ TEST(PeerFinderConfig, applies_legacy_and_explicit_peer_limits)
         EXPECT_EQ(counts.inMax(), testCase.expectedIn);
         EXPECT_EQ(config.ipLimit, testCase.expectedIpLimit);
 
+        // The configuration itself carries the same per-direction allowances
+        // that the slot counts derive, and `maxPeers` is their total. Callers
+        // such as `Overlay::limit` read `maxPeers` directly.
+        EXPECT_EQ(config.outPeers, testCase.expectedOut);
+        EXPECT_EQ(config.inPeers, testCase.expectedIn);
+        EXPECT_EQ(config.maxPeers, config.inPeers + config.outPeers);
+
         NiceMock<MockStore> store;
         allowEmptyStore(store);
         NiceMock<MockChecker> checker;
diff --git a/src/tests/libxrpl/protocol/STXChainBridge.cpp b/src/tests/libxrpl/protocol/STXChainBridge.cpp
index f4e6e60cc9..22f26d7ea0 100644
--- a/src/tests/libxrpl/protocol/STXChainBridge.cpp
+++ b/src/tests/libxrpl/protocol/STXChainBridge.cpp
@@ -28,7 +28,7 @@ account(std::string_view hex)
 // getText() builds its string from eight substitutions of the same type, so a
 // transposed pair would still compile and still type check. Pin the output so
 // the field/value pairing is actually verified.
-TEST(STXChainBridge, getTextPairsEachFieldWithItsValue)
+TEST(STXChainBridge, get_text_pairs_each_field_with_its_value)
 {
     auto const lockingDoor = account("0102030405060708090A0B0C0D0E0F1011121314");
     auto const issuingDoor = account("14131211100F0E0D0C0B0A090807060504030201");
@@ -46,7 +46,7 @@ TEST(STXChainBridge, getTextPairsEachFieldWithItsValue)
     EXPECT_EQ(bridge.getText(), expected);
 }
 
-TEST(STXChainBridge, getTextOnADefaultBridge)
+TEST(STXChainBridge, get_text_on_a_default_bridge)
 {
     STXChainBridge const bridge;
     auto const text = bridge.getText();
diff --git a/src/tests/libxrpl/protocol_autogen/ledger_entries/EscrowTests.cpp b/src/tests/libxrpl/protocol_autogen/ledger_entries/EscrowTests.cpp
index 2dbb450e28..ad5f88fd2f 100644
--- a/src/tests/libxrpl/protocol_autogen/ledger_entries/EscrowTests.cpp
+++ b/src/tests/libxrpl/protocol_autogen/ledger_entries/EscrowTests.cpp
@@ -27,6 +27,8 @@ TEST(EscrowTests, BuilderSettersRoundTrip)
     auto const conditionValue = canonical_VL();
     auto const cancelAfterValue = canonical_UINT32();
     auto const finishAfterValue = canonical_UINT32();
+    auto const bytecodeValue = canonical_VL();
+    auto const dataValue = canonical_VL();
     auto const sourceTagValue = canonical_UINT32();
     auto const destinationTagValue = canonical_UINT32();
     auto const ownerNodeValue = canonical_UINT64();
@@ -49,6 +51,8 @@ TEST(EscrowTests, BuilderSettersRoundTrip)
     builder.setCondition(conditionValue);
     builder.setCancelAfter(cancelAfterValue);
     builder.setFinishAfter(finishAfterValue);
+    builder.setBytecode(bytecodeValue);
+    builder.setData(dataValue);
     builder.setSourceTag(sourceTagValue);
     builder.setDestinationTag(destinationTagValue);
     builder.setDestinationNode(destinationNodeValue);
@@ -132,6 +136,22 @@ TEST(EscrowTests, BuilderSettersRoundTrip)
         EXPECT_TRUE(entry.hasFinishAfter());
     }
 
+    {
+        auto const& expected = bytecodeValue;
+        auto const actualOpt = entry.getBytecode();
+        ASSERT_TRUE(actualOpt.has_value());
+        expectEqualField(expected, *actualOpt, "sfBytecode");
+        EXPECT_TRUE(entry.hasBytecode());
+    }
+
+    {
+        auto const& expected = dataValue;
+        auto const actualOpt = entry.getData();
+        ASSERT_TRUE(actualOpt.has_value());
+        expectEqualField(expected, *actualOpt, "sfData");
+        EXPECT_TRUE(entry.hasData());
+    }
+
     {
         auto const& expected = sourceTagValue;
         auto const actualOpt = entry.getSourceTag();
@@ -192,6 +212,8 @@ TEST(EscrowTests, BuilderFromSleRoundTrip)
     auto const conditionValue = canonical_VL();
     auto const cancelAfterValue = canonical_UINT32();
     auto const finishAfterValue = canonical_UINT32();
+    auto const bytecodeValue = canonical_VL();
+    auto const dataValue = canonical_VL();
     auto const sourceTagValue = canonical_UINT32();
     auto const destinationTagValue = canonical_UINT32();
     auto const ownerNodeValue = canonical_UINT64();
@@ -210,6 +232,8 @@ TEST(EscrowTests, BuilderFromSleRoundTrip)
     sle->at(sfCondition) = conditionValue;
     sle->at(sfCancelAfter) = cancelAfterValue;
     sle->at(sfFinishAfter) = finishAfterValue;
+    sle->at(sfBytecode) = bytecodeValue;
+    sle->at(sfData) = dataValue;
     sle->at(sfSourceTag) = sourceTagValue;
     sle->at(sfDestinationTag) = destinationTagValue;
     sle->at(sfOwnerNode) = ownerNodeValue;
@@ -340,6 +364,32 @@ TEST(EscrowTests, BuilderFromSleRoundTrip)
         expectEqualField(expected, *fromBuilderOpt, "sfFinishAfter");
     }
 
+    {
+        auto const& expected = bytecodeValue;
+
+        auto const fromSleOpt = entryFromSle.getBytecode();
+        auto const fromBuilderOpt = entryFromBuilder.getBytecode();
+
+        ASSERT_TRUE(fromSleOpt.has_value());
+        ASSERT_TRUE(fromBuilderOpt.has_value());
+
+        expectEqualField(expected, *fromSleOpt, "sfBytecode");
+        expectEqualField(expected, *fromBuilderOpt, "sfBytecode");
+    }
+
+    {
+        auto const& expected = dataValue;
+
+        auto const fromSleOpt = entryFromSle.getData();
+        auto const fromBuilderOpt = entryFromBuilder.getData();
+
+        ASSERT_TRUE(fromSleOpt.has_value());
+        ASSERT_TRUE(fromBuilderOpt.has_value());
+
+        expectEqualField(expected, *fromSleOpt, "sfData");
+        expectEqualField(expected, *fromBuilderOpt, "sfData");
+    }
+
     {
         auto const& expected = sourceTagValue;
 
@@ -477,6 +527,10 @@ TEST(EscrowTests, OptionalFieldsReturnNullopt)
     EXPECT_FALSE(entry.getCancelAfter().has_value());
     EXPECT_FALSE(entry.hasFinishAfter());
     EXPECT_FALSE(entry.getFinishAfter().has_value());
+    EXPECT_FALSE(entry.hasBytecode());
+    EXPECT_FALSE(entry.getBytecode().has_value());
+    EXPECT_FALSE(entry.hasData());
+    EXPECT_FALSE(entry.getData().has_value());
     EXPECT_FALSE(entry.hasSourceTag());
     EXPECT_FALSE(entry.getSourceTag().has_value());
     EXPECT_FALSE(entry.hasDestinationTag());
diff --git a/src/tests/libxrpl/protocol_autogen/ledger_entries/FeeSettingsTests.cpp b/src/tests/libxrpl/protocol_autogen/ledger_entries/FeeSettingsTests.cpp
index 479d0c56c6..92bf25398c 100644
--- a/src/tests/libxrpl/protocol_autogen/ledger_entries/FeeSettingsTests.cpp
+++ b/src/tests/libxrpl/protocol_autogen/ledger_entries/FeeSettingsTests.cpp
@@ -27,6 +27,9 @@ TEST(FeeSettingsTests, BuilderSettersRoundTrip)
     auto const baseFeeDropsValue = canonical_AMOUNT();
     auto const reserveBaseDropsValue = canonical_AMOUNT();
     auto const reserveIncrementDropsValue = canonical_AMOUNT();
+    auto const gasLimitValue = canonical_UINT32();
+    auto const bytecodeSizeLimitValue = canonical_UINT32();
+    auto const gasPriceValue = canonical_UINT32();
     auto const previousTxnIDValue = canonical_UINT256();
     auto const previousTxnLgrSeqValue = canonical_UINT32();
 
@@ -40,6 +43,9 @@ TEST(FeeSettingsTests, BuilderSettersRoundTrip)
     builder.setBaseFeeDrops(baseFeeDropsValue);
     builder.setReserveBaseDrops(reserveBaseDropsValue);
     builder.setReserveIncrementDrops(reserveIncrementDropsValue);
+    builder.setGasLimit(gasLimitValue);
+    builder.setBytecodeSizeLimit(bytecodeSizeLimitValue);
+    builder.setGasPrice(gasPriceValue);
     builder.setPreviousTxnID(previousTxnIDValue);
     builder.setPreviousTxnLgrSeq(previousTxnLgrSeqValue);
 
@@ -108,6 +114,30 @@ TEST(FeeSettingsTests, BuilderSettersRoundTrip)
         EXPECT_TRUE(entry.hasReserveIncrementDrops());
     }
 
+    {
+        auto const& expected = gasLimitValue;
+        auto const actualOpt = entry.getGasLimit();
+        ASSERT_TRUE(actualOpt.has_value());
+        expectEqualField(expected, *actualOpt, "sfGasLimit");
+        EXPECT_TRUE(entry.hasGasLimit());
+    }
+
+    {
+        auto const& expected = bytecodeSizeLimitValue;
+        auto const actualOpt = entry.getBytecodeSizeLimit();
+        ASSERT_TRUE(actualOpt.has_value());
+        expectEqualField(expected, *actualOpt, "sfBytecodeSizeLimit");
+        EXPECT_TRUE(entry.hasBytecodeSizeLimit());
+    }
+
+    {
+        auto const& expected = gasPriceValue;
+        auto const actualOpt = entry.getGasPrice();
+        ASSERT_TRUE(actualOpt.has_value());
+        expectEqualField(expected, *actualOpt, "sfGasPrice");
+        EXPECT_TRUE(entry.hasGasPrice());
+    }
+
     {
         auto const& expected = previousTxnIDValue;
         auto const actualOpt = entry.getPreviousTxnID();
@@ -144,6 +174,9 @@ TEST(FeeSettingsTests, BuilderFromSleRoundTrip)
     auto const baseFeeDropsValue = canonical_AMOUNT();
     auto const reserveBaseDropsValue = canonical_AMOUNT();
     auto const reserveIncrementDropsValue = canonical_AMOUNT();
+    auto const gasLimitValue = canonical_UINT32();
+    auto const bytecodeSizeLimitValue = canonical_UINT32();
+    auto const gasPriceValue = canonical_UINT32();
     auto const previousTxnIDValue = canonical_UINT256();
     auto const previousTxnLgrSeqValue = canonical_UINT32();
 
@@ -156,6 +189,9 @@ TEST(FeeSettingsTests, BuilderFromSleRoundTrip)
     sle->at(sfBaseFeeDrops) = baseFeeDropsValue;
     sle->at(sfReserveBaseDrops) = reserveBaseDropsValue;
     sle->at(sfReserveIncrementDrops) = reserveIncrementDropsValue;
+    sle->at(sfGasLimit) = gasLimitValue;
+    sle->at(sfBytecodeSizeLimit) = bytecodeSizeLimitValue;
+    sle->at(sfGasPrice) = gasPriceValue;
     sle->at(sfPreviousTxnID) = previousTxnIDValue;
     sle->at(sfPreviousTxnLgrSeq) = previousTxnLgrSeqValue;
 
@@ -259,6 +295,45 @@ TEST(FeeSettingsTests, BuilderFromSleRoundTrip)
         expectEqualField(expected, *fromBuilderOpt, "sfReserveIncrementDrops");
     }
 
+    {
+        auto const& expected = gasLimitValue;
+
+        auto const fromSleOpt = entryFromSle.getGasLimit();
+        auto const fromBuilderOpt = entryFromBuilder.getGasLimit();
+
+        ASSERT_TRUE(fromSleOpt.has_value());
+        ASSERT_TRUE(fromBuilderOpt.has_value());
+
+        expectEqualField(expected, *fromSleOpt, "sfGasLimit");
+        expectEqualField(expected, *fromBuilderOpt, "sfGasLimit");
+    }
+
+    {
+        auto const& expected = bytecodeSizeLimitValue;
+
+        auto const fromSleOpt = entryFromSle.getBytecodeSizeLimit();
+        auto const fromBuilderOpt = entryFromBuilder.getBytecodeSizeLimit();
+
+        ASSERT_TRUE(fromSleOpt.has_value());
+        ASSERT_TRUE(fromBuilderOpt.has_value());
+
+        expectEqualField(expected, *fromSleOpt, "sfBytecodeSizeLimit");
+        expectEqualField(expected, *fromBuilderOpt, "sfBytecodeSizeLimit");
+    }
+
+    {
+        auto const& expected = gasPriceValue;
+
+        auto const fromSleOpt = entryFromSle.getGasPrice();
+        auto const fromBuilderOpt = entryFromBuilder.getGasPrice();
+
+        ASSERT_TRUE(fromSleOpt.has_value());
+        ASSERT_TRUE(fromBuilderOpt.has_value());
+
+        expectEqualField(expected, *fromSleOpt, "sfGasPrice");
+        expectEqualField(expected, *fromBuilderOpt, "sfGasPrice");
+    }
+
     {
         auto const& expected = previousTxnIDValue;
 
@@ -351,6 +426,12 @@ TEST(FeeSettingsTests, OptionalFieldsReturnNullopt)
     EXPECT_FALSE(entry.getReserveBaseDrops().has_value());
     EXPECT_FALSE(entry.hasReserveIncrementDrops());
     EXPECT_FALSE(entry.getReserveIncrementDrops().has_value());
+    EXPECT_FALSE(entry.hasGasLimit());
+    EXPECT_FALSE(entry.getGasLimit().has_value());
+    EXPECT_FALSE(entry.hasBytecodeSizeLimit());
+    EXPECT_FALSE(entry.getBytecodeSizeLimit().has_value());
+    EXPECT_FALSE(entry.hasGasPrice());
+    EXPECT_FALSE(entry.getGasPrice().has_value());
     EXPECT_FALSE(entry.hasPreviousTxnID());
     EXPECT_FALSE(entry.getPreviousTxnID().has_value());
     EXPECT_FALSE(entry.hasPreviousTxnLgrSeq());
diff --git a/src/tests/libxrpl/protocol_autogen/ledger_entries/MPTokenIssuanceTests.cpp b/src/tests/libxrpl/protocol_autogen/ledger_entries/MPTokenIssuanceTests.cpp
index 974d0e81d7..e8c1b645d8 100644
--- a/src/tests/libxrpl/protocol_autogen/ledger_entries/MPTokenIssuanceTests.cpp
+++ b/src/tests/libxrpl/protocol_autogen/ledger_entries/MPTokenIssuanceTests.cpp
@@ -36,6 +36,8 @@ TEST(MPTokenIssuanceTests, BuilderSettersRoundTrip)
     auto const referenceHoldingValue = canonical_UINT256();
     auto const issuerEncryptionKeyValue = canonical_VL();
     auto const auditorEncryptionKeyValue = canonical_VL();
+    auto const issuerKeyEpochValue = canonical_UINT32();
+    auto const auditorKeyEpochValue = canonical_UINT32();
     auto const confidentialOutstandingAmountValue = canonical_UINT64();
 
     MPTokenIssuanceBuilder builder{
@@ -57,6 +59,8 @@ TEST(MPTokenIssuanceTests, BuilderSettersRoundTrip)
     builder.setReferenceHolding(referenceHoldingValue);
     builder.setIssuerEncryptionKey(issuerEncryptionKeyValue);
     builder.setAuditorEncryptionKey(auditorEncryptionKeyValue);
+    builder.setIssuerKeyEpoch(issuerKeyEpochValue);
+    builder.setAuditorKeyEpoch(auditorKeyEpochValue);
     builder.setConfidentialOutstandingAmount(confidentialOutstandingAmountValue);
 
     builder.setLedgerIndex(index);
@@ -184,6 +188,22 @@ TEST(MPTokenIssuanceTests, BuilderSettersRoundTrip)
         EXPECT_TRUE(entry.hasAuditorEncryptionKey());
     }
 
+    {
+        auto const& expected = issuerKeyEpochValue;
+        auto const actualOpt = entry.getIssuerKeyEpoch();
+        ASSERT_TRUE(actualOpt.has_value());
+        expectEqualField(expected, *actualOpt, "sfIssuerKeyEpoch");
+        EXPECT_TRUE(entry.hasIssuerKeyEpoch());
+    }
+
+    {
+        auto const& expected = auditorKeyEpochValue;
+        auto const actualOpt = entry.getAuditorKeyEpoch();
+        ASSERT_TRUE(actualOpt.has_value());
+        expectEqualField(expected, *actualOpt, "sfAuditorKeyEpoch");
+        EXPECT_TRUE(entry.hasAuditorKeyEpoch());
+    }
+
     {
         auto const& expected = confidentialOutstandingAmountValue;
         auto const actualOpt = entry.getConfidentialOutstandingAmount();
@@ -221,6 +241,8 @@ TEST(MPTokenIssuanceTests, BuilderFromSleRoundTrip)
     auto const referenceHoldingValue = canonical_UINT256();
     auto const issuerEncryptionKeyValue = canonical_VL();
     auto const auditorEncryptionKeyValue = canonical_VL();
+    auto const issuerKeyEpochValue = canonical_UINT32();
+    auto const auditorKeyEpochValue = canonical_UINT32();
     auto const confidentialOutstandingAmountValue = canonical_UINT64();
 
     auto sle = std::make_shared<SLE>(MPTokenIssuance::entryType, index);
@@ -241,6 +263,8 @@ TEST(MPTokenIssuanceTests, BuilderFromSleRoundTrip)
     sle->at(sfReferenceHolding) = referenceHoldingValue;
     sle->at(sfIssuerEncryptionKey) = issuerEncryptionKeyValue;
     sle->at(sfAuditorEncryptionKey) = auditorEncryptionKeyValue;
+    sle->at(sfIssuerKeyEpoch) = issuerKeyEpochValue;
+    sle->at(sfAuditorKeyEpoch) = auditorKeyEpochValue;
     sle->at(sfConfidentialOutstandingAmount) = confidentialOutstandingAmountValue;
 
     MPTokenIssuanceBuilder builderFromSle{sle};
@@ -442,6 +466,32 @@ TEST(MPTokenIssuanceTests, BuilderFromSleRoundTrip)
         expectEqualField(expected, *fromBuilderOpt, "sfAuditorEncryptionKey");
     }
 
+    {
+        auto const& expected = issuerKeyEpochValue;
+
+        auto const fromSleOpt = entryFromSle.getIssuerKeyEpoch();
+        auto const fromBuilderOpt = entryFromBuilder.getIssuerKeyEpoch();
+
+        ASSERT_TRUE(fromSleOpt.has_value());
+        ASSERT_TRUE(fromBuilderOpt.has_value());
+
+        expectEqualField(expected, *fromSleOpt, "sfIssuerKeyEpoch");
+        expectEqualField(expected, *fromBuilderOpt, "sfIssuerKeyEpoch");
+    }
+
+    {
+        auto const& expected = auditorKeyEpochValue;
+
+        auto const fromSleOpt = entryFromSle.getAuditorKeyEpoch();
+        auto const fromBuilderOpt = entryFromBuilder.getAuditorKeyEpoch();
+
+        ASSERT_TRUE(fromSleOpt.has_value());
+        ASSERT_TRUE(fromBuilderOpt.has_value());
+
+        expectEqualField(expected, *fromSleOpt, "sfAuditorKeyEpoch");
+        expectEqualField(expected, *fromBuilderOpt, "sfAuditorKeyEpoch");
+    }
+
     {
         auto const& expected = confidentialOutstandingAmountValue;
 
@@ -539,6 +589,10 @@ TEST(MPTokenIssuanceTests, OptionalFieldsReturnNullopt)
     EXPECT_FALSE(entry.getIssuerEncryptionKey().has_value());
     EXPECT_FALSE(entry.hasAuditorEncryptionKey());
     EXPECT_FALSE(entry.getAuditorEncryptionKey().has_value());
+    EXPECT_FALSE(entry.hasIssuerKeyEpoch());
+    EXPECT_FALSE(entry.getIssuerKeyEpoch().has_value());
+    EXPECT_FALSE(entry.hasAuditorKeyEpoch());
+    EXPECT_FALSE(entry.getAuditorKeyEpoch().has_value());
     EXPECT_FALSE(entry.hasConfidentialOutstandingAmount());
     EXPECT_FALSE(entry.getConfidentialOutstandingAmount().has_value());
 }
diff --git a/src/tests/libxrpl/protocol_autogen/ledger_entries/MPTokenTests.cpp b/src/tests/libxrpl/protocol_autogen/ledger_entries/MPTokenTests.cpp
index 7db4b638a7..41eff1cce7 100644
--- a/src/tests/libxrpl/protocol_autogen/ledger_entries/MPTokenTests.cpp
+++ b/src/tests/libxrpl/protocol_autogen/ledger_entries/MPTokenTests.cpp
@@ -32,6 +32,8 @@ TEST(MPTokenTests, BuilderSettersRoundTrip)
     auto const confidentialBalanceVersionValue = canonical_UINT32();
     auto const issuerEncryptedBalanceValue = canonical_VL();
     auto const auditorEncryptedBalanceValue = canonical_VL();
+    auto const issuerKeyMirrorEpochValue = canonical_UINT32();
+    auto const auditorKeyMirrorEpochValue = canonical_UINT32();
     auto const holderEncryptionKeyValue = canonical_VL();
 
     MPTokenBuilder builder{
@@ -49,6 +51,8 @@ TEST(MPTokenTests, BuilderSettersRoundTrip)
     builder.setConfidentialBalanceVersion(confidentialBalanceVersionValue);
     builder.setIssuerEncryptedBalance(issuerEncryptedBalanceValue);
     builder.setAuditorEncryptedBalance(auditorEncryptedBalanceValue);
+    builder.setIssuerKeyMirrorEpoch(issuerKeyMirrorEpochValue);
+    builder.setAuditorKeyMirrorEpoch(auditorKeyMirrorEpochValue);
     builder.setHolderEncryptionKey(holderEncryptionKeyValue);
 
     builder.setLedgerIndex(index);
@@ -146,6 +150,22 @@ TEST(MPTokenTests, BuilderSettersRoundTrip)
         EXPECT_TRUE(entry.hasAuditorEncryptedBalance());
     }
 
+    {
+        auto const& expected = issuerKeyMirrorEpochValue;
+        auto const actualOpt = entry.getIssuerKeyMirrorEpoch();
+        ASSERT_TRUE(actualOpt.has_value());
+        expectEqualField(expected, *actualOpt, "sfIssuerKeyMirrorEpoch");
+        EXPECT_TRUE(entry.hasIssuerKeyMirrorEpoch());
+    }
+
+    {
+        auto const& expected = auditorKeyMirrorEpochValue;
+        auto const actualOpt = entry.getAuditorKeyMirrorEpoch();
+        ASSERT_TRUE(actualOpt.has_value());
+        expectEqualField(expected, *actualOpt, "sfAuditorKeyMirrorEpoch");
+        EXPECT_TRUE(entry.hasAuditorKeyMirrorEpoch());
+    }
+
     {
         auto const& expected = holderEncryptionKeyValue;
         auto const actualOpt = entry.getHolderEncryptionKey();
@@ -179,6 +199,8 @@ TEST(MPTokenTests, BuilderFromSleRoundTrip)
     auto const confidentialBalanceVersionValue = canonical_UINT32();
     auto const issuerEncryptedBalanceValue = canonical_VL();
     auto const auditorEncryptedBalanceValue = canonical_VL();
+    auto const issuerKeyMirrorEpochValue = canonical_UINT32();
+    auto const auditorKeyMirrorEpochValue = canonical_UINT32();
     auto const holderEncryptionKeyValue = canonical_VL();
 
     auto sle = std::make_shared<SLE>(MPToken::entryType, index);
@@ -195,6 +217,8 @@ TEST(MPTokenTests, BuilderFromSleRoundTrip)
     sle->at(sfConfidentialBalanceVersion) = confidentialBalanceVersionValue;
     sle->at(sfIssuerEncryptedBalance) = issuerEncryptedBalanceValue;
     sle->at(sfAuditorEncryptedBalance) = auditorEncryptedBalanceValue;
+    sle->at(sfIssuerKeyMirrorEpoch) = issuerKeyMirrorEpochValue;
+    sle->at(sfAuditorKeyMirrorEpoch) = auditorKeyMirrorEpochValue;
     sle->at(sfHolderEncryptionKey) = holderEncryptionKeyValue;
 
     MPTokenBuilder builderFromSle{sle};
@@ -347,6 +371,32 @@ TEST(MPTokenTests, BuilderFromSleRoundTrip)
         expectEqualField(expected, *fromBuilderOpt, "sfAuditorEncryptedBalance");
     }
 
+    {
+        auto const& expected = issuerKeyMirrorEpochValue;
+
+        auto const fromSleOpt = entryFromSle.getIssuerKeyMirrorEpoch();
+        auto const fromBuilderOpt = entryFromBuilder.getIssuerKeyMirrorEpoch();
+
+        ASSERT_TRUE(fromSleOpt.has_value());
+        ASSERT_TRUE(fromBuilderOpt.has_value());
+
+        expectEqualField(expected, *fromSleOpt, "sfIssuerKeyMirrorEpoch");
+        expectEqualField(expected, *fromBuilderOpt, "sfIssuerKeyMirrorEpoch");
+    }
+
+    {
+        auto const& expected = auditorKeyMirrorEpochValue;
+
+        auto const fromSleOpt = entryFromSle.getAuditorKeyMirrorEpoch();
+        auto const fromBuilderOpt = entryFromBuilder.getAuditorKeyMirrorEpoch();
+
+        ASSERT_TRUE(fromSleOpt.has_value());
+        ASSERT_TRUE(fromBuilderOpt.has_value());
+
+        expectEqualField(expected, *fromSleOpt, "sfAuditorKeyMirrorEpoch");
+        expectEqualField(expected, *fromBuilderOpt, "sfAuditorKeyMirrorEpoch");
+    }
+
     {
         auto const& expected = holderEncryptionKeyValue;
 
@@ -436,6 +486,10 @@ TEST(MPTokenTests, OptionalFieldsReturnNullopt)
     EXPECT_FALSE(entry.getIssuerEncryptedBalance().has_value());
     EXPECT_FALSE(entry.hasAuditorEncryptedBalance());
     EXPECT_FALSE(entry.getAuditorEncryptedBalance().has_value());
+    EXPECT_FALSE(entry.hasIssuerKeyMirrorEpoch());
+    EXPECT_FALSE(entry.getIssuerKeyMirrorEpoch().has_value());
+    EXPECT_FALSE(entry.hasAuditorKeyMirrorEpoch());
+    EXPECT_FALSE(entry.getAuditorKeyMirrorEpoch().has_value());
     EXPECT_FALSE(entry.hasHolderEncryptionKey());
     EXPECT_FALSE(entry.getHolderEncryptionKey().has_value());
 }
diff --git a/src/tests/libxrpl/protocol_autogen/transactions/ConfidentialMPTMirrorUpdateTests.cpp b/src/tests/libxrpl/protocol_autogen/transactions/ConfidentialMPTMirrorUpdateTests.cpp
new file mode 100644
index 0000000000..6cbeb008bd
--- /dev/null
+++ b/src/tests/libxrpl/protocol_autogen/transactions/ConfidentialMPTMirrorUpdateTests.cpp
@@ -0,0 +1,255 @@
+// Auto-generated unit tests for transaction ConfidentialMPTMirrorUpdate
+
+
+#include <gtest/gtest.h>
+
+#include <protocol_autogen/TestHelpers.h>
+
+#include <xrpl/protocol/SecretKey.h>
+#include <xrpl/protocol/Seed.h>
+#include <xrpl/protocol/STTx.h>
+#include <xrpl/protocol_autogen/transactions/ConfidentialMPTMirrorUpdate.h>
+#include <xrpl/protocol_autogen/transactions/AccountSet.h>
+
+#include <string>
+
+namespace xrpl::transactions {
+
+// 1 & 4) Set fields via builder setters, build, then read them back via
+// wrapper getters. After build(), validate() should succeed.
+TEST(TransactionsConfidentialMPTMirrorUpdateTests, BuilderSettersRoundTrip)
+{
+    // Generate a deterministic keypair for signing
+    auto const [publicKey, secretKey] =
+        generateKeyPair(KeyType::Secp256k1, generateSeed("testConfidentialMPTMirrorUpdate"));
+
+    // Common transaction fields
+    auto const accountValue = calcAccountID(publicKey);
+    std::uint32_t const sequenceValue = 1;
+    auto const feeValue = canonical_AMOUNT();
+
+    // Transaction-specific field values
+    auto const mPTokenIssuanceIDValue = canonical_UINT192();
+    auto const holderValue = canonical_ACCOUNT();
+    auto const issuerEncryptedAmountValue = canonical_VL();
+    auto const auditorEncryptedAmountValue = canonical_VL();
+    auto const zKProofValue = canonical_VL();
+
+    ConfidentialMPTMirrorUpdateBuilder builder{
+        accountValue,
+        mPTokenIssuanceIDValue,
+        zKProofValue,
+        sequenceValue,
+        feeValue
+    };
+
+    // Set optional fields
+    builder.setHolder(holderValue);
+    builder.setIssuerEncryptedAmount(issuerEncryptedAmountValue);
+    builder.setAuditorEncryptedAmount(auditorEncryptedAmountValue);
+
+    auto tx = builder.build(publicKey, secretKey);
+
+    std::string reason;
+    EXPECT_TRUE(tx.validate(reason)) << reason;
+
+    // Verify signing was applied
+    EXPECT_FALSE(tx.getSigningPubKey().empty());
+    EXPECT_TRUE(tx.hasTxnSignature());
+
+    // Verify common fields
+    EXPECT_EQ(tx.getAccount(), accountValue);
+    EXPECT_EQ(tx.getSequence(), sequenceValue);
+    EXPECT_EQ(tx.getFee(), feeValue);
+
+    // Verify required fields
+    {
+        auto const& expected = mPTokenIssuanceIDValue;
+        auto const actual = tx.getMPTokenIssuanceID();
+        expectEqualField(expected, actual, "sfMPTokenIssuanceID");
+    }
+
+    {
+        auto const& expected = zKProofValue;
+        auto const actual = tx.getZKProof();
+        expectEqualField(expected, actual, "sfZKProof");
+    }
+
+    // Verify optional fields
+    {
+        auto const& expected = holderValue;
+        auto const actualOpt = tx.getHolder();
+        ASSERT_TRUE(actualOpt.has_value()) << "Optional field sfHolder should be present";
+        expectEqualField(expected, *actualOpt, "sfHolder");
+        EXPECT_TRUE(tx.hasHolder());
+    }
+
+    {
+        auto const& expected = issuerEncryptedAmountValue;
+        auto const actualOpt = tx.getIssuerEncryptedAmount();
+        ASSERT_TRUE(actualOpt.has_value()) << "Optional field sfIssuerEncryptedAmount should be present";
+        expectEqualField(expected, *actualOpt, "sfIssuerEncryptedAmount");
+        EXPECT_TRUE(tx.hasIssuerEncryptedAmount());
+    }
+
+    {
+        auto const& expected = auditorEncryptedAmountValue;
+        auto const actualOpt = tx.getAuditorEncryptedAmount();
+        ASSERT_TRUE(actualOpt.has_value()) << "Optional field sfAuditorEncryptedAmount should be present";
+        expectEqualField(expected, *actualOpt, "sfAuditorEncryptedAmount");
+        EXPECT_TRUE(tx.hasAuditorEncryptedAmount());
+    }
+
+}
+
+// 2 & 4) Start from an STTx, construct a builder from it, build a new wrapper,
+// and verify all fields match.
+TEST(TransactionsConfidentialMPTMirrorUpdateTests, BuilderFromStTxRoundTrip)
+{
+    // Generate a deterministic keypair for signing
+    auto const [publicKey, secretKey] =
+        generateKeyPair(KeyType::Secp256k1, generateSeed("testConfidentialMPTMirrorUpdateFromTx"));
+
+    // Common transaction fields
+    auto const accountValue = calcAccountID(publicKey);
+    std::uint32_t const sequenceValue = 2;
+    auto const feeValue = canonical_AMOUNT();
+
+    // Transaction-specific field values
+    auto const mPTokenIssuanceIDValue = canonical_UINT192();
+    auto const holderValue = canonical_ACCOUNT();
+    auto const issuerEncryptedAmountValue = canonical_VL();
+    auto const auditorEncryptedAmountValue = canonical_VL();
+    auto const zKProofValue = canonical_VL();
+
+    // Build an initial transaction
+    ConfidentialMPTMirrorUpdateBuilder initialBuilder{
+        accountValue,
+        mPTokenIssuanceIDValue,
+        zKProofValue,
+        sequenceValue,
+        feeValue
+    };
+
+    initialBuilder.setHolder(holderValue);
+    initialBuilder.setIssuerEncryptedAmount(issuerEncryptedAmountValue);
+    initialBuilder.setAuditorEncryptedAmount(auditorEncryptedAmountValue);
+
+    auto initialTx = initialBuilder.build(publicKey, secretKey);
+
+    // Create builder from existing STTx
+    ConfidentialMPTMirrorUpdateBuilder builderFromTx{initialTx.getSTTx()};
+
+    auto rebuiltTx = builderFromTx.build(publicKey, secretKey);
+
+    std::string reason;
+    EXPECT_TRUE(rebuiltTx.validate(reason)) << reason;
+
+    // Verify common fields
+    EXPECT_EQ(rebuiltTx.getAccount(), accountValue);
+    EXPECT_EQ(rebuiltTx.getSequence(), sequenceValue);
+    EXPECT_EQ(rebuiltTx.getFee(), feeValue);
+
+    // Verify required fields
+    {
+        auto const& expected = mPTokenIssuanceIDValue;
+        auto const actual = rebuiltTx.getMPTokenIssuanceID();
+        expectEqualField(expected, actual, "sfMPTokenIssuanceID");
+    }
+
+    {
+        auto const& expected = zKProofValue;
+        auto const actual = rebuiltTx.getZKProof();
+        expectEqualField(expected, actual, "sfZKProof");
+    }
+
+    // Verify optional fields
+    {
+        auto const& expected = holderValue;
+        auto const actualOpt = rebuiltTx.getHolder();
+        ASSERT_TRUE(actualOpt.has_value()) << "Optional field sfHolder should be present";
+        expectEqualField(expected, *actualOpt, "sfHolder");
+    }
+
+    {
+        auto const& expected = issuerEncryptedAmountValue;
+        auto const actualOpt = rebuiltTx.getIssuerEncryptedAmount();
+        ASSERT_TRUE(actualOpt.has_value()) << "Optional field sfIssuerEncryptedAmount should be present";
+        expectEqualField(expected, *actualOpt, "sfIssuerEncryptedAmount");
+    }
+
+    {
+        auto const& expected = auditorEncryptedAmountValue;
+        auto const actualOpt = rebuiltTx.getAuditorEncryptedAmount();
+        ASSERT_TRUE(actualOpt.has_value()) << "Optional field sfAuditorEncryptedAmount should be present";
+        expectEqualField(expected, *actualOpt, "sfAuditorEncryptedAmount");
+    }
+
+}
+
+// 3) Verify wrapper throws when constructed from wrong transaction type.
+TEST(TransactionsConfidentialMPTMirrorUpdateTests, WrapperThrowsOnWrongTxType)
+{
+    // Build a valid transaction of a different type
+    auto const [pk, sk] =
+        generateKeyPair(KeyType::Secp256k1, generateSeed("testWrongType"));
+    auto const account = calcAccountID(pk);
+
+    AccountSetBuilder wrongBuilder{account, 1, canonical_AMOUNT()};
+    auto wrongTx = wrongBuilder.build(pk, sk);
+
+    EXPECT_THROW(ConfidentialMPTMirrorUpdate{wrongTx.getSTTx()}, std::runtime_error);
+}
+
+// 4) Verify builder throws when constructed from wrong transaction type.
+TEST(TransactionsConfidentialMPTMirrorUpdateTests, BuilderThrowsOnWrongTxType)
+{
+    // Build a valid transaction of a different type
+    auto const [pk, sk] =
+        generateKeyPair(KeyType::Secp256k1, generateSeed("testWrongTypeBuilder"));
+    auto const account = calcAccountID(pk);
+
+    AccountSetBuilder wrongBuilder{account, 1, canonical_AMOUNT()};
+    auto wrongTx = wrongBuilder.build(pk, sk);
+
+    EXPECT_THROW(ConfidentialMPTMirrorUpdateBuilder{wrongTx.getSTTx()}, std::runtime_error);
+}
+
+// 5) Build with only required fields and verify optional fields return nullopt.
+TEST(TransactionsConfidentialMPTMirrorUpdateTests, OptionalFieldsReturnNullopt)
+{
+    // Generate a deterministic keypair for signing
+    auto const [publicKey, secretKey] =
+        generateKeyPair(KeyType::Secp256k1, generateSeed("testConfidentialMPTMirrorUpdateNullopt"));
+
+    // Common transaction fields
+    auto const accountValue = calcAccountID(publicKey);
+    std::uint32_t const sequenceValue = 3;
+    auto const feeValue = canonical_AMOUNT();
+
+    // Transaction-specific required field values
+    auto const mPTokenIssuanceIDValue = canonical_UINT192();
+    auto const zKProofValue = canonical_VL();
+
+    ConfidentialMPTMirrorUpdateBuilder builder{
+        accountValue,
+        mPTokenIssuanceIDValue,
+        zKProofValue,
+        sequenceValue,
+        feeValue
+    };
+
+    // Do NOT set optional fields
+
+    auto tx = builder.build(publicKey, secretKey);
+
+    // Verify optional fields are not present
+    EXPECT_FALSE(tx.hasHolder());
+    EXPECT_FALSE(tx.getHolder().has_value());
+    EXPECT_FALSE(tx.hasIssuerEncryptedAmount());
+    EXPECT_FALSE(tx.getIssuerEncryptedAmount().has_value());
+    EXPECT_FALSE(tx.hasAuditorEncryptedAmount());
+    EXPECT_FALSE(tx.getAuditorEncryptedAmount().has_value());
+}
+
+}
diff --git a/src/tests/libxrpl/protocol_autogen/transactions/EscrowCreateTests.cpp b/src/tests/libxrpl/protocol_autogen/transactions/EscrowCreateTests.cpp
index 1d62fadb20..44e3e200d8 100644
--- a/src/tests/libxrpl/protocol_autogen/transactions/EscrowCreateTests.cpp
+++ b/src/tests/libxrpl/protocol_autogen/transactions/EscrowCreateTests.cpp
@@ -30,11 +30,13 @@ TEST(TransactionsEscrowCreateTests, BuilderSettersRoundTrip)
 
     // Transaction-specific field values
     auto const destinationValue = canonical_ACCOUNT();
+    auto const destinationTagValue = canonical_UINT32();
     auto const amountValue = canonical_AMOUNT();
     auto const conditionValue = canonical_VL();
     auto const cancelAfterValue = canonical_UINT32();
     auto const finishAfterValue = canonical_UINT32();
-    auto const destinationTagValue = canonical_UINT32();
+    auto const bytecodeValue = canonical_VL();
+    auto const dataValue = canonical_VL();
 
     EscrowCreateBuilder builder{
         accountValue,
@@ -45,10 +47,12 @@ TEST(TransactionsEscrowCreateTests, BuilderSettersRoundTrip)
     };
 
     // Set optional fields
+    builder.setDestinationTag(destinationTagValue);
     builder.setCondition(conditionValue);
     builder.setCancelAfter(cancelAfterValue);
     builder.setFinishAfter(finishAfterValue);
-    builder.setDestinationTag(destinationTagValue);
+    builder.setBytecode(bytecodeValue);
+    builder.setData(dataValue);
 
     auto tx = builder.build(publicKey, secretKey);
 
@@ -78,6 +82,14 @@ TEST(TransactionsEscrowCreateTests, BuilderSettersRoundTrip)
     }
 
     // Verify optional fields
+    {
+        auto const& expected = destinationTagValue;
+        auto const actualOpt = tx.getDestinationTag();
+        ASSERT_TRUE(actualOpt.has_value()) << "Optional field sfDestinationTag should be present";
+        expectEqualField(expected, *actualOpt, "sfDestinationTag");
+        EXPECT_TRUE(tx.hasDestinationTag());
+    }
+
     {
         auto const& expected = conditionValue;
         auto const actualOpt = tx.getCondition();
@@ -103,11 +115,19 @@ TEST(TransactionsEscrowCreateTests, BuilderSettersRoundTrip)
     }
 
     {
-        auto const& expected = destinationTagValue;
-        auto const actualOpt = tx.getDestinationTag();
-        ASSERT_TRUE(actualOpt.has_value()) << "Optional field sfDestinationTag should be present";
-        expectEqualField(expected, *actualOpt, "sfDestinationTag");
-        EXPECT_TRUE(tx.hasDestinationTag());
+        auto const& expected = bytecodeValue;
+        auto const actualOpt = tx.getBytecode();
+        ASSERT_TRUE(actualOpt.has_value()) << "Optional field sfBytecode should be present";
+        expectEqualField(expected, *actualOpt, "sfBytecode");
+        EXPECT_TRUE(tx.hasBytecode());
+    }
+
+    {
+        auto const& expected = dataValue;
+        auto const actualOpt = tx.getData();
+        ASSERT_TRUE(actualOpt.has_value()) << "Optional field sfData should be present";
+        expectEqualField(expected, *actualOpt, "sfData");
+        EXPECT_TRUE(tx.hasData());
     }
 
 }
@@ -127,11 +147,13 @@ TEST(TransactionsEscrowCreateTests, BuilderFromStTxRoundTrip)
 
     // Transaction-specific field values
     auto const destinationValue = canonical_ACCOUNT();
+    auto const destinationTagValue = canonical_UINT32();
     auto const amountValue = canonical_AMOUNT();
     auto const conditionValue = canonical_VL();
     auto const cancelAfterValue = canonical_UINT32();
     auto const finishAfterValue = canonical_UINT32();
-    auto const destinationTagValue = canonical_UINT32();
+    auto const bytecodeValue = canonical_VL();
+    auto const dataValue = canonical_VL();
 
     // Build an initial transaction
     EscrowCreateBuilder initialBuilder{
@@ -142,10 +164,12 @@ TEST(TransactionsEscrowCreateTests, BuilderFromStTxRoundTrip)
         feeValue
     };
 
+    initialBuilder.setDestinationTag(destinationTagValue);
     initialBuilder.setCondition(conditionValue);
     initialBuilder.setCancelAfter(cancelAfterValue);
     initialBuilder.setFinishAfter(finishAfterValue);
-    initialBuilder.setDestinationTag(destinationTagValue);
+    initialBuilder.setBytecode(bytecodeValue);
+    initialBuilder.setData(dataValue);
 
     auto initialTx = initialBuilder.build(publicKey, secretKey);
 
@@ -176,6 +200,13 @@ TEST(TransactionsEscrowCreateTests, BuilderFromStTxRoundTrip)
     }
 
     // Verify optional fields
+    {
+        auto const& expected = destinationTagValue;
+        auto const actualOpt = rebuiltTx.getDestinationTag();
+        ASSERT_TRUE(actualOpt.has_value()) << "Optional field sfDestinationTag should be present";
+        expectEqualField(expected, *actualOpt, "sfDestinationTag");
+    }
+
     {
         auto const& expected = conditionValue;
         auto const actualOpt = rebuiltTx.getCondition();
@@ -198,10 +229,17 @@ TEST(TransactionsEscrowCreateTests, BuilderFromStTxRoundTrip)
     }
 
     {
-        auto const& expected = destinationTagValue;
-        auto const actualOpt = rebuiltTx.getDestinationTag();
-        ASSERT_TRUE(actualOpt.has_value()) << "Optional field sfDestinationTag should be present";
-        expectEqualField(expected, *actualOpt, "sfDestinationTag");
+        auto const& expected = bytecodeValue;
+        auto const actualOpt = rebuiltTx.getBytecode();
+        ASSERT_TRUE(actualOpt.has_value()) << "Optional field sfBytecode should be present";
+        expectEqualField(expected, *actualOpt, "sfBytecode");
+    }
+
+    {
+        auto const& expected = dataValue;
+        auto const actualOpt = rebuiltTx.getData();
+        ASSERT_TRUE(actualOpt.has_value()) << "Optional field sfData should be present";
+        expectEqualField(expected, *actualOpt, "sfData");
     }
 
 }
@@ -263,14 +301,18 @@ TEST(TransactionsEscrowCreateTests, OptionalFieldsReturnNullopt)
     auto tx = builder.build(publicKey, secretKey);
 
     // Verify optional fields are not present
+    EXPECT_FALSE(tx.hasDestinationTag());
+    EXPECT_FALSE(tx.getDestinationTag().has_value());
     EXPECT_FALSE(tx.hasCondition());
     EXPECT_FALSE(tx.getCondition().has_value());
     EXPECT_FALSE(tx.hasCancelAfter());
     EXPECT_FALSE(tx.getCancelAfter().has_value());
     EXPECT_FALSE(tx.hasFinishAfter());
     EXPECT_FALSE(tx.getFinishAfter().has_value());
-    EXPECT_FALSE(tx.hasDestinationTag());
-    EXPECT_FALSE(tx.getDestinationTag().has_value());
+    EXPECT_FALSE(tx.hasBytecode());
+    EXPECT_FALSE(tx.getBytecode().has_value());
+    EXPECT_FALSE(tx.hasData());
+    EXPECT_FALSE(tx.getData().has_value());
 }
 
 }
diff --git a/src/tests/libxrpl/protocol_autogen/transactions/EscrowFinishTests.cpp b/src/tests/libxrpl/protocol_autogen/transactions/EscrowFinishTests.cpp
index f76bfffb59..e062e24813 100644
--- a/src/tests/libxrpl/protocol_autogen/transactions/EscrowFinishTests.cpp
+++ b/src/tests/libxrpl/protocol_autogen/transactions/EscrowFinishTests.cpp
@@ -34,6 +34,7 @@ TEST(TransactionsEscrowFinishTests, BuilderSettersRoundTrip)
     auto const fulfillmentValue = canonical_VL();
     auto const conditionValue = canonical_VL();
     auto const credentialIDsValue = canonical_VECTOR256();
+    auto const gasValue = canonical_UINT32();
 
     EscrowFinishBuilder builder{
         accountValue,
@@ -47,6 +48,7 @@ TEST(TransactionsEscrowFinishTests, BuilderSettersRoundTrip)
     builder.setFulfillment(fulfillmentValue);
     builder.setCondition(conditionValue);
     builder.setCredentialIDs(credentialIDsValue);
+    builder.setGas(gasValue);
 
     auto tx = builder.build(publicKey, secretKey);
 
@@ -100,6 +102,14 @@ TEST(TransactionsEscrowFinishTests, BuilderSettersRoundTrip)
         EXPECT_TRUE(tx.hasCredentialIDs());
     }
 
+    {
+        auto const& expected = gasValue;
+        auto const actualOpt = tx.getGas();
+        ASSERT_TRUE(actualOpt.has_value()) << "Optional field sfGas should be present";
+        expectEqualField(expected, *actualOpt, "sfGas");
+        EXPECT_TRUE(tx.hasGas());
+    }
+
 }
 
 // 2 & 4) Start from an STTx, construct a builder from it, build a new wrapper,
@@ -121,6 +131,7 @@ TEST(TransactionsEscrowFinishTests, BuilderFromStTxRoundTrip)
     auto const fulfillmentValue = canonical_VL();
     auto const conditionValue = canonical_VL();
     auto const credentialIDsValue = canonical_VECTOR256();
+    auto const gasValue = canonical_UINT32();
 
     // Build an initial transaction
     EscrowFinishBuilder initialBuilder{
@@ -134,6 +145,7 @@ TEST(TransactionsEscrowFinishTests, BuilderFromStTxRoundTrip)
     initialBuilder.setFulfillment(fulfillmentValue);
     initialBuilder.setCondition(conditionValue);
     initialBuilder.setCredentialIDs(credentialIDsValue);
+    initialBuilder.setGas(gasValue);
 
     auto initialTx = initialBuilder.build(publicKey, secretKey);
 
@@ -185,6 +197,13 @@ TEST(TransactionsEscrowFinishTests, BuilderFromStTxRoundTrip)
         expectEqualField(expected, *actualOpt, "sfCredentialIDs");
     }
 
+    {
+        auto const& expected = gasValue;
+        auto const actualOpt = rebuiltTx.getGas();
+        ASSERT_TRUE(actualOpt.has_value()) << "Optional field sfGas should be present";
+        expectEqualField(expected, *actualOpt, "sfGas");
+    }
+
 }
 
 // 3) Verify wrapper throws when constructed from wrong transaction type.
@@ -250,6 +269,8 @@ TEST(TransactionsEscrowFinishTests, OptionalFieldsReturnNullopt)
     EXPECT_FALSE(tx.getCondition().has_value());
     EXPECT_FALSE(tx.hasCredentialIDs());
     EXPECT_FALSE(tx.getCredentialIDs().has_value());
+    EXPECT_FALSE(tx.hasGas());
+    EXPECT_FALSE(tx.getGas().has_value());
 }
 
 }
diff --git a/src/tests/libxrpl/protocol_autogen/transactions/SetFeeTests.cpp b/src/tests/libxrpl/protocol_autogen/transactions/SetFeeTests.cpp
index 9605daee9f..d7cfb469ba 100644
--- a/src/tests/libxrpl/protocol_autogen/transactions/SetFeeTests.cpp
+++ b/src/tests/libxrpl/protocol_autogen/transactions/SetFeeTests.cpp
@@ -37,6 +37,9 @@ TEST(TransactionsSetFeeTests, BuilderSettersRoundTrip)
     auto const baseFeeDropsValue = canonical_AMOUNT();
     auto const reserveBaseDropsValue = canonical_AMOUNT();
     auto const reserveIncrementDropsValue = canonical_AMOUNT();
+    auto const gasLimitValue = canonical_UINT32();
+    auto const bytecodeSizeLimitValue = canonical_UINT32();
+    auto const gasPriceValue = canonical_UINT32();
 
     SetFeeBuilder builder{
         accountValue,
@@ -53,6 +56,9 @@ TEST(TransactionsSetFeeTests, BuilderSettersRoundTrip)
     builder.setBaseFeeDrops(baseFeeDropsValue);
     builder.setReserveBaseDrops(reserveBaseDropsValue);
     builder.setReserveIncrementDrops(reserveIncrementDropsValue);
+    builder.setGasLimit(gasLimitValue);
+    builder.setBytecodeSizeLimit(bytecodeSizeLimitValue);
+    builder.setGasPrice(gasPriceValue);
 
     auto tx = builder.build(publicKey, secretKey);
 
@@ -134,6 +140,30 @@ TEST(TransactionsSetFeeTests, BuilderSettersRoundTrip)
         EXPECT_TRUE(tx.hasReserveIncrementDrops());
     }
 
+    {
+        auto const& expected = gasLimitValue;
+        auto const actualOpt = tx.getGasLimit();
+        ASSERT_TRUE(actualOpt.has_value()) << "Optional field sfGasLimit should be present";
+        expectEqualField(expected, *actualOpt, "sfGasLimit");
+        EXPECT_TRUE(tx.hasGasLimit());
+    }
+
+    {
+        auto const& expected = bytecodeSizeLimitValue;
+        auto const actualOpt = tx.getBytecodeSizeLimit();
+        ASSERT_TRUE(actualOpt.has_value()) << "Optional field sfBytecodeSizeLimit should be present";
+        expectEqualField(expected, *actualOpt, "sfBytecodeSizeLimit");
+        EXPECT_TRUE(tx.hasBytecodeSizeLimit());
+    }
+
+    {
+        auto const& expected = gasPriceValue;
+        auto const actualOpt = tx.getGasPrice();
+        ASSERT_TRUE(actualOpt.has_value()) << "Optional field sfGasPrice should be present";
+        expectEqualField(expected, *actualOpt, "sfGasPrice");
+        EXPECT_TRUE(tx.hasGasPrice());
+    }
+
 }
 
 // 2 & 4) Start from an STTx, construct a builder from it, build a new wrapper,
@@ -158,6 +188,9 @@ TEST(TransactionsSetFeeTests, BuilderFromStTxRoundTrip)
     auto const baseFeeDropsValue = canonical_AMOUNT();
     auto const reserveBaseDropsValue = canonical_AMOUNT();
     auto const reserveIncrementDropsValue = canonical_AMOUNT();
+    auto const gasLimitValue = canonical_UINT32();
+    auto const bytecodeSizeLimitValue = canonical_UINT32();
+    auto const gasPriceValue = canonical_UINT32();
 
     // Build an initial transaction
     SetFeeBuilder initialBuilder{
@@ -174,6 +207,9 @@ TEST(TransactionsSetFeeTests, BuilderFromStTxRoundTrip)
     initialBuilder.setBaseFeeDrops(baseFeeDropsValue);
     initialBuilder.setReserveBaseDrops(reserveBaseDropsValue);
     initialBuilder.setReserveIncrementDrops(reserveIncrementDropsValue);
+    initialBuilder.setGasLimit(gasLimitValue);
+    initialBuilder.setBytecodeSizeLimit(bytecodeSizeLimitValue);
+    initialBuilder.setGasPrice(gasPriceValue);
 
     auto initialTx = initialBuilder.build(publicKey, secretKey);
 
@@ -248,6 +284,27 @@ TEST(TransactionsSetFeeTests, BuilderFromStTxRoundTrip)
         expectEqualField(expected, *actualOpt, "sfReserveIncrementDrops");
     }
 
+    {
+        auto const& expected = gasLimitValue;
+        auto const actualOpt = rebuiltTx.getGasLimit();
+        ASSERT_TRUE(actualOpt.has_value()) << "Optional field sfGasLimit should be present";
+        expectEqualField(expected, *actualOpt, "sfGasLimit");
+    }
+
+    {
+        auto const& expected = bytecodeSizeLimitValue;
+        auto const actualOpt = rebuiltTx.getBytecodeSizeLimit();
+        ASSERT_TRUE(actualOpt.has_value()) << "Optional field sfBytecodeSizeLimit should be present";
+        expectEqualField(expected, *actualOpt, "sfBytecodeSizeLimit");
+    }
+
+    {
+        auto const& expected = gasPriceValue;
+        auto const actualOpt = rebuiltTx.getGasPrice();
+        ASSERT_TRUE(actualOpt.has_value()) << "Optional field sfGasPrice should be present";
+        expectEqualField(expected, *actualOpt, "sfGasPrice");
+    }
+
 }
 
 // 3) Verify wrapper throws when constructed from wrong transaction type.
@@ -319,6 +376,12 @@ TEST(TransactionsSetFeeTests, OptionalFieldsReturnNullopt)
     EXPECT_FALSE(tx.getReserveBaseDrops().has_value());
     EXPECT_FALSE(tx.hasReserveIncrementDrops());
     EXPECT_FALSE(tx.getReserveIncrementDrops().has_value());
+    EXPECT_FALSE(tx.hasGasLimit());
+    EXPECT_FALSE(tx.getGasLimit().has_value());
+    EXPECT_FALSE(tx.hasBytecodeSizeLimit());
+    EXPECT_FALSE(tx.getBytecodeSizeLimit().has_value());
+    EXPECT_FALSE(tx.hasGasPrice());
+    EXPECT_FALSE(tx.getGasPrice().has_value());
 }
 
 }
diff --git a/src/tests/libxrpl/server/InfoSub.cpp b/src/tests/libxrpl/server/InfoSub.cpp
index 6913812a92..08698ae3ac 100644
--- a/src/tests/libxrpl/server/InfoSub.cpp
+++ b/src/tests/libxrpl/server/InfoSub.cpp
@@ -12,7 +12,7 @@ using namespace xrpl;
 // by subscribing the real cap through a WebSocket, which would exceed the frame
 // limit and drop the connection before the check runs) lets the boundary be
 // asserted exactly.
-TEST(InfoSubSubscriptionCap, Boundary)
+TEST(InfoSubSubscriptionCap, boundary)
 {
     constexpr std::size_t cap = kMaxSubscriptionsPerConnection;
 
@@ -30,7 +30,7 @@ TEST(InfoSubSubscriptionCap, Boundary)
     EXPECT_TRUE(exceedsSubscriptionCap(cap - 1, 2));
 }
 
-TEST(InfoSubSubscriptionCap, NoOverflow)
+TEST(InfoSubSubscriptionCap, no_overflow)
 {
     constexpr std::size_t cap = kMaxSubscriptionsPerConnection;
     constexpr std::size_t max = std::numeric_limits<std::size_t>::max();
@@ -41,7 +41,7 @@ TEST(InfoSubSubscriptionCap, NoOverflow)
     EXPECT_TRUE(exceedsSubscriptionCap(cap, max));
 }
 
-TEST(InfoSubSubscriptionCap, ExplicitCap)
+TEST(InfoSubSubscriptionCap, explicit_cap)
 {
     // A configured override is honored: the boundary tracks the passed cap, not
     // the built-in default. This is the seam doSubscribe uses to enforce a
diff --git a/src/tests/libxrpl/shamap/SHAMap.cpp b/src/tests/libxrpl/shamap/SHAMap.cpp
index 7f7d6ffba2..f67c299300 100644
--- a/src/tests/libxrpl/shamap/SHAMap.cpp
+++ b/src/tests/libxrpl/shamap/SHAMap.cpp
@@ -272,6 +272,458 @@ INSTANTIATE_TEST_SUITE_P(
     ::testing::Values(kBackedMode, kUnbackedMode),
     shamapBackingModeName);
 
+// Exercises the traversal stacks built by belowHelper. Each stack entry pairs a node with the ID
+// naming its position, and SHAMap asserts that pairing on every push, so these traversals fail
+// loudly in a Debug build if a node ID is ever derived from the wrong branch.
+class SHAMapTraversal : public ::testing::Test
+{
+protected:
+    beast::Journal const j_{TestSink::instance()};
+
+    // Keys that share a long prefix and then fan out across distinct branches, so the deeper inner
+    // nodes have several children and traversal must descend many levels.
+    static std::vector<uint256>
+    deepFanOutKeys()
+    {
+        std::vector<uint256> keys;
+        for (unsigned int branch = 0; branch < SHAMap::kBranchFactor; ++branch)
+        {
+            // Vary the 6th nibble, keeping the first five identical.
+            auto text = std::string("abcde") + "0123456789abcdef"[branch];
+            text.append(64 - text.size(), '7');
+            keys.emplace_back(std::string_view{text});
+        }
+        return keys;
+    }
+
+    // Keys that share all 63 leading nibbles and fan out only at the last one, so the tree is a
+    // chain of single-child inner nodes down to depth 63 with the leaves as siblings at depth 64.
+    // This exercises kLeafDepth directly, unlike deepFanOutKeys() above, whose fan-out at the 6th
+    // nibble keeps the tree only about 6 levels deep.
+    static std::vector<uint256>
+    deepFanOutKeysAtLeafDepth()
+    {
+        std::vector<uint256> keys;
+        for (unsigned int branch = 0; branch < SHAMap::kBranchFactor; ++branch)
+        {
+            auto text = std::string(63, 'a') + "0123456789abcdef"[branch];
+            keys.emplace_back(std::string_view{text});
+        }
+        return keys;
+    }
+
+    static void
+    fillMap(SHAMap& map, std::vector<uint256> const& keys)
+    {
+        map.setUnbacked();
+        for (auto const& k : keys)
+        {
+            Buffer vuc{32};
+            std::fill_n(vuc.data(), vuc.size(), std::uint8_t{1});
+            EXPECT_TRUE(
+                map.addItem(SHAMapNodeType::TnAccountState, makeShamapitem(k, std::move(vuc))));
+            map.invariants();
+        }
+    }
+};
+
+TEST_F(SHAMapTraversal, forward_iteration_visits_every_key_in_order)
+{
+    tests::TestNodeFamily f{j_};
+    auto keys = deepFanOutKeys();
+    SHAMap map{SHAMapType::FREE, f};
+    fillMap(map, keys);
+
+    std::ranges::sort(keys);
+    std::vector<uint256> visited;
+    for (auto const& item : map)
+        visited.push_back(item.key());
+
+    EXPECT_EQ(visited, keys);
+}
+
+TEST_F(SHAMapTraversal, upper_bound_walks_the_whole_map)
+{
+    tests::TestNodeFamily f{j_};
+    auto keys = deepFanOutKeys();
+    SHAMap map{SHAMapType::FREE, f};
+    fillMap(map, keys);
+    std::ranges::sort(keys);
+
+    // upperBound from each key must land on its successor, driving belowHelper across every
+    // subtree.
+    for (std::size_t k = 0; k + 1 < keys.size(); ++k)
+    {
+        auto it = map.upperBound(keys[k]);
+        ASSERT_NE(it, map.end()) << "no successor for key " << k;
+        EXPECT_EQ(it->key(), keys[k + 1]) << "wrong successor for key " << k;
+    }
+    EXPECT_EQ(map.upperBound(keys.back()), map.end());
+}
+
+TEST_F(SHAMapTraversal, lower_bound_walks_the_whole_map)
+{
+    tests::TestNodeFamily f{j_};
+    auto keys = deepFanOutKeys();
+    SHAMap map{SHAMapType::FREE, f};
+    fillMap(map, keys);
+    std::ranges::sort(keys);
+
+    // lowerBound is the reverse direction: belowHelper descends to the greatest key below a
+    // subtree.
+    for (std::size_t k = 1; k < keys.size(); ++k)
+    {
+        auto it = map.lowerBound(keys[k]);
+        ASSERT_NE(it, map.end()) << "no predecessor for key " << k;
+        EXPECT_EQ(it->key(), keys[k - 1]) << "wrong predecessor for key " << k;
+    }
+    EXPECT_EQ(map.lowerBound(keys.front()), map.end());
+}
+
+TEST_F(SHAMapTraversal, bounds_agree_with_iteration_for_absent_keys)
+{
+    tests::TestNodeFamily f{j_};
+    auto keys = deepFanOutKeys();
+    SHAMap map{SHAMapType::FREE, f};
+    fillMap(map, keys);
+    std::ranges::sort(keys);
+
+    // Probe keys that are not in the map, so the traversal starts mid-tree rather than at a leaf.
+    for (unsigned char const c : {0x00, 0x40, 0x80, 0xc0, 0xff})
+    {
+        uint256 probe;
+        std::fill_n(probe.begin(), probe.size(), c);
+
+        auto const expectedUpper = std::ranges::upper_bound(keys, probe);
+        auto const upper = map.upperBound(probe);
+        if (expectedUpper == keys.end())
+        {
+            EXPECT_EQ(upper, map.end()) << "probe " << static_cast<unsigned>(c);
+        }
+        else
+        {
+            ASSERT_NE(upper, map.end()) << "probe " << static_cast<unsigned>(c);
+            EXPECT_EQ(upper->key(), *expectedUpper) << "probe " << static_cast<unsigned>(c);
+        }
+
+        auto const lowerCount = std::ranges::lower_bound(keys, probe) - keys.begin();
+        auto const lower = map.lowerBound(probe);
+        if (lowerCount == 0)
+        {
+            EXPECT_EQ(lower, map.end()) << "probe " << static_cast<unsigned>(c);
+        }
+        else
+        {
+            ASSERT_NE(lower, map.end()) << "probe " << static_cast<unsigned>(c);
+            EXPECT_EQ(lower->key(), keys[lowerCount - 1]) << "probe " << static_cast<unsigned>(c);
+        }
+    }
+
+    // Probe keys that land on a leaf and require the leaf-pop-and-resume case. Keys share
+    // "abcde" as a prefix and vary the 6th nibble, so a probe that shares the full prefix
+    // but differs in the padding hits a leaf from either side: '0' padded with '0' lands below
+    // the first key, and 'f' padded with 'f' lands above the last.
+    for (char const nibble : {'0', 'f'})
+    {
+        auto text = std::string("abcde") + nibble;
+        text.append(64 - text.size(), nibble);
+        uint256 const probe{std::string_view{text}};
+
+        auto const expectedUpper = std::ranges::upper_bound(keys, probe);
+        auto const upper = map.upperBound(probe);
+        if (expectedUpper == keys.end())
+        {
+            EXPECT_EQ(upper, map.end()) << "nibble " << nibble;
+        }
+        else
+        {
+            ASSERT_NE(upper, map.end()) << "nibble " << nibble;
+            EXPECT_EQ(upper->key(), *expectedUpper) << "nibble " << nibble;
+        }
+
+        auto const lowerCount = std::ranges::lower_bound(keys, probe) - keys.begin();
+        auto const lower = map.lowerBound(probe);
+        if (lowerCount == 0)
+        {
+            EXPECT_EQ(lower, map.end()) << "nibble " << nibble;
+        }
+        else
+        {
+            ASSERT_NE(lower, map.end()) << "nibble " << nibble;
+            EXPECT_EQ(lower->key(), keys[lowerCount - 1]) << "nibble " << nibble;
+        }
+    }
+}
+
+TEST_F(SHAMapTraversal, bounds_on_empty_map_return_end)
+{
+    tests::TestNodeFamily f{j_};
+    SHAMap map{SHAMapType::FREE, f};
+    map.setUnbacked();
+
+    // The root is a childless inner node, so boundHelper's inner-node branch scans every branch on
+    // the requested side of the one id selects, finds them all empty, and falls through to end()
+    // rather than dereference a child.
+    EXPECT_EQ(map.upperBound(uint256{}), map.end());
+    EXPECT_EQ(map.lowerBound(uint256{}), map.end());
+
+    uint256 probe;
+    std::fill_n(probe.begin(), probe.size(), std::uint8_t{0xff});
+    EXPECT_EQ(map.upperBound(probe), map.end());
+    EXPECT_EQ(map.lowerBound(probe), map.end());
+}
+
+TEST_F(SHAMapTraversal, bounds_on_single_item_map_use_the_leaf_below_the_root)
+{
+    tests::TestNodeFamily f{j_};
+    SHAMap map{SHAMapType::FREE, f};
+
+    auto const key = deepFanOutKeys().front();
+    fillMap(map, {key});
+
+    // fillMap adds items in-process, so root_ stays an inner node with the single leaf below it.
+    // The stack holds both, so boundHelper examines the leaf first.
+    uint256 below = key;
+    --below;
+    uint256 above = key;
+    ++above;
+
+    auto const upper = map.upperBound(below);
+    ASSERT_NE(upper, map.end());
+    EXPECT_EQ(upper->key(), key);
+    EXPECT_EQ(map.upperBound(key), map.end());
+    EXPECT_EQ(map.upperBound(above), map.end());
+
+    auto const lower = map.lowerBound(above);
+    ASSERT_NE(lower, map.end());
+    EXPECT_EQ(lower->key(), key);
+    EXPECT_EQ(map.lowerBound(key), map.end());
+    EXPECT_EQ(map.lowerBound(below), map.end());
+}
+
+TEST_F(SHAMapTraversal, iteration_survives_deletions)
+{
+    tests::TestNodeFamily f{j_};
+    auto keys = deepFanOutKeys();
+    SHAMap map{SHAMapType::FREE, f};
+    fillMap(map, keys);
+    std::ranges::sort(keys);
+
+    // Deleting every other key drops the fan-out node's branch count from 16 to 8, never the 1
+    // that would make delItem collapse it into a leaf. So this pins that iteration survives
+    // deletions that reshape the map without collapsing any inner node; the case that does
+    // collapse one is iteration_survives_a_collapsed_inner_node below.
+    for (std::size_t k = 0; k < keys.size(); k += 2)
+    {
+        ASSERT_TRUE(map.delItem(keys[k]));
+        map.invariants();
+    }
+
+    std::vector<uint256> expected;
+    for (std::size_t k = 1; k < keys.size(); k += 2)
+        expected.push_back(keys[k]);
+
+    std::vector<uint256> visited;
+    for (auto const& item : map)
+        visited.push_back(item.key());
+    EXPECT_EQ(visited, expected);
+
+    for (std::size_t k = 0; k + 1 < expected.size(); ++k)
+    {
+        auto it = map.upperBound(expected[k]);
+        ASSERT_NE(it, map.end());
+        EXPECT_EQ(it->key(), expected[k + 1]);
+    }
+}
+
+TEST_F(SHAMapTraversal, iteration_survives_a_collapsed_inner_node)
+{
+    tests::TestNodeFamily f{j_};
+    SHAMap map{SHAMapType::FREE, f};
+
+    // One key in a separate subtree, diverging from the fan-out group at the very first nibble, so
+    // it survives untouched while the fan-out group below is collapsed.
+    auto const sentinel = uint256{std::string_view{std::string(64, '0')}};
+
+    auto fanOutKeys = deepFanOutKeysAtLeafDepth();
+    fillMap(map, fanOutKeys);
+    Buffer vuc{32};
+    std::fill_n(vuc.data(), vuc.size(), std::uint8_t{1});
+    ASSERT_TRUE(
+        map.addItem(SHAMapNodeType::TnAccountState, makeShamapitem(sentinel, std::move(vuc))));
+    map.invariants();
+
+    std::ranges::sort(fanOutKeys);
+
+    // Delete all but the last fan-out key. The fan-out node's branch count drops to 1 on the final
+    // delete, which delItem collapses by pulling the sole remaining leaf up in its place; every
+    // ancestor above it has exactly one child by construction, so each of those also drops to
+    // branch count 1 and collapses in turn, all the way up to (but not including) the root. That
+    // final delete replaces the entire 63-level chain with the root pointing straight at the one
+    // remaining leaf, so the surviving traversal stack is rebuilt over a drastically different tree
+    // shape, not just missing one inner node.
+    for (std::size_t k = 0; k + 1 < fanOutKeys.size(); ++k)
+    {
+        ASSERT_TRUE(map.delItem(fanOutKeys[k]));
+        map.invariants();
+    }
+
+    std::vector<uint256> const expected{sentinel, fanOutKeys.back()};
+    std::vector<uint256> visited;
+    for (auto const& item : map)
+        visited.push_back(item.key());
+    EXPECT_EQ(visited, expected);
+
+    auto it = map.upperBound(sentinel);
+    ASSERT_NE(it, map.end());
+    EXPECT_EQ(it->key(), fanOutKeys.back());
+    EXPECT_EQ(map.upperBound(fanOutKeys.back()), map.end());
+}
+
+// The tests below mirror the ones above but use deepFanOutKeysAtLeafDepth(), whose keys share all
+// 63 leading nibbles and fan out only at the last one. That puts the leaves at depth
+// SHAMap::kLeafDepth, so these traversals walk a chain of single-child inner nodes all the way down
+// and exercise the kLeafDepth guards that deepFanOutKeys() alone (fanning out at the 6th nibble)
+// never reaches.
+
+TEST_F(SHAMapTraversal, forward_iteration_visits_every_key_in_order_at_leaf_depth)
+{
+    tests::TestNodeFamily f{j_};
+    auto keys = deepFanOutKeysAtLeafDepth();
+    SHAMap map{SHAMapType::FREE, f};
+    fillMap(map, keys);
+
+    std::ranges::sort(keys);
+    std::vector<uint256> visited;
+    for (auto const& item : map)
+        visited.push_back(item.key());
+
+    EXPECT_EQ(visited, keys);
+}
+
+TEST_F(SHAMapTraversal, upper_bound_walks_the_whole_map_at_leaf_depth)
+{
+    tests::TestNodeFamily f{j_};
+    auto keys = deepFanOutKeysAtLeafDepth();
+    SHAMap map{SHAMapType::FREE, f};
+    fillMap(map, keys);
+    std::ranges::sort(keys);
+
+    // upperBound from each key must land on its successor, driving belowHelper down to depth
+    // kLeafDepth for every subtree.
+    for (std::size_t k = 0; k + 1 < keys.size(); ++k)
+    {
+        auto it = map.upperBound(keys[k]);
+        ASSERT_NE(it, map.end()) << "no successor for key " << k;
+        EXPECT_EQ(it->key(), keys[k + 1]) << "wrong successor for key " << k;
+    }
+    EXPECT_EQ(map.upperBound(keys.back()), map.end());
+}
+
+TEST_F(SHAMapTraversal, lower_bound_walks_the_whole_map_at_leaf_depth)
+{
+    tests::TestNodeFamily f{j_};
+    auto keys = deepFanOutKeysAtLeafDepth();
+    SHAMap map{SHAMapType::FREE, f};
+    fillMap(map, keys);
+    std::ranges::sort(keys);
+
+    // lowerBound is the reverse direction: belowHelper descends to depth kLeafDepth to find the
+    // greatest key below a subtree.
+    for (std::size_t k = 1; k < keys.size(); ++k)
+    {
+        auto it = map.lowerBound(keys[k]);
+        ASSERT_NE(it, map.end()) << "no predecessor for key " << k;
+        EXPECT_EQ(it->key(), keys[k - 1]) << "wrong predecessor for key " << k;
+    }
+    EXPECT_EQ(map.lowerBound(keys.front()), map.end());
+}
+
+TEST_F(SHAMapTraversal, bounds_agree_with_iteration_for_absent_keys_at_leaf_depth)
+{
+    tests::TestNodeFamily f{j_};
+    auto keys = deepFanOutKeysAtLeafDepth();
+    SHAMap map{SHAMapType::FREE, f};
+    fillMap(map, keys);
+    std::ranges::sort(keys);
+
+    // The keys fill all 16 branches of the last nibble, so an absent key must diverge from the
+    // shared 'a' prefix earlier than that. Diverging at increasingly deep nibbles forces
+    // walkTowardsKey to descend through more single-child inner nodes before it finds the empty
+    // branch, right up to the one just above kLeafDepth.
+    for (unsigned int const divergeAt : {0u, 31u, 61u, 62u})
+    {
+        // '9' sorts below the shared 'a' prefix and 'b' above it, so the probe lands under or
+        // over the whole key block -- driving belowHelper's First and Last descents respectively.
+        for (char const nibble : {'9', 'b'})
+        {
+            auto text = std::string(divergeAt, 'a') + nibble;
+            text.append(64 - text.size(), '0');
+            uint256 const probe{std::string_view{text}};
+
+            auto const expectedUpper = std::ranges::upper_bound(keys, probe);
+            auto const upper = map.upperBound(probe);
+            if (expectedUpper == keys.end())
+            {
+                EXPECT_EQ(upper, map.end()) << "divergeAt " << divergeAt << " nibble " << nibble;
+            }
+            else
+            {
+                ASSERT_NE(upper, map.end()) << "divergeAt " << divergeAt << " nibble " << nibble;
+                EXPECT_EQ(upper->key(), *expectedUpper)
+                    << "divergeAt " << divergeAt << " nibble " << nibble;
+            }
+
+            auto const lowerCount = std::ranges::lower_bound(keys, probe) - keys.begin();
+            auto const lower = map.lowerBound(probe);
+            if (lowerCount == 0)
+            {
+                EXPECT_EQ(lower, map.end()) << "divergeAt " << divergeAt << " nibble " << nibble;
+            }
+            else
+            {
+                ASSERT_NE(lower, map.end()) << "divergeAt " << divergeAt << " nibble " << nibble;
+                EXPECT_EQ(lower->key(), keys[lowerCount - 1])
+                    << "divergeAt " << divergeAt << " nibble " << nibble;
+            }
+        }
+    }
+}
+
+TEST_F(SHAMapTraversal, iteration_survives_deletions_at_leaf_depth)
+{
+    tests::TestNodeFamily f{j_};
+    auto keys = deepFanOutKeysAtLeafDepth();
+    SHAMap map{SHAMapType::FREE, f};
+    fillMap(map, keys);
+    std::ranges::sort(keys);
+
+    // Deleting every other key drops the fan-out node's branch count from 16 to 8, the same
+    // non-collapsing case as iteration_survives_deletions above, but reached by descending through
+    // a chain of single-child inner nodes down to kLeafDepth instead of a shallow one.
+    for (std::size_t k = 0; k < keys.size(); k += 2)
+    {
+        ASSERT_TRUE(map.delItem(keys[k]));
+        map.invariants();
+    }
+
+    std::vector<uint256> expected;
+    for (std::size_t k = 1; k < keys.size(); k += 2)
+        expected.push_back(keys[k]);
+
+    std::vector<uint256> visited;
+    for (auto const& item : map)
+        visited.push_back(item.key());
+    EXPECT_EQ(visited, expected);
+
+    for (std::size_t k = 0; k + 1 < expected.size(); ++k)
+    {
+        auto it = map.upperBound(expected[k]);
+        ASSERT_NE(it, map.end());
+        EXPECT_EQ(it->key(), expected[k + 1]);
+    }
+}
+
 class SHAMapPathProof : public ::testing::Test
 {
 protected:
diff --git a/src/tests/libxrpl/shamap/SHAMapNodeID.cpp b/src/tests/libxrpl/shamap/SHAMapNodeID.cpp
new file mode 100644
index 0000000000..95b7497c9c
--- /dev/null
+++ b/src/tests/libxrpl/shamap/SHAMapNodeID.cpp
@@ -0,0 +1,193 @@
+#include <xrpl/shamap/SHAMapNodeID.h>
+
+#include <xrpl/basics/base_uint.h>
+#include <xrpl/protocol/Serializer.h>
+#include <xrpl/shamap/SHAMap.h>
+
+#include <gtest/gtest.h>
+
+#include <stdexcept>
+
+namespace xrpl::tests {
+
+// An arbitrary 32-byte key reused across tests below that don't care about its specific value,
+// only that it is a well-formed key.
+constexpr uint256 kTestKey("b92891fe4ef6cee585fdc6fda1e09eb4d386363158ec3321b8123e5a772c6ca8");
+
+TEST(SHAMapNodeIDTest, root_is_prefix_of_every_key)
+{
+    SHAMapNodeID const root;
+    EXPECT_EQ(root.getDepth(), 0u);
+    EXPECT_TRUE(root.isPrefixOf(uint256{}));
+    EXPECT_TRUE(root.isPrefixOf(kTestKey));
+}
+
+TEST(SHAMapNodeIDTest, child_id_is_prefix_of_keys_in_that_branch)
+{
+    // Walking the branches spelled by the key's own nibbles must keep every
+    // intermediate ID a prefix of that key.
+    SHAMapNodeID id;
+    for (auto depth = 0u; depth < SHAMap::kLeafDepth; ++depth)
+    {
+        id = id.getChildNodeID(selectBranch(id, kTestKey));
+        EXPECT_EQ(id.getDepth(), depth + 1);
+        EXPECT_TRUE(id.isPrefixOf(kTestKey)) << "depth " << id.getDepth();
+    }
+}
+
+TEST(SHAMapNodeIDTest, wrong_branch_is_not_prefix_of_key)
+{
+    SHAMapNodeID const root;
+    auto const correct = selectBranch(root, kTestKey);
+    ASSERT_EQ(correct, 0xbu);
+
+    // An ID built from the wrong branch still has a valid depth and a self-consistent mask, so
+    // isPrefixOf(kTestKey) below is what actually distinguishes the correct branch from the rest.
+    for (auto branch = 0u; branch < SHAMap::kBranchFactor; ++branch)
+    {
+        auto const child = root.getChildNodeID(branch);
+        EXPECT_EQ(child.getDepth(), 1u);
+        EXPECT_EQ(child.isPrefixOf(kTestKey), branch == correct) << "branch " << branch;
+    }
+}
+
+TEST(SHAMapNodeIDTest, prefix_check_is_depth_sensitive)
+{
+    // kTestKey and kOther agree on the first two nibbles ("b9") and then diverge.
+    constexpr uint256 kOther("b99891fe4ef6cee585fdc6fda1e09eb4d386363158ec3321b8123e5a772c6ca8");
+
+    auto id = SHAMapNodeID{}.getChildNodeID(selectBranch(SHAMapNodeID{}, kTestKey));
+    EXPECT_TRUE(id.isPrefixOf(kTestKey));
+    EXPECT_TRUE(id.isPrefixOf(kOther)) << "shared first nibble";
+
+    id = id.getChildNodeID(selectBranch(id, kTestKey));
+    EXPECT_TRUE(id.isPrefixOf(kTestKey));
+    EXPECT_TRUE(id.isPrefixOf(kOther)) << "shared second nibble";
+
+    // Third nibble differs, so the deeper ID no longer covers kOther.
+    id = id.getChildNodeID(selectBranch(id, kTestKey));
+    EXPECT_TRUE(id.isPrefixOf(kTestKey));
+    EXPECT_FALSE(id.isPrefixOf(kOther));
+}
+
+TEST(SHAMapNodeIDTest, leaf_id_from_key_is_prefix_of_that_key)
+{
+    SHAMapNodeID const leaf{SHAMap::kLeafDepth, kTestKey};
+    EXPECT_TRUE(leaf.isPrefixOf(kTestKey));
+
+    // At full depth the prefix is the whole key, so nothing else matches.
+    constexpr uint256 kOther("b92891fe4ef6cee585fdc6fda1e09eb4d386363158ec3321b8123e5a772c6ca9");
+    EXPECT_FALSE(leaf.isPrefixOf(kOther));
+}
+
+TEST(SHAMapNodeIDTest, create_id_masks_key_to_depth)
+{
+    for (auto depth = 0u; depth <= SHAMap::kLeafDepth; ++depth)
+    {
+        auto const id = SHAMapNodeID::createID(depth, kTestKey);
+        EXPECT_EQ(id.getDepth(), depth);
+        EXPECT_TRUE(id.isPrefixOf(kTestKey)) << "depth " << depth;
+    }
+}
+
+// The guards below must hold with XRPL_ASSERT compiled out (NDEBUG), so each one
+// has to be a real runtime check rather than an assert.
+
+TEST(SHAMapNodeIDTest, child_of_leaf_depth_id_throws)
+{
+    auto const leafDepthID = SHAMapNodeID::createID(SHAMap::kLeafDepth, kTestKey);
+    ASSERT_EQ(leafDepthID.getDepth(), SHAMap::kLeafDepth);
+    EXPECT_THROW((void)leafDepthID.getChildNodeID(0), std::logic_error);
+}
+
+TEST(SHAMapNodeIDDeathTest, out_of_range_depth_is_clamped)
+{
+    // A depth past kLeafDepth has no mask in depthMask's 65-entry table, so both the constructor
+    // and createID clamp it. createID needs its own clamp: it picks the mask while evaluating the
+    // constructor's argument, so the constructor's clamp cannot cover that read.
+    //
+    // Both clamps are marked UNREACHABLE, which is an assert and therefore fatal wherever asserts
+    // are live. Only a build with them compiled out (or routed to Antithesis's non-fatal handler)
+    // reaches the clamp itself, so that is the only configuration that can assert on the result.
+#if defined(NDEBUG) || defined(ENABLE_VOIDSTAR)
+    for (auto const depth : {SHAMap::kLeafDepth + 1u, 100u, 255u, 256u, 320u})
+    {
+        auto const id = SHAMapNodeID::createID(depth, kTestKey);
+
+        // Clamped to a real depth, not the depth asked for, and not a byte-narrowed version of it:
+        // 256 would otherwise become 0 and name the root, 320 would become 64.
+        EXPECT_EQ(id.getDepth(), SHAMap::kLeafDepth) << "depth " << depth;
+
+        // id_ and depth_ still agree, so the object is usable rather than merely non-crashing.
+        EXPECT_TRUE(id.isPrefixOf(kTestKey)) << "depth " << depth;
+        EXPECT_EQ(id, SHAMapNodeID::createID(SHAMap::kLeafDepth, kTestKey)) << "depth " << depth;
+
+        // The clamp holds through the wire format too, which encodes the depth in one byte.
+        auto const roundTripped = deserializeSHAMapNodeID(id.getRawString());
+        ASSERT_TRUE(roundTripped.has_value()) << "depth " << depth;
+        EXPECT_EQ(roundTripped->getDepth(), SHAMap::kLeafDepth) << "depth " << depth;
+    }
+
+    // The constructor clamps on its own, for the paths that do not go through createID.
+    SHAMapNodeID const direct{SHAMap::kLeafDepth + 1u, uint256{}};
+    EXPECT_EQ(direct.getDepth(), SHAMap::kLeafDepth);
+#else
+    EXPECT_DEATH(
+        (void)SHAMapNodeID::createID(SHAMap::kLeafDepth + 1u, kTestKey), "depth within tree");
+#endif
+}
+
+TEST(SHAMapNodeIDDeathTest, select_branch_clamps_leaf_depth)
+{
+    // selectBranch's own precondition is depth < kLeafDepth: a depth-64 ID has no nibble left
+    // to select. That makes it unlike the guards above, which have a throw/return reachable
+    // even with XRPL_ASSERT compiled out; selectBranch has no such path, so the two build
+    // configurations have to be tested differently.
+    //
+    // Under ENABLE_VOIDSTAR, XRPL_ASSERT routes to Antithesis's assert_impl, which only records
+    // the hit and returns rather than aborting, even though NDEBUG is undefined there (voidstar
+    // requires a Debug build). So the assert is live in name but never fatal, the same as the
+    // NDEBUG case below.
+    auto const leafDepthID = SHAMapNodeID::createID(SHAMap::kLeafDepth, kTestKey);
+
+#if defined(NDEBUG) || defined(ENABLE_VOIDSTAR)
+    // With the assert compiled out or routed to a non-fatal handler, the clamp is what stands
+    // between this call and reading past the end of the 32-byte key. Clamping means it reads the
+    // same byte, and returns the same branch, as the deepest ID that still has one: depth 63.
+    auto const deepestWithBranchID = SHAMapNodeID::createID(SHAMap::kLeafDepth - 1u, kTestKey);
+    auto const branch = selectBranch(leafDepthID, kTestKey);
+    EXPECT_LT(branch, SHAMap::kBranchFactor);
+    EXPECT_EQ(branch, selectBranch(deepestWithBranchID, kTestKey));
+#else
+    // In a debug build the assert is live and must reject this call outright, in a forked
+    // process so a failure here cannot take down the rest of the suite.
+    EXPECT_DEATH((void)selectBranch(leafDepthID, kTestKey), "depth below leaf depth");
+#endif
+}
+
+TEST(SHAMapNodeIDTest, deserialize_rejects_out_of_range_depth)
+{
+    // getRawString() only serializes a depth already accepted by the constructor's own
+    // assertion, so an out-of-range depth here is built by hand instead.
+    auto serializeWithRawDepth = [](unsigned int depth) {
+        Serializer s;
+        s.addBitString(uint256{});
+        s.add8(static_cast<unsigned char>(depth));
+        return s.getString();
+    };
+
+    for (auto const depth : {65u, 100u, 255u})
+    {
+        EXPECT_FALSE(deserializeSHAMapNodeID(serializeWithRawDepth(depth)).has_value())
+            << "depth " << depth;
+    }
+
+    // A depth-64 ID is legal, since leaves live there, but it has no children.
+    auto const id =
+        deserializeSHAMapNodeID(SHAMapNodeID{SHAMap::kLeafDepth, uint256{}}.getRawString());
+    ASSERT_TRUE(id.has_value());
+    // NOLINTNEXTLINE(bugprone-unchecked-optional-access) has_value checked above
+    EXPECT_THROW((void)id->getChildNodeID(0), std::logic_error);
+}
+
+}  // namespace xrpl::tests
diff --git a/src/tests/libxrpl/tx/AccountSet.cpp b/src/tests/libxrpl/tx/AccountSet.cpp
index ae291791d4..fe6818670e 100644
--- a/src/tests/libxrpl/tx/AccountSet.cpp
+++ b/src/tests/libxrpl/tx/AccountSet.cpp
@@ -43,7 +43,7 @@
 
 namespace xrpl::test {
 
-TEST(AccountSet, NullAccountSet)
+TEST(AccountSet, null_account_set)
 {
     TxTest env;
 
@@ -60,7 +60,7 @@ TEST(AccountSet, NullAccountSet)
     EXPECT_EQ(accountRoot.getFlags(), 0);
 }
 
-TEST(AccountSet, MostFlags)
+TEST(AccountSet, most_flags)
 {
     Account const alice("alice");
 
@@ -175,7 +175,7 @@ TEST(AccountSet, MostFlags)
     });
 }
 
-TEST(AccountSet, SetAndResetAccountTxnID)
+TEST(AccountSet, set_and_reset_account_txn_id)
 {
     TxTest env;
     Account const alice("alice");
@@ -206,7 +206,7 @@ TEST(AccountSet, SetAndResetAccountTxnID)
     EXPECT_EQ(nowFlags, origFlags);
 }
 
-TEST(AccountSet, SetNoFreeze)
+TEST(AccountSet, set_no_freeze)
 {
     TxTest env;
     Account const alice("alice");
@@ -249,7 +249,7 @@ TEST(AccountSet, SetNoFreeze)
     EXPECT_TRUE(env.getAccountRoot(alice).isFlag(lsfNoFreeze));
 }
 
-TEST(AccountSet, Domain)
+TEST(AccountSet, domain)
 {
     TxTest env;
     Account const alice("alice");
@@ -317,7 +317,7 @@ TEST(AccountSet, Domain)
     }
 }
 
-TEST(AccountSet, MessageKey)
+TEST(AccountSet, message_key)
 {
     TxTest env;
     Account const alice("alice");
@@ -358,7 +358,7 @@ TEST(AccountSet, MessageKey)
         telBAD_PUBLIC_KEY);
 }
 
-TEST(AccountSet, WalletID)
+TEST(AccountSet, wallet_id)
 {
     TxTest env;
     Account const alice("alice");
@@ -391,7 +391,7 @@ TEST(AccountSet, WalletID)
     EXPECT_FALSE(env.getAccountRoot(alice).hasWalletLocator());
 }
 
-TEST(AccountSet, EmailHash)
+TEST(AccountSet, email_hash)
 {
     TxTest env;
     Account const alice("alice");
@@ -422,7 +422,7 @@ TEST(AccountSet, EmailHash)
     EXPECT_FALSE(env.getAccountRoot(alice).hasEmailHash());
 }
 
-TEST(AccountSet, TransferRate)
+TEST(AccountSet, transfer_rate)
 {
     struct TestCase
     {
@@ -473,7 +473,7 @@ TEST(AccountSet, TransferRate)
     }
 }
 
-TEST(AccountSet, BadInputs)
+TEST(AccountSet, bad_inputs)
 {
     TxTest env;
     Account const alice("alice");
@@ -553,7 +553,7 @@ TEST(AccountSet, BadInputs)
         tecNO_ALTERNATIVE_KEY);
 }
 
-TEST(AccountSet, RequireAuthWithDir)
+TEST(AccountSet, require_auth_with_dir)
 {
     TxTest env;
     Account const alice("alice");
@@ -601,7 +601,7 @@ TEST(AccountSet, RequireAuthWithDir)
         tesSUCCESS);
 }
 
-TEST(AccountSet, Ticket)
+TEST(AccountSet, ticket)
 {
     TxTest env;
     Account const alice("alice");
@@ -660,7 +660,7 @@ TEST(AccountSet, Ticket)
         tefNO_TICKET);
 }
 
-TEST(AccountSet, BadSigningKey)
+TEST(AccountSet, bad_signing_key)
 {
     TxTest env;
     Account const alice("alice");
@@ -684,7 +684,7 @@ TEST(AccountSet, BadSigningKey)
     EXPECT_FALSE(result.applied);
 }
 
-TEST(AccountSet, Gateway)
+TEST(AccountSet, gateway)
 {
     Account const alice("alice");
     Account const bob("bob");
diff --git a/src/xrpld/app/ledger/detail/LedgerToJson.cpp b/src/xrpld/app/ledger/detail/LedgerToJson.cpp
index 1d789aa604..419da2a995 100644
--- a/src/xrpld/app/ledger/detail/LedgerToJson.cpp
+++ b/src/xrpld/app/ledger/detail/LedgerToJson.cpp
@@ -3,6 +3,7 @@
 #include <xrpld/app/ledger/LedgerMaster.h>
 #include <xrpld/app/misc/DeliverMax.h>
 #include <xrpld/app/misc/TxQ.h>
+#include <xrpld/rpc/CTID.h>
 #include <xrpld/rpc/Context.h>
 #include <xrpld/rpc/detail/SyntheticFields.h>
 
@@ -11,6 +12,7 @@
 #include <xrpl/basics/chrono.h>
 #include <xrpl/basics/strHex.h>
 #include <xrpl/beast/utility/instrumentation.h>
+#include <xrpl/core/NetworkIDService.h>
 #include <xrpl/json/json_value.h>
 #include <xrpl/ledger/helpers/TokenHelpers.h>
 #include <xrpl/protocol/AccountID.h>
@@ -27,6 +29,7 @@
 #include <xrpl/protocol/jss.h>
 #include <xrpl/protocol/serialize.h>
 
+#include <cstdint>
 #include <exception>
 #include <memory>
 #include <string>
@@ -179,6 +182,19 @@ fillJsonTx(
         }
     }
 
+    // compute outgoing CTID
+    if (stMeta && stMeta->isFieldPresent(sfTransactionIndex))
+    {
+        uint32_t const lgrSeq = fill.ledger.seq();
+        uint32_t const txnIdx = stMeta->getFieldU32(sfTransactionIndex);
+        uint32_t netID = fill.context->app.getNetworkIDService().getNetworkID();
+        if (txn->isFieldPresent(sfNetworkID))
+            netID = txn->getFieldU32(sfNetworkID);
+
+        if (auto ctid = rpc::encodeCTID(lgrSeq, txnIdx, netID))
+            txJson[jss::ctid] = *ctid;
+    }
+
     if (((fill.options & static_cast<int>(LedgerFill::Options::OwnerFunds)) != 0) &&
         txn->getTxnType() == ttOFFER_CREATE)
     {
diff --git a/src/xrpld/app/ledger/detail/TransactionAcquire.h b/src/xrpld/app/ledger/detail/TransactionAcquire.h
index 2faf74b557..e91b69f71e 100644
--- a/src/xrpld/app/ledger/detail/TransactionAcquire.h
+++ b/src/xrpld/app/ledger/detail/TransactionAcquire.h
@@ -9,6 +9,7 @@
 #include <xrpl/basics/base_uint.h>
 #include <xrpl/shamap/SHAMap.h>
 #include <xrpl/shamap/SHAMapAddNode.h>
+#include <xrpl/shamap/SHAMapNodeID.h>
 #include <xrpl/shamap/SHAMapTreeNode.h>
 
 #include <cstddef>
diff --git a/src/xrpld/app/main/Application.cpp b/src/xrpld/app/main/Application.cpp
index d50637d98e..775471854d 100644
--- a/src/xrpld/app/main/Application.cpp
+++ b/src/xrpld/app/main/Application.cpp
@@ -35,6 +35,7 @@
 #include <xrpld/rpc/RPCHandler.h>
 #include <xrpld/rpc/Role.h>
 #include <xrpld/rpc/ServerHandler.h>
+#include <xrpld/rpc/detail/Handler.h>
 #include <xrpld/rpc/detail/PathRequestManager.h>
 #include <xrpld/rpc/detail/Pathfinder.h>
 #include <xrpld/shamap/NodeFamily.h>
@@ -320,6 +321,7 @@ public:
               perf::makePerfLog(
                   perf::setupPerfLog(config_->section(Sections::kPerf), config_->configDir),
                   *this,
+                  rpc::getHandlerNames(),
                   logs_->journal("PerfLog"),
                   [this] { signalStop("PerfLog"); }))
         , txMaster_(*this)
diff --git a/src/xrpld/app/misc/NetworkOPs.cpp b/src/xrpld/app/misc/NetworkOPs.cpp
index b492906a86..0dc6c8dcac 100644
--- a/src/xrpld/app/misc/NetworkOPs.cpp
+++ b/src/xrpld/app/misc/NetworkOPs.cpp
@@ -1460,11 +1460,17 @@ NetworkOPsImp::preProcessTransaction(std::shared_ptr<Transaction>& transaction)
 
     // NOTE ximinez - I think this check is redundant,
     // but I'm not 100% sure yet.
-    // If so, only cost is looking up HashRouter flags.
-    auto const [validity, reason] =
-        checkValidity(registry_.get().getHashRouter(), sttx, view->rules());
-    XRPL_ASSERT(
-        validity == Validity::Valid, "xrpl::NetworkOPsImp::processTransaction : valid validity");
+    //
+    // For an ordinary transaction it is: the relay and submit paths have
+    // already run checkValidity, so this costs a HashRouter lookup. It is not
+    // redundant for a role-signature transaction while fixCleanup3_4_0 is
+    // activating. Those paths verify against the validated rules, which lag
+    // the open ledger rules used here, and checkValidity scopes a cached
+    // verdict to the rules that reached it, so this call can verify the
+    // signature again and come to a different answer. SigBad is therefore
+    // reachable, and the handler below is the correct response to it.
+    auto const& viewRules = view->rules();
+    auto const [validity, reason] = checkValidity(registry_.get().getHashRouter(), sttx, viewRules);
 
     // Not concerned with local checks at this point.
     if (validity == Validity::SigBad)
@@ -1472,7 +1478,15 @@ NetworkOPsImp::preProcessTransaction(std::shared_ptr<Transaction>& transaction)
         JLOG(journal_.info()) << "Transaction has bad signature: " << reason;
         transaction->setStatus(TransStatus::INVALID);
         transaction->setResult(temBAD_SIGNATURE);
-        registry_.get().getHashRouter().setFlags(transaction->getID(), HashRouterFlags::BAD);
+        // See the matching guard in PeerImp::checkTransaction: only cache
+        // BAD for a role-signature transaction once fixCleanup3_4_0 is
+        // enabled on this node. Remove together with the amendment.
+        if (viewRules.enabled(fixCleanup3_4_0) ||
+            (!sttx.isFieldPresent(sfSponsorSignature) &&
+             !sttx.isFieldPresent(sfCounterpartySignature)))
+        {
+            registry_.get().getHashRouter().setFlags(transaction->getID(), HashRouterFlags::BAD);
+        }
         return false;
     }
 
@@ -1872,11 +1886,21 @@ NetworkOPsImp::apply(std::unique_lock<std::mutex>& batchLock)
 
             if (validatedLedgerIndex)
             {
-                auto [fee, accountSeq, availableSeq] =
-                    registry_.get().getTxQ().getTxRequiredFeeAndSeq(
-                        *newOL, e.transaction->getSTransaction());
-                e.transaction->setCurrentLedgerState(
-                    *validatedLedgerIndex, fee, accountSeq, availableSeq);
+                auto maybeFeeAndSeq = registry_.get().getTxQ().getTxRequiredFeeAndSeq(
+                    *newOL, e.transaction->getSTransaction());
+                if (maybeFeeAndSeq.has_value())
+                {
+                    auto [fee, accountSeq, availableSeq] = *maybeFeeAndSeq;
+                    e.transaction->setCurrentLedgerState(
+                        *validatedLedgerIndex, fee, accountSeq, availableSeq);
+                }
+                else
+                {
+                    JLOG(journal_.debug())
+                        << "Unable to compute current ledger state for tx "
+                        << e.transaction->getID() << " in validated ledger "
+                        << *validatedLedgerIndex << ": " << transToken(maybeFeeAndSeq.error());
+                }
             }
         }
     }
diff --git a/src/xrpld/app/misc/TxQ.h b/src/xrpld/app/misc/TxQ.h
index 65b4e9778c..4e6e9edbac 100644
--- a/src/xrpld/app/misc/TxQ.h
+++ b/src/xrpld/app/misc/TxQ.h
@@ -23,6 +23,7 @@
 
 #include <cstddef>
 #include <cstdint>
+#include <expected>
 #include <limits>
 #include <map>
 #include <memory>
@@ -390,10 +391,10 @@ public:
      *        and first available sequence for transaction
      * @param view current open ledger
      * @param tx the transaction
-     * @return minimum required fee, first sequence in the ledger
+     * @return minimum required fee or an error, first sequence in the ledger
      *         and first available sequence
      */
-    FeeAndSeq
+    std::expected<FeeAndSeq, TER>
     getTxRequiredFeeAndSeq(OpenView const& view, std::shared_ptr<STTx const> const& tx) const;
 
     /**
diff --git a/src/xrpld/app/misc/detail/TxQ.cpp b/src/xrpld/app/misc/detail/TxQ.cpp
index b9cfc1d65c..19dc351444 100644
--- a/src/xrpld/app/misc/detail/TxQ.cpp
+++ b/src/xrpld/app/misc/detail/TxQ.cpp
@@ -38,6 +38,7 @@
 #include <algorithm>
 #include <cstddef>
 #include <cstdint>
+#include <expected>
 #include <iterator>
 #include <limits>
 #include <memory>
@@ -54,22 +55,29 @@ namespace xrpl {
 
 //////////////////////////////////////////////////////////////////////////
 
-static FeeLevel64
+/**
+ * Compute the fee level that a transaction pays.
+ * @return The fee level paid, or the error reported by `calculateBaseFee`.
+ */
+static std::expected<FeeLevel64, TER>
 getFeeLevelPaid(ReadView const& view, STTx const& tx)
 {
-    auto const [baseFee, effectiveFeePaid] = [&view, &tx]() {
-        XRPAmount const baseFee = calculateBaseFee(view, tx);
+    auto const computedBaseFee = calculateBaseFee(view, tx);
+    if (!computedBaseFee)
+        return std::unexpected(computedBaseFee.error());
+
+    auto const [baseFee, effectiveFeePaid] = [&view, &tx, fee = *computedBaseFee]() {
         XRPAmount const feePaid = tx[sfFee].xrp();
 
         // If baseFee is 0 then the cost of a basic transaction is free, but we
         // need the effective fee level to be non-zero.
-        XRPAmount const mod = [&view, &tx, baseFee]() {
-            if (baseFee.signum() > 0)
+        XRPAmount const mod = [&view, &tx, fee]() {
+            if (fee.signum() > 0)
                 return XRPAmount{0};
             auto def = calculateDefaultBaseFee(view, tx);
             return def.signum() == 0 ? XRPAmount{1} : def;
         }();
-        return std::pair{baseFee + mod, feePaid + mod};
+        return std::pair{fee + mod, feePaid + mod};
     }();
 
     XRPL_ASSERT(baseFee.signum() > 0, "xrpl::getFeeLevelPaid : positive fee");
@@ -112,10 +120,20 @@ TxQ::FeeMetrics::update(
     auto const size = std::distance(txBegin, txEnd);
     feeLevels.reserve(size);
     std::for_each(txBegin, txEnd, [&](auto const& tx) {
-        feeLevels.push_back(getFeeLevelPaid(view, *tx.first));
+        auto const maybeFeeLevel = getFeeLevelPaid(view, *tx.first);
+        if (maybeFeeLevel.has_value())
+        {
+            feeLevels.push_back(*maybeFeeLevel);
+        }
+        else
+        {
+            // Excluded from the median sample below.
+            JLOG(j_.warn()) << "Unable to compute the fee level for a validated transaction "
+                            << tx.first->getTransactionID() << " in ledger " << view.header().seq
+                            << ": " << transToken(maybeFeeLevel.error());
+        }
     });
     std::ranges::sort(feeLevels);
-    XRPL_ASSERT(size == feeLevels.size(), "xrpl::TxQ::FeeMetrics::update : fee levels size");
 
     JLOG((timeLeap ? j_.warn() : j_.debug()))
         << "Ledger " << view.header().seq << " has " << size << " transactions. "
@@ -159,7 +177,10 @@ TxQ::FeeMetrics::update(
         txnsExpected_ = std::min(next, maximumTxnCount_.value_or(next));
     }
 
-    if (size == 0)
+    // The median is taken over the transactions whose fee level could be
+    // computed, while txnsExpected_ above deliberately uses the full
+    // transaction count.
+    if (feeLevels.empty())
     {
         escalationMultiplier_ = setup.minimumEscalationMultiplier;
     }
@@ -169,8 +190,9 @@ TxQ::FeeMetrics::update(
         // evaluates to the middle element; for an even
         // number of elements, it will add the two elements
         // on either side of the "middle" and average them.
+        auto const count = feeLevels.size();
         escalationMultiplier_ =
-            (feeLevels[size / 2] + feeLevels[(size - 1) / 2] + FeeLevel64{1}) / 2;
+            (feeLevels[count / 2] + feeLevels[(count - 1) / 2] + FeeLevel64{1}) / 2;
         escalationMultiplier_ = std::max(escalationMultiplier_, setup.minimumEscalationMultiplier);
     }
     JLOG(j_.debug()) << "Expected transactions updated to " << txnsExpected_
@@ -878,7 +900,14 @@ TxQ::apply(
     // We may need the base fee for multiple transactions or transaction
     // replacement, so just pull it up now.
     auto const metricsSnapshot = feeMetrics_.getSnapshot();
-    auto const feeLevelPaid = getFeeLevelPaid(view, *tx);
+    auto const computedFeeLevelPaid = getFeeLevelPaid(view, *tx);
+    // Without a fee level there is no way to tell whether the transaction
+    // pays enough, so it can be neither applied nor queued.
+    if (!computedFeeLevelPaid.has_value())
+    {
+        return {computedFeeLevelPaid.error(), false};
+    }
+    FeeLevel64 const feeLevelPaid = *computedFeeLevelPaid;
     auto const requiredFeeLevel = getRequiredFeeLevel(view, flags, metricsSnapshot, lock);
 
     // Is there a blocker already in the account's queue?  If so, don't
@@ -1684,7 +1713,14 @@ TxQ::tryDirectApply(
 
     // If the transaction's fee is high enough we may be able to put the
     // transaction straight into the ledger.
-    FeeLevel64 const feeLevelPaid = getFeeLevelPaid(view, *tx);
+    auto const computedFeeLevelPaid = getFeeLevelPaid(view, *tx);
+    // The fee level is unknown, so the transaction cannot be applied here,
+    // and queueing it would only run into the same failure. Reject it.
+    if (!computedFeeLevelPaid.has_value())
+    {
+        return ApplyResult{computedFeeLevelPaid.error(), false};
+    }
+    FeeLevel64 const feeLevelPaid = *computedFeeLevelPaid;
 
     if (feeLevelPaid >= requiredFeeLevel)
     {
@@ -1768,7 +1804,7 @@ TxQ::getMetrics(OpenView const& view) const
     return result;
 }
 
-TxQ::FeeAndSeq
+std::expected<TxQ::FeeAndSeq, TER>
 TxQ::getTxRequiredFeeAndSeq(OpenView const& view, std::shared_ptr<STTx const> const& tx) const
 {
     auto const account = (*tx)[sfAccount];
@@ -1776,14 +1812,19 @@ TxQ::getTxRequiredFeeAndSeq(OpenView const& view, std::shared_ptr<STTx const> co
     std::scoped_lock const lock(mutex_);
 
     auto const snapshot = feeMetrics_.getSnapshot();
-    auto const baseFee = calculateBaseFee(view, *tx);
+    auto const maybeBaseFee = calculateBaseFee(view, *tx);
+    if (!maybeBaseFee.has_value())
+    {
+        return std::unexpected(maybeBaseFee.error());
+    }
+    auto const baseFee = *maybeBaseFee;
     auto const fee = FeeMetrics::scaleFeeLevel(snapshot, view);
 
     auto const sle = view.read(keylet::account(account));
 
     std::uint32_t const accountSeq = sle ? (*sle)[sfSequence] : 0;
     std::uint32_t const availableSeq = nextQueuableSeqImpl(sle, lock).value();
-    return {
+    return FeeAndSeq{
         .fee = mulDiv(fee, baseFee, kBaseLevel)
                    .value_or(XRPAmount(std::numeric_limits<std::int64_t>::max())),
         .accountSeq = accountSeq,
diff --git a/src/xrpld/overlay/Cluster.h b/src/xrpld/overlay/Cluster.h
index 703e1601aa..bffebca550 100644
--- a/src/xrpld/overlay/Cluster.h
+++ b/src/xrpld/overlay/Cluster.h
@@ -62,6 +62,19 @@ public:
     std::optional<std::string>
     member(PublicKey const& node) const;
 
+    /**
+     * Determines whether a node belongs in the cluster.
+     *
+     * Prefer this to `member` when the comment is not wanted: `member`
+     * copies the node's name out from under the lock, and most callers
+     * only test the result for engagement.
+     *
+     * @param node The node's public identity.
+     * @return Whether the node is a cluster member.
+     */
+    bool
+    isMember(PublicKey const& node) const;
+
     /**
      * The number of nodes in the cluster list.
      */
diff --git a/src/xrpld/overlay/detail/Cluster.cpp b/src/xrpld/overlay/detail/Cluster.cpp
index 15c8fa9c66..5e2e2053e9 100644
--- a/src/xrpld/overlay/detail/Cluster.cpp
+++ b/src/xrpld/overlay/detail/Cluster.cpp
@@ -38,6 +38,14 @@ Cluster::member(PublicKey const& identity) const
     return iter->name();
 }
 
+bool
+Cluster::isMember(PublicKey const& identity) const
+{
+    std::scoped_lock const lock(mutex_);
+
+    return nodes_.contains(identity);
+}
+
 std::size_t
 Cluster::size() const
 {
diff --git a/src/xrpld/overlay/detail/OverlayImpl.cpp b/src/xrpld/overlay/detail/OverlayImpl.cpp
index 587f4f810c..7f5dfcc30a 100644
--- a/src/xrpld/overlay/detail/OverlayImpl.cpp
+++ b/src/xrpld/overlay/detail/OverlayImpl.cpp
@@ -306,7 +306,7 @@ OverlayImpl::onHandoff(
         {
             // The node gets a reserved slot if it is in our cluster
             // or if it has a reservation.
-            bool const reserved = static_cast<bool>(app_.getCluster().member(publicKey)) ||
+            bool const reserved = app_.getCluster().isMember(publicKey) ||
                 app_.getPeerReservations().contains(publicKey);
             auto const result = peerFinder_->activate(slot, publicKey, reserved);
             if (result != peer_finder::Result::Success)
diff --git a/src/xrpld/overlay/detail/PeerImp.cpp b/src/xrpld/overlay/detail/PeerImp.cpp
index 3f0b4453b8..0dc9792f2e 100644
--- a/src/xrpld/overlay/detail/PeerImp.cpp
+++ b/src/xrpld/overlay/detail/PeerImp.cpp
@@ -44,6 +44,7 @@
 #include <xrpl/ledger/Ledger.h>
 #include <xrpl/peerfinder/Slot.h>
 #include <xrpl/peerfinder/Types.h>
+#include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/KeyType.h>
 #include <xrpl/protocol/LedgerHeader.h>
 #include <xrpl/protocol/Protocol.h>
@@ -412,7 +413,7 @@ PeerImp::crawl() const
 bool
 PeerImp::cluster() const
 {
-    return static_cast<bool>(app_.getCluster().member(publicKey_));
+    return app_.getCluster().isMember(publicKey_);
 }
 
 std::string
@@ -1413,6 +1414,10 @@ PeerImp::handleTransaction(
     }
     catch (std::exception const& ex)
     {
+        if (fee_.fee < resource::kFeeInvalidData)
+        {
+            fee_.update(resource::kFeeInvalidData, "tx invalid");
+        }
         JLOG(pJournal_.warn()) << "Transaction invalid: " << strHex(m->rawtransaction())
                                << ". Exception: " << ex.what();
     }
@@ -1486,10 +1491,21 @@ PeerImp::onMessage(std::shared_ptr<protocol::TMGetLedger> const& m)
 
     // Verify ledger node counts. Full parsing of the node IDs is deferred to the job, so the I/O
     // thread is not burdened with SHAMapNodeID deserialization for every TMGetLedger message.
-    if (itype != protocol::liBASE && m->nodeids_size() <= 0)
+    if (itype != protocol::liBASE)
     {
-        badData("Invalid ledger node IDs");
-        return;
+        if (m->nodeids_size() <= 0)
+        {
+            badData("Invalid ledger node IDs");
+            return;
+        }
+
+        if (m->nodeids_size() > tuning::kHardMaxReplyNodes)
+        {
+            badData(
+                "Requested number of ledger node IDs must be less than or equal to " +
+                std::to_string(tuning::kHardMaxReplyNodes));
+            return;
+        }
     }
 
     // Verify query type
@@ -2847,6 +2863,13 @@ PeerImp::onMessage(std::shared_ptr<protocol::TMTransactions> const& m)
         return;
     }
 
+    if (m->transactions_size() > reduce_relay::kMaxTxQueueSize)
+    {
+        JLOG(pJournal_.error()) << "TMTransactions: transaction list too large";
+        fee_.update(resource::kFeeMalformedRequest, "Transaction list too large");
+        return;
+    }
+
     JLOG(pJournal_.trace()) << "received TMTransactions " << m->transactions_size();
 
     overlay_.addTxMetrics(m->transactions_size());
@@ -3087,8 +3110,9 @@ PeerImp::checkTransaction(
         if (checkSignature)
         {
             // Check the signature before handing off to the job queue.
-            if (auto [valid, validReason] = checkValidity(
-                    app_.getHashRouter(), *stx, app_.getLedgerMaster().getValidatedRules());
+            auto const& validatedRules = app_.getLedgerMaster().getValidatedRules();
+            if (auto [valid, validReason] =
+                    checkValidity(app_.getHashRouter(), *stx, validatedRules);
                 valid != Validity::Valid)
             {
                 if (!validReason.empty())
@@ -3096,9 +3120,20 @@ PeerImp::checkTransaction(
                     JLOG(pJournal_.debug()) << "Exception checking transaction: " << validReason;
                 }
 
-                // Probably not necessary to set HashRouterFlags::BAD, but
-                // doesn't hurt.
-                app_.getHashRouter().setFlags(stx->getTransactionID(), HashRouterFlags::BAD);
+                // For a role-signature transaction, only cache BAD once
+                // fixCleanup3_4_0 is enabled on this node: the SigBad verdict
+                // then covers the post-fix prefix and cannot flip back.
+                // Before the amendment activates, checkValidity's own
+                // era-scoped cache handles the repeat lookups; setting BAD
+                // would block a correctly new-prefix-signed transaction until
+                // the router entry ages out. Remove the guard together with
+                // the amendment.
+                if (validatedRules.enabled(fixCleanup3_4_0) ||
+                    (!stx->isFieldPresent(sfSponsorSignature) &&
+                     !stx->isFieldPresent(sfCounterpartySignature)))
+                {
+                    app_.getHashRouter().setFlags(stx->getTransactionID(), HashRouterFlags::BAD);
+                }
                 charge(resource::kFeeInvalidSignature, "check transaction signature failure");
                 return;
             }
diff --git a/src/xrpld/overlay/detail/PeerImp.h b/src/xrpld/overlay/detail/PeerImp.h
index 0f229bf9d8..e87c12279e 100644
--- a/src/xrpld/overlay/detail/PeerImp.h
+++ b/src/xrpld/overlay/detail/PeerImp.h
@@ -696,19 +696,12 @@ private:
     std::shared_ptr<SHAMap const>
     getTxSet(std::shared_ptr<protocol::TMGetLedger> const& m) const;
 
+protected:
     void
     processLedgerRequest(
         std::shared_ptr<protocol::TMGetLedger> const& m,
         std::vector<SHAMapNodeID> nodeIDs);
 
-protected:
-    // Kept `protected` so test subclasses (see
-    // TMGetObjectByHash_test) can drive the
-    // synchronous processor and the differential-pricing helper without
-    // routing through the JobQueue or going through `friend` plumbing.
-    // Production callers reach these members only via
-    // `onMessage(TMGetObjectByHash)` → JobQueue → `processGetObjectByHash`.
-
     /**
      * Process a generic-query TMGetObjectByHash message.
      *
diff --git a/src/xrpld/overlay/detail/ProtocolMessage.h b/src/xrpld/overlay/detail/ProtocolMessage.h
index 88f50e1e2e..9c9b3e0138 100644
--- a/src/xrpld/overlay/detail/ProtocolMessage.h
+++ b/src/xrpld/overlay/detail/ProtocolMessage.h
@@ -278,6 +278,8 @@ parseMessageContent(MessageHeader const& header, Buffers const& buffers)
         return {};
     }
 
+    m->DiscardUnknownFields();
+
     return m;
 }
 
diff --git a/src/xrpld/overlay/detail/ProtocolVersion.cpp b/src/xrpld/overlay/detail/ProtocolVersion.cpp
index 74dad61828..d24928a4ec 100644
--- a/src/xrpld/overlay/detail/ProtocolVersion.cpp
+++ b/src/xrpld/overlay/detail/ProtocolVersion.cpp
@@ -151,4 +151,12 @@ isProtocolSupported(ProtocolVersion const& v)
     return std::end(kSupportedProtocolList) != std::ranges::find(kSupportedProtocolList, v);
 }
 
+ProtocolVersion
+newestSupportedProtocolVersion()
+{
+    // Scans rather than reading the sorted list's last entry, so it does not
+    // depend on an invariant kept elsewhere.
+    return *std::ranges::max_element(kSupportedProtocolList);
+}
+
 }  // namespace xrpl
diff --git a/src/xrpld/overlay/detail/ProtocolVersion.h b/src/xrpld/overlay/detail/ProtocolVersion.h
index 5c05f63e2a..a4342c2453 100644
--- a/src/xrpld/overlay/detail/ProtocolVersion.h
+++ b/src/xrpld/overlay/detail/ProtocolVersion.h
@@ -68,4 +68,13 @@ supportedProtocolVersions();
 bool
 isProtocolSupported(ProtocolVersion const& v);
 
+/**
+ * The version negotiated with a peer that speaks everything we speak, so also
+ * the one that enables every version-gated feature.
+ *
+ * @return The largest version in the list of supported protocol versions.
+ */
+ProtocolVersion
+newestSupportedProtocolVersion();
+
 }  // namespace xrpl
diff --git a/src/xrpld/perflog/detail/PerfLogImp.cpp b/src/xrpld/perflog/detail/PerfLogImp.cpp
index 2777e0dcdb..d7944589af 100644
--- a/src/xrpld/perflog/detail/PerfLogImp.cpp
+++ b/src/xrpld/perflog/detail/PerfLogImp.cpp
@@ -3,6 +3,7 @@
 #include <xrpld/app/main/Application.h>
 
 #include <xrpl/basics/Log.h>
+#include <xrpl/basics/StringUtilities.h>
 #include <xrpl/basics/chrono.h>
 #include <xrpl/beast/core/CurrentThreadName.h>
 #include <xrpl/beast/utility/Journal.h>
@@ -16,6 +17,7 @@
 #include <xrpl/json/json_writer.h>
 #include <xrpl/nodestore/Database.h>
 #include <xrpl/protocol/jss.h>
+#include <xrpl/server/NetworkOPs.h>
 
 #include <chrono>
 #include <cstdint>
@@ -25,8 +27,9 @@
 #include <memory>
 #include <mutex>
 #include <ostream>
-#include <set>
+#include <span>
 #include <string>
+#include <string_view>
 #include <system_error>
 #include <unordered_map>
 #include <utility>
@@ -34,40 +37,39 @@
 
 namespace xrpl::perf {
 
-PerfLogImp::Counters::Counters(std::set<char const*> const& labels, JobTypes const& jobTypes)
+PerfLogImp::Counters::Counters(
+    std::span<NullTerminatedView const> methodNames,
+    JobTypes const& jobTypes)
 {
+    // Only a name that got a counter is kept, so labels and rpc hold the same set
+    // and countersJson() reports each counter once. Keeping a repeated name would
+    // add its counter to the totals twice, because the assertion below is compiled
+    // out of a release build.
+    labels.reserve(methodNames.size());
+    rpc.reserve(methodNames.size());
+    for (auto const& name : methodNames)
     {
-        // populateRpc
-        rpc.reserve(labels.size());
-        for (std::string const label : labels)
+        auto const inserted = rpc.try_emplace(name).second;
+        if (!inserted)
         {
-            auto const inserted = rpc.emplace(label, Rpc()).second;
-            if (!inserted)
-            {
-                // Ensure that no other function populates this entry.
-                // LCOV_EXCL_START
-                UNREACHABLE(
-                    "xrpl::perf::PerfLogImp::Counters::Counters : failed to "
-                    "insert label");
-                // LCOV_EXCL_STOP
-            }
+            // LCOV_EXCL_START
+            UNREACHABLE("xrpl::perf::PerfLogImp::Counters::Counters : method name is unique");
+            continue;
+            // LCOV_EXCL_STOP
         }
+        labels.push_back(name);
     }
+
+    jq.reserve(jobTypes.size());
+    for (auto const& [jobType, _] : jobTypes)
     {
-        // populateJq
-        jq.reserve(jobTypes.size());
-        for (auto const& [jobType, _] : jobTypes)
+        auto const inserted = jq.emplace(jobType, Jq()).second;
+        if (!inserted)
         {
-            auto const inserted = jq.emplace(jobType, Jq()).second;
-            if (!inserted)
-            {
-                // Ensure that no other function populates this entry.
-                // LCOV_EXCL_START
-                UNREACHABLE(
-                    "xrpl::perf::PerfLogImp::Counters::Counters : failed to "
-                    "insert job type");
-                // LCOV_EXCL_STOP
-            }
+            // Nothing else inserts into jq, so a job type cannot repeat.
+            // LCOV_EXCL_START
+            UNREACHABLE("xrpl::perf::PerfLogImp::Counters::Counters : failed to insert job type");
+            // LCOV_EXCL_STOP
         }
     }
 }
@@ -78,17 +80,31 @@ PerfLogImp::Counters::countersJson() const
     json::Value rpcobj(json::ValueType::Object);
     // totalRpc represents all rpc methods. All that started, finished, etc.
     Rpc totalRpc;
-    for (auto const& proc : rpc)
+    // Walked by label rather than by map entry, so that each key can be reported
+    // as a C string. The constructor gives rpc an entry per label, so the lookup
+    // succeeds; it is a find rather than an at() because this runs on the logging
+    // thread, where a throw would end the process.
+    for (auto const& label : labels)
     {
+        auto const entry = rpc.find(label);
+        if (entry == rpc.end())
+        {
+            // LCOV_EXCL_START
+            UNREACHABLE("xrpl::perf::PerfLogImp::Counters::countersJson : label has a counter");
+            continue;
+            // LCOV_EXCL_STOP
+        }
+        auto const& counter = entry->second;
+
         Rpc value;
         {
-            std::scoped_lock const lock(proc.second.mutex);
-            if ((proc.second.value.started == 0u) && (proc.second.value.finished == 0u) &&
-                (proc.second.value.errored == 0u))
+            std::scoped_lock const lock(counter.mutex);
+            if ((counter.value.started == 0u) && (counter.value.finished == 0u) &&
+                (counter.value.errored == 0u))
             {
                 continue;
             }
-            value = proc.second.value;
+            value = counter.value;
         }
 
         json::Value p(json::ValueType::Object);
@@ -100,7 +116,7 @@ PerfLogImp::Counters::countersJson() const
         totalRpc.errored += value.errored;
         p[jss::duration_us] = std::to_string(value.duration.count());
         totalRpc.duration += value.duration;
-        rpcobj[proc.first] = p;
+        rpcobj[json::StaticString{label.asCString()}] = p;
     }
 
     if (totalRpc.started != 0u)
@@ -195,7 +211,9 @@ PerfLogImp::Counters::currentJson() const
     for (auto m : methods)
     {
         json::Value methodobj(json::ValueType::Object);
-        methodobj[jss::method] = m.first;
+        // A key of rpc, per methods' declaration, so borrowed as above.
+        // NOLINTNEXTLINE(bugprone-suspicious-stringview-data-usage)
+        methodobj[jss::method] = json::StaticString{m.first.data()};
         methodobj[jss::duration_us] =
             std::to_string(std::chrono::duration_cast<microseconds>(present - m.second).count());
         methodsArray.append(methodobj);
@@ -299,9 +317,14 @@ PerfLogImp::report()
 PerfLogImp::PerfLogImp(
     Setup setup,
     Application& app,
+    std::span<NullTerminatedView const> methodNames,
     beast::Journal journal,
     std::function<void()>&& signalStop)
-    : setup_(std::move(setup)), app_(app), j_(journal), signalStop_(std::move(signalStop))
+    : setup_(std::move(setup))
+    , app_(app)
+    , j_(journal)
+    , signalStop_(std::move(signalStop))
+    , counters_(methodNames, JobTypes::instance())
 {
     openLog();
 }
@@ -312,7 +335,7 @@ PerfLogImp::~PerfLogImp()
 }
 
 void
-PerfLogImp::rpcStart(std::string const& method, std::uint64_t const requestId)
+PerfLogImp::rpcStart(std::string_view method, std::uint64_t const requestId)
 {
     auto counter = counters_.rpc.find(method);
     if (counter == counters_.rpc.end())
@@ -328,11 +351,12 @@ PerfLogImp::rpcStart(std::string const& method, std::uint64_t const requestId)
         ++counter->second.value.started;
     }
     std::scoped_lock const lock(counters_.methodsMutex);
-    counters_.methods[requestId] = {counter->first.c_str(), steady_clock::now()};
+    // The key, not the method argument: what is stored has to outlive the call.
+    counters_.methods[requestId] = {counter->first, steady_clock::now()};
 }
 
 void
-PerfLogImp::rpcEnd(std::string const& method, std::uint64_t const requestId, bool finish)
+PerfLogImp::rpcEnd(std::string_view method, std::uint64_t const requestId, bool finish)
 {
     auto counter = counters_.rpc.find(method);
     if (counter == counters_.rpc.end())
@@ -501,10 +525,11 @@ std::unique_ptr<PerfLog>
 makePerfLog(
     PerfLog::Setup const& setup,
     Application& app,
+    std::span<NullTerminatedView const> methodNames,
     beast::Journal journal,
     std::function<void()>&& signalStop)
 {
-    return std::make_unique<PerfLogImp>(setup, app, journal, std::move(signalStop));
+    return std::make_unique<PerfLogImp>(setup, app, methodNames, journal, std::move(signalStop));
 }
 
 }  // namespace xrpl::perf
diff --git a/src/xrpld/perflog/detail/PerfLogImp.h b/src/xrpld/perflog/detail/PerfLogImp.h
index 7efdbe1b7f..bb1eb904de 100644
--- a/src/xrpld/perflog/detail/PerfLogImp.h
+++ b/src/xrpld/perflog/detail/PerfLogImp.h
@@ -1,7 +1,6 @@
 #pragma once
 
-#include <xrpld/rpc/detail/Handler.h>
-
+#include <xrpl/basics/StringUtilities.h>
 #include <xrpl/beast/utility/Journal.h>
 #include <xrpl/core/Job.h>
 #include <xrpl/core/JobTypes.h>
@@ -15,8 +14,9 @@
 #include <fstream>
 #include <functional>
 #include <mutex>
-#include <set>
+#include <span>
 #include <string>
+#include <string_view>
 #include <thread>
 #include <unordered_map>
 #include <utility>
@@ -59,7 +59,8 @@ class PerfLogImp : public PerfLog
     struct Counters
     {
     public:
-        using MethodStart = std::pair<char const*, steady_time_point>;
+        using MethodStart = std::pair<std::string_view, steady_time_point>;
+
         /**
          * RPC performance counters.
          */
@@ -91,14 +92,27 @@ class PerfLogImp : public PerfLog
 
         // rpc and jq do not need mutex protection because all
         // keys and values are created before more threads are started.
-        std::unordered_map<std::string, Locked<Rpc>> rpc;
+        //
+        // Every key views the characters of a name from the methodNames constructor
+        // parameter below, which the caller guarantees outlive this object, so the
+        // map copies no name to store one and needs no string to look one up.
+        std::unordered_map<std::string_view, Locked<Rpc>> rpc;
+
+        // The same names, in the order the caller gave them, and still carrying the
+        // proof that each reaches its terminating null. countersJson() walks these
+        // rather than rpc, so that it can report a key as a C string. Held by value,
+        // so that a caller may build the range it passes on the fly: only the names
+        // have to outlive this object, not the container that carried them.
+        std::vector<NullTerminatedView> labels;
         std::unordered_map<JobType, Locked<Jq>> jq;
         std::vector<std::pair<JobType, steady_time_point>> jobs;
         mutable std::mutex jobsMutex;
+        // Each view is a key of rpc above, not the argument rpcStart() received, so
+        // currentJson() may read it as a C string.
         std::unordered_map<std::uint64_t, MethodStart> methods;
         mutable std::mutex methodsMutex;
 
-        Counters(std::set<char const*> const& labels, JobTypes const& jobTypes);
+        Counters(std::span<NullTerminatedView const> methodNames, JobTypes const& jobTypes);
         json::Value
         countersJson() const;
         json::Value
@@ -109,7 +123,7 @@ class PerfLogImp : public PerfLog
     Application& app_;
     beast::Journal const j_;
     std::function<void()> const signalStop_;
-    Counters counters_{xrpl::rpc::getHandlerNames(), JobTypes::instance()};
+    Counters counters_;
     std::ofstream logFile_;
     std::thread thread_;
     std::mutex mutex_;
@@ -126,28 +140,35 @@ class PerfLogImp : public PerfLog
     void
     report();
     void
-    rpcEnd(std::string const& method, std::uint64_t const requestId, bool finish);
+    rpcEnd(std::string_view method, std::uint64_t const requestId, bool finish);
 
 public:
+    /**
+     * @param methodNames The RPC methods to count, one counter per name. The
+     *        names must outlive this object, which holds views of them. Passed
+     *        in rather than looked up here so that this layer needs to know
+     *        nothing about the RPC dispatch table.
+     */
     PerfLogImp(
         Setup setup,
         Application& app,
+        std::span<NullTerminatedView const> methodNames,
         beast::Journal journal,
         std::function<void()>&& signalStop);
 
     ~PerfLogImp() override;
 
     void
-    rpcStart(std::string const& method, std::uint64_t const requestId) override;
+    rpcStart(std::string_view method, std::uint64_t const requestId) override;
 
     void
-    rpcFinish(std::string const& method, std::uint64_t const requestId) override
+    rpcFinish(std::string_view method, std::uint64_t const requestId) override
     {
         rpcEnd(method, requestId, true);
     }
 
     void
-    rpcError(std::string const& method, std::uint64_t const requestId) override
+    rpcError(std::string_view method, std::uint64_t const requestId) override
     {
         rpcEnd(method, requestId, false);
     }
diff --git a/src/xrpld/rpc/MethodNames.h b/src/xrpld/rpc/MethodNames.h
new file mode 100644
index 0000000000..5dc2d9ff88
--- /dev/null
+++ b/src/xrpld/rpc/MethodNames.h
@@ -0,0 +1,95 @@
+#pragma once
+
+#include <string_view>
+
+namespace xrpl::rpc::method {
+
+/**
+ * Names of the RPC methods the server accepts.
+ *
+ * Defined here so the dispatch table in Handler.cpp and the command-line parser
+ * table in RPCCall.cpp name each method through the same constant, and cannot
+ * drift apart.
+ *
+ * Not every method appears in both tables. Whether a method has a command-line
+ * form is recorded by Handler::hasCommandLineForm in the dispatch table, and
+ * checked against the command-line table by RPCCall_test.
+ */
+
+inline constexpr std::string_view kAccountChannels{"account_channels"};
+inline constexpr std::string_view kAccountCurrencies{"account_currencies"};
+inline constexpr std::string_view kAccountInfo{"account_info"};
+inline constexpr std::string_view kAccountLines{"account_lines"};
+inline constexpr std::string_view kAccountNfts{"account_nfts"};
+inline constexpr std::string_view kAccountObjects{"account_objects"};
+inline constexpr std::string_view kAccountOffers{"account_offers"};
+inline constexpr std::string_view kAccountTx{"account_tx"};
+inline constexpr std::string_view kAmmInfo{"amm_info"};
+inline constexpr std::string_view kBlacklist{"blacklist"};
+inline constexpr std::string_view kBookChanges{"book_changes"};
+inline constexpr std::string_view kBookOffers{"book_offers"};
+inline constexpr std::string_view kCanDelete{"can_delete"};
+inline constexpr std::string_view kChannelAuthorize{"channel_authorize"};
+inline constexpr std::string_view kChannelVerify{"channel_verify"};
+inline constexpr std::string_view kConnect{"connect"};
+inline constexpr std::string_view kConsensusInfo{"consensus_info"};
+inline constexpr std::string_view kDepositAuthorized{"deposit_authorized"};
+inline constexpr std::string_view kFeature{"feature"};
+inline constexpr std::string_view kFee{"fee"};
+inline constexpr std::string_view kFetchInfo{"fetch_info"};
+inline constexpr std::string_view kGatewayBalances{"gateway_balances"};
+inline constexpr std::string_view kGetAggregatePrice{"get_aggregate_price"};
+inline constexpr std::string_view kGetCounts{"get_counts"};
+inline constexpr std::string_view kInternal{"internal"};  // command-line wrapper
+inline constexpr std::string_view kJson{"json"};          // command-line wrapper
+inline constexpr std::string_view kJson2{"json2"};        // command-line wrapper
+inline constexpr std::string_view kLedger{"ledger"};
+inline constexpr std::string_view kLedgerAccept{"ledger_accept"};
+inline constexpr std::string_view kLedgerCleaner{"ledger_cleaner"};
+inline constexpr std::string_view kLedgerClosed{"ledger_closed"};
+inline constexpr std::string_view kLedgerCurrent{"ledger_current"};
+inline constexpr std::string_view kLedgerData{"ledger_data"};
+inline constexpr std::string_view kLedgerEntry{"ledger_entry"};
+inline constexpr std::string_view kLedgerHeader{"ledger_header"};
+inline constexpr std::string_view kLedgerRequest{"ledger_request"};
+inline constexpr std::string_view kLogLevel{"log_level"};
+inline constexpr std::string_view kLogrotate{"logrotate"};
+inline constexpr std::string_view kManifest{"manifest"};
+inline constexpr std::string_view kNftBuyOffers{"nft_buy_offers"};
+inline constexpr std::string_view kNftSellOffers{"nft_sell_offers"};
+inline constexpr std::string_view kNorippleCheck{"noripple_check"};
+inline constexpr std::string_view kOwnerInfo{"owner_info"};
+inline constexpr std::string_view kPathFind{"path_find"};
+inline constexpr std::string_view kPeerReservationsAdd{"peer_reservations_add"};
+inline constexpr std::string_view kPeerReservationsDel{"peer_reservations_del"};
+inline constexpr std::string_view kPeerReservationsList{"peer_reservations_list"};
+inline constexpr std::string_view kPeers{"peers"};
+inline constexpr std::string_view kPing{"ping"};
+inline constexpr std::string_view kPrint{"print"};
+inline constexpr std::string_view kRandom{"random"};
+inline constexpr std::string_view kRipplePathFind{"ripple_path_find"};
+inline constexpr std::string_view kServerDefinitions{"server_definitions"};
+inline constexpr std::string_view kServerInfo{"server_info"};
+inline constexpr std::string_view kServerState{"server_state"};
+inline constexpr std::string_view kSign{"sign"};
+inline constexpr std::string_view kSignFor{"sign_for"};
+inline constexpr std::string_view kSimulate{"simulate"};
+inline constexpr std::string_view kStop{"stop"};
+inline constexpr std::string_view kSubmit{"submit"};
+inline constexpr std::string_view kSubmitMultisigned{"submit_multisigned"};
+inline constexpr std::string_view kSubscribe{"subscribe"};
+inline constexpr std::string_view kTransactionEntry{"transaction_entry"};
+inline constexpr std::string_view kTx{"tx"};
+inline constexpr std::string_view kTxHistory{"tx_history"};
+inline constexpr std::string_view kTxReduceRelay{"tx_reduce_relay"};
+inline constexpr std::string_view kUnlList{"unl_list"};
+inline constexpr std::string_view kUnsubscribe{"unsubscribe"};
+inline constexpr std::string_view kValidationCreate{"validation_create"};
+inline constexpr std::string_view kValidatorInfo{"validator_info"};
+inline constexpr std::string_view kValidatorListSites{"validator_list_sites"};
+inline constexpr std::string_view kValidators{"validators"};
+inline constexpr std::string_view kVaultInfo{"vault_info"};
+inline constexpr std::string_view kVersion{"version"};
+inline constexpr std::string_view kWalletPropose{"wallet_propose"};
+
+}  // namespace xrpl::rpc::method
diff --git a/src/xrpld/rpc/RPCCall.h b/src/xrpld/rpc/RPCCall.h
index 2fec78f93b..b3678efa25 100644
--- a/src/xrpld/rpc/RPCCall.h
+++ b/src/xrpld/rpc/RPCCall.h
@@ -10,7 +10,9 @@
 
 #include <cstdint>
 #include <functional>
+#include <span>
 #include <string>
+#include <string_view>
 #include <unordered_map>
 #include <utility>
 #include <vector>
@@ -56,6 +58,15 @@ rpcCmdToJson(
     unsigned int apiVersion,
     beast::Journal j);
 
+/**
+ * Return the names of all methods accepted on the command line.
+ *
+ * The names view refers to storage that outlives the program, so it is safe to
+ * hold on to.
+ */
+std::span<std::string_view const>
+commandLineMethodNames();
+
 /**
  * Internal invocation of RPC client.
  *  Used by both xrpld command line as well as xrpld unit tests
diff --git a/src/xrpld/rpc/RPCHandler.h b/src/xrpld/rpc/RPCHandler.h
index 637a492943..483e7e5baa 100644
--- a/src/xrpld/rpc/RPCHandler.h
+++ b/src/xrpld/rpc/RPCHandler.h
@@ -6,7 +6,7 @@
 
 #include <xrpl/json/json_value.h>
 
-#include <string>
+#include <string_view>
 
 namespace xrpl::rpc {
 
@@ -19,6 +19,6 @@ Status
 doCommand(rpc::JsonContext&, json::Value&);
 
 Role
-roleRequired(unsigned int version, bool betaEnabled, std::string const& method);
+roleRequired(unsigned int version, bool betaEnabled, std::string_view method);
 
 }  // namespace xrpl::rpc
diff --git a/src/xrpld/rpc/detail/Handler.cpp b/src/xrpld/rpc/detail/Handler.cpp
index 326af4f4ee..3c0b41a149 100644
--- a/src/xrpld/rpc/detail/Handler.cpp
+++ b/src/xrpld/rpc/detail/Handler.cpp
@@ -1,50 +1,57 @@
 #include <xrpld/rpc/detail/Handler.h>
 
 #include <xrpld/rpc/Context.h>
+#include <xrpld/rpc/MethodNames.h>
 #include <xrpld/rpc/Role.h>
+#include <xrpld/rpc/Status.h>
 #include <xrpld/rpc/handlers/Handlers.h>
 #include <xrpld/rpc/handlers/ledger/Ledger.h>
 #include <xrpld/rpc/handlers/server_info/Version.h>
 
-#include <xrpl/basics/contract.h>
+#include <xrpl/basics/StringUtilities.h>
 #include <xrpl/beast/utility/instrumentation.h>
 #include <xrpl/json/json_value.h>
 #include <xrpl/protocol/ApiVersion.h>
 
 #include <algorithm>
+#include <array>
 #include <cstddef>
-#include <map>
-#include <set>
-#include <string>
+#include <iterator>
+#include <span>
+#include <string_view>
 #include <utility>
 
 namespace xrpl::rpc {
 namespace {
 
+// Shorthand: the tables below name this type once per entry.
+using Method = Handler::Method;
+
 /**
  * Adjust an old-style handler to be call-by-reference.
+ *
+ * The handler is a template parameter rather than an argument, so that byRef
+ * names a plain function instead of returning a closure over it.
  */
-template <typename Function>
-Handler::Method<json::Value>
-byRef(Function const& f)
+template <json::Value (*Function)(JsonContext&)>
+Status
+byRef(JsonContext& context, json::Value& result)
 {
-    return [f](JsonContext& context, json::Value& result) {
-        result = f(context);
-        if (result.type() != json::ValueType::Object)
-        {
-            // LCOV_EXCL_START
-            UNREACHABLE("xrpl::rpc::byRef : result is object");
-            result = rpc::makeObjectValue(result);
-            // LCOV_EXCL_STOP
-        }
+    result = Function(context);
+    if (result.type() != json::ValueType::Object)
+    {
+        // LCOV_EXCL_START
+        UNREACHABLE("xrpl::rpc::byRef : result is object");
+        result = rpc::makeObjectValue(result);
+        // LCOV_EXCL_STOP
+    }
 
-        return Status();
-    };
+    return Status();
 }
 
-template <class Object, class HandlerImpl>
+template <class HandlerImpl>
 Status
-handle(JsonContext& context, Object& object)
+handle(JsonContext& context, json::Value& object)
 {
     XRPL_ASSERT(
         context.apiVersion >= HandlerImpl::minApiVer &&
@@ -65,427 +72,581 @@ handle(JsonContext& context, Object& object)
 }
 
 template <typename HandlerImpl>
-Handler
+constexpr Handler
 handlerFrom()
 {
+    static_assert(HandlerImpl::minApiVer <= HandlerImpl::maxApiVer);
+    static_assert(HandlerImpl::maxApiVer <= rpc::kApiMaximumValidVersion);
+    static_assert(rpc::kApiMinimumSupportedVersion <= HandlerImpl::minApiVer);
+
     return {
         HandlerImpl::name,
-        &handle<json::Value, HandlerImpl>,
+        Method::of<&handle<HandlerImpl>>(),
         HandlerImpl::role,
         HandlerImpl::condition,
         HandlerImpl::minApiVer,
-        HandlerImpl::maxApiVer};
+        HandlerImpl::maxApiVer,
+    };
 }
 
-Handler const kHandlerArray[]{
-    // Some handlers not specified here are added to the table via addHandler()
+// The handlers that name the function they dispatch to. The order is free:
+// getHandler() searches kHandlers below, which is this array and the next one
+// sorted together.
+constexpr auto kFunctionHandlerArray = std::to_array<Handler>({
     // Request-response methods
-    {.name = "account_info",
-     .valueMethod = byRef(&doAccountInfo),
-     .role = Role::USER,
-     .condition = Condition::NoCondition},
-    {.name = "account_currencies",
-     .valueMethod = byRef(&doAccountCurrencies),
-     .role = Role::USER,
-     .condition = Condition::NoCondition},
-    {.name = "account_lines",
-     .valueMethod = byRef(&doAccountLines),
-     .role = Role::USER,
-     .condition = Condition::NoCondition},
-    {.name = "account_channels",
-     .valueMethod = byRef(&doAccountChannels),
-     .role = Role::USER,
-     .condition = Condition::NoCondition},
-    {.name = "account_nfts",
-     .valueMethod = byRef(&doAccountNFTs),
-     .role = Role::USER,
-     .condition = Condition::NoCondition},
-    {.name = "account_objects",
-     .valueMethod = byRef(&doAccountObjects),
-     .role = Role::USER,
-     .condition = Condition::NoCondition},
-    {.name = "account_offers",
-     .valueMethod = byRef(&doAccountOffers),
-     .role = Role::USER,
-     .condition = Condition::NoCondition},
-    {.name = "account_tx",
-     .valueMethod = byRef(&doAccountTx),
-     .role = Role::USER,
-     .condition = Condition::NoCondition},
-    {.name = "amm_info",
-     .valueMethod = byRef(&doAMMInfo),
-     .role = Role::USER,
-     .condition = Condition::NoCondition},
-    {.name = "blacklist",
-     .valueMethod = byRef(&doBlackList),
-     .role = Role::ADMIN,
-     .condition = Condition::NoCondition},
-    {.name = "book_changes",
-     .valueMethod = byRef(&doBookChanges),
-     .role = Role::USER,
-     .condition = Condition::NoCondition},
-    {.name = "book_offers",
-     .valueMethod = byRef(&doBookOffers),
-     .role = Role::USER,
-     .condition = Condition::NoCondition},
-    {.name = "can_delete",
-     .valueMethod = byRef(&doCanDelete),
-     .role = Role::ADMIN,
-     .condition = Condition::NoCondition},
-    {.name = "channel_authorize",
-     .valueMethod = byRef(&doChannelAuthorize),
-     .role = Role::USER,
-     .condition = Condition::NoCondition},
-    {.name = "channel_verify",
-     .valueMethod = byRef(&doChannelVerify),
-     .role = Role::USER,
-     .condition = Condition::NoCondition},
-    {.name = "connect",
-     .valueMethod = byRef(&doConnect),
-     .role = Role::ADMIN,
-     .condition = Condition::NoCondition},
-    {.name = "consensus_info",
-     .valueMethod = byRef(&doConsensusInfo),
-     .role = Role::ADMIN,
-     .condition = Condition::NoCondition},
-    {.name = "deposit_authorized",
-     .valueMethod = byRef(&doDepositAuthorized),
-     .role = Role::USER,
-     .condition = Condition::NoCondition},
-    {.name = "feature",
-     .valueMethod = byRef(&doFeature),
-     .role = Role::USER,
-     .condition = Condition::NoCondition},
-    {.name = "fee",
-     .valueMethod = byRef(&doFee),
-     .role = Role::USER,
-     .condition = Condition::NeedsCurrentLedger},
-    {.name = "fetch_info",
-     .valueMethod = byRef(&doFetchInfo),
-     .role = Role::ADMIN,
-     .condition = Condition::NoCondition},
-    {.name = "gateway_balances",
-     .valueMethod = byRef(&doGatewayBalances),
-     .role = Role::USER,
-     .condition = Condition::NoCondition},
-    {.name = "get_counts",
-     .valueMethod = byRef(&doGetCounts),
-     .role = Role::ADMIN,
-     .condition = Condition::NoCondition},
-    {.name = "get_aggregate_price",
-     .valueMethod = byRef(&doGetAggregatePrice),
-     .role = Role::USER,
-     .condition = Condition::NoCondition},
-    {.name = "ledger_accept",
-     .valueMethod = byRef(&doLedgerAccept),
-     .role = Role::ADMIN,
-     .condition = Condition::NeedsCurrentLedger},
-    {.name = "ledger_cleaner",
-     .valueMethod = byRef(&doLedgerCleaner),
-     .role = Role::ADMIN,
-     .condition = Condition::NeedsNetworkConnection},
-    {.name = "ledger_closed",
-     .valueMethod = byRef(&doLedgerClosed),
-     .role = Role::USER,
-     .condition = Condition::NeedsClosedLedger},
-    {.name = "ledger_current",
-     .valueMethod = byRef(&doLedgerCurrent),
-     .role = Role::USER,
-     .condition = Condition::NeedsCurrentLedger},
-    {.name = "ledger_data",
-     .valueMethod = byRef(&doLedgerData),
-     .role = Role::USER,
-     .condition = Condition::NoCondition},
-    {.name = "ledger_entry",
-     .valueMethod = byRef(&doLedgerEntry),
-     .role = Role::USER,
-     .condition = Condition::NoCondition},
-    {.name = "ledger_header",
-     .valueMethod = byRef(&doLedgerHeader),
-     .role = Role::USER,
-     .condition = Condition::NoCondition,
-     .minApiVer = 1,
-     .maxApiVer = 1},
-    {.name = "ledger_request",
-     .valueMethod = byRef(&doLedgerRequest),
-     .role = Role::ADMIN,
-     .condition = Condition::NoCondition},
-    {.name = "log_level",
-     .valueMethod = byRef(&doLogLevel),
-     .role = Role::ADMIN,
-     .condition = Condition::NoCondition},
-    {.name = "logrotate",
-     .valueMethod = byRef(&doLogRotate),
-     .role = Role::ADMIN,
-     .condition = Condition::NoCondition},
-    {.name = "manifest",
-     .valueMethod = byRef(&doManifest),
-     .role = Role::USER,
-     .condition = Condition::NoCondition},
-    {.name = "nft_buy_offers",
-     .valueMethod = byRef(&doNFTBuyOffers),
-     .role = Role::USER,
-     .condition = Condition::NoCondition},
-    {.name = "nft_sell_offers",
-     .valueMethod = byRef(&doNFTSellOffers),
-     .role = Role::USER,
-     .condition = Condition::NoCondition},
-    {.name = "noripple_check",
-     .valueMethod = byRef(&doNoRippleCheck),
-     .role = Role::USER,
-     .condition = Condition::NoCondition},
-    {.name = "owner_info",
-     .valueMethod = byRef(&doOwnerInfo),
-     .role = Role::USER,
-     .condition = Condition::NeedsCurrentLedger},
-    {.name = "peers",
-     .valueMethod = byRef(&doPeers),
-     .role = Role::ADMIN,
-     .condition = Condition::NoCondition},
-    {.name = "path_find",
-     .valueMethod = byRef(&doPathFind),
-     .role = Role::USER,
-     .condition = Condition::NeedsCurrentLedger},
-    {.name = "ping",
-     .valueMethod = byRef(&doPing),
-     .role = Role::USER,
-     .condition = Condition::NoCondition},
-    {.name = "print",
-     .valueMethod = byRef(&doPrint),
-     .role = Role::ADMIN,
-     .condition = Condition::NoCondition},
-    //      {   "profile",              byRef (&doProfile), Role::USER,
-    //      NEEDS_CURRENT_LEDGER  },
-    {.name = "random",
-     .valueMethod = byRef(&doRandom),
-     .role = Role::USER,
-     .condition = Condition::NoCondition},
-    {.name = "peer_reservations_add",
-     .valueMethod = byRef(&doPeerReservationsAdd),
-     .role = Role::ADMIN,
-     .condition = Condition::NoCondition},
-    {.name = "peer_reservations_del",
-     .valueMethod = byRef(&doPeerReservationsDel),
-     .role = Role::ADMIN,
-     .condition = Condition::NoCondition},
-    {.name = "peer_reservations_list",
-     .valueMethod = byRef(&doPeerReservationsList),
-     .role = Role::ADMIN,
-     .condition = Condition::NoCondition},
-    {.name = "ripple_path_find",
-     .valueMethod = byRef(&doRipplePathFind),
-     .role = Role::USER,
-     .condition = Condition::NoCondition},
-    {.name = "server_definitions",
-     .valueMethod = byRef(&doServerDefinitions),
-     .role = Role::USER,
-     .condition = Condition::NoCondition},
-    {.name = "server_info",
-     .valueMethod = byRef(&doServerInfo),
-     .role = Role::USER,
-     .condition = Condition::NoCondition},
-    {.name = "server_state",
-     .valueMethod = byRef(&doServerState),
-     .role = Role::USER,
-     .condition = Condition::NoCondition},
-    {.name = "sign",
-     .valueMethod = byRef(&doSign),
-     .role = Role::USER,
-     .condition = Condition::NoCondition},
-    {.name = "sign_for",
-     .valueMethod = byRef(&doSignFor),
-     .role = Role::USER,
-     .condition = Condition::NoCondition},
-    {.name = "simulate",
-     .valueMethod = byRef(&doSimulate),
-     .role = Role::USER,
-     .condition = Condition::NeedsCurrentLedger},
-    {.name = "stop",
-     .valueMethod = byRef(&doStop),
-     .role = Role::ADMIN,
-     .condition = Condition::NoCondition},
-    {.name = "submit",
-     .valueMethod = byRef(&doSubmit),
-     .role = Role::USER,
-     .condition = Condition::NeedsCurrentLedger},
-    {.name = "submit_multisigned",
-     .valueMethod = byRef(&doSubmitMultiSigned),
-     .role = Role::USER,
-     .condition = Condition::NeedsCurrentLedger},
-    {.name = "transaction_entry",
-     .valueMethod = byRef(&doTransactionEntry),
-     .role = Role::USER,
-     .condition = Condition::NoCondition},
-    {.name = "tx",
-     .valueMethod = byRef(&doTxJson),
-     .role = Role::USER,
-     .condition = Condition::NeedsNetworkConnection},
-    {.name = "tx_history",
-     .valueMethod = byRef(&doTxHistory),
-     .role = Role::USER,
-     .condition = Condition::NoCondition,
-     .minApiVer = 1,
-     .maxApiVer = 1},
-    {.name = "tx_reduce_relay",
-     .valueMethod = byRef(&doTxReduceRelay),
-     .role = Role::USER,
-     .condition = Condition::NoCondition},
-    {.name = "unl_list",
-     .valueMethod = byRef(&doUnlList),
-     .role = Role::ADMIN,
-     .condition = Condition::NoCondition},
-    {.name = "validation_create",
-     .valueMethod = byRef(&doValidationCreate),
-     .role = Role::ADMIN,
-     .condition = Condition::NoCondition},
-    {.name = "validators",
-     .valueMethod = byRef(&doValidators),
-     .role = Role::ADMIN,
-     .condition = Condition::NoCondition},
-    {.name = "validator_list_sites",
-     .valueMethod = byRef(&doValidatorListSites),
-     .role = Role::ADMIN,
-     .condition = Condition::NoCondition},
-    {.name = "validator_info",
-     .valueMethod = byRef(&doValidatorInfo),
-     .role = Role::ADMIN,
-     .condition = Condition::NoCondition},
-    {.name = "vault_info",
-     .valueMethod = byRef(&doVaultInfo),
-     .role = Role::USER,
-     .condition = Condition::NoCondition},
-    {.name = "wallet_propose",
-     .valueMethod = byRef(&doWalletPropose),
-     .role = Role::ADMIN,
-     .condition = Condition::NoCondition},
+    {
+        .name = method::kAccountInfo,
+        .valueMethod = Method::of<&byRef<&doAccountInfo>>(),
+        .role = Role::USER,
+        .condition = Condition::NoCondition,
+    },
+    {
+        .name = method::kAccountCurrencies,
+        .valueMethod = Method::of<&byRef<&doAccountCurrencies>>(),
+        .role = Role::USER,
+        .condition = Condition::NoCondition,
+    },
+    {
+        .name = method::kAccountLines,
+        .valueMethod = Method::of<&byRef<&doAccountLines>>(),
+        .role = Role::USER,
+        .condition = Condition::NoCondition,
+    },
+    {
+        .name = method::kAccountChannels,
+        .valueMethod = Method::of<&byRef<&doAccountChannels>>(),
+        .role = Role::USER,
+        .condition = Condition::NoCondition,
+    },
+    {
+        .name = method::kAccountNfts,
+        .valueMethod = Method::of<&byRef<&doAccountNFTs>>(),
+        .role = Role::USER,
+        .condition = Condition::NoCondition,
+    },
+    {
+        .name = method::kAccountObjects,
+        .valueMethod = Method::of<&byRef<&doAccountObjects>>(),
+        .role = Role::USER,
+        .condition = Condition::NoCondition,
+    },
+    {
+        .name = method::kAccountOffers,
+        .valueMethod = Method::of<&byRef<&doAccountOffers>>(),
+        .role = Role::USER,
+        .condition = Condition::NoCondition,
+    },
+    {
+        .name = method::kAccountTx,
+        .valueMethod = Method::of<&byRef<&doAccountTx>>(),
+        .role = Role::USER,
+        .condition = Condition::NoCondition,
+    },
+    {
+        .name = method::kAmmInfo,
+        .valueMethod = Method::of<&byRef<&doAMMInfo>>(),
+        .role = Role::USER,
+        .condition = Condition::NoCondition,
+    },
+    {
+        .name = method::kBlacklist,
+        .valueMethod = Method::of<&byRef<&doBlackList>>(),
+        .role = Role::ADMIN,
+        .condition = Condition::NoCondition,
+        .hasCommandLineForm = false,
+    },
+    {
+        .name = method::kBookChanges,
+        .valueMethod = Method::of<&byRef<&doBookChanges>>(),
+        .role = Role::USER,
+        .condition = Condition::NoCondition,
+    },
+    {
+        .name = method::kBookOffers,
+        .valueMethod = Method::of<&byRef<&doBookOffers>>(),
+        .role = Role::USER,
+        .condition = Condition::NoCondition,
+    },
+    {
+        .name = method::kCanDelete,
+        .valueMethod = Method::of<&byRef<&doCanDelete>>(),
+        .role = Role::ADMIN,
+        .condition = Condition::NoCondition,
+    },
+    {
+        .name = method::kChannelAuthorize,
+        .valueMethod = Method::of<&byRef<&doChannelAuthorize>>(),
+        .role = Role::USER,
+        .condition = Condition::NoCondition,
+    },
+    {
+        .name = method::kChannelVerify,
+        .valueMethod = Method::of<&byRef<&doChannelVerify>>(),
+        .role = Role::USER,
+        .condition = Condition::NoCondition,
+    },
+    {
+        .name = method::kConnect,
+        .valueMethod = Method::of<&byRef<&doConnect>>(),
+        .role = Role::ADMIN,
+        .condition = Condition::NoCondition,
+    },
+    {
+        .name = method::kConsensusInfo,
+        .valueMethod = Method::of<&byRef<&doConsensusInfo>>(),
+        .role = Role::ADMIN,
+        .condition = Condition::NoCondition,
+    },
+    {
+        .name = method::kDepositAuthorized,
+        .valueMethod = Method::of<&byRef<&doDepositAuthorized>>(),
+        .role = Role::USER,
+        .condition = Condition::NoCondition,
+    },
+    {
+        .name = method::kFeature,
+        .valueMethod = Method::of<&byRef<&doFeature>>(),
+        .role = Role::USER,
+        .condition = Condition::NoCondition,
+    },
+    {
+        .name = method::kFee,
+        .valueMethod = Method::of<&byRef<&doFee>>(),
+        .role = Role::USER,
+        .condition = Condition::NeedsCurrentLedger,
+        .hasCommandLineForm = false,
+    },
+    {
+        .name = method::kFetchInfo,
+        .valueMethod = Method::of<&byRef<&doFetchInfo>>(),
+        .role = Role::ADMIN,
+        .condition = Condition::NoCondition,
+    },
+    {
+        .name = method::kGatewayBalances,
+        .valueMethod = Method::of<&byRef<&doGatewayBalances>>(),
+        .role = Role::USER,
+        .condition = Condition::NoCondition,
+    },
+    {
+        .name = method::kGetCounts,
+        .valueMethod = Method::of<&byRef<&doGetCounts>>(),
+        .role = Role::ADMIN,
+        .condition = Condition::NoCondition,
+    },
+    {
+        .name = method::kGetAggregatePrice,
+        .valueMethod = Method::of<&byRef<&doGetAggregatePrice>>(),
+        .role = Role::USER,
+        .condition = Condition::NoCondition,
+        .hasCommandLineForm = false,
+    },
+    {
+        .name = method::kLedgerAccept,
+        .valueMethod = Method::of<&byRef<&doLedgerAccept>>(),
+        .role = Role::ADMIN,
+        .condition = Condition::NeedsCurrentLedger,
+    },
+    {
+        .name = method::kLedgerCleaner,
+        .valueMethod = Method::of<&byRef<&doLedgerCleaner>>(),
+        .role = Role::ADMIN,
+        .condition = Condition::NeedsNetworkConnection,
+        .hasCommandLineForm = false,
+    },
+    {
+        .name = method::kLedgerClosed,
+        .valueMethod = Method::of<&byRef<&doLedgerClosed>>(),
+        .role = Role::USER,
+        .condition = Condition::NeedsClosedLedger,
+    },
+    {
+        .name = method::kLedgerCurrent,
+        .valueMethod = Method::of<&byRef<&doLedgerCurrent>>(),
+        .role = Role::USER,
+        .condition = Condition::NeedsCurrentLedger,
+    },
+    {
+        .name = method::kLedgerData,
+        .valueMethod = Method::of<&byRef<&doLedgerData>>(),
+        .role = Role::USER,
+        .condition = Condition::NoCondition,
+        .hasCommandLineForm = false,
+    },
+    {
+        .name = method::kLedgerEntry,
+        .valueMethod = Method::of<&byRef<&doLedgerEntry>>(),
+        .role = Role::USER,
+        .condition = Condition::NoCondition,
+    },
+    {
+        .name = method::kLedgerHeader,
+        .valueMethod = Method::of<&byRef<&doLedgerHeader>>(),
+        .role = Role::USER,
+        .condition = Condition::NoCondition,
+        .minApiVer = 1,
+        .maxApiVer = 1,
+    },
+    {
+        .name = method::kLedgerRequest,
+        .valueMethod = Method::of<&byRef<&doLedgerRequest>>(),
+        .role = Role::ADMIN,
+        .condition = Condition::NoCondition,
+    },
+    {
+        .name = method::kLogLevel,
+        .valueMethod = Method::of<&byRef<&doLogLevel>>(),
+        .role = Role::ADMIN,
+        .condition = Condition::NoCondition,
+    },
+    {
+        .name = method::kLogrotate,
+        .valueMethod = Method::of<&byRef<&doLogRotate>>(),
+        .role = Role::ADMIN,
+        .condition = Condition::NoCondition,
+    },
+    {
+        .name = method::kManifest,
+        .valueMethod = Method::of<&byRef<&doManifest>>(),
+        .role = Role::USER,
+        .condition = Condition::NoCondition,
+    },
+    {
+        .name = method::kNftBuyOffers,
+        .valueMethod = Method::of<&byRef<&doNFTBuyOffers>>(),
+        .role = Role::USER,
+        .condition = Condition::NoCondition,
+        .hasCommandLineForm = false,
+    },
+    {
+        .name = method::kNftSellOffers,
+        .valueMethod = Method::of<&byRef<&doNFTSellOffers>>(),
+        .role = Role::USER,
+        .condition = Condition::NoCondition,
+        .hasCommandLineForm = false,
+    },
+    {
+        .name = method::kNorippleCheck,
+        .valueMethod = Method::of<&byRef<&doNoRippleCheck>>(),
+        .role = Role::USER,
+        .condition = Condition::NoCondition,
+        .hasCommandLineForm = false,
+    },
+    {
+        .name = method::kOwnerInfo,
+        .valueMethod = Method::of<&byRef<&doOwnerInfo>>(),
+        .role = Role::USER,
+        .condition = Condition::NeedsCurrentLedger,
+    },
+    {
+        .name = method::kPeers,
+        .valueMethod = Method::of<&byRef<&doPeers>>(),
+        .role = Role::ADMIN,
+        .condition = Condition::NoCondition,
+    },
+    {
+        .name = method::kPathFind,
+        .valueMethod = Method::of<&byRef<&doPathFind>>(),
+        .role = Role::USER,
+        .condition = Condition::NeedsCurrentLedger,
+    },
+    {
+        .name = method::kPing,
+        .valueMethod = Method::of<&byRef<&doPing>>(),
+        .role = Role::USER,
+        .condition = Condition::NoCondition,
+    },
+    {
+        .name = method::kPrint,
+        .valueMethod = Method::of<&byRef<&doPrint>>(),
+        .role = Role::ADMIN,
+        .condition = Condition::NoCondition,
+    },
+    {
+        .name = method::kRandom,
+        .valueMethod = Method::of<&byRef<&doRandom>>(),
+        .role = Role::USER,
+        .condition = Condition::NoCondition,
+    },
+    {
+        .name = method::kPeerReservationsAdd,
+        .valueMethod = Method::of<&byRef<&doPeerReservationsAdd>>(),
+        .role = Role::ADMIN,
+        .condition = Condition::NoCondition,
+    },
+    {
+        .name = method::kPeerReservationsDel,
+        .valueMethod = Method::of<&byRef<&doPeerReservationsDel>>(),
+        .role = Role::ADMIN,
+        .condition = Condition::NoCondition,
+    },
+    {
+        .name = method::kPeerReservationsList,
+        .valueMethod = Method::of<&byRef<&doPeerReservationsList>>(),
+        .role = Role::ADMIN,
+        .condition = Condition::NoCondition,
+    },
+    {
+        .name = method::kRipplePathFind,
+        .valueMethod = Method::of<&byRef<&doRipplePathFind>>(),
+        .role = Role::USER,
+        .condition = Condition::NoCondition,
+    },
+    {
+        .name = method::kServerDefinitions,
+        .valueMethod = Method::of<&byRef<&doServerDefinitions>>(),
+        .role = Role::USER,
+        .condition = Condition::NoCondition,
+    },
+    {
+        .name = method::kServerInfo,
+        .valueMethod = Method::of<&byRef<&doServerInfo>>(),
+        .role = Role::USER,
+        .condition = Condition::NoCondition,
+    },
+    {
+        .name = method::kServerState,
+        .valueMethod = Method::of<&byRef<&doServerState>>(),
+        .role = Role::USER,
+        .condition = Condition::NoCondition,
+    },
+    {
+        .name = method::kSign,
+        .valueMethod = Method::of<&byRef<&doSign>>(),
+        .role = Role::USER,
+        .condition = Condition::NoCondition,
+    },
+    {
+        .name = method::kSignFor,
+        .valueMethod = Method::of<&byRef<&doSignFor>>(),
+        .role = Role::USER,
+        .condition = Condition::NoCondition,
+    },
+    {
+        .name = method::kSimulate,
+        .valueMethod = Method::of<&byRef<&doSimulate>>(),
+        .role = Role::USER,
+        .condition = Condition::NeedsCurrentLedger,
+    },
+    {
+        .name = method::kStop,
+        .valueMethod = Method::of<&byRef<&doStop>>(),
+        .role = Role::ADMIN,
+        .condition = Condition::NoCondition,
+    },
+    {
+        .name = method::kSubmit,
+        .valueMethod = Method::of<&byRef<&doSubmit>>(),
+        .role = Role::USER,
+        .condition = Condition::NeedsCurrentLedger,
+    },
+    {
+        .name = method::kSubmitMultisigned,
+        .valueMethod = Method::of<&byRef<&doSubmitMultiSigned>>(),
+        .role = Role::USER,
+        .condition = Condition::NeedsCurrentLedger,
+    },
+    {
+        .name = method::kTransactionEntry,
+        .valueMethod = Method::of<&byRef<&doTransactionEntry>>(),
+        .role = Role::USER,
+        .condition = Condition::NoCondition,
+    },
+    {
+        .name = method::kTx,
+        .valueMethod = Method::of<&byRef<&doTxJson>>(),
+        .role = Role::USER,
+        .condition = Condition::NeedsNetworkConnection,
+    },
+    {
+        .name = method::kTxHistory,
+        .valueMethod = Method::of<&byRef<&doTxHistory>>(),
+        .role = Role::USER,
+        .condition = Condition::NoCondition,
+        .minApiVer = 1,
+        .maxApiVer = 1,
+    },
+    {
+        .name = method::kTxReduceRelay,
+        .valueMethod = Method::of<&byRef<&doTxReduceRelay>>(),
+        .role = Role::USER,
+        .condition = Condition::NoCondition,
+        .hasCommandLineForm = false,
+    },
+    {
+        .name = method::kUnlList,
+        .valueMethod = Method::of<&byRef<&doUnlList>>(),
+        .role = Role::ADMIN,
+        .condition = Condition::NoCondition,
+    },
+    {
+        .name = method::kValidationCreate,
+        .valueMethod = Method::of<&byRef<&doValidationCreate>>(),
+        .role = Role::ADMIN,
+        .condition = Condition::NoCondition,
+    },
+    {
+        .name = method::kValidators,
+        .valueMethod = Method::of<&byRef<&doValidators>>(),
+        .role = Role::ADMIN,
+        .condition = Condition::NoCondition,
+        .hasCommandLineForm = false,
+    },
+    {
+        .name = method::kValidatorListSites,
+        .valueMethod = Method::of<&byRef<&doValidatorListSites>>(),
+        .role = Role::ADMIN,
+        .condition = Condition::NoCondition,
+        .hasCommandLineForm = false,
+    },
+    {
+        .name = method::kValidatorInfo,
+        .valueMethod = Method::of<&byRef<&doValidatorInfo>>(),
+        .role = Role::ADMIN,
+        .condition = Condition::NoCondition,
+    },
+    {
+        .name = method::kVaultInfo,
+        .valueMethod = Method::of<&byRef<&doVaultInfo>>(),
+        .role = Role::USER,
+        .condition = Condition::NoCondition,
+    },
+    {
+        .name = method::kWalletPropose,
+        .valueMethod = Method::of<&byRef<&doWalletPropose>>(),
+        .role = Role::ADMIN,
+        .condition = Condition::NoCondition,
+    },
     // Event methods
-    {.name = "subscribe",
-     .valueMethod = byRef(&doSubscribe),
-     .role = Role::USER,
-     .condition = Condition::NoCondition},
-    {.name = "unsubscribe",
-     .valueMethod = byRef(&doUnsubscribe),
-     .role = Role::USER,
-     .condition = Condition::NoCondition},
-};
+    {
+        .name = method::kSubscribe,
+        .valueMethod = Method::of<&byRef<&doSubscribe>>(),
+        .role = Role::USER,
+        .condition = Condition::NoCondition,
+    },
+    {
+        .name = method::kUnsubscribe,
+        .valueMethod = Method::of<&byRef<&doUnsubscribe>>(),
+        .role = Role::USER,
+        .condition = Condition::NoCondition,
+    },
+});
 
-class HandlerTable
+// The class-based handlers, which carry their name and API range as static
+// members rather than as a table entry, so they cannot go in the array above.
+constexpr auto kClassHandlerArray = std::to_array<Handler>({
+    handlerFrom<LedgerHandler>(),
+    handlerFrom<VersionHandler>(),
+});
+
+/**
+ * Join the two handler arrays above into one.
+ *
+ * Handler has no default constructor, so every entry is built in place from an
+ * index pack rather than the array being sized and then copied into. The packs
+ * come from the arrays themselves, so adding a handler to either needs no change
+ * here.
+ *
+ * @return kFunctionHandlerArray followed by kClassHandlerArray.
+ */
+constexpr auto
+joinHandlers()
 {
-private:
-    using handler_table_t = std::multimap<std::string, Handler>;
+    constexpr auto kFunctionIndices = std::make_index_sequence<std::size(kFunctionHandlerArray)>{};
+    constexpr auto kClassIndices = std::make_index_sequence<std::size(kClassHandlerArray)>{};
 
-    // Use with equal_range to enforce that API range of a newly added handler
-    // does not overlap with API range of an existing handler with same name
-    [[nodiscard]] static bool
-    overlappingApiVersion(
-        std::pair<handler_table_t::iterator, handler_table_t::iterator> range,
-        unsigned minVer,
-        unsigned maxVer)
-    {
-        XRPL_ASSERT(minVer <= maxVer, "xrpl::rpc::HandlerTable : valid API version range");
-        XRPL_ASSERT(
-            maxVer <= rpc::kApiMaximumValidVersion,
-            "xrpl::rpc::HandlerTable : valid max API version");
+    return []<std::size_t... Function, std::size_t... Class>(
+               std::index_sequence<Function...>, std::index_sequence<Class...>) {
+        return std::array<Handler, sizeof...(Function) + sizeof...(Class)>{
+            kFunctionHandlerArray[Function]..., kClassHandlerArray[Class]...};
+    }(kFunctionIndices, kClassIndices);
+}
 
-        return std::any_of(
-            range.first,
-            range.second,  //
-            [minVer, maxVer](auto const& item) {
-                return item.second.minApiVer <= maxVer && item.second.maxApiVer >= minVer;
-            });
-    }
+// The whole dispatch table.
+constexpr auto kHandlers = [] {
+    auto all = joinHandlers();
 
-    template <std::size_t N>
-    explicit HandlerTable(Handler const (&entries)[N])
-    {
-        for (auto const& entry : entries)
+    // Sorted by name, so a handler can be found by binary search.
+    std::ranges::sort(all, {}, &Handler::name);
+    return all;
+}();
+
+// getHandler() relies on this being sorted to binary search it, and
+// kHandlerNames below inherits the order.
+static_assert(
+    std::ranges::is_sorted(kHandlers, {}, &Handler::name),
+    "xrpl::rpc : kHandlers must be sorted by name");
+
+// A name must select exactly one handler, otherwise a request would have two
+// answers. Where a method's behaviour differs by API version, the handler
+// branches on context.apiVersion rather than being registered once per range.
+// Checked here, at compile time, rather than on the first dispatch.
+//
+// The method is not checked: Handler::Method has no default constructor, so an
+// entry that omits it does not compile.
+static_assert(
+    [] {
+        for (std::size_t i = 0; i < kHandlers.size(); ++i)
         {
-            if (overlappingApiVersion(
-                    table_.equal_range(entry.name), entry.minApiVer, entry.maxApiVer))
-            {
-                logicError(
-                    std::string("Handler for ") + entry.name +
-                    " overlaps with an existing handler");
-            }
+            auto const& h = kHandlers[i];
+            if (h.name.empty() || h.minApiVer > h.maxApiVer ||
+                h.maxApiVer > rpc::kApiMaximumValidVersion ||
+                h.minApiVer < rpc::kApiMinimumSupportedVersion)
+                return false;
 
-            table_.insert({entry.name, entry});
+            // Sorted, so a repeat can only be of the preceding entry.
+            if (i > 0 && kHandlers[i - 1].name == h.name)
+                return false;
         }
+        return true;
+    }(),
+    "xrpl::rpc : every handler needs a unique name and a valid API version range");
 
-        // This is where the new-style handlers are added.
-        addHandler<LedgerHandler>();
-        addHandler<VersionHandler>();
-    }
+/**
+ * Convert the handler names to a form that may be read as C strings.
+ *
+ * NullTerminatedView's constructor rejects a name that does not reach its
+ * terminating null, so this replaces the separate assertion that used to check
+ * the same property. It is consteval because that constructor is.
+ *
+ * @tparam I The indices of kHandlers.
+ * @return The names, in the order kHandlers holds them, which is sorted.
+ */
+template <std::size_t... I>
+consteval auto
+checkedHandlerNames(std::index_sequence<I...>)
+{
+    return std::array<NullTerminatedView, sizeof...(I)>{NullTerminatedView{kHandlers[I].name}...};
+}
 
-public:
-    static HandlerTable const&
-    instance()
-    {
-        static HandlerTable const kHandlerTable(kHandlerArray);
-        return kHandlerTable;
-    }
-
-    [[nodiscard]] Handler const*
-    getHandler(unsigned version, bool betaEnabled, std::string const& name) const
-    {
-        if (version < rpc::kApiMinimumSupportedVersion ||
-            version > (betaEnabled ? rpc::kApiBetaVersion : rpc::kApiMaximumSupportedVersion))
-            return nullptr;
-
-        auto const range = table_.equal_range(name);
-        auto const i = std::find_if(range.first, range.second, [version](auto const& entry) {
-            return entry.second.minApiVer <= version && version <= entry.second.maxApiVer;
-        });
-
-        return i == range.second ? nullptr : &i->second;
-    }
-
-    [[nodiscard]] std::set<char const*>
-    getHandlerNames() const
-    {
-        std::set<char const*> ret;
-        for (auto const& i : table_)
-            ret.insert(i.second.name);
-
-        return ret;
-    }
-
-private:
-    handler_table_t table_;
-
-    template <class HandlerImpl>
-    void
-    addHandler()
-    {
-        static_assert(HandlerImpl::minApiVer <= HandlerImpl::maxApiVer);
-        static_assert(HandlerImpl::maxApiVer <= rpc::kApiMaximumValidVersion);
-        static_assert(rpc::kApiMinimumSupportedVersion <= HandlerImpl::minApiVer);
-
-        if (overlappingApiVersion(
-                table_.equal_range(HandlerImpl::name),
-                HandlerImpl::minApiVer,
-                HandlerImpl::maxApiVer))
-        {
-            logicError(
-                std::string("Handler for ") + HandlerImpl::name +
-                " overlaps with an existing handler");
-        }
-
-        table_.insert({HandlerImpl::name, handlerFrom<HandlerImpl>()});
-    }
-};
+// The handler names, which are already distinct and sorted.
+constexpr auto kHandlerNames = checkedHandlerNames(std::make_index_sequence<kHandlers.size()>{});
 
 }  // namespace
 
 Handler const*
-getHandler(unsigned version, bool betaEnabled, std::string const& name)
+getHandler(unsigned version, bool betaEnabled, std::string_view name)
 {
-    return HandlerTable::instance().getHandler(version, betaEnabled, name);
+    if (version < rpc::kApiMinimumSupportedVersion ||
+        version > (betaEnabled ? rpc::kApiBetaVersion : rpc::kApiMaximumSupportedVersion))
+        return nullptr;
+
+    // Names are unique, so the binary search finds the only candidate; it then
+    // answers this request only if it serves this version.
+    auto const i = std::ranges::lower_bound(kHandlers, name, {}, &Handler::name);
+    if (i == kHandlers.end() || i->name != name)
+        return nullptr;
+
+    if (i->minApiVer <= version && version <= i->maxApiVer)
+        return &*i;
+
+    return nullptr;
 }
 
-std::set<char const*>
+std::span<NullTerminatedView const>
 getHandlerNames()
 {
-    return HandlerTable::instance().getHandlerNames();
+    return kHandlerNames;
 }
 
 }  // namespace xrpl::rpc
diff --git a/src/xrpld/rpc/detail/Handler.h b/src/xrpld/rpc/detail/Handler.h
index 7342c5fcbf..593eafb4a4 100644
--- a/src/xrpld/rpc/detail/Handler.h
+++ b/src/xrpld/rpc/detail/Handler.h
@@ -6,19 +6,15 @@
 #include <xrpld/rpc/detail/Tuning.h>
 
 #include <xrpl/basics/Log.h>
+#include <xrpl/basics/StringUtilities.h>
 #include <xrpl/json/json_value.h>
 #include <xrpl/protocol/ApiVersion.h>
 #include <xrpl/protocol/ErrorCodes.h>
 #include <xrpl/protocol/jss.h>
 #include <xrpl/server/NetworkOPs.h>
 
-#include <functional>
-#include <set>
-#include <string>
-
-namespace json {
-class Object;
-}  // namespace json
+#include <span>
+#include <string_view>
 
 namespace xrpl::rpc {
 
@@ -32,20 +28,89 @@ enum class Condition {
 
 struct Handler
 {
-    template <class JsonValue>
-    using Method = std::function<Status(JsonContext&, JsonValue&)>;
+    /**
+     * The function a handler dispatches to.
+     *
+     * A plain function pointer, not a std::function: every method is a free
+     * function known at compile time, so nothing needs to be captured. That
+     * keeps Handler a literal type, letting the dispatch table be built and
+     * checked at compile time.
+     *
+     * of() takes the function as a template argument, and there is no default
+     * constructor, so a table entry that omits its method does not compile.
+     *
+     * The pointer is not also checked against null, because gcc under
+     * -fsanitize=undefined does not fold the address of a function template
+     * instantiation in a constant expression. A null check in the table
+     * assertion, or a requires clause on Fn, both fail to compile there.
+     */
+    class Method
+    {
+    public:
+        using Function = Status (*)(JsonContext&, json::Value&);
 
-    char const* name;
-    Method<json::Value> valueMethod;
+        /**
+         * Build a Method that calls a given function.
+         *
+         * @tparam Fn The function to call.
+         * @return The Method.
+         */
+        template <Function Fn>
+        static constexpr Method
+        of() noexcept
+        {
+            return Method{Fn};
+        }
+
+        /**
+         * Call the function.
+         *
+         * @param context The request being served.
+         * @param result The object the function writes its reply into.
+         * @return The status the function returns.
+         */
+        Status
+        operator()(JsonContext& context, json::Value& result) const
+        {
+            return fn_(context, result);
+        }
+
+    private:
+        constexpr explicit Method(Function fn) noexcept : fn_(fn)
+        {
+        }
+
+        Function fn_;
+    };
+
+    std::string_view name;
+    Method valueMethod;
     Role role;
     rpc::Condition condition;
 
     unsigned minApiVer = kApiMinimumSupportedVersion;
     unsigned maxApiVer = kApiMaximumValidVersion;
+
+    // Whether the command-line client accepts this method as a command. The
+    // exceptions are methods whose arguments have no positional form. A field
+    // rather than a comment, so that RPCCall_test can check it against the
+    // command-line table in both directions.
+    bool hasCommandLineForm = true;
 };
 
+/**
+ * Find the handler that answers a method at an API version.
+ *
+ * @param version The API version the request asks for.
+ * @param betaEnabled Whether the beta API version is enabled, without which
+ *        @p version cannot exceed kApiMaximumSupportedVersion.
+ * @param name The method name, matched exactly.
+ * @return The handler, or nullptr if the version is not served, no method has
+ *         this name, or the method is not served at this version. The pointer is
+ *         into the dispatch table, so it outlives every caller.
+ */
 Handler const*
-getHandler(unsigned int version, bool betaEnabled, std::string const&);
+getHandler(unsigned int version, bool betaEnabled, std::string_view name);
 
 /**
  * Return a json::ValueType::Object with a single entry.
@@ -60,9 +125,13 @@ makeObjectValue(Value const& value, json::StaticString const& field = jss::messa
 }
 
 /**
- * Return names of all methods.
+ * Return the names of all methods, sorted and without duplicates.
+ *
+ * The names refer to storage that outlives the program, so they are safe to
+ * hold on to, and each reaches its terminating null, so a caller may read one
+ * as a C string.
  */
-std::set<char const*>
+std::span<NullTerminatedView const>
 getHandlerNames();
 
 template <class T>
diff --git a/src/xrpld/rpc/detail/Pathfinder.cpp b/src/xrpld/rpc/detail/Pathfinder.cpp
index 1f530a1165..c3e74fa4eb 100644
--- a/src/xrpld/rpc/detail/Pathfinder.cpp
+++ b/src/xrpld/rpc/detail/Pathfinder.cpp
@@ -862,10 +862,11 @@ Pathfinder::addPathsForType(
         return it->second;
 
     // Otherwise, if the type has no nodes, return the empty path.
-    if (pathType.empty())
-        return paths_[pathType];
-    if (continueCallback && !continueCallback())
-        return paths_[{}];
+    if (pathType.empty() || (continueCallback && !continueCallback()))
+    {
+        static auto const kEmptyPath = PathType{};
+        return paths_.try_emplace(kEmptyPath, STPathSet::DeduplicationTag{}).first->second;
+    }
 
     // Otherwise, get the paths for the parent PathType by calling
     // addPathsForType recursively.
@@ -873,7 +874,7 @@ Pathfinder::addPathsForType(
     parentPathType.pop_back();
 
     STPathSet const& parentPaths = addPathsForType(parentPathType, continueCallback);
-    STPathSet& pathsOut = paths_[pathType];
+    STPathSet& pathsOut = paths_.try_emplace(pathType, STPathSet::DeduplicationTag{}).first->second;
 
     JLOG(j_.debug()) << "getPaths< adding onto '" << pathTypeToString(parentPathType)
                      << "' to get '" << pathTypeToString(pathType) << "'";
@@ -959,15 +960,6 @@ Pathfinder::isNoRippleOut(STPath const& currentPath)
     return endElement.hasCurrency() && isNoRipple(fromAccount, toAccount, endElement.getCurrency());
 }
 
-void
-addUniquePath(STPathSet& pathSet, STPath const& path)
-{
-    if (!pathSet.contains(path))
-    {
-        pathSet.pushBack(path);
-    }
-}
-
 void
 Pathfinder::addLink(
     STPath const& currentPath,   // The path to build from
@@ -999,7 +991,7 @@ Pathfinder::addLink(
             {  // non-default path to XRP destination
                 JLOG(j_.trace()) << "complete path found ax: "
                                  << currentPath.getJson(JsonOptions::Values::None);
-                addUniquePath(completePaths_, currentPath);
+                completePaths_.pushBack(currentPath);
             }
         }
         else
@@ -1107,7 +1099,7 @@ Pathfinder::addLink(
                                         JLOG(j_.trace())
                                             << "complete path found ae: "
                                             << currentPath.getJson(JsonOptions::Values::None);
-                                        addUniquePath(completePaths_, currentPath);
+                                        completePaths_.pushBack(currentPath);
                                     }
                                 }
                                 else if (!bDestOnly)
@@ -1237,11 +1229,12 @@ Pathfinder::addLink(
                             // complete
                             JLOG(j_.trace()) << "complete path found bx: "
                                              << currentPath.getJson(JsonOptions::Values::None);
-                            addUniquePath(completePaths_, newPath);
+                            completePaths_.pushBack(newPath);
                         }
                         else
                         {
-                            incompletePaths.pushBack(newPath);
+                            [[maybe_unused]] auto result = incompletePaths.pushBack(newPath);
+                            XRPL_ASSERT(result, "xrpl::Pathfinder::addLink : unique path");
                         }
                     }
                     else if (!currentPath.hasSeen(
@@ -1283,7 +1276,7 @@ Pathfinder::addLink(
                            // complete
                             JLOG(j_.trace()) << "complete path found ba: "
                                              << currentPath.getJson(JsonOptions::Values::None);
-                            addUniquePath(completePaths_, newPath);
+                            completePaths_.pushBack(newPath);
                         }
                         else
                         {
diff --git a/src/xrpld/rpc/detail/Pathfinder.h b/src/xrpld/rpc/detail/Pathfinder.h
index aeacd218d2..0b4da6abde 100644
--- a/src/xrpld/rpc/detail/Pathfinder.h
+++ b/src/xrpld/rpc/detail/Pathfinder.h
@@ -207,7 +207,7 @@ private:
     std::shared_ptr<AssetCache> rLCache_;
 
     STPathElement source_;
-    STPathSet completePaths_;
+    STPathSet completePaths_{STPathSet::DeduplicationTag{}};
     std::vector<PathRank> pathRanks_;
     std::map<PathType, STPathSet> paths_;
 
diff --git a/src/xrpld/rpc/detail/RPCCall.cpp b/src/xrpld/rpc/detail/RPCCall.cpp
index a752858527..09d244b7e7 100644
--- a/src/xrpld/rpc/detail/RPCCall.cpp
+++ b/src/xrpld/rpc/detail/RPCCall.cpp
@@ -1,6 +1,7 @@
 #include <xrpld/rpc/RPCCall.h>
 
 #include <xrpld/core/Config.h>
+#include <xrpld/rpc/MethodNames.h>
 #include <xrpld/rpc/ServerHandler.h>
 
 #include <xrpl/basics/ByteUtilities.h>
@@ -44,10 +45,13 @@
 #include <exception>
 #include <functional>
 #include <iostream>
+#include <limits>
 #include <optional>
+#include <span>
 #include <sstream>
 #include <stdexcept>
 #include <string>
+#include <string_view>
 #include <unordered_map>
 #include <utility>
 #include <vector>
@@ -56,6 +60,77 @@ namespace xrpl {
 
 class RPCParser;
 
+namespace {
+
+/**
+ * The member function a command dispatches to.
+ *
+ * of() takes the function as a template argument, and there is no default
+ * constructor, so a table entry that omits its parser does not compile.
+ *
+ * The pointer is not also checked against null, because gcc under
+ * -fsanitize=undefined does not fold a pointer to a member function in a
+ * constant expression. A null check in commandsValid(), or a requires clause on
+ * Fn, both fail to compile there.
+ */
+class Parse
+{
+public:
+    using Function = json::Value (RPCParser::*)(json::Value const& jvParams);
+
+    /**
+     * Build a Parse that calls a given member function.
+     *
+     * @tparam Fn The member function to call.
+     * @return The Parse.
+     */
+    template <Function Fn>
+    static constexpr Parse
+    of() noexcept
+    {
+        return Parse{Fn};
+    }
+
+    /**
+     * Call the parser.
+     *
+     * Defined below RPCParser, because calling one of its members needs the
+     * complete class.
+     *
+     * @param parser The parser to call the member function on.
+     * @param jvParams The command line arguments, as an array.
+     * @return The request, or an error.
+     */
+    json::Value
+    operator()(RPCParser& parser, json::Value const& jvParams) const;
+
+private:
+    constexpr explicit Parse(Function fn) noexcept : fn_(fn)
+    {
+    }
+
+    Function fn_;
+};
+
+// One command the command line accepts: the method it names, the parser that
+// turns arguments into a request, and how many arguments that parser needs.
+//
+// Declared out here, rather than nested in RPCParser, so that the defaults
+// below can be used: a default member initializer is not available while the
+// enclosing class is still incomplete, which is when the table is built.
+struct Command
+{
+    // For a command that accepts any number of parameters.
+    static constexpr unsigned kUnlimitedParams = std::numeric_limits<unsigned>::max();
+
+    std::string_view name;
+    Parse parse;
+    unsigned minParams = 0;
+    unsigned maxParams = kUnlimitedParams;
+};
+
+}  // namespace
+
 //
 // HTTP protocol
 //
@@ -1239,7 +1314,429 @@ private:
         return jvRequest;
     }
 
+    // An omitted minParams means the command takes no arguments; an omitted
+    // maxParams means it takes any number. See Command.
+    //
+    // The commands. The order is free: parseCommand() searches kSortedCommands
+    // below.
+    static constexpr auto kCommandArray = std::to_array<Command>({
+        // Request-response methods
+        // - Returns an error, or the request.
+        // - To modify the method, provide a new method in the request.
+        {
+            .name = rpc::method::kAccountCurrencies,
+            .parse = Parse::of<&RPCParser::parseAccountCurrencies>(),
+            .minParams = 1,
+            .maxParams = 3,
+        },
+        {
+            .name = rpc::method::kAccountInfo,
+            .parse = Parse::of<&RPCParser::parseAccountItems>(),
+            .minParams = 1,
+            .maxParams = 3,
+        },
+        {
+            .name = rpc::method::kAccountLines,
+            .parse = Parse::of<&RPCParser::parseAccountLines>(),
+            .minParams = 1,
+            .maxParams = 5,
+        },
+        {
+            .name = rpc::method::kAccountChannels,
+            .parse = Parse::of<&RPCParser::parseAccountChannels>(),
+            .minParams = 1,
+            .maxParams = 3,
+        },
+        {
+            .name = rpc::method::kAccountNfts,
+            .parse = Parse::of<&RPCParser::parseAccountItems>(),
+            .minParams = 1,
+            .maxParams = 5,
+        },
+        {
+            .name = rpc::method::kAccountObjects,
+            .parse = Parse::of<&RPCParser::parseAccountItems>(),
+            .minParams = 1,
+            .maxParams = 5,
+        },
+        {
+            .name = rpc::method::kAccountOffers,
+            .parse = Parse::of<&RPCParser::parseAccountItems>(),
+            .minParams = 1,
+            .maxParams = 4,
+        },
+        {
+            .name = rpc::method::kAccountTx,
+            .parse = Parse::of<&RPCParser::parseAccountTransactions>(),
+            .minParams = 1,
+            .maxParams = 8,
+        },
+        {
+            .name = rpc::method::kAmmInfo,
+            .parse = Parse::of<&RPCParser::parseAsIs>(),
+            .minParams = 1,
+            .maxParams = 2,
+        },
+        {
+            .name = rpc::method::kVaultInfo,
+            .parse = Parse::of<&RPCParser::parseVault>(),
+            .minParams = 1,
+            .maxParams = 2,
+        },
+        {
+            .name = rpc::method::kBookChanges,
+            .parse = Parse::of<&RPCParser::parseLedgerId>(),
+            .minParams = 1,
+            .maxParams = 1,
+        },
+        {
+            .name = rpc::method::kBookOffers,
+            .parse = Parse::of<&RPCParser::parseBookOffers>(),
+            .minParams = 2,
+            .maxParams = 7,
+        },
+        {
+            .name = rpc::method::kCanDelete,
+            .parse = Parse::of<&RPCParser::parseCanDelete>(),
+            .maxParams = 1,
+        },
+        {
+            .name = rpc::method::kChannelAuthorize,
+            .parse = Parse::of<&RPCParser::parseChannelAuthorize>(),
+            .minParams = 3,
+            .maxParams = 4,
+        },
+        {
+            .name = rpc::method::kChannelVerify,
+            .parse = Parse::of<&RPCParser::parseChannelVerify>(),
+            .minParams = 4,
+            .maxParams = 4,
+        },
+        {
+            .name = rpc::method::kConnect,
+            .parse = Parse::of<&RPCParser::parseConnect>(),
+            .minParams = 1,
+            .maxParams = 2,
+        },
+        {
+            .name = rpc::method::kConsensusInfo,
+            .parse = Parse::of<&RPCParser::parseAsIs>(),
+            .maxParams = 0,
+        },
+        {
+            .name = rpc::method::kDepositAuthorized,
+            .parse = Parse::of<&RPCParser::parseDepositAuthorized>(),
+            .minParams = 2,
+            .maxParams = 11,
+        },
+        {
+            .name = rpc::method::kFeature,
+            .parse = Parse::of<&RPCParser::parseFeature>(),
+            .maxParams = 2,
+        },
+        {
+            .name = rpc::method::kFetchInfo,
+            .parse = Parse::of<&RPCParser::parseFetchInfo>(),
+            .maxParams = 1,
+        },
+        {
+            .name = rpc::method::kGatewayBalances,
+            .parse = Parse::of<&RPCParser::parseGatewayBalances>(),
+            .minParams = 1,
+        },
+        {
+            .name = rpc::method::kGetCounts,
+            .parse = Parse::of<&RPCParser::parseGetCounts>(),
+            .maxParams = 1,
+        },
+        {
+            .name = rpc::method::kJson,
+            .parse = Parse::of<&RPCParser::parseJson>(),
+            .minParams = 2,
+            .maxParams = 2,
+        },
+        {
+            .name = rpc::method::kJson2,
+            .parse = Parse::of<&RPCParser::parseJson2>(),
+            .minParams = 1,
+            .maxParams = 1,
+        },
+        {
+            .name = rpc::method::kLedger,
+            .parse = Parse::of<&RPCParser::parseLedger>(),
+            .maxParams = 2,
+        },
+        {
+            .name = rpc::method::kLedgerAccept,
+            .parse = Parse::of<&RPCParser::parseAsIs>(),
+            .maxParams = 0,
+        },
+        {
+            .name = rpc::method::kLedgerClosed,
+            .parse = Parse::of<&RPCParser::parseAsIs>(),
+            .maxParams = 0,
+        },
+        {
+            .name = rpc::method::kLedgerCurrent,
+            .parse = Parse::of<&RPCParser::parseAsIs>(),
+            .maxParams = 0,
+        },
+        {
+            .name = rpc::method::kLedgerEntry,
+            .parse = Parse::of<&RPCParser::parseLedgerEntry>(),
+            .minParams = 1,
+            .maxParams = 2,
+        },
+        {
+            .name = rpc::method::kLedgerHeader,
+            .parse = Parse::of<&RPCParser::parseLedgerId>(),
+            .minParams = 1,
+            .maxParams = 1,
+        },
+        {
+            .name = rpc::method::kLedgerRequest,
+            .parse = Parse::of<&RPCParser::parseLedgerId>(),
+            .minParams = 1,
+            .maxParams = 1,
+        },
+        {
+            .name = rpc::method::kLogLevel,
+            .parse = Parse::of<&RPCParser::parseLogLevel>(),
+            .maxParams = 2,
+        },
+        {
+            .name = rpc::method::kLogrotate,
+            .parse = Parse::of<&RPCParser::parseAsIs>(),
+            .maxParams = 0,
+        },
+        {
+            .name = rpc::method::kManifest,
+            .parse = Parse::of<&RPCParser::parseManifest>(),
+            .minParams = 1,
+            .maxParams = 1,
+        },
+        {
+            .name = rpc::method::kOwnerInfo,
+            .parse = Parse::of<&RPCParser::parseAccountItems>(),
+            .minParams = 1,
+            .maxParams = 3,
+        },
+        {
+            .name = rpc::method::kPeers,
+            .parse = Parse::of<&RPCParser::parseAsIs>(),
+            .maxParams = 0,
+        },
+        {
+            .name = rpc::method::kPing,
+            .parse = Parse::of<&RPCParser::parseAsIs>(),
+            .maxParams = 0,
+        },
+        {
+            .name = rpc::method::kPrint,
+            .parse = Parse::of<&RPCParser::parseAsIs>(),
+            .maxParams = 1,
+        },
+        {
+            .name = rpc::method::kRandom,
+            .parse = Parse::of<&RPCParser::parseAsIs>(),
+            .maxParams = 0,
+        },
+        {
+            .name = rpc::method::kPeerReservationsAdd,
+            .parse = Parse::of<&RPCParser::parsePeerReservationsAdd>(),
+            .minParams = 1,
+            .maxParams = 2,
+        },
+        {
+            .name = rpc::method::kPeerReservationsDel,
+            .parse = Parse::of<&RPCParser::parsePeerReservationsDel>(),
+            .minParams = 1,
+            .maxParams = 1,
+        },
+        {
+            .name = rpc::method::kPeerReservationsList,
+            .parse = Parse::of<&RPCParser::parseAsIs>(),
+            .maxParams = 0,
+        },
+        {
+            .name = rpc::method::kRipplePathFind,
+            .parse = Parse::of<&RPCParser::parseRipplePathFind>(),
+            .minParams = 1,
+            .maxParams = 2,
+        },
+        {
+            .name = rpc::method::kServerDefinitions,
+            .parse = Parse::of<&RPCParser::parseServerDefinitions>(),
+            .maxParams = 1,
+        },
+        {
+            .name = rpc::method::kServerInfo,
+            .parse = Parse::of<&RPCParser::parseServerInfo>(),
+            .maxParams = 1,
+        },
+        {
+            .name = rpc::method::kServerState,
+            .parse = Parse::of<&RPCParser::parseServerInfo>(),
+            .maxParams = 1,
+        },
+        {
+            .name = rpc::method::kSign,
+            .parse = Parse::of<&RPCParser::parseSignSubmit>(),
+            .minParams = 2,
+            .maxParams = 4,
+        },
+        {
+            .name = rpc::method::kSignFor,
+            .parse = Parse::of<&RPCParser::parseSignFor>(),
+            .minParams = 3,
+            .maxParams = 4,
+        },
+        {
+            .name = rpc::method::kStop,
+            .parse = Parse::of<&RPCParser::parseAsIs>(),
+            .maxParams = 0,
+        },
+        {
+            .name = rpc::method::kSimulate,
+            .parse = Parse::of<&RPCParser::parseSimulate>(),
+            .minParams = 1,
+            .maxParams = 2,
+        },
+        {
+            .name = rpc::method::kSubmit,
+            .parse = Parse::of<&RPCParser::parseSignSubmit>(),
+            .minParams = 1,
+            .maxParams = 4,
+        },
+        {
+            .name = rpc::method::kSubmitMultisigned,
+            .parse = Parse::of<&RPCParser::parseSubmitMultiSigned>(),
+            .minParams = 1,
+            .maxParams = 1,
+        },
+        {
+            .name = rpc::method::kTransactionEntry,
+            .parse = Parse::of<&RPCParser::parseTransactionEntry>(),
+            .minParams = 2,
+            .maxParams = 2,
+        },
+        {
+            .name = rpc::method::kTx,
+            .parse = Parse::of<&RPCParser::parseTx>(),
+            .minParams = 1,
+            .maxParams = 4,
+        },
+        {
+            .name = rpc::method::kTxHistory,
+            .parse = Parse::of<&RPCParser::parseTxHistory>(),
+            .minParams = 1,
+            .maxParams = 1,
+        },
+        {
+            .name = rpc::method::kUnlList,
+            .parse = Parse::of<&RPCParser::parseAsIs>(),
+            .maxParams = 0,
+        },
+        {
+            .name = rpc::method::kValidationCreate,
+            .parse = Parse::of<&RPCParser::parseValidationCreate>(),
+            .maxParams = 1,
+        },
+        {
+            .name = rpc::method::kValidatorInfo,
+            .parse = Parse::of<&RPCParser::parseAsIs>(),
+            .maxParams = 0,
+        },
+        {
+            .name = rpc::method::kVersion,
+            .parse = Parse::of<&RPCParser::parseAsIs>(),
+            .maxParams = 0,
+        },
+        {
+            .name = rpc::method::kWalletPropose,
+            .parse = Parse::of<&RPCParser::parseWalletPropose>(),
+            .maxParams = 1,
+        },
+        {
+            .name = rpc::method::kInternal,
+            .parse = Parse::of<&RPCParser::parseInternal>(),
+            .minParams = 1,
+        },
+
+        // Event methods, rejected below, so the parameter range is unconstrained
+        {
+            .name = rpc::method::kPathFind,
+            .parse = Parse::of<&RPCParser::parseEvented>(),
+        },
+        {
+            .name = rpc::method::kSubscribe,
+            .parse = Parse::of<&RPCParser::parseEvented>(),
+        },
+        {
+            .name = rpc::method::kUnsubscribe,
+            .parse = Parse::of<&RPCParser::parseEvented>(),
+        },
+    });
+
+    // kCommandArray sorted by name, so a command can be found by binary search.
+    static constexpr auto kSortedCommands = [] {
+        auto commands = kCommandArray;
+        std::ranges::sort(commands, {}, &Command::name);
+        return commands;
+    }();
+
+    // parseCommand() relies on this being sorted to binary search it, and
+    // kCommandNames below inherits the order.
+    static_assert(
+        std::ranges::is_sorted(kSortedCommands, {}, &Command::name),
+        "xrpl::RPCParser : kSortedCommands must be sorted");
+
+    // The command names, which are already distinct and sorted.
+    static constexpr auto kCommandNames = [] {
+        std::array<std::string_view, kSortedCommands.size()> names{};
+        std::ranges::transform(kSortedCommands, names.begin(), &Command::name);
+        return names;
+    }();
+
 public:
+    /**
+     * Names of every method the command line accepts.
+     */
+    static std::span<std::string_view const>
+    methodNames()
+    {
+        return kCommandNames;
+    }
+
+    /**
+     * Whether the command table is well formed.
+     *
+     * A name must select exactly one command, and must name a method the server
+     * can dispatch, or the command line would accept a command it cannot
+     * answer. RPCCall_test checks the second property, because it can see the
+     * handler table. This checks the first, and the parameter range.
+     *
+     * The parser is not checked: Parse has no default constructor, so an entry
+     * that omits it does not compile.
+     *
+     * This is a function the static_assert below the class calls, rather than
+     * the assert itself, because the table names members of RPCParser, and that
+     * is only a constant expression once RPCParser is complete.
+     */
+    static constexpr bool
+    commandsValid()
+    {
+        for (std::size_t i = 0; i < kSortedCommands.size(); ++i)
+        {
+            auto const& command = kSortedCommands[i];
+            if (command.name.empty() || command.minParams > command.maxParams)
+                return false;
+            if (i > 0 && kSortedCommands[i - 1].name == command.name)
+                return false;
+        }
+        return true;
+    }
+
     //--------------------------------------------------------------------------
 
     explicit RPCParser(unsigned apiVersion, beast::Journal j) : apiVersion_(apiVersion), j_(j)
@@ -1251,7 +1748,7 @@ public:
     // Convert a rpc method and params to a request.
     // <-- { method: xyz, params: [... ] } or { error: ..., ... }
     json::Value
-    parseCommand(std::string strMethod, json::Value jvParams, bool allowAnyCommand)
+    parseCommand(std::string_view strMethod, json::Value const& jvParams, bool allowAnyCommand)
     {
         if (auto stream = j_.trace())
         {
@@ -1259,254 +1756,48 @@ public:
             stream << "Params: " << jvParams;
         }
 
-        struct Command
+        auto const found = std::ranges::lower_bound(kSortedCommands, strMethod, {}, &Command::name);
+
+        if (found == kSortedCommands.end() || found->name != strMethod)
         {
-            char const* name;
-            parseFuncPtr parse;
-            int minParams;
-            int maxParams;
-        };
+            // The command could not be found
+            if (!allowAnyCommand)
+                return rpcError(RpcUnknownCommand);
 
-        static constexpr Command kCommands[] = {
-            // Request-response methods
-            // - Returns an error, or the request.
-            // - To modify the method, provide a new method in the request.
-            {.name = "account_currencies",
-             .parse = &RPCParser::parseAccountCurrencies,
-             .minParams = 1,
-             .maxParams = 3},
-            {.name = "account_info",
-             .parse = &RPCParser::parseAccountItems,
-             .minParams = 1,
-             .maxParams = 3},
-            {.name = "account_lines",
-             .parse = &RPCParser::parseAccountLines,
-             .minParams = 1,
-             .maxParams = 5},
-            {.name = "account_channels",
-             .parse = &RPCParser::parseAccountChannels,
-             .minParams = 1,
-             .maxParams = 3},
-            {.name = "account_nfts",
-             .parse = &RPCParser::parseAccountItems,
-             .minParams = 1,
-             .maxParams = 5},
-            {.name = "account_objects",
-             .parse = &RPCParser::parseAccountItems,
-             .minParams = 1,
-             .maxParams = 5},
-            {.name = "account_offers",
-             .parse = &RPCParser::parseAccountItems,
-             .minParams = 1,
-             .maxParams = 4},
-            {.name = "account_tx",
-             .parse = &RPCParser::parseAccountTransactions,
-             .minParams = 1,
-             .maxParams = 8},
-            {.name = "amm_info", .parse = &RPCParser::parseAsIs, .minParams = 1, .maxParams = 2},
-            {.name = "vault_info", .parse = &RPCParser::parseVault, .minParams = 1, .maxParams = 2},
-            {.name = "book_changes",
-             .parse = &RPCParser::parseLedgerId,
-             .minParams = 1,
-             .maxParams = 1},
-            {.name = "book_offers",
-             .parse = &RPCParser::parseBookOffers,
-             .minParams = 2,
-             .maxParams = 7},
-            {.name = "can_delete",
-             .parse = &RPCParser::parseCanDelete,
-             .minParams = 0,
-             .maxParams = 1},
-            {.name = "channel_authorize",
-             .parse = &RPCParser::parseChannelAuthorize,
-             .minParams = 3,
-             .maxParams = 4},
-            {.name = "channel_verify",
-             .parse = &RPCParser::parseChannelVerify,
-             .minParams = 4,
-             .maxParams = 4},
-            {.name = "connect", .parse = &RPCParser::parseConnect, .minParams = 1, .maxParams = 2},
-            {.name = "consensus_info",
-             .parse = &RPCParser::parseAsIs,
-             .minParams = 0,
-             .maxParams = 0},
-            {.name = "deposit_authorized",
-             .parse = &RPCParser::parseDepositAuthorized,
-             .minParams = 2,
-             .maxParams = 11},
-            {.name = "feature", .parse = &RPCParser::parseFeature, .minParams = 0, .maxParams = 2},
-            {.name = "fetch_info",
-             .parse = &RPCParser::parseFetchInfo,
-             .minParams = 0,
-             .maxParams = 1},
-            {.name = "gateway_balances",
-             .parse = &RPCParser::parseGatewayBalances,
-             .minParams = 1,
-             .maxParams = -1},
-            {.name = "get_counts",
-             .parse = &RPCParser::parseGetCounts,
-             .minParams = 0,
-             .maxParams = 1},
-            {.name = "json", .parse = &RPCParser::parseJson, .minParams = 2, .maxParams = 2},
-            {.name = "json2", .parse = &RPCParser::parseJson2, .minParams = 1, .maxParams = 1},
-            {.name = "ledger", .parse = &RPCParser::parseLedger, .minParams = 0, .maxParams = 2},
-            {.name = "ledger_accept",
-             .parse = &RPCParser::parseAsIs,
-             .minParams = 0,
-             .maxParams = 0},
-            {.name = "ledger_closed",
-             .parse = &RPCParser::parseAsIs,
-             .minParams = 0,
-             .maxParams = 0},
-            {.name = "ledger_current",
-             .parse = &RPCParser::parseAsIs,
-             .minParams = 0,
-             .maxParams = 0},
-            {.name = "ledger_entry",
-             .parse = &RPCParser::parseLedgerEntry,
-             .minParams = 1,
-             .maxParams = 2},
-            {.name = "ledger_header",
-             .parse = &RPCParser::parseLedgerId,
-             .minParams = 1,
-             .maxParams = 1},
-            {.name = "ledger_request",
-             .parse = &RPCParser::parseLedgerId,
-             .minParams = 1,
-             .maxParams = 1},
-            {.name = "log_level",
-             .parse = &RPCParser::parseLogLevel,
-             .minParams = 0,
-             .maxParams = 2},
-            {.name = "logrotate", .parse = &RPCParser::parseAsIs, .minParams = 0, .maxParams = 0},
-            {.name = "manifest",
-             .parse = &RPCParser::parseManifest,
-             .minParams = 1,
-             .maxParams = 1},
-            {.name = "owner_info",
-             .parse = &RPCParser::parseAccountItems,
-             .minParams = 1,
-             .maxParams = 3},
-            {.name = "peers", .parse = &RPCParser::parseAsIs, .minParams = 0, .maxParams = 0},
-            {.name = "ping", .parse = &RPCParser::parseAsIs, .minParams = 0, .maxParams = 0},
-            {.name = "print", .parse = &RPCParser::parseAsIs, .minParams = 0, .maxParams = 1},
-            //      {   "profile",              &RPCParser::parseProfile, 1,  9
-            //      },
-            {.name = "random", .parse = &RPCParser::parseAsIs, .minParams = 0, .maxParams = 0},
-            {.name = "peer_reservations_add",
-             .parse = &RPCParser::parsePeerReservationsAdd,
-             .minParams = 1,
-             .maxParams = 2},
-            {.name = "peer_reservations_del",
-             .parse = &RPCParser::parsePeerReservationsDel,
-             .minParams = 1,
-             .maxParams = 1},
-            {.name = "peer_reservations_list",
-             .parse = &RPCParser::parseAsIs,
-             .minParams = 0,
-             .maxParams = 0},
-            {.name = "ripple_path_find",
-             .parse = &RPCParser::parseRipplePathFind,
-             .minParams = 1,
-             .maxParams = 2},
-            {.name = "server_definitions",
-             .parse = &RPCParser::parseServerDefinitions,
-             .minParams = 0,
-             .maxParams = 1},
-            {.name = "server_info",
-             .parse = &RPCParser::parseServerInfo,
-             .minParams = 0,
-             .maxParams = 1},
-            {.name = "server_state",
-             .parse = &RPCParser::parseServerInfo,
-             .minParams = 0,
-             .maxParams = 1},
-            {.name = "sign", .parse = &RPCParser::parseSignSubmit, .minParams = 2, .maxParams = 4},
-            {.name = "sign_for", .parse = &RPCParser::parseSignFor, .minParams = 3, .maxParams = 4},
-            {.name = "stop", .parse = &RPCParser::parseAsIs, .minParams = 0, .maxParams = 0},
-            {.name = "simulate",
-             .parse = &RPCParser::parseSimulate,
-             .minParams = 1,
-             .maxParams = 2},
-            {.name = "submit",
-             .parse = &RPCParser::parseSignSubmit,
-             .minParams = 1,
-             .maxParams = 4},
-            {.name = "submit_multisigned",
-             .parse = &RPCParser::parseSubmitMultiSigned,
-             .minParams = 1,
-             .maxParams = 1},
-            {.name = "transaction_entry",
-             .parse = &RPCParser::parseTransactionEntry,
-             .minParams = 2,
-             .maxParams = 2},
-            {.name = "tx", .parse = &RPCParser::parseTx, .minParams = 1, .maxParams = 4},
-            {.name = "tx_history",
-             .parse = &RPCParser::parseTxHistory,
-             .minParams = 1,
-             .maxParams = 1},
-            {.name = "unl_list", .parse = &RPCParser::parseAsIs, .minParams = 0, .maxParams = 0},
-            {.name = "validation_create",
-             .parse = &RPCParser::parseValidationCreate,
-             .minParams = 0,
-             .maxParams = 1},
-            {.name = "validator_info",
-             .parse = &RPCParser::parseAsIs,
-             .minParams = 0,
-             .maxParams = 0},
-            {.name = "version", .parse = &RPCParser::parseAsIs, .minParams = 0, .maxParams = 0},
-            {.name = "wallet_propose",
-             .parse = &RPCParser::parseWalletPropose,
-             .minParams = 0,
-             .maxParams = 1},
-            {.name = "internal",
-             .parse = &RPCParser::parseInternal,
-             .minParams = 1,
-             .maxParams = -1},
-
-            // Event methods
-            {.name = "path_find",
-             .parse = &RPCParser::parseEvented,
-             .minParams = -1,
-             .maxParams = -1},
-            {.name = "subscribe",
-             .parse = &RPCParser::parseEvented,
-             .minParams = -1,
-             .maxParams = -1},
-            {.name = "unsubscribe",
-             .parse = &RPCParser::parseEvented,
-             .minParams = -1,
-             .maxParams = -1},
-        };
-
-        auto const count = jvParams.size();
-
-        for (auto const& command : kCommands)
-        {
-            if (strMethod == command.name)
-            {
-                if ((command.minParams >= 0 && count < command.minParams) ||
-                    (command.maxParams >= 0 && count > command.maxParams))
-                {
-                    JLOG(j_.debug()) << "Wrong number of parameters for " << command.name
-                                     << " minimum=" << command.minParams
-                                     << " maximum=" << command.maxParams << " actual=" << count;
-
-                    return rpcError(RpcBadSyntax);
-                }
-
-                return (this->*(command.parse))(jvParams);
-            }
+            return parseAsIs(jvParams);
         }
 
-        // The command could not be found
-        if (!allowAnyCommand)
-            return rpcError(RpcUnknownCommand);
+        auto const count = jvParams.size();
+        if (count < found->minParams || count > found->maxParams)
+        {
+            JLOG(j_.debug()) << "Wrong number of parameters for " << found->name
+                             << " minimum=" << found->minParams << " maximum=" << found->maxParams
+                             << " actual=" << count;
 
-        return parseAsIs(jvParams);
+            return rpcError(RpcBadSyntax);
+        }
+
+        return found->parse(*this, jvParams);
     }
 };
 
+namespace {
+
+// Out of line because RPCParser is incomplete where Parse is declared.
+json::Value
+Parse::operator()(RPCParser& parser, json::Value const& jvParams) const
+{
+    return (parser.*fn_)(jvParams);
+}
+
+}  // namespace
+
+// See the comment on commandsValid() for why this is out here.
+static_assert(
+    RPCParser::commandsValid(),
+    "xrpl::RPCParser : every command needs a unique name and a valid parameter "
+    "count range");
+
 //------------------------------------------------------------------------------
 
 //
@@ -1614,6 +1905,12 @@ struct RPCCallImp
 
 //------------------------------------------------------------------------------
 
+std::span<std::string_view const>
+commandLineMethodNames()
+{
+    return RPCParser::methodNames();
+}
+
 // Used internally by rpcClient.
 json::Value
 rpcCmdToJson(
diff --git a/src/xrpld/rpc/detail/RPCHandler.cpp b/src/xrpld/rpc/detail/RPCHandler.cpp
index 96d6bf72d7..5501cdfde3 100644
--- a/src/xrpld/rpc/detail/RPCHandler.cpp
+++ b/src/xrpld/rpc/detail/RPCHandler.cpp
@@ -23,6 +23,7 @@
 #include <cstdint>
 #include <exception>
 #include <string>
+#include <string_view>
 
 namespace xrpl::rpc {
 
@@ -153,9 +154,8 @@ fillHandler(JsonContext& context, Handler const*& result)
     return RpcSuccess;
 }
 
-template <class Object, class Method>
 Status
-callMethod(JsonContext& context, Method method, std::string const& name, Object& result)
+callMethod(JsonContext& context, Handler::Method method, std::string_view name, json::Value& result)
 {
     static std::atomic<std::uint64_t> kRequestId{0};
     auto& perfLog = context.app.getPerfLog();
@@ -163,7 +163,8 @@ callMethod(JsonContext& context, Method method, std::string const& name, Object&
     try
     {
         perfLog.rpcStart(name, curId);
-        auto v = context.app.getJobQueue().makeLoadEvent(JtGeneric, "cmd:" + name);
+        auto v =
+            context.app.getJobQueue().makeLoadEvent(JtGeneric, std::string{"cmd:"}.append(name));
 
         auto start = std::chrono::system_clock::now();
         auto ret = method(context, result);
@@ -199,32 +200,28 @@ doCommand(rpc::JsonContext& context, json::Value& result)
         return error;
     }
 
-    if (auto method = handler->valueMethod)
+    // No null check on the method: Handler::Method has no default constructor, so
+    // every entry in the dispatch table names one.
+    if (!context.headers.user.empty() || !context.headers.forwardedFor.empty())
     {
-        if (!context.headers.user.empty() || !context.headers.forwardedFor.empty())
-        {
-            JLOG(context.j.debug())
-                << "start command: " << handler->name << ", user: " << context.headers.user
-                << ", forwarded for: " << context.headers.forwardedFor;
+        JLOG(context.j.debug()) << "start command: " << handler->name
+                                << ", user: " << context.headers.user
+                                << ", forwarded for: " << context.headers.forwardedFor;
 
-            auto ret = callMethod(context, method, handler->name, result);
+        auto const ret = callMethod(context, handler->valueMethod, handler->name, result);
 
-            JLOG(context.j.debug())
-                << "finish command: " << handler->name << ", user: " << context.headers.user
-                << ", forwarded for: " << context.headers.forwardedFor;
+        JLOG(context.j.debug()) << "finish command: " << handler->name
+                                << ", user: " << context.headers.user
+                                << ", forwarded for: " << context.headers.forwardedFor;
 
-            return ret;
-        }
-
-        auto ret = callMethod(context, method, handler->name, result);
         return ret;
     }
 
-    return RpcUnknownCommand;
+    return callMethod(context, handler->valueMethod, handler->name, result);
 }
 
 Role
-roleRequired(unsigned int version, bool betaEnabled, std::string const& method)
+roleRequired(unsigned int version, bool betaEnabled, std::string_view method)
 {
     auto handler = rpc::getHandler(version, betaEnabled, method);
 
diff --git a/src/xrpld/rpc/detail/ServerHandler.cpp b/src/xrpld/rpc/detail/ServerHandler.cpp
index 28e7eebd63..fdadc4ba8b 100644
--- a/src/xrpld/rpc/detail/ServerHandler.cpp
+++ b/src/xrpld/rpc/detail/ServerHandler.cpp
@@ -533,8 +533,6 @@ ServerHandler::processSession(
     }
     else
     {
-        if (jr[jss::result].isMember("forwarded") && jr[jss::result]["forwarded"])
-            jr = jr[jss::result];
         jr[jss::status] = jss::success;
     }
 
diff --git a/src/xrpld/rpc/detail/TransactionSign.cpp b/src/xrpld/rpc/detail/TransactionSign.cpp
index 9c97577b27..6ea879aa2c 100644
--- a/src/xrpld/rpc/detail/TransactionSign.cpp
+++ b/src/xrpld/rpc/detail/TransactionSign.cpp
@@ -460,7 +460,8 @@ transactionPreProcessImpl(
     Role role,
     SigningForParams& signingArgs,
     std::chrono::seconds validatedLedgerAge,
-    Application& app)
+    Application& app,
+    Rules const& rules)
 {
     auto j = app.getJournal("RPCHandler");
 
@@ -482,13 +483,16 @@ transactionPreProcessImpl(
     }();
 
     // Make sure the signature target field is valid, if specified, and save the
-    // template for use later
+    // template for use later. Only a field that holds a transaction signature
+    // is a valid target; the signature is bound to that field's role.
     auto const signatureTemplate = signatureTarget
         ? InnerObjectFormats::getInstance().findSOTemplateBySField(*signatureTarget)
         : nullptr;
+    auto const signatureRoleOpt =
+        signatureTarget ? signatureRole(signatureTarget->get()) : SignatureRole::Transaction;
     if (signatureTarget)
     {
-        if (signatureTemplate == nullptr)
+        if (!signatureRoleOpt || signatureTemplate == nullptr)
         {  // Invalid target field
             return rpc::makeError(RpcInvalidParams, signatureTarget->get().getName());
         }
@@ -687,7 +691,8 @@ transactionPreProcessImpl(
     // If multisign then return multiSignature, else set TxnSignature field.
     if (signingArgs.isMultiSigning())
     {
-        Serializer const s = buildMultiSigningData(*stTx, signingArgs.getSigner());
+        Serializer const s = buildMultiSigningData(
+            *stTx, signingArgs.getSigner(), signingPrefix(*signatureRoleOpt, true, rules));
 
         auto multisig = xrpl::sign(pk, sk, s.slice());
 
@@ -695,7 +700,7 @@ transactionPreProcessImpl(
     }
     else if (signingArgs.isSingleSigning())
     {
-        stTx->sign(pk, sk, signatureTarget);
+        stTx->sign(pk, sk, *signatureRoleOpt, rules);
     }
 
     return TransactionPreProcessResult{std::move(stTx)};
@@ -882,7 +887,10 @@ getTxFee(Application const& app, Config const& config, json::Value tx)
         if (!passesLocalChecks(stTx, reason))
             return config.fees.referenceFee;
 
-        return calculateBaseFee(*app.getOpenLedger().current(), stTx);
+        // This fee is only a suggestion returned to the caller, so fall back to
+        // the reference fee as the other failure paths in this function do.
+        return calculateBaseFee(*app.getOpenLedger().current(), stTx)
+            .value_or(config.fees.referenceFee);
     }
     catch (std::exception& e)
     {
@@ -1007,18 +1015,20 @@ transactionSign(
 {
     using namespace detail;
 
+    // Sign and verify against the same ruleset: a ledger close in between
+    // could change the signing prefix of an alternate signature field.
+    std::shared_ptr<ReadView const> const ledger = app.getOpenLedger().current();
     auto j = app.getJournal("RPCHandler");
     JLOG(j.debug()) << "transactionSign: " << jvRequest;
 
     // Add and amend fields based on the transaction type.
     SigningForParams signForParams;
-    TransactionPreProcessResult const preprocResult =
-        transactionPreProcessImpl(jvRequest, role, signForParams, validatedLedgerAge, app);
+    TransactionPreProcessResult const preprocResult = transactionPreProcessImpl(
+        jvRequest, role, signForParams, validatedLedgerAge, app, ledger->rules());
 
     if (!preprocResult.second)
         return preprocResult.first;
 
-    std::shared_ptr<ReadView const> const ledger = app.getOpenLedger().current();
     // Make sure the STTx makes a legitimate Transaction.
     std::pair<json::Value, Transaction::pointer> const txn =
         transactionConstructImpl(preprocResult.second, ledger->rules(), app);
@@ -1050,8 +1060,8 @@ transactionSubmit(
 
     // Add and amend fields based on the transaction type.
     SigningForParams signForParams;
-    TransactionPreProcessResult const preprocResult =
-        transactionPreProcessImpl(jvRequest, role, signForParams, validatedLedgerAge, app);
+    TransactionPreProcessResult const preprocResult = transactionPreProcessImpl(
+        jvRequest, role, signForParams, validatedLedgerAge, app, ledger->rules());
 
     if (!preprocResult.second)
         return preprocResult.first;
@@ -1218,8 +1228,8 @@ transactionSignFor(
     // Add and amend fields based on the transaction type.
     SigningForParams signForParams(*signerAccountID);
 
-    TransactionPreProcessResult const preprocResult =
-        transactionPreProcessImpl(jvRequest, role, signForParams, validatedLedgerAge, app);
+    TransactionPreProcessResult const preprocResult = transactionPreProcessImpl(
+        jvRequest, role, signForParams, validatedLedgerAge, app, ledger->rules());
 
     if (!preprocResult.second)
         return preprocResult.first;
diff --git a/src/xrpld/rpc/handlers/account/NoRippleCheck.cpp b/src/xrpld/rpc/handlers/account/NoRippleCheck.cpp
index 4be6e6f1af..283ef7cb3f 100644
--- a/src/xrpld/rpc/handlers/account/NoRippleCheck.cpp
+++ b/src/xrpld/rpc/handlers/account/NoRippleCheck.cpp
@@ -21,6 +21,8 @@
 
 #include <cstdint>
 #include <memory>
+#include <string>
+#include <utility>
 
 namespace xrpl {
 
@@ -32,12 +34,13 @@ fillTransaction(
     std::uint32_t& sequence,
     ReadView const& ledger)
 {
-    txArray["Sequence"] = json::UInt(sequence++);
-    txArray["Account"] = toBase58(accountID);
+    txArray[jss::Sequence] = json::UInt(sequence++);
+    txArray[jss::Account] = toBase58(accountID);
     auto& fees = ledger.fees();
     // Convert the reference transaction cost in fee units to drops
     // scaled to represent the current fee load.
-    txArray["Fee"] = scaleFeeLoad(fees.base, context.app.getFeeTrack(), fees, false).jsonClipped();
+    txArray[jss::Fee] =
+        scaleFeeLoad(fees.base, context.app.getFeeTrack(), fees, false).jsonClipped();
 }
 
 // {
@@ -53,24 +56,33 @@ doNoRippleCheck(rpc::JsonContext& context)
 {
     auto const& params(context.params);
     if (!params.isMember(jss::account))
-        return rpc::missingFieldError("account");
-
-    if (!params.isMember("role"))
-        return rpc::missingFieldError("role");
+        return rpc::missingFieldError(jss::account);
 
     if (!params[jss::account].isString())
         return rpc::invalidFieldError(jss::account);
 
+    auto id = parseBase58<AccountID>(params[jss::account].asString());
+    if (!id)
+    {
+        return rpcError(RpcActMalformed);
+    }
+    auto const accountID{id.value()};
+
+    if (!params.isMember(jss::role))
+        return rpc::missingFieldError(jss::role);
+
     bool roleGateway = false;
     {
-        std::string const role = params["role"].asString();
-        if (role == "gateway")
+        if (!params[jss::role].isString())
+            return rpc::expectedFieldError(jss::role, "string");
+        std::string const role = params[jss::role].asString();
+        if (role == jss::gateway)
         {
             roleGateway = true;
         }
-        else if (role != "user")
+        else if (role != jss::user)
         {
-            return rpc::invalidFieldError("role");
+            return rpc::invalidFieldError(jss::role);
         }
     }
 
@@ -78,61 +90,49 @@ doNoRippleCheck(rpc::JsonContext& context)
     if (auto err = readLimitField(limit, rpc::tuning::kNoRippleCheck, context))
         return *err;
 
-    bool transactions = false;
-    if (params.isMember(jss::transactions))
-        transactions = params["transactions"].asBool();
-
-    // The document[https://xrpl.org/noripple_check.html#noripple_check] states
-    // that transactions params is a boolean value, however, assigning any
-    // string value works. Do not allow this. This check is for api Version 2
-    // onwards only
+    // API v1 silently accepts any string as `transactions`; v2+ enforces bool.
     if (context.apiVersion > 1u && params.isMember(jss::transactions) &&
         !params[jss::transactions].isBool())
     {
         return rpc::invalidFieldError(jss::transactions);
     }
 
+    bool transactions = false;
+    if (params.isMember(jss::transactions))
+        transactions = params[jss::transactions].asBool();
+
     std::shared_ptr<ReadView const> ledger;
     auto result = rpc::lookupLedger(ledger, context);
     if (!ledger)
         return result;
 
-    json::Value dummy;  // NOLINT(misc-const-correctness)
-    json::Value& jvTransactions =
-        transactions ? (result[jss::transactions] = json::ValueType::Array) : dummy;
-
-    auto id = parseBase58<AccountID>(params[jss::account].asString());
-    if (!id)
-    {
-        rpc::injectError(RpcActMalformed, result);
-        return result;
-    }
-    auto const accountID{id.value()};
     auto const sle = ledger->read(keylet::account(accountID));
     if (!sle)
         return rpcError(RpcActNotFound);
 
     std::uint32_t seq = sle->getFieldU32(sfSequence);
 
-    json::Value& problems = (result["problems"] = json::ValueType::Array);
+    json::Value& problems = (result[jss::problems] = json::ValueType::Array);
 
-    bool const bDefaultRipple = sle->isFlag(lsfDefaultRipple);
+    bool const defaultRipple = sle->isFlag(lsfDefaultRipple);
 
-    if (bDefaultRipple && !roleGateway)
+    json::Value jvTransactions = json::ValueType::Array;
+
+    if (defaultRipple && !roleGateway)
     {
         problems.append(
             "You appear to have set your default ripple flag even though you "
             "are not a gateway. This is not recommended unless you are "
             "experimenting");
     }
-    else if (roleGateway && !bDefaultRipple)
+    else if (roleGateway && !defaultRipple)
     {
         problems.append("You should immediately set your default ripple flag");
         if (transactions)
         {
             json::Value& tx = jvTransactions.append(json::ValueType::Object);
-            tx["TransactionType"] = jss::AccountSet;
-            tx["SetFlag"] = 8;
+            tx[jss::TransactionType] = jss::AccountSet;
+            tx[jss::SetFlag] = 8;
             fillTransaction(context, tx, accountID, seq, *ledger);
         }
     }
@@ -140,18 +140,18 @@ doNoRippleCheck(rpc::JsonContext& context)
     forEachItemAfter(*ledger, accountID, uint256(), 0, limit, [&](SLE::const_ref ownedItem) {
         if (ownedItem->getType() == ltRIPPLE_STATE)
         {
-            bool const bLow = accountID == ownedItem->getFieldAmount(sfLowLimit).getIssuer();
+            bool const low = accountID == ownedItem->getFieldAmount(sfLowLimit).getIssuer();
 
-            bool const bNoRipple = ownedItem->isFlag(bLow ? lsfLowNoRipple : lsfHighNoRipple);
+            bool const noRipple = ownedItem->isFlag(low ? lsfLowNoRipple : lsfHighNoRipple);
 
             std::string problem;
             bool needFix = false;
-            if (bNoRipple && roleGateway)
+            if (noRipple && roleGateway)
             {
                 problem = "You should clear the no ripple flag on your ";
                 needFix = true;
             }
-            else if (!roleGateway && !bNoRipple)
+            else if (!roleGateway && !noRipple)
             {
                 problem = "You should probably set the no ripple flag on your ";
                 needFix = true;
@@ -159,22 +159,25 @@ doNoRippleCheck(rpc::JsonContext& context)
             if (needFix)
             {
                 AccountID const peer =
-                    ownedItem->getFieldAmount(bLow ? sfHighLimit : sfLowLimit).getIssuer();
+                    ownedItem->getFieldAmount(low ? sfHighLimit : sfLowLimit).getIssuer();
                 STAmount const peerLimit =
-                    ownedItem->getFieldAmount(bLow ? sfHighLimit : sfLowLimit);
+                    ownedItem->getFieldAmount(low ? sfHighLimit : sfLowLimit);
                 problem += to_string(peerLimit.get<Issue>().currency);
                 problem += " line to ";
                 problem += to_string(peerLimit.getIssuer());
                 problems.append(problem);
 
-                STAmount limitAmount(ownedItem->getFieldAmount(bLow ? sfLowLimit : sfHighLimit));
+                STAmount limitAmount(ownedItem->getFieldAmount(low ? sfLowLimit : sfHighLimit));
                 limitAmount.get<Issue>().account = peer;
 
-                json::Value& tx = jvTransactions.append(json::ValueType::Object);
-                tx["TransactionType"] = jss::TrustSet;
-                tx["LimitAmount"] = limitAmount.getJson(JsonOptions::Values::None);
-                tx["Flags"] = bNoRipple ? tfClearNoRipple : tfSetNoRipple;
-                fillTransaction(context, tx, accountID, seq, *ledger);
+                if (transactions)
+                {
+                    json::Value& tx = jvTransactions.append(json::ValueType::Object);
+                    tx[jss::TransactionType] = jss::TrustSet;
+                    tx[jss::LimitAmount] = limitAmount.getJson(JsonOptions::Values::None);
+                    tx[jss::Flags] = noRipple ? tfClearNoRipple : tfSetNoRipple;
+                    fillTransaction(context, tx, accountID, seq, *ledger);
+                }
 
                 return true;
             }
@@ -182,6 +185,8 @@ doNoRippleCheck(rpc::JsonContext& context)
         return false;
     });
 
+    if (transactions)
+        result[jss::transactions] = std::move(jvTransactions);
     return result;
 }
 
diff --git a/src/xrpld/rpc/handlers/ledger/Ledger.h b/src/xrpld/rpc/handlers/ledger/Ledger.h
index 07d24b497d..17c95e2653 100644
--- a/src/xrpld/rpc/handlers/ledger/Ledger.h
+++ b/src/xrpld/rpc/handlers/ledger/Ledger.h
@@ -3,6 +3,7 @@
 #include <xrpld/app/main/Application.h>
 #include <xrpld/app/misc/TxQ.h>  // IWYU pragma: keep
 #include <xrpld/rpc/Context.h>
+#include <xrpld/rpc/MethodNames.h>
 #include <xrpld/rpc/Role.h>
 #include <xrpld/rpc/Status.h>
 #include <xrpld/rpc/detail/Handler.h>
@@ -12,12 +13,9 @@
 #include <xrpl/protocol/ApiVersion.h>
 
 #include <memory>
+#include <string_view>
 #include <vector>
 
-namespace json {
-class Object;
-}  // namespace json
-
 namespace xrpl::rpc {
 
 struct JsonContext;
@@ -40,7 +38,7 @@ public:
     writeResult(json::Value&);
 
     // NOLINTBEGIN(readability-identifier-naming)
-    static constexpr char name[] = "ledger";
+    static constexpr std::string_view name = method::kLedger;
 
     static constexpr unsigned minApiVer = rpc::kApiMinimumSupportedVersion;
 
diff --git a/src/xrpld/rpc/handlers/server_info/Version.h b/src/xrpld/rpc/handlers/server_info/Version.h
index 40ad4e5e71..98c9fa987c 100644
--- a/src/xrpld/rpc/handlers/server_info/Version.h
+++ b/src/xrpld/rpc/handlers/server_info/Version.h
@@ -2,6 +2,7 @@
 
 #include <xrpld/app/main/Application.h>  // IWYU pragma: keep
 #include <xrpld/rpc/Context.h>
+#include <xrpld/rpc/MethodNames.h>
 #include <xrpld/rpc/Role.h>
 #include <xrpld/rpc/Status.h>
 #include <xrpld/rpc/detail/Handler.h>
@@ -9,6 +10,8 @@
 #include <xrpl/json/json_value.h>
 #include <xrpl/protocol/ApiVersion.h>
 
+#include <string_view>
+
 namespace xrpl::rpc {
 
 class VersionHandler
@@ -32,7 +35,7 @@ public:
     }
 
     // NOLINTBEGIN(readability-identifier-naming)
-    static constexpr char const* name = "version";
+    static constexpr std::string_view name = method::kVersion;
 
     static constexpr unsigned minApiVer = rpc::kApiMinimumSupportedVersion;