more detailed tracing

logs for ref counts
2026-06-04 17:27:00 +00:00 · 2026-06-01 11:57:19 +01:00 · 2026-05-31 18:04:34 +01:00
349 changed files with 2157 additions and 3231 deletions
--- a/.github/actions/build-deps/action.yml
+++ b/.github/actions/build-deps/action.yml
@@ -37,12 +37,12 @@ runs:
      run: |
        echo 'Installing dependencies.'
        conan install \
-            --profile ci \
-            --build="${BUILD_OPTION}" \
-            --options:host='&:tests=True' \
-            --options:host='&:xrpld=True' \
-            --settings:all build_type="${BUILD_TYPE}" \
-            --conf:all tools.build:jobs=${BUILD_NPROC} \
-            --conf:all tools.build:verbosity="${LOG_VERBOSITY}" \
-            --conf:all tools.compilation:verbosity="${LOG_VERBOSITY}" \
-            .
+          --profile ci \
+          --build="${BUILD_OPTION}" \
+          --options:host='&:tests=True' \
+          --options:host='&:xrpld=True' \
+          --settings:all build_type="${BUILD_TYPE}" \
+          --conf:all tools.build:jobs=${BUILD_NPROC} \
+          --conf:all tools.build:verbosity="${LOG_VERBOSITY}" \
+          --conf:all tools.compilation:verbosity="${LOG_VERBOSITY}" \
+          .
--- a/.github/actions/generate-version/action.yml
+++ b/.github/actions/generate-version/action.yml
@@ -15,7 +15,7 @@ runs:
      shell: bash
      env:
        VERSION: ${{ github.ref_name }}
-      run: echo "VERSION=${VERSION}" >>"${GITHUB_ENV}"
+      run: echo "VERSION=${VERSION}" >> "${GITHUB_ENV}"

    # When a tag is not pushed, then the version (e.g. 1.2.3-b0) is extracted
    # from the BuildInfo.cpp file and the shortened commit hash appended to it.
@@ -28,17 +28,17 @@ runs:
        echo 'Extracting version from BuildInfo.cpp.'
        VERSION="$(cat src/libxrpl/protocol/BuildInfo.cpp | grep "versionString =" | awk -F '"' '{print $2}')"
        if [[ -z "${VERSION}" ]]; then
-            echo 'Unable to extract version from BuildInfo.cpp.'
-            exit 1
+          echo 'Unable to extract version from BuildInfo.cpp.'
+          exit 1
        fi

        echo 'Appending shortened commit hash to version.'
        SHA='${{ github.sha }}'
        VERSION="${VERSION}+${SHA:0:7}"

-        echo "VERSION=${VERSION}" >>"${GITHUB_ENV}"
+        echo "VERSION=${VERSION}" >> "${GITHUB_ENV}"

    - name: Output version
      id: version
      shell: bash
-      run: echo "version=${VERSION}" >>"${GITHUB_OUTPUT}"
+      run: echo "version=${VERSION}" >> "${GITHUB_OUTPUT}"
--- a/.github/scripts/format-inline-bash.py
+++ b/.github/scripts/format-inline-bash.py
@@ -1,403 +0,0 @@
-#!/usr/bin/env python3
-
-"""
-Format embedded shell snippets using the shfmt hook configured in
-.pre-commit-config.yaml.
-
-Two shapes are recognised:
-
-* YAML workflow/action files: literal block-scalar runs (`run: |`) and
-  single-line runs (`run: some command`). A single-line run is upgraded to
-  a `run: |` block scalar if shfmt's output spans multiple lines.
-
-* Markdown files: ``` ```bash ``` fenced code blocks.
-
-Any block that shfmt cannot parse is skipped with a warning on stderr, so
-the file is left untouched and surrounding blocks still get formatted.
-
-For each occurrence the body is dedented, written to a temp .sh file,
-formatted via `pre-commit run shfmt --files <temp>` (falling back to
-`prek`), then re-indented and written back in place.
-
-When invoked without arguments, every .yml/.yaml under .github/ plus every
-.md file in the repo is scanned. When invoked with file arguments (the
-pre-commit case), only those files are processed.
-"""
-
-from __future__ import annotations
-
-import re
-import shutil
-import subprocess
-import sys
-import tempfile
-from dataclasses import dataclass
-from pathlib import Path
-from typing import Union
-
-REPO = Path(__file__).resolve().parents[2]
-
-_HOOK_RUNNER = next((cmd for cmd in ("pre-commit", "prek") if shutil.which(cmd)), None)
-if _HOOK_RUNNER is None:
-    sys.exit("error: neither `pre-commit` nor `prek` found on PATH")
-
-RUN_BLOCK_RE = re.compile(r"^(?P<prefix>[ \t]*(?:- )?)run:[ \t]*\|[+-]?[ \t]*$")
-RUN_INLINE_RE = re.compile(
-    r"^(?P<prefix>[ \t]*(?:- )?)run:[ \t]+" r"(?P<value>(?!\|[+-]?[ \t]*$)\S.*?)[ \t]*$"
-)
-MD_BASH_OPEN_RE = re.compile(r"^(?P<indent>[ ]{0,3})`{3}bash[ \t]*$")
-MD_FENCE_CLOSE_RE = re.compile(r"^[ ]{0,3}`{3,}[ \t]*$")
-
-
-@dataclass(frozen=True)
-class BlockRun:
-    """A `run: |` block scalar; `body_start:body_end` slices into `lines`."""
-
-    body_start: int
-    body_end: int
-    body_indent: int
-
-
-@dataclass(frozen=True)
-class InlineRun:
-    """A single-line `run: value` at `line_idx`."""
-
-    line_idx: int
-    prefix: str
-    value: str
-
-
-@dataclass(frozen=True)
-class MdBashBlock:
-    """A markdown ``` ```bash ``` fenced code block.
-
-    `body_start:body_end` slices into the file's lines; `open_line_idx`
-    points at the opening fence line.
-    """
-
-    open_line_idx: int
-    body_start: int
-    body_end: int
-    body_indent: int
-
-
-RunItem = Union[BlockRun, InlineRun]
-
-
-def _scan_block_body(
-    lines: list[str], body_start: int, run_col: int
-) -> tuple[int | None, int]:
-    """Locate the body of a `run: |` block scalar starting at `body_start`.
-
-    Returns `(body_indent, scan_end)`. `scan_end` is the line index where the
-    outer scanner should resume. `body_indent` is `None` when no body is
-    present (the scalar is empty, or the next non-blank line has indent
-    `<= run_col`).
-    """
-    body_indent: int | None = None
-    scan_end = len(lines)
-    for idx in range(body_start, len(lines)):
-        line = lines[idx]
-        if line.strip() == "":
-            continue
-        indent = len(line) - len(line.lstrip(" "))
-        if body_indent is None:
-            if indent > run_col:
-                body_indent = indent
-            else:
-                scan_end = idx
-                break
-        elif indent < body_indent:
-            scan_end = idx
-            break
-    if body_indent is not None:
-        while scan_end > body_start and lines[scan_end - 1].strip() == "":
-            scan_end -= 1
-        if scan_end <= body_start:
-            body_indent = None
-    return body_indent, scan_end
-
-
-def find_run_blocks(lines: list[str]) -> list[RunItem]:
-    """Return run items in document order."""
-    items: list[RunItem] = []
-    line_idx = 0
-    while line_idx < len(lines):
-        line = lines[line_idx]
-        if block_match := RUN_BLOCK_RE.match(line):
-            run_col = len(block_match.group("prefix"))
-            body_start = line_idx + 1
-            body_indent, scan_end = _scan_block_body(lines, body_start, run_col)
-            if body_indent is not None:
-                items.append(
-                    BlockRun(
-                        body_start=body_start,
-                        body_end=scan_end,
-                        body_indent=body_indent,
-                    )
-                )
-            line_idx = scan_end
-            continue
-        if inline_match := RUN_INLINE_RE.match(line):
-            items.append(
-                InlineRun(
-                    line_idx=line_idx,
-                    prefix=inline_match.group("prefix"),
-                    value=inline_match.group("value"),
-                )
-            )
-        line_idx += 1
-    return items
-
-
-def find_md_bash_blocks(lines: list[str]) -> list[MdBashBlock]:
-    """Return ``` ```bash ``` fenced code blocks in document order."""
-    blocks: list[MdBashBlock] = []
-    line_idx = 0
-    while line_idx < len(lines):
-        open_match = MD_BASH_OPEN_RE.match(lines[line_idx])
-        if not open_match:
-            line_idx += 1
-            continue
-        body_start = line_idx + 1
-        close_idx = next(
-            (
-                j
-                for j in range(body_start, len(lines))
-                if MD_FENCE_CLOSE_RE.match(lines[j])
-            ),
-            None,
-        )
-        if close_idx is None:
-            line_idx = body_start
-            continue
-        body = lines[body_start:close_idx]
-        non_blank = [b for b in body if b.strip()]
-        body_indent = (
-            min(len(b) - len(b.lstrip(" ")) for b in non_blank)
-            if non_blank
-            else len(open_match.group("indent"))
-        )
-        blocks.append(
-            MdBashBlock(
-                open_line_idx=line_idx,
-                body_start=body_start,
-                body_end=close_idx,
-                body_indent=body_indent,
-            )
-        )
-        line_idx = close_idx + 1
-    return blocks
-
-
-def dedent(lines: list[str], n: int) -> list[str]:
-    pad = " " * n
-    return [
-        (
-            ""
-            if line.strip() == ""
-            else (line[n:] if line.startswith(pad) else line.lstrip(" "))
-        )
-        for line in lines
-    ]
-
-
-def reindent(lines: list[str], n: int) -> list[str]:
-    pad = " " * n
-    return [pad + line if line else "" for line in lines]
-
-
-_SHFMT_ERR_RE = re.compile(r"\.sh:\d+:\d+:\s")
-_GHA_EXPR_RE = re.compile(r"\$\{\{.*?\}\}", re.DOTALL)
-_GHA_PLACEHOLDER_RE = re.compile(r"__GHA_EXPR_(\d+)__")
-
-
-def _encode_gha_exprs(text: str) -> tuple[str, list[str]]:
-    """Replace `${{ ... }}` expressions with bash-safe placeholder identifiers."""
-    exprs: list[str] = []
-
-    def repl(match: re.Match[str]) -> str:
-        exprs.append(match.group(0))
-        return f"__GHA_EXPR_{len(exprs) - 1}__"
-
-    return _GHA_EXPR_RE.sub(repl, text), exprs
-
-
-def _decode_gha_exprs(text: str, exprs: list[str]) -> str:
-    """Restore `${{ ... }}` expressions from placeholder identifiers."""
-    return _GHA_PLACEHOLDER_RE.sub(lambda m: exprs[int(m.group(1))], text)
-
-
-def shfmt_via_hook(tmp_path: Path) -> tuple[bool, str]:
-    # `${{ ... }}` is not valid shell, so swap it for a placeholder identifier
-    # that shfmt can parse, then restore it after formatting.
-    encoded, exprs = _encode_gha_exprs(tmp_path.read_text())
-    if exprs:
-        tmp_path.write_text(encoded)
-    res = subprocess.run(
-        [_HOOK_RUNNER, "run", "shfmt", "--files", str(tmp_path)],
-        cwd=REPO,
-        capture_output=True,
-        text=True,
-    )
-    output = res.stdout + res.stderr
-    # shfmt emits parse errors as "<path>:<line>:<col>: <message>".
-    parse_err = bool(_SHFMT_ERR_RE.search(output))
-    # A non-zero exit that is neither a parse error nor pre-commit's "I had
-    # to modify files" signal means the hook itself failed to run (missing
-    # binary, install failure, bad config, ...). Surface that loudly rather
-    # than silently treating it as a no-op.
-    if (
-        res.returncode != 0
-        and not parse_err
-        and "files were modified by this hook" not in output
-    ):
-        sys.exit(
-            f"error: `{_HOOK_RUNNER} run shfmt` failed with exit {res.returncode}:\n{output}"
-        )
-    if exprs and not parse_err:
-        tmp_path.write_text(_decode_gha_exprs(tmp_path.read_text(), exprs))
-    return not parse_err, output
-
-
-def _skip(path: Path, where: int, kind: str, output: str) -> None:
-    print(
-        f"  shfmt could not parse {kind} at {path}:{where + 1} — skipped",
-        file=sys.stderr,
-    )
-    print(f"    {output.strip()}", file=sys.stderr)
-
-
-def process_yaml_file(path: Path, tmp_path: Path) -> int:
-    text = path.read_text()
-    had_nl = text.endswith("\n")
-    lines = text.split("\n")
-    if had_nl:
-        lines = lines[:-1]
-    items = find_run_blocks(lines)
-    if not items:
-        return 0
-    changed = 0
-    # Process in reverse so earlier indices remain valid as we splice.
-    for item in reversed(items):
-        if isinstance(item, BlockRun):
-            body = lines[item.body_start : item.body_end]
-            tmp_path.write_text("\n".join(dedent(body, item.body_indent)) + "\n")
-            ok, output = shfmt_via_hook(tmp_path)
-            if not ok:
-                _skip(path, item.body_start, "block", output)
-                continue
-            formatted = tmp_path.read_text().rstrip("\n")
-            new_body = reindent(formatted.split("\n"), item.body_indent)
-            if new_body != body:
-                lines[item.body_start : item.body_end] = new_body
-                changed += 1
-        else:
-            tmp_path.write_text(item.value + "\n")
-            ok, output = shfmt_via_hook(tmp_path)
-            if not ok:
-                _skip(path, item.line_idx, "inline run", output)
-                continue
-            formatted = tmp_path.read_text().rstrip("\n")
-            if formatted == item.value:
-                continue
-            formatted_lines = formatted.split("\n")
-            if len(formatted_lines) == 1:
-                lines[item.line_idx] = f"{item.prefix}run: {formatted}"
-            else:
-                body_indent = len(item.prefix) + 2
-                lines[item.line_idx : item.line_idx + 1] = [
-                    f"{item.prefix}run: |",
-                    *reindent(formatted_lines, body_indent),
-                ]
-            changed += 1
-    new_text = "\n".join(lines) + ("\n" if had_nl else "")
-    if new_text != text:
-        path.write_text(new_text)
-    return changed
-
-
-def process_md_file(path: Path, tmp_path: Path) -> int:
-    text = path.read_text()
-    had_nl = text.endswith("\n")
-    lines = text.split("\n")
-    if had_nl:
-        lines = lines[:-1]
-    blocks = find_md_bash_blocks(lines)
-    if not blocks:
-        return 0
-    changed = 0
-    for block in reversed(blocks):
-        body = lines[block.body_start : block.body_end]
-        tmp_path.write_text("\n".join(dedent(body, block.body_indent)) + "\n")
-        ok, output = shfmt_via_hook(tmp_path)
-        if not ok:
-            _skip(path, block.open_line_idx, "```bash block", output)
-            continue
-        formatted = tmp_path.read_text().rstrip("\n")
-        formatted_lines = formatted.split("\n") if formatted else []
-        new_body = reindent(formatted_lines, block.body_indent)
-        if new_body != body:
-            lines[block.body_start : block.body_end] = new_body
-            changed += 1
-    new_text = "\n".join(lines) + ("\n" if had_nl else "")
-    if new_text != text:
-        path.write_text(new_text)
-    return changed
-
-
-def process_file(path: Path, tmp_path: Path) -> int:
-    if path.suffix in (".yml", ".yaml"):
-        return process_yaml_file(path, tmp_path)
-    if path.suffix == ".md":
-        return process_md_file(path, tmp_path)
-    return 0
-
-
-def gather_files(argv: list[str]) -> list[Path]:
-    """Return YAML workflow/action files and markdown files that we should
-    process — either the paths in `argv` or, when `argv` is empty, every
-    such file in the repo (skipping `external/`)."""
-    if argv:
-        candidates: list[Path] = [
-            (REPO / a).resolve() if not Path(a).is_absolute() else Path(a) for a in argv
-        ]
-    else:
-        gh = REPO / ".github"
-        candidates = [
-            *gh.rglob("*.yml"),
-            *gh.rglob("*.yaml"),
-            *(
-                p
-                for p in REPO.rglob("*.md")
-                if "external" not in p.relative_to(REPO).parts
-            ),
-        ]
-    return sorted(
-        p
-        for p in candidates
-        if p.exists()
-        and (
-            (p.suffix in (".yml", ".yaml") and ".github" in p.parts)
-            or p.suffix == ".md"
-        )
-    )
-
-
-def main(argv: list[str]) -> int:
-    files = gather_files(argv)
-    if not files:
-        return 0
-    with tempfile.TemporaryDirectory(prefix="format-inline-bash-") as tmpdir:
-        tmp_path = Path(tmpdir) / "shfmt.sh"
-        total = 0
-        for f in files:
-            n = process_file(f, tmp_path)
-            if n:
-                print(f"{f.relative_to(REPO)}: reformatted {n} block(s)")
-                total += n
-        return 1 if total else 0
-
-
-if __name__ == "__main__":
-    sys.exit(main(sys.argv[1:]))
--- a/.github/workflows/build-nix-image.yml
+++ b/.github/workflows/build-nix-image.yml
@@ -100,8 +100,8 @@ jobs:

      - name: Create multi-arch manifests
        run: |
-          for tag in $(jq -cr '.tags[]' <<<"$DOCKER_METADATA_OUTPUT_JSON"); do
-              docker buildx imagetools create -t "$tag" "${tag}-amd64" "${tag}-arm64"
+          for tag in $(jq -cr '.tags[]' <<< "$DOCKER_METADATA_OUTPUT_JSON"); do
+            docker buildx imagetools create -t "$tag" "${tag}-amd64" "${tag}-arm64"
          done

      - name: Inspect image
--- a/.github/workflows/check-pr-description.yml
+++ b/.github/workflows/check-pr-description.yml
@@ -5,17 +5,8 @@ on:
    types:
      - checks_requested
  pull_request:
-    types:
-      - opened
-      - edited
-      - reopened
-      - synchronize
-      - ready_for_review
-    branches:
-      - develop
-      - "release-*"
-      - "release/*"
-      - "staging/*"
+    types: [opened, edited, reopened, synchronize, ready_for_review]
+    branches: [develop]

 jobs:
  check_description:
@@ -29,11 +20,11 @@ jobs:
        env:
          PR_BODY: ${{ github.event.pull_request.body }}
        if: ${{ github.event_name == 'pull_request' }}
-        run: printenv PR_BODY >pr_body.md
+        run: printenv PR_BODY > pr_body.md

      - name: Check PR description differs from template
        if: ${{ github.event_name == 'pull_request' }}
-        run: |
-          python .github/scripts/check-pr-description.py \
-              --template-file .github/pull_request_template.md \
-              --pr-body-file pr_body.md
+        run: >
+          python .github/scripts/check-pr-description.py
+          --template-file .github/pull_request_template.md
+          --pr-body-file pr_body.md
--- a/.github/workflows/check-pr-title.yml
+++ b/.github/workflows/check-pr-title.yml
@@ -5,19 +5,10 @@ on:
    types:
      - checks_requested
  pull_request:
-    types:
-      - opened
-      - edited
-      - reopened
-      - synchronize
-      - ready_for_review
-    branches:
-      - develop
-      - "release-*"
-      - "release/*"
-      - "staging/*"
+    types: [opened, edited, reopened, synchronize, ready_for_review]
+    branches: [develop]

 jobs:
  check_title:
    if: ${{ github.event.pull_request.draft != true }}
-    uses: XRPLF/actions/.github/workflows/check-pr-title.yml@cba1f0891650baf1a9c88624dc2d72573be2eb81
+    uses: XRPLF/actions/.github/workflows/check-pr-title.yml@291206777251b4d493641b5afbdf7c23009d2988
--- a/.github/workflows/conflicting-pr.yml
+++ b/.github/workflows/conflicting-pr.yml
@@ -17,7 +17,7 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Check if PRs are dirty
-        uses: eps1lon/actions-label-merge-conflict@0273be72a0bbd58fcd71d0d6c02c209b50d1e5e1 # v3.1.0
+        uses: eps1lon/actions-label-merge-conflict@1df065ebe6e3310545d4f4c4e862e43bdca146f0 # v3.0.3
        with:
          dirtyLabel: "PR: has conflicts"
          repoToken: "${{ secrets.GITHUB_TOKEN }}"
--- a/.github/workflows/on-pr.yml
+++ b/.github/workflows/on-pr.yml
@@ -98,7 +98,7 @@ jobs:
          READY: ${{ contains(github.event.pull_request.labels.*.name, 'Ready to merge') }}
          MERGE: ${{ github.event_name == 'merge_group' }}
        run: |
-          echo "go=${{ (env.DRAFT != 'true' && env.READY == 'true') || env.FILES == 'true' || env.MERGE == 'true' }}" >>"${GITHUB_OUTPUT}"
+          echo "go=${{ (env.DRAFT != 'true' && env.READY == 'true') || env.FILES == 'true' || env.MERGE == 'true' }}" >> "${GITHUB_OUTPUT}"
          cat "${GITHUB_OUTPUT}"
    outputs:
      go: ${{ steps.go.outputs.go == 'true' }}
@@ -168,9 +168,9 @@ jobs:
          PR_URL: ${{ github.event.pull_request.html_url }}
        run: |
          gh api --method POST -H "Accept: application/vnd.github+json" -H "X-GitHub-Api-Version: 2022-11-28" \
-              /repos/xrplf/clio/dispatches -f "event_type=check_libxrpl" \
-              -F "client_payload[ref]=${{ needs.upload-recipe.outputs.recipe_ref }}" \
-              -F "client_payload[pr_url]=${PR_URL}"
+          /repos/xrplf/clio/dispatches -f "event_type=check_libxrpl" \
+          -F "client_payload[ref]=${{ needs.upload-recipe.outputs.recipe_ref }}" \
+          -F "client_payload[pr_url]=${PR_URL}"

  passed:
    if: failure() || cancelled()
--- 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@cba1f0891650baf1a9c88624dc2d72573be2eb81
+    uses: XRPLF/actions/.github/workflows/pre-commit.yml@5e942d61bf32f7557a7c159cfac4712a687b3e3a
    with:
      runs_on: ubuntu-latest
      container: '{ "image": "ghcr.io/xrplf/ci/tools-rippled-pre-commit:sha-41ec7c1" }'
--- a/.github/workflows/reusable-build-docker-image.yml
+++ b/.github/workflows/reusable-build-docker-image.yml
@@ -53,7 +53,7 @@ jobs:
        env:
          PLATFORM: ${{ inputs.platform }}
        run: |
-          echo "arch=${PLATFORM##*/}" >>$GITHUB_OUTPUT
+          echo "arch=${PLATFORM##*/}" >> $GITHUB_OUTPUT

      - name: Set up Docker Buildx
        uses: docker/setup-buildx-action@d7f5e7f509e45cec5c76c4d5afdd7de93d0b3df5 # v4.1.0
--- a/.github/workflows/reusable-build-test-config.yml
+++ b/.github/workflows/reusable-build-test-config.yml
@@ -113,7 +113,7 @@ jobs:

      - name: Set ccache log file
        if: ${{ inputs.ccache_enabled && runner.debug == '1' }}
-        run: echo "CCACHE_LOGFILE=${{ runner.temp }}/ccache.log" >>"${GITHUB_ENV}"
+        run: echo "CCACHE_LOGFILE=${{ runner.temp }}/ccache.log" >> "${GITHUB_ENV}"

      - name: Print build environment
        uses: XRPLF/actions/print-build-env@59dec886e4afb05a1724443af08baccbc045b574
@@ -146,11 +146,11 @@ jobs:
          CMAKE_ARGS: ${{ inputs.cmake_args }}
        run: |
          cmake \
-              -G '${{ runner.os == 'Windows' && 'Visual Studio 17 2022' || 'Ninja' }}' \
-              -DCMAKE_TOOLCHAIN_FILE:FILEPATH=build/generators/conan_toolchain.cmake \
-              -DCMAKE_BUILD_TYPE="${BUILD_TYPE}" \
-              ${CMAKE_ARGS} \
-              ..
+            -G '${{ runner.os == 'Windows' && 'Visual Studio 17 2022' || 'Ninja' }}' \
+            -DCMAKE_TOOLCHAIN_FILE:FILEPATH=build/generators/conan_toolchain.cmake \
+            -DCMAKE_BUILD_TYPE="${BUILD_TYPE}" \
+            ${CMAKE_ARGS} \
+            ..

      - name: Check protocol autogen files are up-to-date
        working-directory: ${{ env.BUILD_DIR }}
@@ -172,10 +172,10 @@ jobs:
          cmake --build . --target code_gen
          DIFF=$(git -C .. status --porcelain -- include/xrpl/protocol_autogen src/tests/libxrpl/protocol_autogen)
          if [ -n "${DIFF}" ]; then
-              echo "::error::Generated protocol files are out of date"
-              git -C .. diff -- include/xrpl/protocol_autogen src/tests/libxrpl/protocol_autogen
-              echo "${MESSAGE}"
-              exit 1
+            echo "::error::Generated protocol files are out of date"
+            git -C .. diff -- include/xrpl/protocol_autogen src/tests/libxrpl/protocol_autogen
+            echo "${MESSAGE}"
+            exit 1
          fi

      - name: Build the binary
@@ -186,18 +186,18 @@ jobs:
          CMAKE_TARGET: ${{ inputs.cmake_target }}
        run: |
          cmake \
-              --build . \
-              --config "${BUILD_TYPE}" \
-              --parallel "${BUILD_NPROC}" \
-              --target "${CMAKE_TARGET}"
+            --build . \
+            --config "${BUILD_TYPE}" \
+            --parallel "${BUILD_NPROC}" \
+            --target "${CMAKE_TARGET}"

      - name: Show ccache statistics
        if: ${{ inputs.ccache_enabled }}
        run: |
          ccache --show-stats -vv
          if [ '${{ runner.debug }}' = '1' ]; then
-              cat "${CCACHE_LOGFILE}"
-              curl ${CCACHE_REMOTE_STORAGE%|*}/status || true
+            cat "${CCACHE_LOGFILE}"
+            curl ${CCACHE_REMOTE_STORAGE%|*}/status || true
          fi

      - name: Upload the binary (Linux)
@@ -214,7 +214,7 @@ jobs:
        working-directory: ${{ env.BUILD_DIR }}
        run: |
          set -o pipefail
-          ./xrpld --definitions | python3 -m json.tool >server_definitions.json
+          ./xrpld --definitions | python3 -m json.tool > server_definitions.json

      - name: Upload server definitions
        if: ${{ github.event.repository.visibility == 'public' && inputs.config_name == 'debian-bookworm-gcc-13-amd64-release' }}
@@ -231,10 +231,10 @@ jobs:
        run: |
          ldd ./xrpld
          if [ "$(ldd ./xrpld | grep -E '(libstdc\+\+|libgcc)' | wc -l)" -eq 0 ]; then
-              echo 'The binary is statically linked.'
+            echo 'The binary is statically linked.'
          else
-              echo 'The binary is dynamically linked.'
-              exit 1
+            echo 'The binary is dynamically linked.'
+            exit 1
          fi

      - name: Verify presence of instrumentation (Linux)
@@ -250,12 +250,12 @@ jobs:
        run: |
          ASAN_OPTS="include=${GITHUB_WORKSPACE}/sanitizers/suppressions/runtime-asan-options.txt:suppressions=${GITHUB_WORKSPACE}/sanitizers/suppressions/asan.supp"
          if [[ "${CONFIG_NAME}" == *gcc* ]]; then
-              ASAN_OPTS="${ASAN_OPTS}:alloc_dealloc_mismatch=0"
+            ASAN_OPTS="${ASAN_OPTS}:alloc_dealloc_mismatch=0"
          fi
-          echo "ASAN_OPTIONS=${ASAN_OPTS}" >>${GITHUB_ENV}
-          echo "TSAN_OPTIONS=include=${GITHUB_WORKSPACE}/sanitizers/suppressions/runtime-tsan-options.txt:suppressions=${GITHUB_WORKSPACE}/sanitizers/suppressions/tsan.supp" >>${GITHUB_ENV}
-          echo "UBSAN_OPTIONS=include=${GITHUB_WORKSPACE}/sanitizers/suppressions/runtime-ubsan-options.txt:suppressions=${GITHUB_WORKSPACE}/sanitizers/suppressions/ubsan.supp" >>${GITHUB_ENV}
-          echo "LSAN_OPTIONS=include=${GITHUB_WORKSPACE}/sanitizers/suppressions/runtime-lsan-options.txt:suppressions=${GITHUB_WORKSPACE}/sanitizers/suppressions/lsan.supp" >>${GITHUB_ENV}
+          echo "ASAN_OPTIONS=${ASAN_OPTS}" >> ${GITHUB_ENV}
+          echo "TSAN_OPTIONS=include=${GITHUB_WORKSPACE}/sanitizers/suppressions/runtime-tsan-options.txt:suppressions=${GITHUB_WORKSPACE}/sanitizers/suppressions/tsan.supp" >> ${GITHUB_ENV}
+          echo "UBSAN_OPTIONS=include=${GITHUB_WORKSPACE}/sanitizers/suppressions/runtime-ubsan-options.txt:suppressions=${GITHUB_WORKSPACE}/sanitizers/suppressions/ubsan.supp" >> ${GITHUB_ENV}
+          echo "LSAN_OPTIONS=include=${GITHUB_WORKSPACE}/sanitizers/suppressions/runtime-lsan-options.txt:suppressions=${GITHUB_WORKSPACE}/sanitizers/suppressions/lsan.supp" >> ${GITHUB_ENV}

      - name: Run the separate tests
        if: ${{ !inputs.build_only }}
@@ -266,9 +266,9 @@ jobs:
          PARALLELISM: ${{ runner.os == 'Windows' && '1' || steps.nproc.outputs.nproc }}
        run: |
          ctest \
-              --output-on-failure \
-              -C "${BUILD_TYPE}" \
-              -j "${PARALLELISM}"
+            --output-on-failure \
+            -C "${BUILD_TYPE}" \
+            -j "${PARALLELISM}"

      - name: Run the embedded tests
        if: ${{ !inputs.build_only }}
@@ -278,7 +278,7 @@ jobs:
        run: |
          set -o pipefail
          # Coverage builds are slower due to instrumentation; use fewer parallel jobs to avoid flakiness
-          [ "$COVERAGE_ENABLED" = "true" ] && BUILD_NPROC=$((BUILD_NPROC - 2))
+          [ "$COVERAGE_ENABLED" = "true" ] && BUILD_NPROC=$(( BUILD_NPROC - 2 ))
          ./xrpld --unittest --unittest-jobs "${BUILD_NPROC}" 2>&1 | tee unittest.log

      - name: Show test failure summary
@@ -287,19 +287,19 @@ jobs:
          WORKING_DIR: ${{ runner.os == 'Windows' && format('{0}\{1}', env.BUILD_DIR, inputs.build_type) || env.BUILD_DIR }}
        run: |
          if [ ! -d "${WORKING_DIR}" ]; then
-              echo "Working directory '${WORKING_DIR}' does not exist."
-              exit 0
+            echo "Working directory '${WORKING_DIR}' does not exist."
+            exit 0
          fi

          cd "${WORKING_DIR}"

          if [ ! -f unittest.log ]; then
-              echo "unittest.log not found; embedded tests may not have run."
-              exit 0
+            echo "unittest.log not found; embedded tests may not have run."
+            exit 0
          fi

          if ! grep -E "failed" unittest.log; then
-              echo "Log present but no failure lines found in unittest.log."
+            echo "Log present but no failure lines found in unittest.log."
          fi
      - name: Debug failure (Linux)
        if: ${{ failure() && runner.os == 'Linux' && !inputs.build_only }}
@@ -317,10 +317,10 @@ jobs:
          BUILD_TYPE: ${{ inputs.build_type }}
        run: |
          cmake \
-              --build . \
-              --config "${BUILD_TYPE}" \
-              --parallel "${BUILD_NPROC}" \
-              --target coverage
+            --build . \
+            --config "${BUILD_TYPE}" \
+            --parallel "${BUILD_NPROC}" \
+            --target coverage

      - name: Upload coverage report
        if: ${{ github.repository == 'XRPLF/rippled' && !inputs.build_only && env.COVERAGE_ENABLED == 'true' }}
--- a/.github/workflows/reusable-check-levelization.yml
+++ b/.github/workflows/reusable-check-levelization.yml
@@ -38,9 +38,9 @@ jobs:
        run: |
          DIFF=$(git status --porcelain)
          if [ -n "${DIFF}" ]; then
-              # Print the differences to give the contributor a hint about what to
-              # expect when running levelization on their own machine.
-              git diff
-              echo "${MESSAGE}"
-              exit 1
+            # Print the differences to give the contributor a hint about what to
+            # expect when running levelization on their own machine.
+            git diff
+            echo "${MESSAGE}"
+            exit 1
          fi
--- a/.github/workflows/reusable-check-rename.yml
+++ b/.github/workflows/reusable-check-rename.yml
@@ -48,9 +48,9 @@ jobs:
        run: |
          DIFF=$(git status --porcelain)
          if [ -n "${DIFF}" ]; then
-              # Print the differences to give the contributor a hint about what to
-              # expect when running the renaming scripts on their own machine.
-              git diff
-              echo "${MESSAGE}"
-              exit 1
+            # Print the differences to give the contributor a hint about what to
+            # expect when running the renaming scripts on their own machine.
+            git diff
+            echo "${MESSAGE}"
+            exit 1
          fi
--- a/.github/workflows/reusable-clang-tidy.yml
+++ b/.github/workflows/reusable-clang-tidy.yml
@@ -70,13 +70,13 @@ jobs:
        working-directory: ${{ env.BUILD_DIR }}
        run: |
          cmake \
-              -G 'Ninja' \
-              -DCMAKE_TOOLCHAIN_FILE:FILEPATH=build/generators/conan_toolchain.cmake \
-              -DCMAKE_BUILD_TYPE="${BUILD_TYPE}" \
-              -Dtests=ON \
-              -Dwerr=ON \
-              -Dxrpld=ON \
-              ..
+            -G 'Ninja' \
+            -DCMAKE_TOOLCHAIN_FILE:FILEPATH=build/generators/conan_toolchain.cmake \
+            -DCMAKE_BUILD_TYPE="${BUILD_TYPE}" \
+            -Dtests=ON \
+            -Dwerr=ON \
+            -Dxrpld=ON \
+            ..

      # clang-tidy needs headers generated from proto files
      - name: Build libxrpl.libpb
@@ -133,7 +133,7 @@ jobs:
      - name: Write issue header
        if: ${{ steps.run_clang_tidy.outcome != 'success' }}
        run: |
-          cat >"${ISSUE_FILE}" <<EOF
+          cat > "${ISSUE_FILE}" <<EOF
          ## Clang-tidy Check Failed

          ### Clang-tidy Output:
@@ -144,30 +144,30 @@ jobs:
        if: ${{ steps.run_clang_tidy.outcome != 'success' }}
        run: |
          if [ -f "${OUTPUT_FILE}" ]; then
-              # Extract lines containing 'error:', 'warning:', or 'note:'
-              grep -E '(error:|warning:|note:)' "${OUTPUT_FILE}" >filtered-output.txt || true
+            # Extract lines containing 'error:', 'warning:', or 'note:'
+            grep -E '(error:|warning:|note:)' "${OUTPUT_FILE}" > filtered-output.txt || true

-              # If filtered output is empty, use original (might be a different error format)
-              if [ ! -s filtered-output.txt ]; then
-                  cp "${OUTPUT_FILE}" filtered-output.txt
-              fi
+            # If filtered output is empty, use original (might be a different error format)
+            if [ ! -s filtered-output.txt ]; then
+              cp "${OUTPUT_FILE}" filtered-output.txt
+            fi

-              # Truncate if too large
-              head -c 60000 filtered-output.txt >>"${ISSUE_FILE}"
-              if [ "$(wc -c <filtered-output.txt)" -gt 60000 ]; then
-                  echo "" >>"${ISSUE_FILE}"
-                  echo "... (output truncated, see artifacts for full output)" >>"${ISSUE_FILE}"
-              fi
+            # Truncate if too large
+            head -c 60000 filtered-output.txt >> "${ISSUE_FILE}"
+            if [ "$(wc -c < filtered-output.txt)" -gt 60000 ]; then
+              echo "" >> "${ISSUE_FILE}"
+              echo "... (output truncated, see artifacts for full output)" >> "${ISSUE_FILE}"
+            fi

-              rm filtered-output.txt
+            rm filtered-output.txt
          else
-              echo "No output file found" >>"${ISSUE_FILE}"
+            echo "No output file found" >> "${ISSUE_FILE}"
          fi

      - name: Append issue footer
        if: ${{ steps.run_clang_tidy.outcome != 'success' }}
        run: |
-          cat >>"${ISSUE_FILE}" <<EOF
+          cat >> "${ISSUE_FILE}" <<EOF
          \`\`\`

          ---
@@ -176,7 +176,7 @@ jobs:

      - name: Create issue
        if: ${{ steps.run_clang_tidy.outcome != 'success' && inputs.create_issue_on_failure }}
-        uses: XRPLF/actions/create-issue@2b8bc36af85b88bca0dd7bfac2e2dc05f94ad712
+        uses: XRPLF/actions/create-issue@36d450d12d301e8410c1b7936e5de70c291cbe36
        with:
          title: "Clang-tidy check failed"
          body_file: ${{ env.ISSUE_FILE }}
--- a/.github/workflows/reusable-package.yml
+++ b/.github/workflows/reusable-package.yml
@@ -39,7 +39,7 @@ jobs:
        id: generate
        working-directory: .github/scripts/strategy-matrix
        run: |
-          ./generate.py --packaging --config=linux.json >>"${GITHUB_OUTPUT}"
+          ./generate.py --packaging --config=linux.json >> "${GITHUB_OUTPUT}"

  generate-version:
    runs-on: ubuntu-latest
--- a/.github/workflows/reusable-strategy-matrix.yml
+++ b/.github/workflows/reusable-strategy-matrix.yml
@@ -42,4 +42,4 @@ jobs:
        env:
          GENERATE_CONFIG: ${{ inputs.os != '' && format('--config={0}.json', inputs.os) || '' }}
          GENERATE_OPTION: ${{ inputs.strategy_matrix == 'all' && '--all' || '' }}
-        run: ./generate.py ${GENERATE_OPTION} ${GENERATE_CONFIG} >>"${GITHUB_OUTPUT}"
+        run: ./generate.py ${GENERATE_OPTION} ${GENERATE_CONFIG} >> "${GITHUB_OUTPUT}"
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -66,19 +66,6 @@ repos:
      - id: shfmt
        args: [--write, --indent=4, --case-indent=true]

-  - repo: local
-    hooks:
-      - id: format-inline-bash-workflows
-        name: "format `run:` blocks in workflows/actions"
-        entry: ./.github/scripts/format-inline-bash.py
-        language: python
-        files: ^\.github/(workflows|actions)/.*\.ya?ml$
-      - id: format-inline-bash-markdown
-        name: "format ```bash blocks in markdown"
-        entry: ./.github/scripts/format-inline-bash.py
-        language: python
-        files: \.md$
-
  - repo: https://github.com/streetsidesoftware/cspell-cli
    rev: 4643f154907327ee0a2c7038f0296e0dd77d9776 # frozen: v10.0.0
    hooks:
--- a/BUILD.md
+++ b/BUILD.md
@@ -151,8 +151,8 @@ git init
 git remote add origin git@github.com:XRPLF/conan-center-index.git
 git sparse-checkout init
 for recipe in "${recipes[@]}"; do
-    echo "Checking out recipe '${recipe}'..."
-    git sparse-checkout add recipes/${recipe}
+  echo "Checking out recipe '${recipe}'..."
+  git sparse-checkout add recipes/${recipe}
 done
 git fetch origin master
 git checkout master
@@ -180,7 +180,7 @@ the new recipe will be automatically pulled from the official Conan Center.

 If you see an error similar to the following after running `conan profile show`:

-```text
+```bash
 ERROR: Invalid setting '17' is not a valid 'settings.compiler.version' value.
 Possible values are ['5.0', '5.1', '6.0', '6.1', '7.0', '7.3', '8.0', '8.1',
 '9.0', '9.1', '10.0', '11.0', '12.0', '13', '13.0', '13.1', '14', '14.0', '15',
--- a/cfg/xrpld-example.cfg
+++ b/cfg/xrpld-example.cfg
@@ -953,21 +953,6 @@
 #
 #   Optional keys for NuDB and RocksDB:
 #
-#       cache_size          Size of cache for database records. Default is 16384.
-#                           Setting this value to 0 will use the default value.
-#
-#       cache_age           Length of time in minutes to keep database records
-#                           cached. Default is 5 minutes. Setting this value to
-#                           0 will use the default value.
-#
-#                           Note: if cache_size or cache_age is not specified,
-#                           default values will be used for the unspecified
-#                           parameter.
-#
-#                           Note: the cache will not be created if online_delete
-#                           is specified, because the rotating NodeStore does
-#                           not use this cache).
-#
 #       fast_load           Boolean. If set, load the last persisted ledger
 #                           from disk upon process start before syncing to
 #                           the network. This is likely to improve performance
--- a/cmake/scripts/codegen/templates/LedgerEntry.h.mako
+++ b/cmake/scripts/codegen/templates/LedgerEntry.h.mako
@@ -33,7 +33,7 @@ public:
     * @brief Construct a ${name} ledger entry wrapper from an existing SLE object.
     * @throws std::runtime_error if the ledger entry type doesn't match.
     */
-    explicit ${name}(SLE::const_pointer sle)
+    explicit ${name}(std::shared_ptr<SLE const> sle)
        : LedgerEntryBase(std::move(sle))
    {
        // Verify ledger entry type
@@ -168,7 +168,7 @@ ${field['typeData']['setter_type']} ${field['paramName']}${',' if i < len(requir
     * @param sle The existing ledger entry to copy from.
     * @throws std::runtime_error if the ledger entry type doesn't match.
     */
-    ${name}Builder(SLE::const_pointer sle)
+    ${name}Builder(std::shared_ptr<SLE const> sle)
    {
        if (sle->at(sfLedgerEntryType) != ${tag})
        {
--- a/cspell.config.yaml
+++ b/cspell.config.yaml
@@ -93,7 +93,6 @@ words:
  - daria
  - dcmake
  - dearmor
-  - dedented
  - deleteme
  - demultiplexer
  - deserializaton
--- a/docker/check-sanitizers.sh
+++ b/docker/check-sanitizers.sh
@@ -0,0 +1,48 @@
+#!/bin/bash
+
+# Sanity-check that the sanitizer runtimes shipped with g++/clang++ work
+# end-to-end against the system loader: compile each example with both
+# compilers, run it, and confirm the expected diagnostic is emitted.
+
+set -eo pipefail
+
+cpp_files_dir="${1:?usage: $0 <cpp_files_dir>}"
+
+case "$(uname -m)" in
+    x86_64) loader=/lib64/ld-linux-x86-64.so.2 ;;
+    aarch64) loader=/lib/ld-linux-aarch64.so.1 ;;
+    *)
+        echo "Unsupported arch: $(uname -m)" >&2
+        exit 1
+        ;;
+esac
+
+declare -A sanitize=(
+    [asan]="-fsanitize=address"
+    [tsan]="-fsanitize=thread"
+    [ubsan]="-fsanitize=undefined"
+)
+declare -A expect=(
+    [asan]="heap-use-after-free"
+    [tsan]="data race"
+    [ubsan]="signed integer overflow"
+)
+
+for compiler in g++ clang++; do
+    for name in asan tsan ubsan; do
+        bin="/tmp/${name}-${compiler}"
+        echo "=== Build ${name} with ${compiler} ==="
+        "$compiler" -std=c++20 -O1 -g ${sanitize[$name]} \
+            -Wl,--dynamic-linker=$loader \
+            "${cpp_files_dir}/${name}.cpp" -o "$bin"
+        echo "=== Run ${name}-${compiler} ==="
+        output=$("$bin" 2>&1) || true
+        echo "$output"
+        echo "$output" | grep -q "${expect[$name]}" ||
+            {
+                echo "expected '${expect[$name]}' from $bin"
+                exit 1
+            }
+        rm -f "$bin"
+    done
+done
--- a/docker/check-tools.sh
+++ b/docker/check-tools.sh
@@ -1,32 +0,0 @@
-#!/bin/bash
-# Verify that every tool expected in the Nix CI env is present and runnable.
-set -euo pipefail
-
-ccache --version
-clang --version
-clang++ --version
-clang-format --version
-cmake --version
-conan --version
-g++ --version
-gcc --version
-gcov --version
-gcovr --version
-git --version
-less --version
-make --version
-mold --version
-netstat --version
-ninja --version
-perl --version
-pkg-config --version
-pre-commit --version
-python3 --version
-run-clang-tidy --help
-vim --version
-
-# A simple test to verify that git can clone a repository over HTTPS
-# (i.e. the CA bundle is wired up). Clone to a temp dir and clean up.
-tmp_clone="$(mktemp -d)"
-git clone --depth 1 https://github.com/XRPLF/actions.git "${tmp_clone}/actions"
-rm -rf "${tmp_clone}"
--- a/docker/test_files/cpp_sources/asan.cpp
+++ b/docker/test_files/cpp_sources/asan.cpp
--- a/docker/test_files/cpp_sources/tsan.cpp
+++ b/docker/test_files/cpp_sources/tsan.cpp
--- a/docker/test_files/cpp_sources/ubsan.cpp
+++ b/docker/test_files/cpp_sources/ubsan.cpp
--- a/docker/install-sanitizer-libs.sh
+++ b/docker/install-sanitizer-libs.sh
@@ -1,89 +0,0 @@
-#!/bin/bash
-# Install sanitizer runtime libraries required to run binaries compiled with:
-#   -fsanitize=address   → libasan.so.8
-#   -fsanitize=thread    → libtsan.so.2
-#   -fsanitize=undefined → libubsan.so.1
-#
-# The exact SONAMEs required depend on the compiler toolchain used to build the
-# test binaries (see nix/ci-env.nix). If the toolchain is bumped and SONAMEs
-# change, update the list below (or detect them from the binaries).
-#
-# Supported base images:
-#   debian:bookworm
-#   ubuntu:20.04
-#   rhel:9
-#   nixos/nix        — tests are skipped; this script is not called
-
-set -euo pipefail
-
-if [ ! -f /etc/os-release ]; then
-    echo "ERROR: /etc/os-release not found; cannot detect OS" >&2
-    exit 1
-fi
-
-# shellcheck source=/dev/null
-. /etc/os-release
-
-echo "Detected OS: ${ID} ${VERSION_ID:-}"
-
-case "${ID}" in
-    debian)
-        apt-get update -y
-        apt-get install -y --no-install-recommends \
-            libasan8 \
-            libtsan2 \
-            libubsan1
-
-        apt-get clean
-        rm -rf /var/lib/apt/lists/*
-        ;;
-
-    ubuntu)
-        apt-get update -y
-        apt-get install -y --no-install-recommends \
-            gnupg \
-            software-properties-common
-        add-apt-repository -y ppa:ubuntu-toolchain-r/test
-        apt-get update -y
-        apt-get install -y --no-install-recommends \
-            libasan8 \
-            libtsan2 \
-            libubsan1
-
-        apt-get clean
-        rm -rf /var/lib/apt/lists/*
-        ;;
-
-    rhel | centos | rocky | almalinux)
-        dnf install -y \
-            libasan8 \
-            libtsan2 \
-            libubsan
-
-        dnf clean -y all
-        rm -rf /var/cache/dnf/*
-        ;;
-
-    *)
-        echo "ERROR: unsupported OS '${ID}'. Supported: debian, ubuntu, rhel-family" >&2
-        exit 1
-        ;;
-esac
-
-# Verify that every expected library is now resolvable by the dynamic linker.
-missing=0
-for lib in libasan.so.8 libtsan.so.2 libubsan.so.1; do
-    if ldconfig -p | grep -q "${lib}"; then
-        echo "OK: ${lib} found"
-    else
-        echo "ERROR: ${lib} not found after installation" >&2
-        missing=$((missing + 1))
-    fi
-done
-
-if [ "${missing}" -ne 0 ]; then
-    echo "ERROR: ${missing} library/libraries missing" >&2
-    exit 1
-fi
-
-echo "All sanitizer runtime libraries installed successfully."
--- a/docker/loader-path.sh
+++ b/docker/loader-path.sh
@@ -1,12 +0,0 @@
-#!/bin/bash
-
-case "$(uname -m)" in
-    x86_64) LOADER=/lib64/ld-linux-x86-64.so.2 ;;
-    aarch64) LOADER=/lib/ld-linux-aarch64.so.1 ;;
-    *)
-        echo "Unsupported arch: $(uname -m)" >&2
-        exit 1
-        ;;
-esac
-
-echo "${LOADER}"
--- a/docker/nix.Dockerfile
+++ b/docker/nix.Dockerfile
@@ -27,12 +27,10 @@ RUN mkdir /tmp/nix-store-closure && \
    cp -R $(nix-store -qR result/) /tmp/nix-store-closure

 # Final image
-FROM ${BASE_IMAGE} AS final
-
-ARG BASE_IMAGE
+FROM ${BASE_IMAGE}

 # bash is not located at /bin/bash in nixos/nix, so we need to create a symlink to it.
-RUN if echo "${BASE_IMAGE}" | grep -qiE 'nixos'; then \
+RUN if [ -d /nix ]; then \
        ln -s /root/.nix-profile/bin/bash /bin/bash; \
    fi

@@ -45,70 +43,53 @@ ENTRYPOINT ["/bin/bash"]
 COPY --from=builder /tmp/nix-store-closure /nix/store
 COPY --from=builder /tmp/build/result /nix/ci-env

-ENV PATH="/nix/ci-env/bin:${PATH}"
-
-# Point HTTPS clients (git, curl, conan, ...) at the CA bundle shipped in the
-# Nix CI environment, so TLS verification works without ca-certificates being
-# installed in the system.
-ENV SSL_CERT_FILE="/nix/ci-env/etc/ssl/certs/ca-bundle.crt"
-ENV GIT_SSL_CAINFO="/nix/ci-env/etc/ssl/certs/ca-bundle.crt"
+ENV PATH="/nix/ci-env/bin:$PATH"

 # Externally-built dynamically-linked ELF binaries hard-code the loader path
-# (e.g. /lib64/ld-linux-x86-64.so.2) in their PT_INTERP header. Install it
-# from the Nix store when the base image doesn't already provide one.
-COPY docker/loader-path.sh /tmp/loader-path.sh
-
+# (e.g. /lib64/ld-linux-x86-64.so.2) in their PT_INTERP header. Copy the
+# loader from the Nix store to that path when the base image doesn't already
+# provide one (i.e. on nixos/nix).
 RUN <<EOF
-target="$(/tmp/loader-path.sh)"
-
-if [ ! -e "${target}" ]; then
+case "$(uname -m)" in
+    x86_64)  target=/lib64/ld-linux-x86-64.so.2 ;;
+    aarch64) target=/lib/ld-linux-aarch64.so.1 ;;
+    *) echo "Unsupported arch: $(uname -m)" >&2; exit 1 ;;
+esac
+if [ ! -e "$target" ]; then
    # Use the loader from the same glibc that gcc links libc against, so
    # ld-linux and libc/libpthread share GLIBC_PRIVATE symbols at runtime.
-    src="$(dirname "$(gcc -print-file-name=libc.so.6)")/$(basename "${target}")"
-    [ -e "${src}" ] || { echo "ld-linux not found at ${src}" >&2; exit 1; }
-    mkdir -p "$(dirname "${target}")"
-    cp "${src}" "${target}"
+    src="$(dirname "$(gcc -print-file-name=libc.so.6)")/$(basename "$target")"
+    [ -e "$src" ] || { echo "ld-linux not found at $src" >&2; exit 1; }
+    mkdir -p "$(dirname "$target")"
+    cp "$src" "$target"
 fi
 EOF

-COPY docker/check-tools.sh /tmp/check-tools.sh
-RUN /tmp/check-tools.sh
-
-# Sanity-check that the g++/clang++ are able to build binaries, including sanitizer-instrumented ones.
-COPY docker/test_files/cpp_sources/ /tmp/cpp_sources/
-COPY docker/test_files/compile-cpp-sources.sh /tmp/compile-cpp-sources.sh
-RUN /tmp/compile-cpp-sources.sh /tmp/cpp_sources /tmp/bins
-
-# Tester: start from a clean BASE_IMAGE, install sanitizer runtime libraries,
-# and run the compiled test binaries to verify they execute correctly.
-FROM ${BASE_IMAGE} AS tester
-
-ARG BASE_IMAGE
-
-# bash is not located at /bin/bash in nixos/nix, so we need to create a symlink to it.
-RUN if echo "${BASE_IMAGE}" | grep -qiE 'nixos'; then \
-        ln -s /root/.nix-profile/bin/bash /bin/bash; \
-    fi
-
-SHELL ["/bin/bash", "-e", "-o", "pipefail", "-c"]
-
-# Sanity-check that the built binaries run correctly in the vanilla base image, with the necessary sanitizer runtime libraries installed.
-COPY docker/install-sanitizer-libs.sh /tmp/install-sanitizer-libs.sh
-COPY docker/test_files/run-test-binaries.sh /tmp/run-test-binaries.sh
-COPY --from=final /tmp/bins /tmp/bins
-
 RUN <<EOF
-if echo "${BASE_IMAGE}" | grep -qiE 'nixos'; then
-    echo "Skipping runnning binaries on NixOS."
-else
-    /tmp/install-sanitizer-libs.sh
-    /tmp/run-test-binaries.sh /tmp/bins
-fi
-touch /tmp/tests-passed
+ccache --version
+clang --version
+clang++ --version
+clang-format --version
+cmake --version
+conan --version
+g++ --version
+gcc --version
+gcovr --version
+git --version
+make --version
+mold --version
+ninja --version
+perl --version
+pkg-config --version
+pre-commit --version
+python3 --version
+run-clang-tidy --help
+vim --version
 EOF

-# Output: the final image, gated on a successful test run in the tester stage.
-# Copying the sentinel from tester creates a hard build dependency: if the test
-# run above failed, this stage — and the overall build — fails too.
-FROM final
-COPY --from=tester /tmp/tests-passed /tmp/tests-passed
+# Sanity-check that the sanitizer runtimes shipped with g++/clang++ work
+# end-to-end against the system loader.
+COPY docker/cpp_files/ /tmp/cpp_files/
+COPY docker/check-sanitizers.sh /tmp/check-sanitizers.sh
+
+RUN grep -qi ubuntu /etc/os-release 2>/dev/null && /tmp/check-sanitizers.sh /tmp/cpp_files || true
--- a/docker/test_files/compile-cpp-sources.sh
+++ b/docker/test_files/compile-cpp-sources.sh
@@ -1,57 +0,0 @@
-#!/bin/bash
-# Compile all C++ test binaries during the Docker image build.
-# Each binary has the target system's ELF PT_INTERP (dynamic-linker path)
-# baked in so it can run on the (potentially minimal) final BASE_IMAGE.
-
-set -eo pipefail
-
-src_dir="${1:?usage: $0 <src_dir> <dst_dir>}"
-dst_dir="${2:?usage: $0 <src_dir> <dst_dir>}"
-
-loader="$(/tmp/loader-path.sh)"
-
-mkdir -p "${dst_dir}"
-
-function compile() {
-    local compiler="${1}"
-    local name="${2}"
-    local san_flag="${3:-}"
-
-    local src="${src_dir}/${name}.cpp"
-    local binary="${dst_dir}/${name}-${compiler}"
-
-    echo "=== Compiling ${name} with ${compiler} ==="
-    # Always statically link libstdc++ so the test binary does not depend on
-    # the host's libstdc++.so.6 version.
-    local compile_cmd="${compiler} -std=c++23 -O1 -g \
-        -pthread \
-        -static-libstdc++ \
-        ${san_flag} \
-        ${src} -o ${binary}"
-    echo "Compile cmd: ${compile_cmd}"
-    eval "${compile_cmd}"
-
-    echo "=== Patching ${binary} to use ${loader} as PT_INTERP ==="
-    local patch_cmd="patchelf --set-interpreter ${loader} --remove-rpath ${binary}"
-    echo "Patch cmd: ${patch_cmd}"
-    eval "${patch_cmd}"
-}
-
-declare -A sanitize=(
-    [regular]=""
-
-    [asan]="-fsanitize=address"
-    [tsan]="-fsanitize=thread"
-    [ubsan]="-fsanitize=undefined -fno-sanitize-recover=all"
-)
-
-for name in regular asan tsan ubsan; do
-    san_flag="${sanitize[${name}]}"
-    for compiler in g++ clang++; do
-        compile "${compiler}" "${name}" "${san_flag}"
-    done
-done
-
-echo "=== All binaries compiled ==="
-
-ls -la "${dst_dir}"
--- a/docker/test_files/cpp_sources/regular.cpp
+++ b/docker/test_files/cpp_sources/regular.cpp
@@ -1,28 +0,0 @@
-#include <iostream>
-#include <mutex>
-#include <thread>
-#include <vector>
-
-static std::mutex gMutex;
-
-void
-worker(int id)
-{
-    std::lock_guard<std::mutex> lock(gMutex);
-    std::cout << "Hello from thread " << id << "\n";
-}
-
-int
-main()
-{
-    constexpr int kNumThreads = 10;
-    std::vector<std::thread> threads;
-    threads.reserve(kNumThreads);
-    for (int i = 0; i < kNumThreads; ++i)
-        threads.emplace_back(worker, i);
-    for (auto& t : threads)
-        t.join();
-
-    std::cout << "Hello from main thread\n";
-    return 0;
-}
--- a/docker/test_files/run-test-binaries.sh
+++ b/docker/test_files/run-test-binaries.sh
@@ -1,86 +0,0 @@
-#!/bin/bash
-# Run pre-compiled sanitizer binaries and confirm each emits its expected diagnostic.
-# Binaries must already exist in <bins_dir> with the layout:
-# <name>-g++ and <name>-clang++ for name in {regular,asan,tsan,ubsan}
-
-set -eo pipefail
-
-bins_dir="${1:?usage: $0 <bins_dir>}"
-
-failed_binaries=()
-
-# Run a binary and verify its exit code and output.
-# Usage: run <binary> <expected_output> <expected_rc>
-function run() {
-    local binary="${1}"
-    local expected_output="${2}"
-    local expected_rc="${3}"
-
-    local out_file
-    out_file="$(mktemp)"
-
-    echo "=== Run ${binary} ==="
-    set +e
-    "${binary}" >"${out_file}" 2>&1
-    local rc=$?
-    set -e
-
-    cat "${out_file}"
-
-    local failed=0
-    if [ "${expected_rc}" = "nonzero" ]; then
-        if [ "${rc}" -eq 0 ]; then
-            echo "ERROR: expected non-zero exit code from ${binary}, got ${rc}" >&2
-            failed=1
-        fi
-    elif [ "${rc}" -ne "${expected_rc}" ]; then
-        echo "ERROR: expected exit code ${expected_rc} from ${binary}, got ${rc}" >&2
-        failed=1
-    fi
-
-    if ! grep -q "${expected_output}" "${out_file}"; then
-        echo "ERROR: expected '${expected_output}' from ${binary}" >&2
-        failed=1
-    fi
-
-    if [ "${failed}" -eq 0 ]; then
-        echo "OK: '${expected_output}' detected"
-    else
-        failed_binaries+=("${binary}")
-    fi
-}
-
-declare -A expect=(
-    [regular]="Hello from main thread"
-
-    [asan]="heap-use-after-free"
-    [tsan]="data race"
-    [ubsan]="signed integer overflow"
-)
-
-for compiler in g++ clang++; do
-    for name in regular asan tsan ubsan; do
-        binary="${bins_dir}/${name}-${compiler}"
-
-        if [ "${name}" = "tsan" ] && [ "${compiler}" = "g++" ] &&
-            grep -qi 'debian' /etc/os-release 2>/dev/null &&
-            [ "$(uname -m)" = "aarch64" ]; then
-            echo "=== Skipping ${binary} (tsan-g++ unsupported on Debian ARM64) ==="
-            echo "    NOTE: to enable it, add --security-opt seccomp=unconfined to your docker run command"
-            continue
-        fi
-
-        if [ "${name}" = "regular" ]; then
-            expected_rc=0
-        else
-            expected_rc=nonzero
-        fi
-        run "${binary}" "${expect[$name]}" "${expected_rc}"
-    done
-done
-
-if [ "${#failed_binaries[@]}" -gt 0 ]; then
-    echo "ERROR: the following binaries failed:" >&2
-    printf '  %s\n' "${failed_binaries[@]}" >&2
-    exit 1
-fi
--- a/flake.lock
+++ b/flake.lock
@@ -2,11 +2,11 @@
  "nodes": {
    "nixpkgs": {
      "locked": {
-        "lastModified": 1780243769,
-        "narHash": "sha256-x5UQuRsH3MqI0U9afaXSNqzTPSeZlRLvFAav2Ux1pNw=",
+        "lastModified": 1777954456,
+        "narHash": "sha256-hGdgeU2Nk87RAuZyYjyDjFL6LK7dAZN5RE9+hrDTkDU=",
        "owner": "NixOS",
        "repo": "nixpkgs",
-        "rev": "331800de5053fcebacf6813adb5db9c9dca22a0c",
+        "rev": "549bd84d6279f9852cae6225e372cc67fb91a4c1",
        "type": "github"
      },
      "original": {
--- a/include/xrpl/basics/IntrusiveRefCounts.h
+++ b/include/xrpl/basics/IntrusiveRefCounts.h
@@ -7,6 +7,24 @@

 namespace xrpl {

+namespace detail {
+// All-time peak strong/weak ref counts ever observed across all
+// IntrusiveRefCounts instances. Read from doSweep periodically.
+inline std::atomic<std::uint32_t> kPeakStrongObserved{0};
+inline std::atomic<std::uint32_t> kPeakWeakObserved{0};
+
+inline void
+updateRefCountPeak(std::atomic<std::uint32_t>& peak, std::uint32_t v) noexcept
+{
+    auto cur = peak.load(std::memory_order_relaxed);
+    while (v > cur && !peak.compare_exchange_weak(
+                          cur, v, std::memory_order_relaxed))
+    {
+        // retry; cur is updated by compare_exchange_weak on failure
+    }
+}
+}  // namespace detail
+
 /** Action to perform when releasing a strong pointer.

    noop: Do nothing. For example, a `noop` action will occur when a count is
@@ -226,13 +244,18 @@ private:
 inline void
 IntrusiveRefCounts::addStrongRef() const noexcept
 {
-    refCounts_.fetch_add(kStrongDelta, std::memory_order_acq_rel);
+    auto const prev = refCounts_.fetch_add(kStrongDelta, std::memory_order_acq_rel);
+    auto const newStrong = static_cast<std::uint32_t>((prev & kStrongMask) + 1);
+    detail::updateRefCountPeak(detail::kPeakStrongObserved, newStrong);
 }

 inline void
 IntrusiveRefCounts::addWeakRef() const noexcept
 {
-    refCounts_.fetch_add(kWeakDelta, std::memory_order_acq_rel);
+    auto const prev = refCounts_.fetch_add(kWeakDelta, std::memory_order_acq_rel);
+    auto const newWeak =
+        static_cast<std::uint32_t>(((prev & kWeakMask) >> kStrongCountNumBits) + 1);
+    detail::updateRefCountPeak(detail::kPeakWeakObserved, newWeak);
 }

 inline ReleaseStrongRefAction
@@ -331,6 +354,11 @@ IntrusiveRefCounts::addWeakReleaseStrongRef() const
                (!(prevIntVal & kPartialDestroyStartedMask)),
                "xrpl::IntrusiveRefCounts::addWeakReleaseStrongRef : not "
                "started partial destroy");
+            // This op converts one strong into one weak: capture the new
+            // weak count for the leak-proof peak.
+            auto const newWeak = static_cast<std::uint32_t>(
+                ((prevIntVal & kWeakMask) >> kStrongCountNumBits) + 1);
+            detail::updateRefCountPeak(detail::kPeakWeakObserved, newWeak);
            return action;
        }
    }
@@ -377,6 +405,10 @@ IntrusiveRefCounts::checkoutStrongRefFromWeak() const noexcept

        desiredValue = curValue + kStrongDelta;
    }
+    // Successful CAS promoted a weak ref to strong. Capture the new strong
+    // count for the leak-proof peak.
+    auto const newStrong = static_cast<std::uint32_t>(desiredValue & kStrongMask);
+    detail::updateRefCountPeak(detail::kPeakStrongObserved, newStrong);
    return true;
 }

@@ -413,6 +445,8 @@ inline IntrusiveRefCounts::RefCountPair::RefCountPair(IntrusiveRefCounts::FieldT
    , partialDestroyStartedBit{v & kPartialDestroyStartedMask}
    , partialDestroyFinishedBit{v & kPartialDestroyFinishedMask}
 {
+    detail::updateRefCountPeak(detail::kPeakStrongObserved, strong);
+    detail::updateRefCountPeak(detail::kPeakWeakObserved, weak);
    XRPL_ASSERT(
        (strong < kCheckStrongMaxValue && weak < kCheckWeakMaxValue),
        "xrpl::IntrusiveRefCounts::RefCountPair(FieldType) : inputs inside "
--- a/include/xrpl/basics/Number.h
+++ b/include/xrpl/basics/Number.h
@@ -2,14 +2,12 @@

 #include <xrpl/beast/utility/instrumentation.h>

-#include <array>
 #include <cstdint>
 #include <functional>
 #include <limits>
 #include <optional>
 #include <ostream>
 #include <set>
-#include <stdexcept>
 #include <string>
 #include <unordered_map>

@@ -42,47 +40,6 @@ isPowerOfTen(T value)
    return logTen(value).has_value();
 }

-namespace detail {
-
-/** Builds a table of the powers of 10
- *
- * This function is marked consteval, so it can only be run in
- * a constexpr context. This assures that it is and can only be run at
- * compile time. Doing it at runtime would be pretty wasteful and
- * inefficient.
- */
-constexpr std::size_t kInt64Digits = 20;
-consteval std::array<std::uint64_t, kInt64Digits>
-buildPowersOfTen()
-{
-    std::array<std::uint64_t, kInt64Digits> result{};
-
-    std::uint64_t power = 1;
-    std::size_t exponent = 0;
-    // end the loop early so it doesn't overflow;
-    for (; exponent < result.size() - 1; ++exponent, power *= 10)
-    {
-        result[exponent] = power;
-        if (power > std::numeric_limits<std::uint64_t>::max() / 10)
-            throw std::logic_error("Power of 10 table is too big");
-    }
-    result[exponent] = power;
-    if (power < std::numeric_limits<std::uint64_t>::max() / 10)
-        throw std::logic_error("Power of 10 table is not big enough for the uint64_t type");
-
-    return result;
-}
-
-}  // namespace detail
-
-constexpr std::array<std::uint64_t, detail::kInt64Digits> kPowerOfTen = detail::buildPowersOfTen();
-
-static_assert(kPowerOfTen[0] == 1);
-static_assert(kPowerOfTen[1] == 10);
-static_assert(kPowerOfTen[10] == 10'000'000'000);
-static_assert(
-    isPowerOfTen(kPowerOfTen.back()) && *logTen(kPowerOfTen.back()) == detail::kInt64Digits - 1);
-
 /** MantissaRange defines a range for the mantissa of a normalized Number.
 *
 * The mantissa is in the range [min, max], where
@@ -119,7 +76,6 @@ static_assert(
 struct MantissaRange final
 {
    using rep = std::uint64_t;
-
    enum class MantissaScale {
        Small,
        // LargeLegacy can be removed when fixCleanup3_2_0 is retired
@@ -133,15 +89,19 @@ struct MantissaRange final
        Enabled = true,
    };

-    explicit constexpr MantissaRange(MantissaScale sc) : scale(sc)
+    explicit constexpr MantissaRange(MantissaScale scale)
+        : min(getMin(scale))
+        , cuspRoundingFixEnabled(isCuspFixEnabled(scale))
+        , log(logTen(min).value_or(-1))
+        , scale(scale)
    {
    }

-    MantissaScale const scale;
-    int const log{getExponent(scale)};
-    rep const min{getMin(scale, log)};
-    rep const max{(min * 10) - 1};
-    CuspRoundingFix const cuspRoundingFixEnabled{isCuspFixEnabled(scale)};
+    rep min;
+    rep max{(min * 10) - 1};
+    CuspRoundingFix cuspRoundingFixEnabled;
+    int log;
+    MantissaScale scale;

    static MantissaRange const&
    getMantissaRange(MantissaScale scale);
@@ -150,35 +110,23 @@ struct MantissaRange final
    getAllScales();

 private:
-    static constexpr int
-    getExponent(MantissaScale scale)
+    static constexpr rep
+    getMin(MantissaScale scale)
    {
        switch (scale)
        {
            case MantissaScale::Small:
-                return 15;
+                return 1'000'000'000'000'000ULL;
            case MantissaScale::LargeLegacy:
            case MantissaScale::Large:
-                return 18;
-            // LCOV_EXCL_START
+                return 1'000'000'000'000'000'000ULL;
            default:
                // If called in a constexpr context, this throw assures that the build fails if an
                // invalid scale is used.
-                throw std::runtime_error("Unknown mantissa scale");
-                // LCOV_EXCL_STOP
+                throw std::runtime_error("Unknown mantissa scale");  // LCOV_EXCL_LINE
        }
    }

-    // Keep this function for future use with different ways to compute
-    // the ranges.
-    static constexpr rep
-    getMin(MantissaScale scale, int exponent)
-    {
-        if (exponent < 0 || exponent >= kPowerOfTen.size())
-            throw std::runtime_error("Invalid exponent");  // LCOV_EXCL_LINE
-        return kPowerOfTen[exponent];
-    }
-
    static constexpr CuspRoundingFix
    isCuspFixEnabled(MantissaScale scale)
    {
@@ -408,38 +356,33 @@ public:
    }

    friend constexpr bool
-    operator<(Number const& l, Number const& r) noexcept
+    operator<(Number const& x, Number const& y) noexcept
    {
-        bool const lneg = l.negative_;
-        bool const rneg = r.negative_;
-
        // If the two amounts have different signs (zero is treated as positive)
        // then the comparison is true iff the left is negative.
+        bool const lneg = x.negative_;
+        bool const rneg = y.negative_;
+
        if (lneg != rneg)
            return lneg;

-        // Both have same sign and the left is zero: both must be non-negative.
-        // If the right is greater than 0, then it is larger, so the comparison is true.
-        if (l.mantissa_ == 0)
-            return r.mantissa_ > 0;
+        // Both have same sign and the left is zero: the right must be
+        // greater than 0.
+        if (x.mantissa_ == 0)
+            return y.mantissa_ > 0;

-        // Both have same sign, the right is zero and the left is non-zero, so the left must be
-        // positive, and thus is larger, so the comparison is false.
-        if (r.mantissa_ == 0)
+        // Both have same sign, the right is zero and the left is non-zero.
+        if (y.mantissa_ == 0)
            return false;

        // Both have the same sign, compare by exponents:
-        if (l.exponent_ > r.exponent_)
+        if (x.exponent_ > y.exponent_)
            return lneg;
-        if (l.exponent_ < r.exponent_)
+        if (x.exponent_ < y.exponent_)
            return !lneg;

-        // If equal signs and exponents, compare mantissas.
-        if (lneg)
-            // If negative, the operator is reversed.
-            return l.mantissa_ > r.mantissa_;
-
-        return l.mantissa_ < r.mantissa_;
+        // If equal exponents, compare mantissas
+        return x.mantissa_ < y.mantissa_;
    }

    /** Return the sign of the amount */
@@ -534,7 +477,8 @@ public:
    template <
        auto MinMantissa,
        auto MaxMantissa,
-        Integral64 T = std::decay_t<decltype(MinMantissa)>>
+        Integral64 T = std::decay_t<decltype(MinMantissa)>,
+        Integral64 TMax = std::decay_t<decltype(MaxMantissa)>>
    [[nodiscard]]
    std::pair<T, int>
    normalizeToRange() const;
@@ -575,8 +519,7 @@ private:
        int& exponent,
        MantissaRange::rep const& minMantissa,
        MantissaRange::rep const& maxMantissa,
-        MantissaRange::CuspRoundingFix cuspRoundingFixEnabled,
-        bool dropped);
+        MantissaRange::CuspRoundingFix cuspRoundingFixEnabled);

    [[nodiscard]] bool
    isnormal() const noexcept;
@@ -782,18 +725,16 @@ Number::isnormal() const noexcept
         kMinExponent <= exponent_ && exponent_ <= kMaxExponent);
 }

-template <auto MinMantissa, auto MaxMantissa, Integral64 T>
+template <auto MinMantissa, auto MaxMantissa, Integral64 T, Integral64 TMax>
 std::pair<T, int>
 Number::normalizeToRange() const
 {
    static_assert(std::is_same_v<T, std::uint64_t> || std::is_same_v<T, std::int64_t>);
-    static_assert(std::is_same_v<T, std::decay_t<decltype(MinMantissa)>>);
-    static_assert(std::is_same_v<T, std::decay_t<decltype(MaxMantissa)>>);
+    static_assert(std::is_same_v<T, TMax>);
    auto constexpr kMIN = static_cast<T>(MinMantissa);
    auto constexpr kMAX = static_cast<T>(MaxMantissa);
    static_assert(kMIN > 0);
    static_assert(kMIN % 10 == 0);
-    static_assert(isPowerOfTen(kMIN));
    static_assert(kMAX % 10 == 9);
    static_assert((kMAX + 1) / 10 == kMIN);

--- a/include/xrpl/basics/TaggedCache.h
+++ b/include/xrpl/basics/TaggedCache.h
@@ -157,7 +157,7 @@ public:
    /** Fetch an item from the cache.
        If the digest was not found, Handler
        will be called with this signature:
-            SLE::const_pointer(void)
+            std::shared_ptr<SLE const>(void)
    */
    template <class Handler>
    SharedPointerType
--- a/include/xrpl/ledger/ApplyView.h
+++ b/include/xrpl/ledger/ApplyView.h
@@ -123,7 +123,7 @@ private:
        bool preserveOrder,
        Keylet const& directory,
        uint256 const& key,
-        std::function<void(SLE::ref)> const& describe);
+        std::function<void(std::shared_ptr<SLE> const&)> const& describe);

 public:
    ApplyView() = default;
@@ -153,7 +153,7 @@ public:

        @return `nullptr` if the key is not present
    */
-    virtual SLE::pointer
+    virtual std::shared_ptr<SLE>
    peek(Keylet const& k) = 0;

    /** Remove a peeked SLE.
@@ -168,7 +168,7 @@ public:
            The key is no longer associated with the SLE.
    */
    virtual void
-    erase(SLE::ref sle) = 0;
+    erase(std::shared_ptr<SLE> const& sle) = 0;

    /** Insert a new state SLE

@@ -189,7 +189,7 @@ public:
        @note The key is taken from the SLE
    */
    virtual void
-    insert(SLE::ref sle) = 0;
+    insert(std::shared_ptr<SLE> const& sle) = 0;

    /** Indicate changes to a peeked SLE

@@ -208,7 +208,7 @@ public:
    */
    /** @{ */
    virtual void
-    update(SLE::ref sle) = 0;
+    update(std::shared_ptr<SLE> const& sle) = 0;

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

@@ -301,7 +301,7 @@ public:
    dirAppend(
        Keylet const& directory,
        Keylet const& key,
-        std::function<void(SLE::ref)> const& describe)
+        std::function<void(std::shared_ptr<SLE> const&)> const& describe)
    {
        if (key.type != ltOFFER)
        {
@@ -340,7 +340,7 @@ public:
    dirInsert(
        Keylet const& directory,
        uint256 const& key,
-        std::function<void(SLE::ref)> const& describe)
+        std::function<void(std::shared_ptr<SLE> const&)> const& describe)
    {
        return dirAdd(false, directory, key, describe);
    }
@@ -349,7 +349,7 @@ public:
    dirInsert(
        Keylet const& directory,
        Keylet const& key,
-        std::function<void(SLE::ref)> const& describe)
+        std::function<void(std::shared_ptr<SLE> const&)> const& describe)
    {
        return dirAdd(false, directory, key.key, describe);
    }
@@ -411,7 +411,7 @@ createRoot(
    ApplyView& view,
    Keylet const& directory,
    uint256 const& key,
-    std::function<void(SLE::ref)> const& describe);
+    std::function<void(std::shared_ptr<SLE> const&)> const& describe);

 auto
 findPreviousPage(ApplyView& view, Keylet const& directory, SLE::ref start);
@@ -434,7 +434,7 @@ insertPage(
    SLE::ref next,
    uint256 const& key,
    Keylet const& directory,
-    std::function<void(SLE::ref)> const& describe);
+    std::function<void(std::shared_ptr<SLE> const&)> const& describe);

 }  // namespace directory
 }  // namespace xrpl
--- a/include/xrpl/ledger/ApplyViewImpl.h
+++ b/include/xrpl/ledger/ApplyViewImpl.h
@@ -67,8 +67,8 @@ public:
        std::function<void(
            uint256 const& key,
            bool isDelete,
-            SLE::const_ref before,
-            SLE::const_ref after)> const& func);
+            std::shared_ptr<SLE const> const& before,
+            std::shared_ptr<SLE const> const& after)> const& func);

 private:
    std::optional<STAmount> deliver_;
--- a/include/xrpl/ledger/BookDirs.h
+++ b/include/xrpl/ledger/BookDirs.h
@@ -11,13 +11,13 @@ private:
    uint256 const root_;
    uint256 const nextQuality_;
    uint256 const key_;
-    SLE::const_pointer sle_ = nullptr;
+    std::shared_ptr<SLE const> sle_ = nullptr;
    unsigned int entry_ = 0;
    uint256 index_;

 public:
    class const_iterator;  // NOLINT(readability-identifier-naming)
-    using value_type = SLE::const_pointer;
+    using value_type = std::shared_ptr<SLE const>;

    BookDirs(ReadView const&, Book const&);

@@ -76,7 +76,7 @@ private:
    uint256 nextQuality_;
    uint256 key_;
    uint256 curKey_;
-    SLE::const_pointer sle_;
+    std::shared_ptr<SLE const> sle_;
    unsigned int entry_ = 0;
    uint256 index_;
    std::optional<value_type> mutable cache_;
--- a/include/xrpl/ledger/CachedView.h
+++ b/include/xrpl/ledger/CachedView.h
@@ -36,7 +36,7 @@ public:
    bool
    exists(Keylet const& k) const override;

-    SLE::const_pointer
+    std::shared_ptr<SLE const>
    read(Keylet const& k) const override;

    bool
--- a/include/xrpl/ledger/Dir.h
+++ b/include/xrpl/ledger/Dir.h
@@ -22,12 +22,12 @@ class Dir
 private:
    ReadView const* view_ = nullptr;
    Keylet root_;
-    SLE::const_pointer sle_;
+    std::shared_ptr<SLE const> sle_;
    STVector256 const* indexes_ = nullptr;

 public:
    class ConstIterator;
-    using value_type = SLE::const_pointer;
+    using value_type = std::shared_ptr<SLE const>;

    Dir(ReadView const&, Keylet const&);

@@ -102,7 +102,7 @@ private:
    Keylet page_;
    uint256 index_;
    std::optional<value_type> mutable cache_;
-    SLE::const_pointer sle_;
+    std::shared_ptr<SLE const> sle_;
    STVector256 const* indexes_ = nullptr;
    std::vector<uint256>::const_iterator it_;
 };
--- a/include/xrpl/ledger/Ledger.h
+++ b/include/xrpl/ledger/Ledger.h
@@ -166,7 +166,7 @@ public:
    std::optional<uint256>
    succ(uint256 const& key, std::optional<uint256> const& last = std::nullopt) const override;

-    SLE::const_pointer
+    std::shared_ptr<SLE const>
    read(Keylet const& k) const override;

    std::unique_ptr<SlesType::iter_base>
@@ -202,16 +202,16 @@ public:
    //

    void
-    rawErase(SLE::ref sle) override;
+    rawErase(std::shared_ptr<SLE> const& sle) override;

    void
-    rawInsert(SLE::ref sle) override;
+    rawInsert(std::shared_ptr<SLE> const& sle) override;

    void
    rawErase(uint256 const& key);

    void
-    rawReplace(SLE::ref sle) override;
+    rawReplace(std::shared_ptr<SLE> const& sle) override;

    void
    rawDestroyXRP(XRPAmount const& fee) override
@@ -361,7 +361,7 @@ public:
    bool
    isVotingLedger() const;

-    SLE::pointer
+    std::shared_ptr<SLE>
    peek(Keylet const& k) const;

 private:
--- a/include/xrpl/ledger/OpenView.h
+++ b/include/xrpl/ledger/OpenView.h
@@ -197,7 +197,7 @@ public:
    std::optional<key_type>
    succ(key_type const& key, std::optional<key_type> const& last = std::nullopt) const override;

-    SLE::const_pointer
+    std::shared_ptr<SLE const>
    read(Keylet const& k) const override;

    std::unique_ptr<SlesType::iter_base>
@@ -224,13 +224,13 @@ public:
    // RawView

    void
-    rawErase(SLE::ref sle) override;
+    rawErase(std::shared_ptr<SLE> const& sle) override;

    void
-    rawInsert(SLE::ref sle) override;
+    rawInsert(std::shared_ptr<SLE> const& sle) override;

    void
-    rawReplace(SLE::ref sle) override;
+    rawReplace(std::shared_ptr<SLE> const& sle) override;

    void
    rawDestroyXRP(XRPAmount const& fee) override;
--- a/include/xrpl/ledger/RawView.h
+++ b/include/xrpl/ledger/RawView.h
@@ -25,7 +25,7 @@ public:
        can calculate metadata.
    */
    virtual void
-    rawErase(SLE::ref sle) = 0;
+    rawErase(std::shared_ptr<SLE> const& sle) = 0;

    /** Unconditionally insert a state item.

@@ -39,7 +39,7 @@ public:
        @note The key is taken from the SLE
    */
    virtual void
-    rawInsert(SLE::ref sle) = 0;
+    rawInsert(std::shared_ptr<SLE> const& sle) = 0;

    /** Unconditionally replace a state item.

@@ -54,7 +54,7 @@ public:
        @note The key is taken from the SLE
    */
    virtual void
-    rawReplace(SLE::ref sle) = 0;
+    rawReplace(std::shared_ptr<SLE> const& sle) = 0;

    /** Destroy XRP.

--- a/include/xrpl/ledger/ReadView.h
+++ b/include/xrpl/ledger/ReadView.h
@@ -34,9 +34,9 @@ public:

    using key_type = uint256;

-    using mapped_type = SLE::const_pointer;
+    using mapped_type = std::shared_ptr<SLE const>;

-    struct SlesType : detail::ReadViewFwdRange<SLE::const_pointer>
+    struct SlesType : detail::ReadViewFwdRange<std::shared_ptr<SLE const>>
    {
        explicit SlesType(ReadView const& view);
        [[nodiscard]] Iterator
@@ -143,7 +143,7 @@ public:
        @return `nullptr` if the key is not present or
                if the type does not match.
    */
-    [[nodiscard]] virtual SLE::const_pointer
+    [[nodiscard]] virtual std::shared_ptr<SLE const>
    read(Keylet const& k) const = 0;

    // Accounts in a payment are not allowed to use assets acquired during that
--- a/include/xrpl/ledger/View.h
+++ b/include/xrpl/ledger/View.h
@@ -12,6 +12,7 @@
 #include <cstdint>
 #include <functional>
 #include <map>
+#include <memory>
 #include <optional>
 #include <set>
 #include <utility>
@@ -134,7 +135,7 @@ areCompatible(
 dirLink(
    ApplyView& view,
    AccountID const& owner,
-    SLE::pointer& object,
+    std::shared_ptr<SLE>& object,
    SF_UINT64 const& node = sfOwnerNode);

 /** Checks that can withdraw funds from an object to itself or a destination.
@@ -214,8 +215,8 @@ doWithdraw(
 * (if should not be skipped) and if the entry should be skipped. The status
 * is always tesSUCCESS if the entry should be skipped.
 */
-using EntryDeleter =
-    std::function<std::pair<TER, SkipEntry>(LedgerEntryType, uint256 const&, SLE::pointer&)>;
+using EntryDeleter = std::function<
+    std::pair<TER, SkipEntry>(LedgerEntryType, uint256 const&, std::shared_ptr<SLE>&)>;
 /** Cleanup owner directory entries on account delete.
 * Used for a regular and AMM accounts deletion. The caller
 * has to provide the deleter function, which handles details of
--- a/include/xrpl/ledger/detail/ApplyStateTable.h
+++ b/include/xrpl/ledger/detail/ApplyStateTable.h
@@ -8,6 +8,8 @@
 #include <xrpl/protocol/TxMeta.h>
 #include <xrpl/protocol/XRPAmount.h>

+#include <memory>
+
 namespace xrpl::detail {

 // Helper class that buffers modifications
@@ -24,7 +26,7 @@ private:
        Modify,
    };

-    using items_t = std::map<key_type, std::pair<Action, SLE::pointer>>;
+    using items_t = std::map<key_type, std::pair<Action, std::shared_ptr<SLE>>>;

    items_t items_;
    XRPAmount dropsDestroyed_{0};
@@ -58,10 +60,10 @@ public:
    [[nodiscard]] std::optional<key_type>
    succ(ReadView const& base, key_type const& key, std::optional<key_type> const& last) const;

-    [[nodiscard]] SLE::const_pointer
+    [[nodiscard]] std::shared_ptr<SLE const>
    read(ReadView const& base, Keylet const& k) const;

-    SLE::pointer
+    std::shared_ptr<SLE>
    peek(ReadView const& base, Keylet const& k);

    [[nodiscard]] std::size_t
@@ -73,23 +75,23 @@ public:
        std::function<void(
            uint256 const& key,
            bool isDelete,
-            SLE::const_ref before,
-            SLE::const_ref after)> const& func) const;
+            std::shared_ptr<SLE const> const& before,
+            std::shared_ptr<SLE const> const& after)> const& func) const;

    void
-    erase(ReadView const& base, SLE::ref sle);
+    erase(ReadView const& base, std::shared_ptr<SLE> const& sle);

    void
-    rawErase(ReadView const& base, SLE::ref sle);
+    rawErase(ReadView const& base, std::shared_ptr<SLE> const& sle);

    void
-    insert(ReadView const& base, SLE::ref sle);
+    insert(ReadView const& base, std::shared_ptr<SLE> const& sle);

    void
-    update(ReadView const& base, SLE::ref sle);
+    update(ReadView const& base, std::shared_ptr<SLE> const& sle);

    void
-    replace(ReadView const& base, SLE::ref sle);
+    replace(ReadView const& base, std::shared_ptr<SLE> const& sle);

    void
    destroyXRP(XRPAmount const& fee);
@@ -102,12 +104,12 @@ public:
    }

 private:
-    using Mods = hash_map<key_type, SLE::pointer>;
+    using Mods = hash_map<key_type, std::shared_ptr<SLE>>;

    static void
-    threadItem(TxMeta& meta, SLE::ref to);
+    threadItem(TxMeta& meta, std::shared_ptr<SLE> const& to);

-    SLE::pointer
+    std::shared_ptr<SLE>
    getForMod(ReadView const& base, key_type const& key, Mods& mods, beast::Journal j);

    void
@@ -117,7 +119,7 @@ private:
    threadOwners(
        ReadView const& base,
        TxMeta& meta,
-        SLE::const_ref sle,
+        std::shared_ptr<SLE const> const& sle,
        Mods& mods,
        beast::Journal j);
 };
--- a/include/xrpl/ledger/detail/ApplyViewBase.h
+++ b/include/xrpl/ledger/detail/ApplyViewBase.h
@@ -40,7 +40,7 @@ public:
    [[nodiscard]] std::optional<key_type>
    succ(key_type const& key, std::optional<key_type> const& last = std::nullopt) const override;

-    [[nodiscard]] SLE::const_pointer
+    [[nodiscard]] std::shared_ptr<SLE const>
    read(Keylet const& k) const override;

    [[nodiscard]] std::unique_ptr<SlesType::iter_base>
@@ -69,28 +69,28 @@ public:
    [[nodiscard]] ApplyFlags
    flags() const override;

-    SLE::pointer
+    std::shared_ptr<SLE>
    peek(Keylet const& k) override;

    void
-    erase(SLE::ref sle) override;
+    erase(std::shared_ptr<SLE> const& sle) override;

    void
-    insert(SLE::ref sle) override;
+    insert(std::shared_ptr<SLE> const& sle) override;

    void
-    update(SLE::ref sle) override;
+    update(std::shared_ptr<SLE> const& sle) override;

    // RawView

    void
-    rawErase(SLE::ref sle) override;
+    rawErase(std::shared_ptr<SLE> const& sle) override;

    void
-    rawInsert(SLE::ref sle) override;
+    rawInsert(std::shared_ptr<SLE> const& sle) override;

    void
-    rawReplace(SLE::ref sle) override;
+    rawReplace(std::shared_ptr<SLE> const& sle) override;

    void
    rawDestroyXRP(XRPAmount const& feeDrops) override;
--- a/include/xrpl/ledger/detail/RawStateTable.h
+++ b/include/xrpl/ledger/detail/RawStateTable.h
@@ -49,15 +49,15 @@ public:
    succ(ReadView const& base, key_type const& key, std::optional<key_type> const& last) const;

    void
-    erase(SLE::ref sle);
+    erase(std::shared_ptr<SLE> const& sle);

    void
-    insert(SLE::ref sle);
+    insert(std::shared_ptr<SLE> const& sle);

    void
-    replace(SLE::ref sle);
+    replace(std::shared_ptr<SLE> const& sle);

-    [[nodiscard]] SLE::const_pointer
+    [[nodiscard]] std::shared_ptr<SLE const>
    read(ReadView const& base, Keylet const& k) const;

    void
@@ -84,10 +84,10 @@ private:
    struct SleAction
    {
        Action action;
-        SLE::pointer sle;
+        std::shared_ptr<SLE> sle;

        // Constructor needed for emplacement in std::map
-        SleAction(Action action, SLE::pointer sle) : action(action), sle(std::move(sle))
+        SleAction(Action action, std::shared_ptr<SLE> const& sle) : action(action), sle(sle)
        {
        }
    };
--- a/include/xrpl/ledger/helpers/AMMHelpers.h
+++ b/include/xrpl/ledger/helpers/AMMHelpers.h
@@ -792,7 +792,7 @@ deleteAMMAccount(Sandbox& view, Asset const& asset, Asset const& asset2, beast::
 void
 initializeFeeAuctionVote(
    ApplyView& view,
-    SLE::pointer& ammSle,
+    std::shared_ptr<SLE>& ammSle,
    AccountID const& account,
    Asset const& lptAsset,
    std::uint16_t tfee);
@@ -812,7 +812,7 @@ Expected<bool, TER>
 verifyAndAdjustLPTokenBalance(
    Sandbox& sb,
    STAmount const& lpTokens,
-    SLE::pointer& ammSle,
+    std::shared_ptr<SLE>& ammSle,
    AccountID const& account);

 }  // namespace xrpl
--- a/include/xrpl/ledger/helpers/AccountRootHelpers.h
+++ b/include/xrpl/ledger/helpers/AccountRootHelpers.h
@@ -9,6 +9,7 @@
 #include <xrpl/protocol/STLedgerEntry.h>
 #include <xrpl/protocol/TER.h>

+#include <memory>
 #include <set>
 #include <vector>

@@ -35,7 +36,11 @@ xrpLiquid(ReadView const& view, AccountID const& id, std::int32_t ownerCountAdj,

 /** Adjust the owner count up or down. */
 void
-adjustOwnerCount(ApplyView& view, SLE::ref sle, std::int32_t amount, beast::Journal j);
+adjustOwnerCount(
+    ApplyView& view,
+    std::shared_ptr<SLE> const& sle,
+    std::int32_t amount,
+    beast::Journal j);

 /** Returns IOU issuer transfer fee as Rate. Rate specifies
 * the fee as fractions of 1 billion. For example, 1% transfer rate
@@ -71,7 +76,9 @@ getPseudoAccountFields();
    - null pointer
 */
 [[nodiscard]] bool
-isPseudoAccount(SLE::const_pointer sleAcct, std::set<SField const*> const& pseudoFieldFilter = {});
+isPseudoAccount(
+    std::shared_ptr<SLE const> sleAcct,
+    std::set<SField const*> const& pseudoFieldFilter = {});

 /** Convenience overload that reads the account from the view. */
 [[nodiscard]] inline bool
@@ -91,7 +98,7 @@ isPseudoAccount(
 * before using a field. The amendment check is **not** performed in
 * createPseudoAccount.
 */
-[[nodiscard]] Expected<SLE::pointer, TER>
+[[nodiscard]] Expected<std::shared_ptr<SLE>, TER>
 createPseudoAccount(ApplyView& view, uint256 const& pseudoOwnerKey, SField const& ownerField);

 /** Checks the destination and tag.
--- a/include/xrpl/ledger/helpers/CredentialHelpers.h
+++ b/include/xrpl/ledger/helpers/CredentialHelpers.h
@@ -23,7 +23,7 @@ checkExpired(SLE const& sleCredential, NetClock::time_point const& closed);

 // Actually remove a credentials object from the ledger
 [[nodiscard]] TER
-deleteSLE(ApplyView& view, SLE::ref sleCredential, beast::Journal j);
+deleteSLE(ApplyView& view, std::shared_ptr<SLE> const& sleCredential, beast::Journal j);

 // Amendment and parameters checks for sfCredentialIDs field
 NotTEC
@@ -70,7 +70,7 @@ verifyDepositPreauth(
    ApplyView& view,
    AccountID const& src,
    AccountID const& dst,
-    SLE::const_ref sleDst,
+    std::shared_ptr<SLE const> const& sleDst,
    beast::Journal j);

 }  // namespace xrpl
--- a/include/xrpl/ledger/helpers/DelegateHelpers.h
+++ b/include/xrpl/ledger/helpers/DelegateHelpers.h
@@ -15,7 +15,7 @@ namespace xrpl {
 * if not.
 */
 NotTEC
-checkTxPermission(SLE::const_ref delegate, STTx const& tx);
+checkTxPermission(std::shared_ptr<SLE const> const& delegate, STTx const& tx);

 /**
 * Load the granular permissions granted to the delegate account for the
@@ -28,7 +28,7 @@ checkTxPermission(SLE::const_ref delegate, STTx const& tx);
 */
 void
 loadGranularPermission(
-    SLE::const_ref delegate,
+    std::shared_ptr<SLE const> const& delegate,
    TxType const& type,
    std::unordered_set<GranularPermissionType>& granularPermissions);

--- a/include/xrpl/ledger/helpers/DirectoryHelpers.h
+++ b/include/xrpl/ledger/helpers/DirectoryHelpers.h
@@ -115,7 +115,7 @@ bool
 cdirFirst(
    ReadView const& view,
    uint256 const& root,
-    SLE::const_pointer& page,
+    std::shared_ptr<SLE const>& page,
    unsigned int& index,
    uint256& entry);

@@ -123,7 +123,7 @@ bool
 dirFirst(
    ApplyView& view,
    uint256 const& root,
-    SLE::pointer& page,
+    std::shared_ptr<SLE>& page,
    unsigned int& index,
    uint256& entry);
 /** @} */
@@ -147,7 +147,7 @@ bool
 cdirNext(
    ReadView const& view,
    uint256 const& root,
-    SLE::const_pointer& page,
+    std::shared_ptr<SLE const>& page,
    unsigned int& index,
    uint256& entry);

@@ -155,14 +155,17 @@ bool
 dirNext(
    ApplyView& view,
    uint256 const& root,
-    SLE::pointer& page,
+    std::shared_ptr<SLE>& page,
    unsigned int& index,
    uint256& entry);
 /** @} */

 /** Iterate all items in the given directory. */
 void
-forEachItem(ReadView const& view, Keylet const& root, std::function<void(SLE::const_ref)> const& f);
+forEachItem(
+    ReadView const& view,
+    Keylet const& root,
+    std::function<void(std::shared_ptr<SLE const> const&)> const& f);

 /** Iterate all items after an item in the given directory.
    @param after The key of the item to start after
@@ -177,11 +180,14 @@ forEachItemAfter(
    uint256 const& after,
    std::uint64_t const hint,
    unsigned int limit,
-    std::function<bool(SLE::const_ref)> const& f);
+    std::function<bool(std::shared_ptr<SLE const> const&)> const& f);

 /** Iterate all items in an account's owner directory. */
 inline void
-forEachItem(ReadView const& view, AccountID const& id, std::function<void(SLE::const_ref)> const& f)
+forEachItem(
+    ReadView const& view,
+    AccountID const& id,
+    std::function<void(std::shared_ptr<SLE const> const&)> const& f)
 {
    forEachItem(view, keylet::ownerDir(id), f);
 }
@@ -199,7 +205,7 @@ forEachItemAfter(
    uint256 const& after,
    std::uint64_t const hint,
    unsigned int limit,
-    std::function<bool(SLE::const_ref)> const& f)
+    std::function<bool(std::shared_ptr<SLE const> const&)> const& f)
 {
    return forEachItemAfter(view, keylet::ownerDir(id), after, hint, limit, f);
 }
--- a/include/xrpl/ledger/helpers/EscrowHelpers.h
+++ b/include/xrpl/ledger/helpers/EscrowHelpers.h
@@ -18,7 +18,7 @@ TER
 escrowUnlockApplyHelper(
    ApplyView& view,
    Rate lockedRate,
-    SLE::ref sleDest,
+    std::shared_ptr<SLE> const& sleDest,
    STAmount const& xrpBalance,
    STAmount const& amount,
    AccountID const& issuer,
@@ -32,7 +32,7 @@ inline TER
 escrowUnlockApplyHelper<Issue>(
    ApplyView& view,
    Rate lockedRate,
-    SLE::ref sleDest,
+    std::shared_ptr<SLE> const& sleDest,
    STAmount const& xrpBalance,
    STAmount const& amount,
    AccountID const& issuer,
@@ -162,7 +162,7 @@ inline TER
 escrowUnlockApplyHelper<MPTIssue>(
    ApplyView& view,
    Rate lockedRate,
-    SLE::ref sleDest,
+    std::shared_ptr<SLE> const& sleDest,
    STAmount const& xrpBalance,
    STAmount const& amount,
    AccountID const& issuer,
--- a/include/xrpl/ledger/helpers/LendingHelpers.h
+++ b/include/xrpl/ledger/helpers/LendingHelpers.h
@@ -461,7 +461,6 @@ loanAccruedInterest(

 ExtendedPaymentComponents
 computeOverpaymentComponents(
-    Rules const& rules,
    Asset const& asset,
    int32_t const loanScale,
    Number const& overpayment,
--- a/include/xrpl/ledger/helpers/NFTokenHelpers.h
+++ b/include/xrpl/ledger/helpers/NFTokenHelpers.h
@@ -28,9 +28,10 @@ findToken(ReadView const& view, AccountID const& owner, uint256 const& nftokenID
 struct TokenAndPage
 {
    STObject token;
-    SLE::pointer page;
+    std::shared_ptr<SLE> page;

-    TokenAndPage(STObject token, SLE::pointer page) : token(std::move(token)), page(std::move(page))
+    TokenAndPage(STObject token, std::shared_ptr<SLE> page)
+        : token(std::move(token)), page(std::move(page))
    {
    }
 };
@@ -46,7 +47,11 @@ TER
 removeToken(ApplyView& view, AccountID const& owner, uint256 const& nftokenID);

 TER
-removeToken(ApplyView& view, AccountID const& owner, uint256 const& nftokenID, SLE::ref page);
+removeToken(
+    ApplyView& view,
+    AccountID const& owner,
+    uint256 const& nftokenID,
+    std::shared_ptr<SLE> const& page);

 /** Deletes the given token offer.

@@ -58,7 +63,7 @@ removeToken(ApplyView& view, AccountID const& owner, uint256 const& nftokenID, S
    The offer also consumes one incremental reserve.
 */
 bool
-deleteTokenOffer(ApplyView& view, SLE::ref offer);
+deleteTokenOffer(ApplyView& view, std::shared_ptr<SLE> const& offer);

 /** Repairs the links in an NFTokenPage directory.

--- a/include/xrpl/ledger/helpers/OfferHelpers.h
+++ b/include/xrpl/ledger/helpers/OfferHelpers.h
@@ -5,6 +5,8 @@
 #include <xrpl/protocol/STLedgerEntry.h>
 #include <xrpl/protocol/TER.h>

+#include <memory>
+
 namespace xrpl {

 /** Delete an offer.
@@ -21,6 +23,6 @@ namespace xrpl {
 */
 // [[nodiscard]] // nodiscard commented out so Flow, BookTip and others compile.
 TER
-offerDelete(ApplyView& view, SLE::ref sle, beast::Journal j);
+offerDelete(ApplyView& view, std::shared_ptr<SLE> const& sle, beast::Journal j);

 }  // namespace xrpl
--- a/include/xrpl/ledger/helpers/PaymentChannelHelpers.h
+++ b/include/xrpl/ledger/helpers/PaymentChannelHelpers.h
@@ -8,6 +8,10 @@
 namespace xrpl {

 TER
-closeChannel(SLE::ref slep, ApplyView& view, uint256 const& key, beast::Journal j);
+closeChannel(
+    std::shared_ptr<SLE> const& slep,
+    ApplyView& view,
+    uint256 const& key,
+    beast::Journal j);

 }  // namespace xrpl
--- a/include/xrpl/ledger/helpers/RippleStateHelpers.h
+++ b/include/xrpl/ledger/helpers/RippleStateHelpers.h
@@ -154,7 +154,7 @@ trustCreate(
 [[nodiscard]] TER
 trustDelete(
    ApplyView& view,
-    SLE::ref sleRippleState,
+    std::shared_ptr<SLE> const& sleRippleState,
    AccountID const& uLowAccountID,
    AccountID const& uHighAccountID,
    beast::Journal j);
@@ -248,7 +248,7 @@ removeEmptyHolding(
 [[nodiscard]] TER
 deleteAMMTrustLine(
    ApplyView& view,
-    SLE::pointer sleState,
+    std::shared_ptr<SLE> sleState,
    std::optional<AccountID> const& ammAccountID,
    beast::Journal j);

@@ -258,7 +258,7 @@ deleteAMMTrustLine(
 [[nodiscard]] TER
 deleteAMMMPToken(
    ApplyView& view,
-    SLE::pointer sleMPT,
+    std::shared_ptr<SLE> sleMPT,
    AccountID const& ammAccountID,
    beast::Journal j);

--- a/include/xrpl/ledger/helpers/VaultHelpers.h
+++ b/include/xrpl/ledger/helpers/VaultHelpers.h
@@ -5,6 +5,7 @@
 #include <xrpl/protocol/STAmount.h>
 #include <xrpl/protocol/STLedgerEntry.h>

+#include <memory>
 #include <optional>

 namespace xrpl {
@@ -20,7 +21,10 @@ namespace xrpl {
    @return The number of shares, or nullopt on error.
 */
 [[nodiscard]] std::optional<STAmount>
-assetsToSharesDeposit(SLE::const_ref vault, SLE::const_ref issuance, STAmount const& assets);
+assetsToSharesDeposit(
+    std::shared_ptr<SLE const> const& vault,
+    std::shared_ptr<SLE const> const& issuance,
+    STAmount const& assets);

 /** From the perspective of a vault, return the number of assets to take from
    depositor when they receive a fixed amount of shares. Note, since shares are
@@ -33,7 +37,10 @@ assetsToSharesDeposit(SLE::const_ref vault, SLE::const_ref issuance, STAmount co
    @return The number of assets, or nullopt on error.
 */
 [[nodiscard]] std::optional<STAmount>
-sharesToAssetsDeposit(SLE::const_ref vault, SLE::const_ref issuance, STAmount const& shares);
+sharesToAssetsDeposit(
+    std::shared_ptr<SLE const> const& vault,
+    std::shared_ptr<SLE const> const& issuance,
+    STAmount const& shares);

 /** Controls whether to truncate shares instead of rounding. */
 enum class TruncateShares : bool { No = false, Yes = true };
@@ -62,8 +69,8 @@ enum class WaiveUnrealizedLoss : bool { No = false, Yes = true };
 */
 [[nodiscard]] std::optional<STAmount>
 assetsToSharesWithdraw(
-    SLE::const_ref vault,
-    SLE::const_ref issuance,
+    std::shared_ptr<SLE const> const& vault,
+    std::shared_ptr<SLE const> const& issuance,
    STAmount const& assets,
    TruncateShares truncate = TruncateShares::No,
    WaiveUnrealizedLoss waive = WaiveUnrealizedLoss::No);
@@ -82,8 +89,8 @@ assetsToSharesWithdraw(
 */
 [[nodiscard]] std::optional<STAmount>
 sharesToAssetsWithdraw(
-    SLE::const_ref vault,
-    SLE::const_ref issuance,
+    std::shared_ptr<SLE const> const& vault,
+    std::shared_ptr<SLE const> const& issuance,
    STAmount const& shares,
    WaiveUnrealizedLoss waive = WaiveUnrealizedLoss::No);

@@ -97,6 +104,9 @@ sharesToAssetsWithdraw(
                    both the share MPTID and the outstanding-amount total.
 */
 [[nodiscard]] bool
-isSoleShareholder(ReadView const& view, AccountID const& account, SLE::const_ref issuance);
+isSoleShareholder(
+    ReadView const& view,
+    AccountID const& account,
+    std::shared_ptr<SLE const> const& issuance);

 }  // namespace xrpl
--- a/include/xrpl/nodestore/Database.h
+++ b/include/xrpl/nodestore/Database.h
@@ -131,10 +131,6 @@ public:
        std::uint32_t ledgerSeq,
        std::function<void(std::shared_ptr<NodeObject> const&)>&& callback);

-    /** Remove expired entries from the positive and negative caches. */
-    virtual void
-    sweep() = 0;
-
    /** Gather statistics pertaining to read and write activities.
     *
     * @param obj Json object reference into which to place counters.
--- a/include/xrpl/nodestore/detail/DatabaseNodeImp.h
+++ b/include/xrpl/nodestore/detail/DatabaseNodeImp.h
@@ -22,32 +22,6 @@ public:
        beast::Journal j)
        : Database(scheduler, readThreads, config, j), backend_(std::move(backend))
    {
-        std::optional<int> cacheSize, cacheAge;
-
-        if (config.exists("cache_size"))
-        {
-            cacheSize = get<int>(config, "cache_size");
-            if (cacheSize.value() < 0)
-                Throw<std::runtime_error>("Specified negative value for cache_size");
-        }
-
-        if (config.exists("cache_age"))
-        {
-            cacheAge = get<int>(config, "cache_age");
-            if (cacheAge.value() < 0)
-                Throw<std::runtime_error>("Specified negative value for cache_age");
-        }
-
-        if (cacheSize.has_value() || cacheAge.has_value())
-        {
-            cache_ = std::make_shared<TaggedCache<uint256, NodeObject>>(
-                "DatabaseNodeImp",
-                cacheSize.value_or(0),
-                std::chrono::minutes(cacheAge.value_or(0)),
-                stopwatch(),
-                j);
-        }
-
        XRPL_ASSERT(
            backend_,
            "xrpl::NodeStore::DatabaseNodeImp::DatabaseNodeImp : non-null "
@@ -99,13 +73,7 @@ public:
        std::uint32_t ledgerSeq,
        std::function<void(std::shared_ptr<NodeObject> const&)>&& callback) override;

-    void
-    sweep() override;
-
 private:
-    // Cache for database objects. This cache is not always initialized. Check
-    // for null before using.
-    std::shared_ptr<TaggedCache<uint256, NodeObject>> cache_;
    // Persistent key/value storage
    std::shared_ptr<Backend> backend_;

--- a/include/xrpl/nodestore/detail/DatabaseRotatingImp.h
+++ b/include/xrpl/nodestore/detail/DatabaseRotatingImp.h
@@ -55,9 +55,6 @@ public:
    void
    sync() override;

-    void
-    sweep() override;
-
 private:
    std::shared_ptr<Backend> writableBackend_;
    std::shared_ptr<Backend> archiveBackend_;
--- a/include/xrpl/protocol_autogen/LedgerEntryBase.h
+++ b/include/xrpl/protocol_autogen/LedgerEntryBase.h
@@ -27,7 +27,7 @@ public:
     * @brief Construct a ledger entry wrapper from an existing SLE object.
     * @param sle The underlying serialized ledger entry to wrap
     */
-    explicit LedgerEntryBase(SLE::const_pointer sle) : sle_(std::move(sle))
+    explicit LedgerEntryBase(std::shared_ptr<SLE const> sle) : sle_(std::move(sle))
    {
    }

@@ -151,7 +151,7 @@ public:
     * @return A constant reference to the underlying SLE object
     */
    [[nodiscard]]
-    SLE::const_pointer
+    std::shared_ptr<SLE const>
    getSle() const
    {
        return sle_;
@@ -159,7 +159,7 @@ public:

 protected:
    /** @brief The underlying serialized ledger entry being wrapped. */
-    SLE::const_pointer sle_;
+    std::shared_ptr<SLE const> sle_;
 };

 }  // namespace xrpl::ledger_entries
--- a/include/xrpl/protocol_autogen/README.md
+++ b/include/xrpl/protocol_autogen/README.md
@@ -15,8 +15,8 @@ Generation requires a one-time setup step to create a virtual environment
 and install Python dependencies, followed by running the generation target:

 ```bash
-cmake --build . --target setup_code_gen # create venv and install dependencies (once)
-cmake --build . --target code_gen       # generate code
+cmake --build . --target setup_code_gen  # create venv and install dependencies (once)
+cmake --build . --target code_gen        # generate code
 ```

 By default, `CODEGEN_VENV_DIR` points to `.venv` in the project root. The
--- a/include/xrpl/protocol_autogen/ledger_entries/AMM.h
+++ b/include/xrpl/protocol_autogen/ledger_entries/AMM.h
@@ -33,7 +33,7 @@ public:
     * @brief Construct a AMM ledger entry wrapper from an existing SLE object.
     * @throws std::runtime_error if the ledger entry type doesn't match.
     */
-    explicit AMM(SLE::const_pointer sle)
+    explicit AMM(std::shared_ptr<SLE const> sle)
        : LedgerEntryBase(std::move(sle))
    {
        // Verify ledger entry type
@@ -256,7 +256,7 @@ public:
     * @param sle The existing ledger entry to copy from.
     * @throws std::runtime_error if the ledger entry type doesn't match.
     */
-    AMMBuilder(SLE::const_pointer sle)
+    AMMBuilder(std::shared_ptr<SLE const> sle)
    {
        if (sle->at(sfLedgerEntryType) != ltAMM)
        {
--- a/include/xrpl/protocol_autogen/ledger_entries/AccountRoot.h
+++ b/include/xrpl/protocol_autogen/ledger_entries/AccountRoot.h
@@ -33,7 +33,7 @@ public:
     * @brief Construct a AccountRoot ledger entry wrapper from an existing SLE object.
     * @throws std::runtime_error if the ledger entry type doesn't match.
     */
-    explicit AccountRoot(SLE::const_pointer sle)
+    explicit AccountRoot(std::shared_ptr<SLE const> sle)
        : LedgerEntryBase(std::move(sle))
    {
        // Verify ledger entry type
@@ -555,7 +555,7 @@ public:
     * @param sle The existing ledger entry to copy from.
     * @throws std::runtime_error if the ledger entry type doesn't match.
     */
-    AccountRootBuilder(SLE::const_pointer sle)
+    AccountRootBuilder(std::shared_ptr<SLE const> sle)
    {
        if (sle->at(sfLedgerEntryType) != ltACCOUNT_ROOT)
        {
--- a/include/xrpl/protocol_autogen/ledger_entries/Amendments.h
+++ b/include/xrpl/protocol_autogen/ledger_entries/Amendments.h
@@ -33,7 +33,7 @@ public:
     * @brief Construct a Amendments ledger entry wrapper from an existing SLE object.
     * @throws std::runtime_error if the ledger entry type doesn't match.
     */
-    explicit Amendments(SLE::const_pointer sle)
+    explicit Amendments(std::shared_ptr<SLE const> sle)
        : LedgerEntryBase(std::move(sle))
    {
        // Verify ledger entry type
@@ -166,7 +166,7 @@ public:
     * @param sle The existing ledger entry to copy from.
     * @throws std::runtime_error if the ledger entry type doesn't match.
     */
-    AmendmentsBuilder(SLE::const_pointer sle)
+    AmendmentsBuilder(std::shared_ptr<SLE const> sle)
    {
        if (sle->at(sfLedgerEntryType) != ltAMENDMENTS)
        {
--- a/include/xrpl/protocol_autogen/ledger_entries/Bridge.h
+++ b/include/xrpl/protocol_autogen/ledger_entries/Bridge.h
@@ -33,7 +33,7 @@ public:
     * @brief Construct a Bridge ledger entry wrapper from an existing SLE object.
     * @throws std::runtime_error if the ledger entry type doesn't match.
     */
-    explicit Bridge(SLE::const_pointer sle)
+    explicit Bridge(std::shared_ptr<SLE const> sle)
        : LedgerEntryBase(std::move(sle))
    {
        // Verify ledger entry type
@@ -210,7 +210,7 @@ public:
     * @param sle The existing ledger entry to copy from.
     * @throws std::runtime_error if the ledger entry type doesn't match.
     */
-    BridgeBuilder(SLE::const_pointer sle)
+    BridgeBuilder(std::shared_ptr<SLE const> sle)
    {
        if (sle->at(sfLedgerEntryType) != ltBRIDGE)
        {
--- a/include/xrpl/protocol_autogen/ledger_entries/Check.h
+++ b/include/xrpl/protocol_autogen/ledger_entries/Check.h
@@ -33,7 +33,7 @@ public:
     * @brief Construct a Check ledger entry wrapper from an existing SLE object.
     * @throws std::runtime_error if the ledger entry type doesn't match.
     */
-    explicit Check(SLE::const_pointer sle)
+    explicit Check(std::shared_ptr<SLE const> sle)
        : LedgerEntryBase(std::move(sle))
    {
        // Verify ledger entry type
@@ -269,7 +269,7 @@ public:
     * @param sle The existing ledger entry to copy from.
     * @throws std::runtime_error if the ledger entry type doesn't match.
     */
-    CheckBuilder(SLE::const_pointer sle)
+    CheckBuilder(std::shared_ptr<SLE const> sle)
    {
        if (sle->at(sfLedgerEntryType) != ltCHECK)
        {
--- a/include/xrpl/protocol_autogen/ledger_entries/Credential.h
+++ b/include/xrpl/protocol_autogen/ledger_entries/Credential.h
@@ -33,7 +33,7 @@ public:
     * @brief Construct a Credential ledger entry wrapper from an existing SLE object.
     * @throws std::runtime_error if the ledger entry type doesn't match.
     */
-    explicit Credential(SLE::const_pointer sle)
+    explicit Credential(std::shared_ptr<SLE const> sle)
        : LedgerEntryBase(std::move(sle))
    {
        // Verify ledger entry type
@@ -219,7 +219,7 @@ public:
     * @param sle The existing ledger entry to copy from.
     * @throws std::runtime_error if the ledger entry type doesn't match.
     */
-    CredentialBuilder(SLE::const_pointer sle)
+    CredentialBuilder(std::shared_ptr<SLE const> sle)
    {
        if (sle->at(sfLedgerEntryType) != ltCREDENTIAL)
        {
--- a/include/xrpl/protocol_autogen/ledger_entries/DID.h
+++ b/include/xrpl/protocol_autogen/ledger_entries/DID.h
@@ -33,7 +33,7 @@ public:
     * @brief Construct a DID ledger entry wrapper from an existing SLE object.
     * @throws std::runtime_error if the ledger entry type doesn't match.
     */
-    explicit DID(SLE::const_pointer sle)
+    explicit DID(std::shared_ptr<SLE const> sle)
        : LedgerEntryBase(std::move(sle))
    {
        // Verify ledger entry type
@@ -193,7 +193,7 @@ public:
     * @param sle The existing ledger entry to copy from.
     * @throws std::runtime_error if the ledger entry type doesn't match.
     */
-    DIDBuilder(SLE::const_pointer sle)
+    DIDBuilder(std::shared_ptr<SLE const> sle)
    {
        if (sle->at(sfLedgerEntryType) != ltDID)
        {
--- a/include/xrpl/protocol_autogen/ledger_entries/Delegate.h
+++ b/include/xrpl/protocol_autogen/ledger_entries/Delegate.h
@@ -33,7 +33,7 @@ public:
     * @brief Construct a Delegate ledger entry wrapper from an existing SLE object.
     * @throws std::runtime_error if the ledger entry type doesn't match.
     */
-    explicit Delegate(SLE::const_pointer sle)
+    explicit Delegate(std::shared_ptr<SLE const> sle)
        : LedgerEntryBase(std::move(sle))
    {
        // Verify ledger entry type
@@ -172,7 +172,7 @@ public:
     * @param sle The existing ledger entry to copy from.
     * @throws std::runtime_error if the ledger entry type doesn't match.
     */
-    DelegateBuilder(SLE::const_pointer sle)
+    DelegateBuilder(std::shared_ptr<SLE const> sle)
    {
        if (sle->at(sfLedgerEntryType) != ltDELEGATE)
        {
--- a/include/xrpl/protocol_autogen/ledger_entries/DepositPreauth.h
+++ b/include/xrpl/protocol_autogen/ledger_entries/DepositPreauth.h
@@ -33,7 +33,7 @@ public:
     * @brief Construct a DepositPreauth ledger entry wrapper from an existing SLE object.
     * @throws std::runtime_error if the ledger entry type doesn't match.
     */
-    explicit DepositPreauth(SLE::const_pointer sle)
+    explicit DepositPreauth(std::shared_ptr<SLE const> sle)
        : LedgerEntryBase(std::move(sle))
    {
        // Verify ledger entry type
@@ -170,7 +170,7 @@ public:
     * @param sle The existing ledger entry to copy from.
     * @throws std::runtime_error if the ledger entry type doesn't match.
     */
-    DepositPreauthBuilder(SLE::const_pointer sle)
+    DepositPreauthBuilder(std::shared_ptr<SLE const> sle)
    {
        if (sle->at(sfLedgerEntryType) != ltDEPOSIT_PREAUTH)
        {
--- a/include/xrpl/protocol_autogen/ledger_entries/DirectoryNode.h
+++ b/include/xrpl/protocol_autogen/ledger_entries/DirectoryNode.h
@@ -33,7 +33,7 @@ public:
     * @brief Construct a DirectoryNode ledger entry wrapper from an existing SLE object.
     * @throws std::runtime_error if the ledger entry type doesn't match.
     */
-    explicit DirectoryNode(SLE::const_pointer sle)
+    explicit DirectoryNode(std::shared_ptr<SLE const> sle)
        : LedgerEntryBase(std::move(sle))
    {
        // Verify ledger entry type
@@ -431,7 +431,7 @@ public:
     * @param sle The existing ledger entry to copy from.
     * @throws std::runtime_error if the ledger entry type doesn't match.
     */
-    DirectoryNodeBuilder(SLE::const_pointer sle)
+    DirectoryNodeBuilder(std::shared_ptr<SLE const> sle)
    {
        if (sle->at(sfLedgerEntryType) != ltDIR_NODE)
        {
--- a/include/xrpl/protocol_autogen/ledger_entries/Escrow.h
+++ b/include/xrpl/protocol_autogen/ledger_entries/Escrow.h
@@ -33,7 +33,7 @@ public:
     * @brief Construct a Escrow ledger entry wrapper from an existing SLE object.
     * @throws std::runtime_error if the ledger entry type doesn't match.
     */
-    explicit Escrow(SLE::const_pointer sle)
+    explicit Escrow(std::shared_ptr<SLE const> sle)
        : LedgerEntryBase(std::move(sle))
    {
        // Verify ledger entry type
@@ -363,7 +363,7 @@ public:
     * @param sle The existing ledger entry to copy from.
     * @throws std::runtime_error if the ledger entry type doesn't match.
     */
-    EscrowBuilder(SLE::const_pointer sle)
+    EscrowBuilder(std::shared_ptr<SLE const> sle)
    {
        if (sle->at(sfLedgerEntryType) != ltESCROW)
        {
--- a/include/xrpl/protocol_autogen/ledger_entries/FeeSettings.h
+++ b/include/xrpl/protocol_autogen/ledger_entries/FeeSettings.h
@@ -33,7 +33,7 @@ public:
     * @brief Construct a FeeSettings ledger entry wrapper from an existing SLE object.
     * @throws std::runtime_error if the ledger entry type doesn't match.
     */
-    explicit FeeSettings(SLE::const_pointer sle)
+    explicit FeeSettings(std::shared_ptr<SLE const> sle)
        : LedgerEntryBase(std::move(sle))
    {
        // Verify ledger entry type
@@ -285,7 +285,7 @@ public:
     * @param sle The existing ledger entry to copy from.
     * @throws std::runtime_error if the ledger entry type doesn't match.
     */
-    FeeSettingsBuilder(SLE::const_pointer sle)
+    FeeSettingsBuilder(std::shared_ptr<SLE const> sle)
    {
        if (sle->at(sfLedgerEntryType) != ltFEE_SETTINGS)
        {
--- a/include/xrpl/protocol_autogen/ledger_entries/LedgerHashes.h
+++ b/include/xrpl/protocol_autogen/ledger_entries/LedgerHashes.h
@@ -33,7 +33,7 @@ public:
     * @brief Construct a LedgerHashes ledger entry wrapper from an existing SLE object.
     * @throws std::runtime_error if the ledger entry type doesn't match.
     */
-    explicit LedgerHashes(SLE::const_pointer sle)
+    explicit LedgerHashes(std::shared_ptr<SLE const> sle)
        : LedgerEntryBase(std::move(sle))
    {
        // Verify ledger entry type
@@ -130,7 +130,7 @@ public:
     * @param sle The existing ledger entry to copy from.
     * @throws std::runtime_error if the ledger entry type doesn't match.
     */
-    LedgerHashesBuilder(SLE::const_pointer sle)
+    LedgerHashesBuilder(std::shared_ptr<SLE const> sle)
    {
        if (sle->at(sfLedgerEntryType) != ltLEDGER_HASHES)
        {
--- a/include/xrpl/protocol_autogen/ledger_entries/Loan.h
+++ b/include/xrpl/protocol_autogen/ledger_entries/Loan.h
@@ -33,7 +33,7 @@ public:
     * @brief Construct a Loan ledger entry wrapper from an existing SLE object.
     * @throws std::runtime_error if the ledger entry type doesn't match.
     */
-    explicit Loan(SLE::const_pointer sle)
+    explicit Loan(std::shared_ptr<SLE const> sle)
        : LedgerEntryBase(std::move(sle))
    {
        // Verify ledger entry type
@@ -607,7 +607,7 @@ public:
     * @param sle The existing ledger entry to copy from.
     * @throws std::runtime_error if the ledger entry type doesn't match.
     */
-    LoanBuilder(SLE::const_pointer sle)
+    LoanBuilder(std::shared_ptr<SLE const> sle)
    {
        if (sle->at(sfLedgerEntryType) != ltLOAN)
        {
--- a/include/xrpl/protocol_autogen/ledger_entries/LoanBroker.h
+++ b/include/xrpl/protocol_autogen/ledger_entries/LoanBroker.h
@@ -33,7 +33,7 @@ public:
     * @brief Construct a LoanBroker ledger entry wrapper from an existing SLE object.
     * @throws std::runtime_error if the ledger entry type doesn't match.
     */
-    explicit LoanBroker(SLE::const_pointer sle)
+    explicit LoanBroker(std::shared_ptr<SLE const> sle)
        : LedgerEntryBase(std::move(sle))
    {
        // Verify ledger entry type
@@ -378,7 +378,7 @@ public:
     * @param sle The existing ledger entry to copy from.
     * @throws std::runtime_error if the ledger entry type doesn't match.
     */
-    LoanBrokerBuilder(SLE::const_pointer sle)
+    LoanBrokerBuilder(std::shared_ptr<SLE const> sle)
    {
        if (sle->at(sfLedgerEntryType) != ltLOAN_BROKER)
        {
--- a/include/xrpl/protocol_autogen/ledger_entries/MPToken.h
+++ b/include/xrpl/protocol_autogen/ledger_entries/MPToken.h
@@ -33,7 +33,7 @@ public:
     * @brief Construct a MPToken ledger entry wrapper from an existing SLE object.
     * @throws std::runtime_error if the ledger entry type doesn't match.
     */
-    explicit MPToken(SLE::const_pointer sle)
+    explicit MPToken(std::shared_ptr<SLE const> sle)
        : LedgerEntryBase(std::move(sle))
    {
        // Verify ledger entry type
@@ -182,7 +182,7 @@ public:
     * @param sle The existing ledger entry to copy from.
     * @throws std::runtime_error if the ledger entry type doesn't match.
     */
-    MPTokenBuilder(SLE::const_pointer sle)
+    MPTokenBuilder(std::shared_ptr<SLE const> sle)
    {
        if (sle->at(sfLedgerEntryType) != ltMPTOKEN)
        {
--- a/include/xrpl/protocol_autogen/ledger_entries/MPTokenIssuance.h
+++ b/include/xrpl/protocol_autogen/ledger_entries/MPTokenIssuance.h
@@ -33,7 +33,7 @@ public:
     * @brief Construct a MPTokenIssuance ledger entry wrapper from an existing SLE object.
     * @throws std::runtime_error if the ledger entry type doesn't match.
     */
-    explicit MPTokenIssuance(SLE::const_pointer sle)
+    explicit MPTokenIssuance(std::shared_ptr<SLE const> sle)
        : LedgerEntryBase(std::move(sle))
    {
        // Verify ledger entry type
@@ -339,7 +339,7 @@ public:
     * @param sle The existing ledger entry to copy from.
     * @throws std::runtime_error if the ledger entry type doesn't match.
     */
-    MPTokenIssuanceBuilder(SLE::const_pointer sle)
+    MPTokenIssuanceBuilder(std::shared_ptr<SLE const> sle)
    {
        if (sle->at(sfLedgerEntryType) != ltMPTOKEN_ISSUANCE)
        {
--- a/include/xrpl/protocol_autogen/ledger_entries/NFTokenOffer.h
+++ b/include/xrpl/protocol_autogen/ledger_entries/NFTokenOffer.h
@@ -33,7 +33,7 @@ public:
     * @brief Construct a NFTokenOffer ledger entry wrapper from an existing SLE object.
     * @throws std::runtime_error if the ledger entry type doesn't match.
     */
-    explicit NFTokenOffer(SLE::const_pointer sle)
+    explicit NFTokenOffer(std::shared_ptr<SLE const> sle)
        : LedgerEntryBase(std::move(sle))
    {
        // Verify ledger entry type
@@ -208,7 +208,7 @@ public:
     * @param sle The existing ledger entry to copy from.
     * @throws std::runtime_error if the ledger entry type doesn't match.
     */
-    NFTokenOfferBuilder(SLE::const_pointer sle)
+    NFTokenOfferBuilder(std::shared_ptr<SLE const> sle)
    {
        if (sle->at(sfLedgerEntryType) != ltNFTOKEN_OFFER)
        {
--- a/include/xrpl/protocol_autogen/ledger_entries/NFTokenPage.h
+++ b/include/xrpl/protocol_autogen/ledger_entries/NFTokenPage.h
@@ -33,7 +33,7 @@ public:
     * @brief Construct a NFTokenPage ledger entry wrapper from an existing SLE object.
     * @throws std::runtime_error if the ledger entry type doesn't match.
     */
-    explicit NFTokenPage(SLE::const_pointer sle)
+    explicit NFTokenPage(std::shared_ptr<SLE const> sle)
        : LedgerEntryBase(std::move(sle))
    {
        // Verify ledger entry type
@@ -157,7 +157,7 @@ public:
     * @param sle The existing ledger entry to copy from.
     * @throws std::runtime_error if the ledger entry type doesn't match.
     */
-    NFTokenPageBuilder(SLE::const_pointer sle)
+    NFTokenPageBuilder(std::shared_ptr<SLE const> sle)
    {
        if (sle->at(sfLedgerEntryType) != ltNFTOKEN_PAGE)
        {
--- a/include/xrpl/protocol_autogen/ledger_entries/NegativeUNL.h
+++ b/include/xrpl/protocol_autogen/ledger_entries/NegativeUNL.h
@@ -33,7 +33,7 @@ public:
     * @brief Construct a NegativeUNL ledger entry wrapper from an existing SLE object.
     * @throws std::runtime_error if the ledger entry type doesn't match.
     */
-    explicit NegativeUNL(SLE::const_pointer sle)
+    explicit NegativeUNL(std::shared_ptr<SLE const> sle)
        : LedgerEntryBase(std::move(sle))
    {
        // Verify ledger entry type
@@ -190,7 +190,7 @@ public:
     * @param sle The existing ledger entry to copy from.
     * @throws std::runtime_error if the ledger entry type doesn't match.
     */
-    NegativeUNLBuilder(SLE::const_pointer sle)
+    NegativeUNLBuilder(std::shared_ptr<SLE const> sle)
    {
        if (sle->at(sfLedgerEntryType) != ltNEGATIVE_UNL)
        {
--- a/include/xrpl/protocol_autogen/ledger_entries/Offer.h
+++ b/include/xrpl/protocol_autogen/ledger_entries/Offer.h
@@ -33,7 +33,7 @@ public:
     * @brief Construct a Offer ledger entry wrapper from an existing SLE object.
     * @throws std::runtime_error if the ledger entry type doesn't match.
     */
-    explicit Offer(SLE::const_pointer sle)
+    explicit Offer(std::shared_ptr<SLE const> sle)
        : LedgerEntryBase(std::move(sle))
    {
        // Verify ledger entry type
@@ -259,7 +259,7 @@ public:
     * @param sle The existing ledger entry to copy from.
     * @throws std::runtime_error if the ledger entry type doesn't match.
     */
-    OfferBuilder(SLE::const_pointer sle)
+    OfferBuilder(std::shared_ptr<SLE const> sle)
    {
        if (sle->at(sfLedgerEntryType) != ltOFFER)
        {
--- a/include/xrpl/protocol_autogen/ledger_entries/Oracle.h
+++ b/include/xrpl/protocol_autogen/ledger_entries/Oracle.h
@@ -33,7 +33,7 @@ public:
     * @brief Construct a Oracle ledger entry wrapper from an existing SLE object.
     * @throws std::runtime_error if the ledger entry type doesn't match.
     */
-    explicit Oracle(SLE::const_pointer sle)
+    explicit Oracle(std::shared_ptr<SLE const> sle)
        : LedgerEntryBase(std::move(sle))
    {
        // Verify ledger entry type
@@ -222,7 +222,7 @@ public:
     * @param sle The existing ledger entry to copy from.
     * @throws std::runtime_error if the ledger entry type doesn't match.
     */
-    OracleBuilder(SLE::const_pointer sle)
+    OracleBuilder(std::shared_ptr<SLE const> sle)
    {
        if (sle->at(sfLedgerEntryType) != ltORACLE)
        {
--- a/include/xrpl/protocol_autogen/ledger_entries/PayChannel.h
+++ b/include/xrpl/protocol_autogen/ledger_entries/PayChannel.h
@@ -33,7 +33,7 @@ public:
     * @brief Construct a PayChannel ledger entry wrapper from an existing SLE object.
     * @throws std::runtime_error if the ledger entry type doesn't match.
     */
-    explicit PayChannel(SLE::const_pointer sle)
+    explicit PayChannel(std::shared_ptr<SLE const> sle)
        : LedgerEntryBase(std::move(sle))
    {
        // Verify ledger entry type
@@ -330,7 +330,7 @@ public:
     * @param sle The existing ledger entry to copy from.
     * @throws std::runtime_error if the ledger entry type doesn't match.
     */
-    PayChannelBuilder(SLE::const_pointer sle)
+    PayChannelBuilder(std::shared_ptr<SLE const> sle)
    {
        if (sle->at(sfLedgerEntryType) != ltPAYCHAN)
        {
--- a/include/xrpl/protocol_autogen/ledger_entries/PermissionedDomain.h
+++ b/include/xrpl/protocol_autogen/ledger_entries/PermissionedDomain.h
@@ -33,7 +33,7 @@ public:
     * @brief Construct a PermissionedDomain ledger entry wrapper from an existing SLE object.
     * @throws std::runtime_error if the ledger entry type doesn't match.
     */
-    explicit PermissionedDomain(SLE::const_pointer sle)
+    explicit PermissionedDomain(std::shared_ptr<SLE const> sle)
        : LedgerEntryBase(std::move(sle))
    {
        // Verify ledger entry type
@@ -148,7 +148,7 @@ public:
     * @param sle The existing ledger entry to copy from.
     * @throws std::runtime_error if the ledger entry type doesn't match.
     */
-    PermissionedDomainBuilder(SLE::const_pointer sle)
+    PermissionedDomainBuilder(std::shared_ptr<SLE const> sle)
    {
        if (sle->at(sfLedgerEntryType) != ltPERMISSIONED_DOMAIN)
        {
--- a/include/xrpl/protocol_autogen/ledger_entries/RippleState.h
+++ b/include/xrpl/protocol_autogen/ledger_entries/RippleState.h
@@ -33,7 +33,7 @@ public:
     * @brief Construct a RippleState ledger entry wrapper from an existing SLE object.
     * @throws std::runtime_error if the ledger entry type doesn't match.
     */
-    explicit RippleState(SLE::const_pointer sle)
+    explicit RippleState(std::shared_ptr<SLE const> sle)
        : LedgerEntryBase(std::move(sle))
    {
        // Verify ledger entry type
@@ -278,7 +278,7 @@ public:
     * @param sle The existing ledger entry to copy from.
     * @throws std::runtime_error if the ledger entry type doesn't match.
     */
-    RippleStateBuilder(SLE::const_pointer sle)
+    RippleStateBuilder(std::shared_ptr<SLE const> sle)
    {
        if (sle->at(sfLedgerEntryType) != ltRIPPLE_STATE)
        {
--- a/include/xrpl/protocol_autogen/ledger_entries/SignerList.h
+++ b/include/xrpl/protocol_autogen/ledger_entries/SignerList.h
@@ -33,7 +33,7 @@ public:
     * @brief Construct a SignerList ledger entry wrapper from an existing SLE object.
     * @throws std::runtime_error if the ledger entry type doesn't match.
     */
-    explicit SignerList(SLE::const_pointer sle)
+    explicit SignerList(std::shared_ptr<SLE const> sle)
        : LedgerEntryBase(std::move(sle))
    {
        // Verify ledger entry type
@@ -172,7 +172,7 @@ public:
     * @param sle The existing ledger entry to copy from.
     * @throws std::runtime_error if the ledger entry type doesn't match.
     */
-    SignerListBuilder(SLE::const_pointer sle)
+    SignerListBuilder(std::shared_ptr<SLE const> sle)
    {
        if (sle->at(sfLedgerEntryType) != ltSIGNER_LIST)
        {
--- a/include/xrpl/protocol_autogen/ledger_entries/Ticket.h
+++ b/include/xrpl/protocol_autogen/ledger_entries/Ticket.h
@@ -33,7 +33,7 @@ public:
     * @brief Construct a Ticket ledger entry wrapper from an existing SLE object.
     * @throws std::runtime_error if the ledger entry type doesn't match.
     */
-    explicit Ticket(SLE::const_pointer sle)
+    explicit Ticket(std::shared_ptr<SLE const> sle)
        : LedgerEntryBase(std::move(sle))
    {
        // Verify ledger entry type
@@ -134,7 +134,7 @@ public:
     * @param sle The existing ledger entry to copy from.
     * @throws std::runtime_error if the ledger entry type doesn't match.
     */
-    TicketBuilder(SLE::const_pointer sle)
+    TicketBuilder(std::shared_ptr<SLE const> sle)
    {
        if (sle->at(sfLedgerEntryType) != ltTICKET)
        {
--- a/include/xrpl/protocol_autogen/ledger_entries/Vault.h
+++ b/include/xrpl/protocol_autogen/ledger_entries/Vault.h
@@ -33,7 +33,7 @@ public:
     * @brief Construct a Vault ledger entry wrapper from an existing SLE object.
     * @throws std::runtime_error if the ledger entry type doesn't match.
     */
-    explicit Vault(SLE::const_pointer sle)
+    explicit Vault(std::shared_ptr<SLE const> sle)
        : LedgerEntryBase(std::move(sle))
    {
        // Verify ledger entry type
@@ -330,7 +330,7 @@ public:
     * @param sle The existing ledger entry to copy from.
     * @throws std::runtime_error if the ledger entry type doesn't match.
     */
-    VaultBuilder(SLE::const_pointer sle)
+    VaultBuilder(std::shared_ptr<SLE const> sle)
    {
        if (sle->at(sfLedgerEntryType) != ltVAULT)
        {
--- a/include/xrpl/protocol_autogen/ledger_entries/XChainOwnedClaimID.h
+++ b/include/xrpl/protocol_autogen/ledger_entries/XChainOwnedClaimID.h
@@ -33,7 +33,7 @@ public:
     * @brief Construct a XChainOwnedClaimID ledger entry wrapper from an existing SLE object.
     * @throws std::runtime_error if the ledger entry type doesn't match.
     */
-    explicit XChainOwnedClaimID(SLE::const_pointer sle)
+    explicit XChainOwnedClaimID(std::shared_ptr<SLE const> sle)
        : LedgerEntryBase(std::move(sle))
    {
        // Verify ledger entry type
@@ -187,7 +187,7 @@ public:
     * @param sle The existing ledger entry to copy from.
     * @throws std::runtime_error if the ledger entry type doesn't match.
     */
-    XChainOwnedClaimIDBuilder(SLE::const_pointer sle)
+    XChainOwnedClaimIDBuilder(std::shared_ptr<SLE const> sle)
    {
        if (sle->at(sfLedgerEntryType) != ltXCHAIN_OWNED_CLAIM_ID)
        {
--- a/include/xrpl/protocol_autogen/ledger_entries/XChainOwnedCreateAccountClaimID.h
+++ b/include/xrpl/protocol_autogen/ledger_entries/XChainOwnedCreateAccountClaimID.h
@@ -33,7 +33,7 @@ public:
     * @brief Construct a XChainOwnedCreateAccountClaimID ledger entry wrapper from an existing SLE object.
     * @throws std::runtime_error if the ledger entry type doesn't match.
     */
-    explicit XChainOwnedCreateAccountClaimID(SLE::const_pointer sle)
+    explicit XChainOwnedCreateAccountClaimID(std::shared_ptr<SLE const> sle)
        : LedgerEntryBase(std::move(sle))
    {
        // Verify ledger entry type
@@ -161,7 +161,7 @@ public:
     * @param sle The existing ledger entry to copy from.
     * @throws std::runtime_error if the ledger entry type doesn't match.
     */
-    XChainOwnedCreateAccountClaimIDBuilder(SLE::const_pointer sle)
+    XChainOwnedCreateAccountClaimIDBuilder(std::shared_ptr<SLE const> sle)
    {
        if (sle->at(sfLedgerEntryType) != ltXCHAIN_OWNED_CREATE_ACCOUNT_CLAIM_ID)
        {
--- a/include/xrpl/shamap/SHAMap.h
+++ b/include/xrpl/shamap/SHAMap.h
@@ -85,7 +85,7 @@ private:
    /** The sequence of the ledger that this map references, if any. */
    std::uint32_t ledgerSeq_ = 0;

-    SHAMapTreeNodePtr root_;
+    intr_ptr::SharedPtr<SHAMapTreeNode> root_;
    mutable SHAMapState state_;
    SHAMapType const type_;
    bool backed_ = true;         // Map is backed by the database
@@ -326,32 +326,36 @@ public:
    invariants() const;

 private:
-    using SharedPtrNodeStack = std::stack<std::pair<SHAMapTreeNodePtr, SHAMapNodeID>>;
+    using SharedPtrNodeStack =
+        std::stack<std::pair<intr_ptr::SharedPtr<SHAMapTreeNode>, SHAMapNodeID>>;
    using DeltaRef =
        std::pair<boost::intrusive_ptr<SHAMapItem const>, boost::intrusive_ptr<SHAMapItem const>>;

    // tree node cache operations
-    SHAMapTreeNodePtr
+    intr_ptr::SharedPtr<SHAMapTreeNode>
    cacheLookup(SHAMapHash const& hash) const;

    void
-    canonicalize(SHAMapHash const& hash, SHAMapTreeNodePtr&) const;
+    canonicalize(SHAMapHash const& hash, intr_ptr::SharedPtr<SHAMapTreeNode>&) const;

    // database operations
-    SHAMapTreeNodePtr
+    intr_ptr::SharedPtr<SHAMapTreeNode>
    fetchNodeFromDB(SHAMapHash const& hash) const;
-    SHAMapTreeNodePtr
+    intr_ptr::SharedPtr<SHAMapTreeNode>
    fetchNodeNT(SHAMapHash const& hash) const;
-    SHAMapTreeNodePtr
+    intr_ptr::SharedPtr<SHAMapTreeNode>
    fetchNodeNT(SHAMapHash const& hash, SHAMapSyncFilter* filter) const;
-    SHAMapTreeNodePtr
+    intr_ptr::SharedPtr<SHAMapTreeNode>
    fetchNode(SHAMapHash const& hash) const;
-    SHAMapTreeNodePtr
+    intr_ptr::SharedPtr<SHAMapTreeNode>
    checkFilter(SHAMapHash const& hash, SHAMapSyncFilter* filter) const;

    /** Update hashes up to the root */
    void
-    dirtyUp(SharedPtrNodeStack& stack, uint256 const& target, SHAMapTreeNodePtr terminal);
+    dirtyUp(
+        SharedPtrNodeStack& stack,
+        uint256 const& target,
+        intr_ptr::SharedPtr<SHAMapTreeNode> terminal);

    /** Walk towards the specified id, returning the node.  Caller must check
        if the return is nullptr, and if not, if the node->peekItem()->key() ==
@@ -373,21 +377,25 @@ private:
    preFlushNode(intr_ptr::SharedPtr<Node> node) const;

    /** write and canonicalize modified node */
-    SHAMapTreeNodePtr
-    writeNode(NodeObjectType t, SHAMapTreeNodePtr node) const;
+    intr_ptr::SharedPtr<SHAMapTreeNode>
+    writeNode(NodeObjectType t, intr_ptr::SharedPtr<SHAMapTreeNode> node) const;

    // returns the first item at or below this node
    SHAMapLeafNode*
-    firstBelow(SHAMapTreeNodePtr node, SharedPtrNodeStack& stack, int branch = 0) const;
+    firstBelow(intr_ptr::SharedPtr<SHAMapTreeNode>, SharedPtrNodeStack& stack, int branch = 0)
+        const;

    // returns the last item at or below this node
    SHAMapLeafNode*
-    lastBelow(SHAMapTreeNodePtr node, SharedPtrNodeStack& stack, int branch = kBranchFactor) const;
+    lastBelow(
+        intr_ptr::SharedPtr<SHAMapTreeNode> node,
+        SharedPtrNodeStack& stack,
+        int branch = kBranchFactor) const;

    // helper function for firstBelow and lastBelow
    SHAMapLeafNode*
    belowHelper(
-        SHAMapTreeNodePtr node,
+        intr_ptr::SharedPtr<SHAMapTreeNode> node,
        SharedPtrNodeStack& stack,
        int branch,
        std::tuple<int, std::function<bool(int)>, std::function<void(int&)>> const& loopParams)
@@ -399,14 +407,15 @@ private:
    descend(SHAMapInnerNode*, int branch) const;
    SHAMapTreeNode*
    descendThrow(SHAMapInnerNode*, int branch) const;
-    SHAMapTreeNodePtr
+    intr_ptr::SharedPtr<SHAMapTreeNode>
    descend(SHAMapInnerNode&, int branch) const;
-    SHAMapTreeNodePtr
+    intr_ptr::SharedPtr<SHAMapTreeNode>
    descendThrow(SHAMapInnerNode&, int branch) const;

    // Descend with filter
    // If pending, callback is called as if it called fetchNodeNT
-    using descendCallback = std::function<void(SHAMapTreeNodePtr, SHAMapHash const&)>;
+    using descendCallback =
+        std::function<void(intr_ptr::SharedPtr<SHAMapTreeNode>, SHAMapHash const&)>;
    SHAMapTreeNode*
    descendAsync(
        SHAMapInnerNode* parent,
@@ -424,7 +433,7 @@ private:

    // Non-storing
    // Does not hook the returned node to its parent
-    SHAMapTreeNodePtr
+    intr_ptr::SharedPtr<SHAMapTreeNode>
    descendNoStore(SHAMapInnerNode&, int branch) const;

    /** If there is only one leaf below this node, get its contents */
@@ -486,10 +495,10 @@ private:

        // nodes we may have acquired from deferred reads
        using DeferredNode = std::tuple<
-            SHAMapInnerNode*,    // parent node
-            SHAMapNodeID,        // parent node ID
-            int,                 // branch
-            SHAMapTreeNodePtr>;  // node
+            SHAMapInnerNode*,                      // parent node
+            SHAMapNodeID,                          // parent node ID
+            int,                                   // branch
+            intr_ptr::SharedPtr<SHAMapTreeNode>>;  // node

        int deferred;
        std::mutex deferLock;
@@ -515,7 +524,7 @@ private:
    gmnProcessDeferredReads(MissingNodes&);

    // fetch from DB helper function
-    SHAMapTreeNodePtr
+    intr_ptr::SharedPtr<SHAMapTreeNode>
    finishFetch(SHAMapHash const& hash, std::shared_ptr<NodeObject> const& object) const;
 };

--- a/include/xrpl/shamap/SHAMapAccountStateLeafNode.h
+++ b/include/xrpl/shamap/SHAMapAccountStateLeafNode.h
@@ -27,7 +27,7 @@ public:
    {
    }

-    SHAMapTreeNodePtr
+    intr_ptr::SharedPtr<SHAMapTreeNode>
    clone(std::uint32_t cowid) const final
    {
        return intr_ptr::makeShared<SHAMapAccountStateLeafNode>(item_, cowid, hash_);
--- a/include/xrpl/shamap/SHAMapInnerNode.h
+++ b/include/xrpl/shamap/SHAMapInnerNode.h
@@ -87,7 +87,7 @@ public:
    void
    partialDestructor() override;

-    SHAMapTreeNodePtr
+    intr_ptr::SharedPtr<SHAMapTreeNode>
    clone(std::uint32_t cowid) const override;

    SHAMapNodeType
@@ -121,19 +121,19 @@ public:
    getChildHash(int m) const;

    void
-    setChild(int m, SHAMapTreeNodePtr child);
+    setChild(int m, intr_ptr::SharedPtr<SHAMapTreeNode> child);

    void
-    shareChild(int m, SHAMapTreeNodePtr const& child);
+    shareChild(int m, intr_ptr::SharedPtr<SHAMapTreeNode> const& child);

    SHAMapTreeNode*
    getChildPointer(int branch);

-    SHAMapTreeNodePtr
+    intr_ptr::SharedPtr<SHAMapTreeNode>
    getChild(int branch);

-    SHAMapTreeNodePtr
-    canonicalizeChild(int branch, SHAMapTreeNodePtr node);
+    intr_ptr::SharedPtr<SHAMapTreeNode>
+    canonicalizeChild(int branch, intr_ptr::SharedPtr<SHAMapTreeNode> node);

    // sync functions
    bool
@@ -161,10 +161,10 @@ public:
    void
    invariants(bool isRoot = false) const override;

-    static SHAMapTreeNodePtr
+    static intr_ptr::SharedPtr<SHAMapTreeNode>
    makeFullInner(Slice data, SHAMapHash const& hash, bool hashValid);

-    static SHAMapTreeNodePtr
+    static intr_ptr::SharedPtr<SHAMapTreeNode>
    makeCompressedInner(Slice data);
 };

--- a/include/xrpl/shamap/SHAMapTreeNode.h
+++ b/include/xrpl/shamap/SHAMapTreeNode.h
@@ -13,9 +13,6 @@

 namespace xrpl {

-class SHAMapTreeNode;
-using SHAMapTreeNodePtr = intr_ptr::SharedPtr<SHAMapTreeNode>;
-
 // These are wire-protocol identifiers used during serialization to encode the
 // type of a node. They should not be arbitrarily be changed.
 static constexpr unsigned char const kWireTypeTransaction = 0;
@@ -115,7 +112,7 @@ public:
    }

    /** Make a copy of this node, setting the owner. */
-    virtual SHAMapTreeNodePtr
+    virtual intr_ptr::SharedPtr<SHAMapTreeNode>
    clone(std::uint32_t cowid) const = 0;
    /** @} */

@@ -156,20 +153,20 @@ public:
    virtual void
    invariants(bool isRoot = false) const = 0;

-    static SHAMapTreeNodePtr
+    static intr_ptr::SharedPtr<SHAMapTreeNode>
    makeFromPrefix(Slice rawNode, SHAMapHash const& hash);

-    static SHAMapTreeNodePtr
+    static intr_ptr::SharedPtr<SHAMapTreeNode>
    makeFromWire(Slice rawNode);

 private:
-    static SHAMapTreeNodePtr
+    static intr_ptr::SharedPtr<SHAMapTreeNode>
    makeTransaction(Slice data, SHAMapHash const& hash, bool hashValid);

-    static SHAMapTreeNodePtr
+    static intr_ptr::SharedPtr<SHAMapTreeNode>
    makeAccountState(Slice data, SHAMapHash const& hash, bool hashValid);

-    static SHAMapTreeNodePtr
+    static intr_ptr::SharedPtr<SHAMapTreeNode>
    makeTransactionWithMeta(Slice data, SHAMapHash const& hash, bool hashValid);
 };

--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Valentin Balaschenko	5fc815703e	more detailed tracing	2026-06-01 11:57:19 +01:00
Valentin Balaschenko	a4abf883cf	logs for ref counts	2026-05-31 18:04:34 +01:00