diff --git a/.circleci/config.yml b/.circleci/config.yml new file mode 100644 index 00000000000..4ed70d500ab --- /dev/null +++ b/.circleci/config.yml @@ -0,0 +1,243 @@ +version: 2.1 + +# Runs this fork's validation workflows through pinned act because GitHub Actions is disabled. +# Pull requests and branch pushes run the PR checks; merge queues add stage.yml. Event metadata is +# generated once per CircleCI revision and shared by all shards. +# +# The read-only GitHub token is exposed to PR code, so its CircleCI context must remain +# restricted to trusted contributors. Keep CircleCI auto-cancellation enabled. +# +# The act binary, checksum, and runner image are pinned. Compiler caches are no-ops because +# act's local cache is not reusable across these machines; Pages plumbing is skipped after the +# validation build. Lint and unit jobs are distributed; other workflows run up to four jobs. +# +# Excluded: pr-title.yml, label-pr.yml, and the privileged cyclops-audit.yml integration. + +jobs: + # Replaces lint.yml's `deny` job, which calls tempoxyz/ci's reusable deny.yml. That workflow starts + # with tempoxyz's secure-runner, which needs a GitHub OIDC token that act never receives, so the + # check itself runs natively here. Its policy comes from deny.toml in this repo. + # + # When re-applying this CI patch onto a new reth release, diff lint.yml's `deny:` job and the + # tempoxyz/ci deny.yml it calls against this job (toolchain, cargo-deny version, `check` + # arguments, deny flags), and update both pins here. + cargo-deny: + docker: + - image: rust:1.95-bookworm@sha256:6258907abe69656e41cd992e0b705cdcfabcbbe3db374f92ed2d47121282d4a1 + resource_class: medium + steps: + - checkout + - run: + name: Install pinned cargo-deny + command: | + set -euo pipefail + readonly DENY_VERSION="0.20.2" + readonly DENY_SHA256="9f12ed4c49936e09b48bf862b595cde2fe64fcbd9d74dfacac6131ca824c8d5f" + readonly DENY_ARCHIVE="cargo-deny-${DENY_VERSION}-x86_64-unknown-linux-musl.tar.gz" + curl --fail --silent --show-error --location \ + "https://github.com/EmbarkStudios/cargo-deny/releases/download/${DENY_VERSION}/${DENY_ARCHIVE}" \ + --output "/tmp/${DENY_ARCHIVE}" + echo "${DENY_SHA256} /tmp/${DENY_ARCHIVE}" | sha256sum --check + tar -xzf "/tmp/${DENY_ARCHIVE}" -C /usr/local/bin --strip-components=1 \ + "cargo-deny-${DENY_VERSION}-x86_64-unknown-linux-musl/cargo-deny" + test "$(cargo-deny --version)" = "cargo-deny ${DENY_VERSION}" + - run: + name: cargo deny check + command: cargo deny --log-level warn --all-features check all + + prepare-act-event: + machine: + image: ubuntu-2404:2025.09.1 + resource_class: medium + steps: + - checkout + - run: + name: Snapshot GitHub event + command: | + mkdir -p /tmp/act-event + if ! .circleci/prepare-act-event.sh; then + echo "GitHub event preparation failed; act shards will report the failure" | + tee /tmp/act-event/failed + fi + - persist_to_workspace: + root: /tmp/act-event + paths: + - . + + act: + parameters: + wf: + type: string + job: + type: string + default: "" + concurrent_jobs: + type: integer + default: 4 + machine: + image: ubuntu-2404:2025.09.1 + resource_class: xlarge + steps: + - checkout + - attach_workspace: + at: /tmp/act-event + - run: + name: Check event snapshot + command: | + if [ -f /tmp/act-event/failed ]; then + cat /tmp/act-event/failed >&2 + exit 1 + fi + - run: + name: Install pinned act + command: | + set -euo pipefail + readonly ACT_VERSION="0.2.89-action-cache-fix.1" + readonly ACT_RELEASE="v0.2.89-action-cache-fix.4" + readonly ACT_BINARY="act_Linux_x86_64" + readonly ACT_SHA256="28bfcf1502f59a834b14f2fb23c39e5b253c2234d875592b5aa0a175f9674dce" + curl --fail --silent --show-error --location \ + "https://github.com/ethereum-optimism/act/releases/download/${ACT_RELEASE}/${ACT_BINARY}" \ + --output "/tmp/${ACT_BINARY}" + echo "${ACT_SHA256} /tmp/${ACT_BINARY}" | sha256sum --check + sudo install -m 0755 "/tmp/${ACT_BINARY}" /usr/local/bin/act + test "$(act --version)" = "act version ${ACT_VERSION}" + - run: + name: Stub unsupported non-check actions + command: | + mkdir -p /tmp/noop-action + printf '%s\n' \ + 'name: noop' \ + 'description: disabled service plumbing under act' \ + 'inputs:' \ + ' cache-bin: {required: false}' \ + ' cache-on-failure: {required: false}' \ + ' cache-targets: {required: false}' \ + ' prefix-key: {required: false}' \ + 'runs:' \ + ' using: composite' \ + ' steps:' \ + ' - run: echo "Service plumbing disabled under act"' \ + ' shell: bash' \ + > /tmp/noop-action/action.yml + - run: + name: Run << parameters.wf >> via act + no_output_timeout: 45m + command: | + set -euo pipefail + event_path=/tmp/act-event/github-event.json + event_name="$(jq -er 'if .pull_request then "pull_request" elif .merge_group then "merge_group" elif .ref and .after then "push" else error("unsupported event") end' "$event_path")" + base_ref="$(jq -r '(.pull_request.base.ref // .merge_group.base_ref // "") | sub("^refs/heads/"; "")' "$event_path")" + target_job="<< parameters.job >>" + # Validate documentation without entering Pages deployment on branch pushes. + if [ "<< parameters.wf >>" = "book.yml" ]; then + target_job=build + fi + act_job=() + if [ -n "$target_job" ]; then + case "$target_job" in + crate-checks-*) + partition="${target_job#crate-checks-}" + if [[ ! "$partition" =~ ^[1-9][0-9]*$ ]]; then + echo "invalid crate-checks partition: $partition" >&2 + exit 1 + fi + act_job=(-j crate-checks --matrix "partition:${partition}") + ;; + *) + act_job=(-j "$target_job") + ;; + esac + fi + + act_env=(--env "RUSTC_WRAPPER=" --env "GITHUB_BASE_REF=${base_ref}") + if [ "<< parameters.wf >>" = "unit.yml" ] && [ "$target_job" = "state" ]; then + # EF tests use Rayon internally, so unrestricted nextest processes multiply + # runnable threads and starve valid_blocks past its upstream timeout. + act_env+=(--env "NEXTEST_TEST_THREADS=2") + fi + if [ "$event_name" != "pull_request" ]; then + act_env+=( + --env "GITHUB_REF=refs/heads/${CIRCLE_BRANCH}" + --env "GITHUB_SHA=${CIRCLE_SHA1}" + ) + fi + + act "$event_name" -W ".github/workflows/<< parameters.wf >>" \ + "${act_job[@]}" \ + --eventpath "$event_path" \ + -P "ubuntu-latest=catthehacker/ubuntu@sha256:b839c14c4410998529ec18f951262bdf87a2b23bc1467304d07b491b9455e074" \ + --concurrent-jobs << parameters.concurrent_jobs >> \ + "${act_env[@]}" \ + -s GITHUB_TOKEN="${MISE_GITHUB_TOKEN:?missing restricted read-only GitHub token}" \ + --local-repository "mozilla-actions/sccache-action@fc920bf0ec8de6ee65d409111f7ec508035751ba=/tmp/noop-action" \ + --local-repository "Swatinem/rust-cache@6323deb102c322ba6fcbdcafc7e3dddab59af2b6=/tmp/noop-action" \ + --local-repository "actions/configure-pages@45bfe0192ca1faeb007ade9deae92b16b8254a0d=/tmp/noop-action" \ + --local-repository "actions/upload-pages-artifact@fc324d3547104276b827a68afc52ff2a11cc49c9=/tmp/noop-action" + +workflows: + reth-act: + jobs: + - prepare-act-event: + context: + - circleci-repo-readonly-authenticated-github-token + - act: + context: + - circleci-repo-readonly-authenticated-github-token + name: "act-<< matrix.wf >>" + requires: + - prepare-act-event + matrix: + parameters: + wf: + - book.yml + - compact.yml + - e2e.yml + - grafana.yml + - integration.yml + - lint-actions.yml + - stage.yml + - act: + wf: lint.yml + concurrent_jobs: 1 + context: + - circleci-repo-readonly-authenticated-github-token + name: "act-lint-<< matrix.job >>" + requires: + - prepare-act-event + matrix: + parameters: + job: + - clippy-binaries + - clippy + - wasm + - riscv + - crate-checks-1 + - crate-checks-2 + - crate-checks-3 + - msrv + - docs + - fmt + - udeps + - book + - typos + - check-toml + - grafana + - no-test-deps + - feature-propagation + - cargo-deny: + name: lint-deny + - act: + wf: unit.yml + concurrent_jobs: 1 + context: + - circleci-repo-readonly-authenticated-github-token + name: "act-unit-<< matrix.job >>" + requires: + - prepare-act-event + matrix: + parameters: + job: + - test + - state + - doc diff --git a/.circleci/prepare-act-event.sh b/.circleci/prepare-act-event.sh new file mode 100755 index 00000000000..99cccb27f3c --- /dev/null +++ b/.circleci/prepare-act-event.sh @@ -0,0 +1,102 @@ +#!/usr/bin/env bash +set -euo pipefail + +readonly OUTPUT_DIR="${ACT_EVENT_OUTPUT_DIR:-/tmp/act-event}" +readonly EVENT_PATH="${OUTPUT_DIR}/github-event.json" + +mkdir -p "$OUTPUT_DIR" +rm -f "$EVENT_PATH" + +: "${CIRCLE_SHA1:?missing CircleCI revision}" +: "${CIRCLE_PROJECT_USERNAME:?missing CircleCI project owner}" +: "${CIRCLE_PROJECT_REPONAME:?missing CircleCI project repository}" + +repository="${CIRCLE_PROJECT_USERNAME}/${CIRCLE_PROJECT_REPONAME}" + +if [[ "${CIRCLE_BRANCH:-}" == gh-readonly-queue/* ]]; then + event_name="merge_group" +elif [[ -n "${CIRCLE_PULL_REQUEST:-}" ]]; then + event_name="pull_request" +else + event_name="push" +fi + +case "$event_name" in + pull_request) + : "${CIRCLE_PULL_REQUEST:?pull-request trigger must provide CIRCLE_PULL_REQUEST}" + pr_number="${CIRCLE_PULL_REQUEST##*/}" + if [[ ! "$pr_number" =~ ^[1-9][0-9]*$ ]]; then + echo "invalid pull-request URL: ${CIRCLE_PULL_REQUEST}" >&2 + exit 1 + fi + + pull_request_path="${OUTPUT_DIR}/pull-request.json" + curl --fail --silent --show-error --location \ + -H "Accept: application/vnd.github+json" \ + -H "Authorization: Bearer ${MISE_GITHUB_TOKEN:?missing restricted read-only GitHub token}" \ + -H "X-GitHub-Api-Version: 2022-11-28" \ + "https://api.github.com/repos/${repository}/pulls/${pr_number}" > "$pull_request_path" + + event_head_sha="$(jq -er '.head.sha' "$pull_request_path")" + if [[ "$event_head_sha" != "$CIRCLE_SHA1" ]]; then + echo "PR head does not match CircleCI revision: ${CIRCLE_SHA1} != ${event_head_sha}" >&2 + exit 1 + fi + + jq '{ + action: "synchronize", + number: .number, + pull_request: ., + repository: .base.repo, + sender: .user + }' "$pull_request_path" > "$EVENT_PATH" + base_ref="$(jq -er '.base.ref | select(length > 0)' "$pull_request_path")" + head_ref="$(jq -er '.head.ref | select(length > 0)' "$pull_request_path")" + echo "act event: pull_request #${pr_number}, ${head_ref} -> ${base_ref}" + ;; + push) + : "${CIRCLE_BRANCH:?push trigger must provide CIRCLE_BRANCH}" + jq -n \ + --arg ref "refs/heads/${CIRCLE_BRANCH}" \ + --arg after "$CIRCLE_SHA1" \ + '{ref: $ref, after: $after}' > "$EVENT_PATH" + echo "act event: push ${CIRCLE_BRANCH} at ${CIRCLE_SHA1}" + ;; + merge_group) + : "${CIRCLE_BRANCH:?merge-queue trigger must provide CIRCLE_BRANCH}" + if [[ ! "$CIRCLE_BRANCH" =~ ^gh-readonly-queue/(.+)/pr-([1-9][0-9]*)-[^/]+$ ]]; then + echo "merge_group requires a gh-readonly-queue//pr-- branch, got: ${CIRCLE_BRANCH}" >&2 + exit 1 + fi + base_ref="${BASH_REMATCH[1]}" + + if ! base_sha="$(git rev-parse "${CIRCLE_SHA1}^1" 2>/dev/null)"; then + git fetch --no-tags --depth=2 origin "$CIRCLE_SHA1" + base_sha="$(git rev-parse "${CIRCLE_SHA1}^1")" + fi + + jq -n \ + --arg head_sha "$CIRCLE_SHA1" \ + --arg head_ref "refs/heads/${CIRCLE_BRANCH}" \ + --arg base_sha "$base_sha" \ + --arg base_ref "refs/heads/${base_ref}" \ + --arg repository "$repository" \ + --arg repository_name "$CIRCLE_PROJECT_REPONAME" \ + --arg repository_owner "$CIRCLE_PROJECT_USERNAME" \ + '{ + action: "checks_requested", + merge_group: { + head_sha: $head_sha, + head_ref: $head_ref, + base_sha: $base_sha, + base_ref: $base_ref + }, + repository: { + full_name: $repository, + name: $repository_name, + owner: {login: $repository_owner} + } + }' > "$EVENT_PATH" + echo "act event: merge_group ${CIRCLE_BRANCH} -> ${base_ref} at ${base_sha}" + ;; +esac diff --git a/.github/scripts/check_rv32imac.sh b/.github/scripts/check_rv32imac.sh index 4e477cdbed1..988a95a3309 100755 --- a/.github/scripts/check_rv32imac.sh +++ b/.github/scripts/check_rv32imac.sh @@ -32,7 +32,7 @@ trap 'rm -rf -- "$tmpdir"' EXIT INT TERM for crate in "${crates_to_check[@]}"; do outfile="$tmpdir/$crate.log" - if cargo +stable build -p "$crate" --target riscv32imac-unknown-none-elf --no-default-features --color never >"$outfile" 2>&1; then + if cargo build -p "$crate" --target riscv32imac-unknown-none-elf --no-default-features --color never >"$outfile" 2>&1; then echo "✅ $crate" else echo "❌ $crate" diff --git a/.github/scripts/check_wasm.sh b/.github/scripts/check_wasm.sh index 15a8b8122ff..e4d5a8037a8 100755 --- a/.github/scripts/check_wasm.sh +++ b/.github/scripts/check_wasm.sh @@ -110,7 +110,7 @@ for crate in "${crates[@]}"; do fi outfile="$tmpdir/$crate.log" - if cargo +stable build -p "$crate" --target wasm32-wasip1 --no-default-features --color never >"$outfile" 2>&1; then + if cargo build -p "$crate" --target wasm32-wasip1 --no-default-features --color never >"$outfile" 2>&1; then echo "✅ $crate" else echo "❌ $crate" diff --git a/.github/workflows/book.yml b/.github/workflows/book.yml index 07f26676b62..86a39c9945b 100644 --- a/.github/workflows/book.yml +++ b/.github/workflows/book.yml @@ -40,6 +40,8 @@ jobs: - name: Install Rust nightly uses: dtolnay/rust-toolchain@nightly + with: + toolchain: nightly-2026-07-14 - name: Build docs run: cd docs/vocs && bash scripts/build-cargo-docs.sh diff --git a/.github/workflows/compact.yml b/.github/workflows/compact.yml index 52ad1ff8374..ac60ce324b2 100644 --- a/.github/workflows/compact.yml +++ b/.github/workflows/compact.yml @@ -1,6 +1,6 @@ # Ensures that `Compact` codec changes are backwards compatible. # -# 1) checkout `main` +# 1) checkout the PR base, or the selected release for maintenance-branch pushes # 2) randomly generate and serialize to disk many different type vectors with `Compact` (eg. Header, Transaction, etc) # 3) checkout `pr` # 4) deserialize previously generated test vectors @@ -35,6 +35,8 @@ jobs: - uses: rui314/setup-mold@7e4f20ad28a2e8ca6fd0892ccf72e2abb706b9c3 # v1 - run: .github/scripts/install_llvm.sh ubuntu - uses: dtolnay/rust-toolchain@stable + with: + toolchain: "1.97.0" - uses: mozilla-actions/sccache-action@fc920bf0ec8de6ee65d409111f7ec508035751ba # v0.0.11 - uses: Swatinem/rust-cache@6323deb102c322ba6fcbdcafc7e3dddab59af2b6 # v2.9.2 with: @@ -42,9 +44,11 @@ jobs: - name: Checkout base uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 with: - ref: ${{ github.base_ref || 'main' }} + # Use v2.6.0's commit: the fork carries its history but does not mirror upstream tags. + # The maintenance branch must decode its release's data, not unreleased main formats. + ref: ${{ github.base_ref || (github.ref == 'refs/heads/optimism' && '73a3a00862a8f14f89e30da8de001456f18cfae0' || 'main') }} persist-credentials: false - # On `main` branch, generates test vectors and serializes them to disk using `Compact`. + # On the comparison base, generate test vectors and serialize them to disk using `Compact`. - name: Generate compact vectors run: | ${{ matrix.bin }} -- test-vectors compact --write diff --git a/.github/workflows/e2e.yml b/.github/workflows/e2e.yml index 6031cd278a5..98f7d55e787 100644 --- a/.github/workflows/e2e.yml +++ b/.github/workflows/e2e.yml @@ -35,6 +35,8 @@ jobs: - uses: rui314/setup-mold@7e4f20ad28a2e8ca6fd0892ccf72e2abb706b9c3 # v1 - run: .github/scripts/install_llvm.sh ubuntu - uses: dtolnay/rust-toolchain@stable + with: + toolchain: "1.97.0" - uses: mozilla-actions/sccache-action@fc920bf0ec8de6ee65d409111f7ec508035751ba # v0.0.11 - uses: taiki-e/install-action@d438492cf8a250514fa2d34b30bc3c0dc37c65ff # v2.87.8 with: @@ -71,6 +73,8 @@ jobs: - uses: rui314/setup-mold@7e4f20ad28a2e8ca6fd0892ccf72e2abb706b9c3 # v1 - run: .github/scripts/install_llvm.sh ubuntu - uses: dtolnay/rust-toolchain@stable + with: + toolchain: "1.97.0" - uses: mozilla-actions/sccache-action@fc920bf0ec8de6ee65d409111f7ec508035751ba # v0.0.11 - uses: taiki-e/install-action@d438492cf8a250514fa2d34b30bc3c0dc37c65ff # v2.87.8 with: diff --git a/.github/workflows/integration.yml b/.github/workflows/integration.yml index 3d3ff5abf6d..45567fed0b0 100644 --- a/.github/workflows/integration.yml +++ b/.github/workflows/integration.yml @@ -42,6 +42,8 @@ jobs: - uses: rui314/setup-mold@7e4f20ad28a2e8ca6fd0892ccf72e2abb706b9c3 # v1 - run: .github/scripts/install_llvm.sh ubuntu - uses: dtolnay/rust-toolchain@stable + with: + toolchain: "1.97.0" - name: Install Geth run: .github/scripts/install_geth.sh - uses: taiki-e/install-action@d438492cf8a250514fa2d34b30bc3c0dc37c65ff # v2.87.8 @@ -86,6 +88,8 @@ jobs: - uses: rui314/setup-mold@7e4f20ad28a2e8ca6fd0892ccf72e2abb706b9c3 # v1 - run: .github/scripts/install_llvm.sh ubuntu - uses: dtolnay/rust-toolchain@stable + with: + toolchain: "1.97.0" - uses: taiki-e/install-action@d438492cf8a250514fa2d34b30bc3c0dc37c65ff # v2.87.8 with: tool: nextest diff --git a/.github/workflows/lint.yml b/.github/workflows/lint.yml index b52ca66799c..1368de51907 100644 --- a/.github/workflows/lint.yml +++ b/.github/workflows/lint.yml @@ -38,6 +38,7 @@ jobs: - run: .github/scripts/install_llvm.sh ubuntu - uses: dtolnay/rust-toolchain@clippy with: + toolchain: nightly-2026-07-14 components: clippy - uses: mozilla-actions/sccache-action@fc920bf0ec8de6ee65d409111f7ec508035751ba # v0.0.11 - uses: Swatinem/rust-cache@6323deb102c322ba6fcbdcafc7e3dddab59af2b6 # v2.9.2 @@ -62,6 +63,7 @@ jobs: - run: .github/scripts/install_llvm.sh ubuntu - uses: dtolnay/rust-toolchain@nightly with: + toolchain: nightly-2026-07-14 components: clippy - uses: mozilla-actions/sccache-action@fc920bf0ec8de6ee65d409111f7ec508035751ba # v0.0.11 - uses: Swatinem/rust-cache@6323deb102c322ba6fcbdcafc7e3dddab59af2b6 # v2.9.2 @@ -81,8 +83,10 @@ jobs: with: persist-credentials: false - uses: rui314/setup-mold@7e4f20ad28a2e8ca6fd0892ccf72e2abb706b9c3 # v1 + - run: .github/scripts/install_llvm.sh ubuntu - uses: dtolnay/rust-toolchain@stable with: + toolchain: "1.97.0" target: wasm32-wasip1 - uses: taiki-e/install-action@d438492cf8a250514fa2d34b30bc3c0dc37c65ff # v2.87.8 with: @@ -94,7 +98,7 @@ jobs: - uses: dcarbone/install-jq-action@4fcb5062d7ce9bc4382d1a352d19ba3ba2c317c1 # v4.0.1 - name: Run Wasm checks run: | - sudo apt update && sudo apt install gcc-multilib + sudo apt update && sudo apt install --yes gcc-multilib .github/scripts/check_wasm.sh riscv: @@ -109,6 +113,7 @@ jobs: - uses: rui314/setup-mold@7e4f20ad28a2e8ca6fd0892ccf72e2abb706b9c3 # v1 - uses: dtolnay/rust-toolchain@stable with: + toolchain: "1.97.0" target: riscv32imac-unknown-none-elf - uses: taiki-e/install-action@d438492cf8a250514fa2d34b30bc3c0dc37c65ff # v2.87.8 with: @@ -138,6 +143,8 @@ jobs: - uses: rui314/setup-mold@7e4f20ad28a2e8ca6fd0892ccf72e2abb706b9c3 # v1 - run: .github/scripts/install_llvm.sh ubuntu - uses: dtolnay/rust-toolchain@stable + with: + toolchain: "1.97.0" - uses: taiki-e/install-action@d438492cf8a250514fa2d34b30bc3c0dc37c65ff # v2.87.8 with: tool: cargo-hack @@ -183,6 +190,8 @@ jobs: - uses: rui314/setup-mold@7e4f20ad28a2e8ca6fd0892ccf72e2abb706b9c3 # v1 - run: .github/scripts/install_llvm.sh ubuntu - uses: dtolnay/rust-toolchain@nightly + with: + toolchain: nightly-2026-07-14 - uses: mozilla-actions/sccache-action@fc920bf0ec8de6ee65d409111f7ec508035751ba # v0.0.11 - uses: Swatinem/rust-cache@6323deb102c322ba6fcbdcafc7e3dddab59af2b6 # v2.9.2 with: @@ -206,6 +215,7 @@ jobs: - uses: rui314/setup-mold@7e4f20ad28a2e8ca6fd0892ccf72e2abb706b9c3 # v1 - uses: dtolnay/rust-toolchain@nightly with: + toolchain: nightly-2026-07-14 components: rustfmt - uses: mozilla-actions/sccache-action@fc920bf0ec8de6ee65d409111f7ec508035751ba # v0.0.11 - name: Run fmt @@ -224,6 +234,8 @@ jobs: - uses: rui314/setup-mold@7e4f20ad28a2e8ca6fd0892ccf72e2abb706b9c3 # v1 - run: .github/scripts/install_llvm.sh ubuntu - uses: dtolnay/rust-toolchain@nightly + with: + toolchain: nightly-2026-07-14 - uses: mozilla-actions/sccache-action@fc920bf0ec8de6ee65d409111f7ec508035751ba # v0.0.11 - uses: Swatinem/rust-cache@6323deb102c322ba6fcbdcafc7e3dddab59af2b6 # v2.9.2 with: @@ -246,6 +258,8 @@ jobs: - uses: rui314/setup-mold@7e4f20ad28a2e8ca6fd0892ccf72e2abb706b9c3 # v1 - run: .github/scripts/install_llvm.sh ubuntu - uses: dtolnay/rust-toolchain@nightly + with: + toolchain: nightly-2026-07-14 - uses: mozilla-actions/sccache-action@fc920bf0ec8de6ee65d409111f7ec508035751ba # v0.0.11 - uses: Swatinem/rust-cache@6323deb102c322ba6fcbdcafc7e3dddab59af2b6 # v2.9.2 with: @@ -308,6 +322,8 @@ jobs: persist-credentials: false - uses: rui314/setup-mold@7e4f20ad28a2e8ca6fd0892ccf72e2abb706b9c3 # v1 - uses: dtolnay/rust-toolchain@stable + with: + toolchain: "1.97.0" - name: Ensure no arbitrary or proptest dependency on default build run: cargo tree --package reth -e=features,no-dev | grep -Eq "arbitrary|proptest" && exit 1 || exit 0 @@ -323,6 +339,8 @@ jobs: persist-credentials: false - run: .github/scripts/install_llvm.sh ubuntu - uses: dtolnay/rust-toolchain@stable + with: + toolchain: "1.97.0" - uses: mozilla-actions/sccache-action@fc920bf0ec8de6ee65d409111f7ec508035751ba # v0.0.11 - uses: rui314/setup-mold@7e4f20ad28a2e8ca6fd0892ccf72e2abb706b9c3 # v1 - uses: taiki-e/cache-cargo-install-action@9ee83daaa7b96a6fab930949ecf1122bba04a389 # v3.0.8 diff --git a/.github/workflows/stage.yml b/.github/workflows/stage.yml index bb5c2422482..a235be631cf 100644 --- a/.github/workflows/stage.yml +++ b/.github/workflows/stage.yml @@ -39,6 +39,8 @@ jobs: - uses: rui314/setup-mold@7e4f20ad28a2e8ca6fd0892ccf72e2abb706b9c3 # v1 - run: .github/scripts/install_llvm.sh ubuntu - uses: dtolnay/rust-toolchain@stable + with: + toolchain: "1.97.0" - uses: mozilla-actions/sccache-action@fc920bf0ec8de6ee65d409111f7ec508035751ba # v0.0.11 - uses: Swatinem/rust-cache@6323deb102c322ba6fcbdcafc7e3dddab59af2b6 # v2.9.2 with: diff --git a/.github/workflows/unit.yml b/.github/workflows/unit.yml index 9e59205b8d8..a42d46af854 100644 --- a/.github/workflows/unit.yml +++ b/.github/workflows/unit.yml @@ -42,6 +42,8 @@ jobs: - uses: rui314/setup-mold@7e4f20ad28a2e8ca6fd0892ccf72e2abb706b9c3 # v1 - run: .github/scripts/install_llvm.sh ubuntu - uses: dtolnay/rust-toolchain@stable + with: + toolchain: "1.97.0" - uses: mozilla-actions/sccache-action@fc920bf0ec8de6ee65d409111f7ec508035751ba # v0.0.11 - uses: Swatinem/rust-cache@6323deb102c322ba6fcbdcafc7e3dddab59af2b6 # v2.9.2 with: @@ -94,6 +96,8 @@ jobs: - uses: rui314/setup-mold@7e4f20ad28a2e8ca6fd0892ccf72e2abb706b9c3 # v1 - run: .github/scripts/install_llvm.sh ubuntu - uses: dtolnay/rust-toolchain@stable + with: + toolchain: "1.97.0" - uses: taiki-e/install-action@d438492cf8a250514fa2d34b30bc3c0dc37c65ff # v2.87.8 with: tool: nextest @@ -118,6 +122,8 @@ jobs: - uses: rui314/setup-mold@7e4f20ad28a2e8ca6fd0892ccf72e2abb706b9c3 # v1 - run: .github/scripts/install_llvm.sh ubuntu - uses: dtolnay/rust-toolchain@stable + with: + toolchain: "1.97.0" - uses: mozilla-actions/sccache-action@fc920bf0ec8de6ee65d409111f7ec508035751ba # v0.0.11 - uses: Swatinem/rust-cache@6323deb102c322ba6fcbdcafc7e3dddab59af2b6 # v2.9.2 with: diff --git a/Cargo.lock b/Cargo.lock index 9a19ff74073..3c61ed85363 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1756,12 +1756,6 @@ dependencies = [ "serde_core", ] -[[package]] -name = "bitmaps" -version = "3.2.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a1d084b0137aaa901caf9f1e8b21daa6aa24d41cd806e111335541eff9683bd6" - [[package]] name = "bitvec" version = "1.0.1" @@ -5014,13 +5008,12 @@ dependencies = [ [[package]] name = "imbl" -version = "7.0.1" +version = "7.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "43ea8d4c37ee560727e824d62804183624d371e632019b0e9e3532bce64a33e5" +checksum = "46bad832b9b463ed9398b8506488cc2e3b897a9d44f13af115f382aac71f4fec" dependencies = [ "arbitrary", "archery", - "bitmaps", "equivalent", "imbl-sized-chunks", "rand_core 0.9.5", @@ -5032,12 +5025,9 @@ dependencies = [ [[package]] name = "imbl-sized-chunks" -version = "0.1.3" +version = "0.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8f4241005618a62f8d57b2febd02510fb96e0137304728543dfc5fd6f052c22d" -dependencies = [ - "bitmaps", -] +checksum = "2a0813be332553f857953298749fa19549e8b61b80589757c29b4e2a804fa9c6" [[package]] name = "impl-codec" diff --git a/crates/chain-state/src/in_memory.rs b/crates/chain-state/src/in_memory.rs index ef0fa4fabb3..adf6790bf0f 100644 --- a/crates/chain-state/src/in_memory.rs +++ b/crates/chain-state/src/in_memory.rs @@ -1001,12 +1001,22 @@ impl> NewCanonicalChain { /// Returns the new tip for [`Self::Reorg`] and [`Self::Commit`] variants which commit at least /// 1 new block. pub fn tip(&self) -> &RecoveredBlock { + self.new_blocks().last().expect("non empty blocks").recovered_block() + } + + /// Returns the blocks added to the canonical chain by this update. + pub fn new_blocks(&self) -> &[ExecutedBlock] { match self { - Self::Commit { new } | Self::Reorg { new, .. } => { - new.last().expect("non empty blocks").recovered_block() - } + Self::Commit { new } | Self::Reorg { new, .. } => new, } } + + /// Returns whether the newly canonicalized blocks contain the given hash. + /// + /// This does not include the unchanged canonical prefix before the first new block. + pub fn contains(&self, hash: B256) -> bool { + self.new_blocks().iter().any(|block| block.recovered_block().hash() == hash) + } } #[cfg(test)] diff --git a/crates/engine/tree/src/tree/mod.rs b/crates/engine/tree/src/tree/mod.rs index d45cfcab271..9e16234ec2e 100644 --- a/crates/engine/tree/src/tree/mod.rs +++ b/crates/engine/tree/src/tree/mod.rs @@ -1252,6 +1252,10 @@ where trace!(target: "engine::tree", "fcu head hash is already canonical"); + if !self.is_consistent_forkchoice_state(state, None)? { + return Ok(Some(TreeOutcome::new(OnForkChoiceUpdated::invalid_state()))); + } + // Update the safe and finalized blocks and ensure their values are valid if let Err(outcome) = self.ensure_consistent_forkchoice_state(state) { // safe or finalized hashes are invalid @@ -1320,6 +1324,10 @@ where return Ok(Some(TreeOutcome::new(OnForkChoiceUpdated::too_deep_reorg()))); } + if !self.is_consistent_forkchoice_state(state, None)? { + return Ok(Some(TreeOutcome::new(OnForkChoiceUpdated::invalid_state()))); + } + // We need to effectively unwind the _canonical_ chain to the FCU's head, which is // part of the canonical chain. We need to update the latest block state to reflect // the canonical ancestor. This ensures that state providers and the transaction @@ -1348,6 +1356,10 @@ where // Ensure we can apply a new chain update for the head block if let Some(chain_update) = self.on_new_head(state.head_block_hash)? { + if !self.is_consistent_forkchoice_state(state, Some(&chain_update))? { + return Ok(Some(TreeOutcome::new(OnForkChoiceUpdated::invalid_state()))); + } + let tip = chain_update.tip().clone_sealed_header(); self.on_canonical_chain_update(chain_update); @@ -3360,17 +3372,81 @@ where } /// Attempts to find the header for the given block hash if it is canonical. + /// + /// A persisted header can still be found by hash while its disk reorg is pending, so it is + /// only canonical if it is not above the canonical head and matches the canonical hash at its + /// height. The in-memory canonical hash is preferred over the persisted one. pub fn find_canonical_header( &self, hash: B256, ) -> Result>, ProviderError> { - let mut canonical = self.canonical_in_memory_state.header_by_hash(hash); + if let Some(header) = self.canonical_in_memory_state.header_by_hash(hash) { + return Ok(Some(header)) + } - if canonical.is_none() { - canonical = self.provider.header(hash)?.map(|header| SealedHeader::new(header, hash)); + let Some(header) = self.provider.sealed_header_by_hash(hash)? else { return Ok(None) }; + // Reorged-out headers remain on disk until persistence catches up, so reject old tips above + // the in-memory head and use in-memory hashes to reject old blocks at shared heights. + let number = header.number(); + if number > self.canonical_in_memory_state.get_canonical_block_number() { + return Ok(None) } + let canonical_hash = + if let Some(hash) = self.canonical_in_memory_state.hash_by_number(number) { + Some(hash) + } else { + self.provider.block_hash(number)? + }; - Ok(canonical) + Ok((canonical_hash == Some(hash)).then_some(header)) + } + + /// Checks that nonzero safe and finalized hashes belong to the chain defined by the FCU head. + /// + /// The [Engine API forkchoiceUpdated specification] requires `-38002` when a `VALID` head's + /// safe or finalized hash is outside that chain, and requires all forkchoice state updates to + /// be atomic. In direct FCU processing, this check must therefore run before canonicalizing + /// the head or updating either marker; checking only after canonicalization would leave an + /// invalid reorg applied. + /// + /// `chain_update` describes a proposed commit or reorg that has not yet been applied. Its new + /// blocks and the canonical prefix below its first block form the proposed chain. Without a + /// chain update, the proposed head is already canonical, so only canonical blocks through its + /// height are eligible. Canonical-prefix hashes are resolved via + /// [`Self::find_canonical_header`], which rejects stale persisted headers whose disk reorg + /// cleanup is pending. A zero safe or finalized hash leaves that marker unchanged. + /// Returns `Ok(false)` for an unknown or off-chain hash and propagates provider errors. + /// + /// [Engine API forkchoiceUpdated specification]: https://github.com/ethereum/execution-apis/blob/main/src/engine/paris.md#specification-1 + fn is_consistent_forkchoice_state( + &self, + state: ForkchoiceState, + chain_update: Option<&NewCanonicalChain>, + ) -> ProviderResult { + let canonical_head_number = match chain_update { + Some(chain_update) => { + let new = chain_update.new_blocks(); + // Only the canonical prefix below the new branch remains on the proposed chain. + new.first().expect("non empty chain").block_number() - 1 + } + None => { + let Some(head) = self.find_canonical_header(state.head_block_hash)? else { + return Ok(false) + }; + head.number() + } + }; + + for hash in [state.finalized_block_hash, state.safe_block_hash] { + if hash.is_zero() || chain_update.is_some_and(|update| update.contains(hash)) { + continue + } + let Some(header) = self.find_canonical_header(hash)? else { return Ok(false) }; + if header.number() > canonical_head_number { + return Ok(false) + } + } + Ok(true) } /// Updates the tracked finalized block if we have it. diff --git a/crates/engine/tree/src/tree/tests.rs b/crates/engine/tree/src/tree/tests.rs index 6830500088a..e4b88ebc1aa 100644 --- a/crates/engine/tree/src/tree/tests.rs +++ b/crates/engine/tree/src/tree/tests.rs @@ -30,7 +30,9 @@ use reth_ethereum_primitives::{Block, EthPrimitives}; use reth_evm_ethereum::MockEvmConfig; use reth_payload_builder::PayloadServiceCommand; use reth_primitives_traits::Block as _; -use reth_provider::{test_utils::MockEthProvider, BalStoreHandle, InMemoryBalStore, RawBal}; +use reth_provider::{ + test_utils::MockEthProvider, BalStoreHandle, HeaderProvider, InMemoryBalStore, RawBal, +}; use reth_tasks::spawn_os_thread; use reth_trie_common::ComputedTrieData; use std::{ @@ -3350,3 +3352,96 @@ async fn test_on_backfill_sync_finished_opstack_retriggers_backfill_to_buffered_ async fn test_on_backfill_sync_finished_eth_retriggers_backfill_to_buffered_finalized() { assert_post_backfill_recheck_retriggers_to_buffered_target(EngineApiKind::Ethereum).await; } + +/// A stale persisted hash must not count as an ancestor after an in-memory reorg. +#[test] +fn test_forkchoice_rejects_stale_persisted_prefix_hash() { + let mut test_harness = TestHarness::new(MAINNET.clone()); + let old: Vec<_> = test_harness.block_builder.get_executed_blocks(0..3).collect(); + test_harness = test_harness.with_blocks(old.clone()); + + let new: Vec<_> = test_harness + .block_builder + .create_fork(old[0].recovered_block(), 2) + .into_iter() + .map(|block| { + ExecutedBlock::new( + Arc::new(block), + Arc::new(BlockExecutionOutput::default()), + ComputedTrieData::default(), + ) + }) + .collect(); + test_harness.tree.canonical_in_memory_state.update_chain(NewCanonicalChain::Reorg { + new: vec![new[0].clone()], + old: old[1..].to_vec(), + }); + + let state = ForkchoiceState { + head_block_hash: new[1].recovered_block().hash(), + safe_block_hash: old[1].recovered_block().hash(), + finalized_block_hash: old[0].recovered_block().hash(), + }; + let update = NewCanonicalChain::Commit { new: vec![new[1].clone()] }; + assert!(!test_harness.tree.is_consistent_forkchoice_state(state, Some(&update)).unwrap()); + + let state = ForkchoiceState { safe_block_hash: new[0].recovered_block().hash(), ..state }; + assert!(test_harness.tree.is_consistent_forkchoice_state(state, Some(&update)).unwrap()); +} + +/// Reorgs from a persisted chain to a sibling branch of `sibling_len` blocks without advancing +/// persistence, then asserts that an FCU back to the reorged-out tip makes it canonical again. +async fn assert_fcu_back_to_reorged_out_head_with_pending_disk_reorg(sibling_len: u64) { + reth_tracing::init_test_tracing(); + let mut test_harness = TestHarness::new(MAINNET.clone()); + let old: Vec<_> = test_harness.block_builder.get_executed_blocks(0..4).collect(); + test_harness = test_harness.with_blocks(old.clone()); + let old_tip = old[3].recovered_block().hash(); + + let new: Vec<_> = test_harness + .block_builder + .create_fork(old[0].recovered_block(), sibling_len) + .into_iter() + .map(|block| { + ExecutedBlock::new( + Arc::new(block), + Arc::new(BlockExecutionOutput::default()), + ComputedTrieData::default(), + ) + }) + .collect(); + for block in &new { + test_harness.tree.state.tree_state.insert_executed(block.clone()); + } + let new_tip = new.last().unwrap().recovered_block().hash(); + + let fcu = |head_block_hash| ForkchoiceState { + head_block_hash, + safe_block_hash: B256::ZERO, + finalized_block_hash: B256::ZERO, + }; + + let outcome = test_harness.tree.on_forkchoice_updated(fcu(new_tip), None).unwrap(); + assert_eq!(outcome.outcome.forkchoice_status(), ForkchoiceStatus::Valid); + assert_eq!(test_harness.tree.canonical_in_memory_state.get_canonical_head().hash(), new_tip); + + // Persistence is not advanced, so the reorged-out blocks are still found on disk. + assert!(test_harness.provider.header(old_tip).unwrap().is_some()); + + let outcome = test_harness.tree.on_forkchoice_updated(fcu(old_tip), None).unwrap(); + assert_eq!(outcome.outcome.forkchoice_status(), ForkchoiceStatus::Valid); + assert_eq!(test_harness.tree.state.tree_state.canonical_block_hash(), old_tip); + assert_eq!(test_harness.tree.canonical_in_memory_state.get_canonical_head().hash(), old_tip); +} + +/// A reorged-out head must become canonical again while its disk reorg is still pending. +#[tokio::test] +async fn test_fcu_back_to_reorged_out_head_with_pending_disk_reorg() { + assert_fcu_back_to_reorged_out_head_with_pending_disk_reorg(3).await; +} + +/// Same as above, but the reorged-out head is above the tip of the shorter sibling branch. +#[tokio::test] +async fn test_fcu_back_to_reorged_out_head_above_shorter_branch_with_pending_disk_reorg() { + assert_fcu_back_to_reorged_out_head_with_pending_disk_reorg(1).await; +} diff --git a/crates/ethereum/node/tests/e2e/forkchoice.rs b/crates/ethereum/node/tests/e2e/forkchoice.rs new file mode 100644 index 00000000000..6e0e5806922 --- /dev/null +++ b/crates/ethereum/node/tests/e2e/forkchoice.rs @@ -0,0 +1,288 @@ +//! Tests for canonical chain and atomic forkchoice state updates via the Engine API. + +use crate::utils::eth_payload_attributes; +use alloy_eips::BlockNumberOrTag; +use alloy_primitives::B256; +use alloy_provider::{Provider, ProviderBuilder}; +use alloy_rpc_types_engine::{ForkchoiceState, PayloadStatusEnum}; +use jsonrpsee_core::client::Error; +use reth_chainspec::{ChainSpecBuilder, MAINNET}; +use reth_e2e_test_utils::{trie::wait_for_persisted_block, E2ETestSetupBuilder}; +use reth_node_ethereum::{EthEngineTypes, EthereumNode}; +use reth_provider::{DatabaseProviderFactory, HeaderProvider}; +use reth_rpc_api::{EngineApiClient, TestingBuildBlockRequestV1}; +use reth_rpc_server_types::{RethRpcModule, RpcModuleSelection}; +use std::{sync::Arc, time::Duration}; + +#[tokio::test] +async fn invalid_forkchoice_preserves_canonical_state() -> eyre::Result<()> { + reth_tracing::init_test_tracing(); + + let chain_spec = Arc::new( + ChainSpecBuilder::default() + .chain(MAINNET.chain) + .genesis(serde_json::from_str(include_str!("../assets/genesis.json")).unwrap()) + .cancun_activated() + .build(), + ); + let (mut nodes, _) = + E2ETestSetupBuilder::::new(2, chain_spec, eth_payload_attributes) + .with_connect_nodes(false) + .with_node_config_modifier(|mut config| { + config.rpc.http_api = + Some(RpcModuleSelection::from([RethRpcModule::Eth, RethRpcModule::Testing])); + config + }) + .build() + .await?; + let node = nodes.pop().unwrap(); + let producer = nodes.pop().unwrap(); + let genesis = node.block_hash(0); + let engine = node.auth_server_handle().http_client(); + let producer_engine = producer.auth_server_handle().http_client(); + let rpc = ProviderBuilder::new().connect_http(node.rpc_url()); + + // Build a1 <- a2 <- a3 and b1 <- b2, both rooted at genesis. Only chain A is canonical. + let mut chains = [vec![genesis], vec![genesis]]; + for (branch, length) in [3, 2].into_iter().enumerate() { + for number in 1..=length { + let envelope = producer + .testing_build_block_v1(TestingBuildBlockRequestV1 { + parent_block_hash: *chains[branch].last().unwrap(), + payload_attributes: eth_payload_attributes(number + branch as u64 * 10), + transactions: vec![], + extra_data: None, + }) + .await?; + let payload = envelope.execution_payload; + let hash = payload.payload_inner.payload_inner.block_hash; + for client in [&producer_engine, &engine] { + let status = EngineApiClient::::new_payload_v3( + client, + payload.clone(), + vec![], + B256::ZERO, + ) + .await?; + assert_eq!(status.status, PayloadStatusEnum::Valid); + } + producer.update_forkchoice(genesis, hash).await?; + chains[branch].push(hash); + } + if branch == 0 { + let status = EngineApiClient::::fork_choice_updated_v3( + &engine, + ForkchoiceState { + head_block_hash: chains[0][3], + safe_block_hash: genesis, + finalized_block_hash: genesis, + }, + None, + ) + .await?; + assert_eq!(status.payload_status.status, PayloadStatusEnum::Valid); + } + } + let [a, b] = chains; + + for (head, safe, finalized) in [ + (b[2], a[2], a[1]), + (b[2], a[2], b[1]), + (b[2], b[1], a[1]), + (b[2], B256::repeat_byte(0xff), b[1]), + (a[3], b[1], a[1]), + (a[2], a[3], genesis), + ] { + let state = ForkchoiceState { + head_block_hash: head, + safe_block_hash: safe, + finalized_block_hash: finalized, + }; + let err = EngineApiClient::::fork_choice_updated_v3(&engine, state, None) + .await + .unwrap_err(); + let Error::Call(err) = err else { panic!("Expected an RPC error, got {err:?}") }; + assert_eq!(err.code(), -38002, "{state:?}"); + + for (tag, hash) in [ + (BlockNumberOrTag::Latest, a[3]), + (BlockNumberOrTag::Safe, genesis), + (BlockNumberOrTag::Finalized, genesis), + (BlockNumberOrTag::Number(1), a[1]), + (BlockNumberOrTag::Number(2), a[2]), + (BlockNumberOrTag::Number(3), a[3]), + ] { + assert_eq!( + rpc.get_block_by_number(tag).await?.unwrap().header.hash, + hash, + "{tag:?} changed after rejecting {state:?}" + ); + } + } + + // Safe/finalized hashes on the proposed branch must be accepted before it is canonical. + let status = EngineApiClient::::fork_choice_updated_v3( + &engine, + ForkchoiceState { + head_block_hash: b[2], + safe_block_hash: b[2], + finalized_block_hash: b[1], + }, + None, + ) + .await?; + assert_eq!(status.payload_status.status, PayloadStatusEnum::Valid); + for (tag, hash) in [ + (BlockNumberOrTag::Latest, b[2]), + (BlockNumberOrTag::Safe, b[2]), + (BlockNumberOrTag::Finalized, b[1]), + (BlockNumberOrTag::Number(1), b[1]), + (BlockNumberOrTag::Number(2), b[2]), + ] { + assert_eq!(rpc.get_block_by_number(tag).await?.unwrap().header.hash, hash); + } + assert!(rpc.get_block_by_number(BlockNumberOrTag::Number(3)).await?.is_none()); + + // Invalid payload attributes must not roll back an otherwise valid forkchoice update. + let err = EngineApiClient::::fork_choice_updated_v3( + &engine, + ForkchoiceState::same_hash(b[2]), + Some(eth_payload_attributes(1)), + ) + .await + .unwrap_err(); + let Error::Call(err) = err else { panic!("Expected an RPC error, got {err:?}") }; + assert_eq!(err.code(), -38003); + assert_eq!( + rpc.get_block_by_number(BlockNumberOrTag::Finalized).await?.unwrap().header.hash, + b[2] + ); + + Ok(()) +} + +/// Restoring a persisted head must update canonical state before disk reorg cleanup completes. +#[tokio::test] +async fn fcu_restores_reorged_out_persisted_head() -> eyre::Result<()> { + assert_fcu_restores_reorged_out_persisted_head(3).await +} + +/// A stale persisted head above a shorter sibling branch must also become canonical again. +#[tokio::test] +async fn fcu_restores_reorged_out_persisted_head_above_shorter_branch() -> eyre::Result<()> { + assert_fcu_restores_reorged_out_persisted_head(1).await +} + +/// Holds the database writer lock across both FCUs so disk cleanup cannot win the race. +async fn assert_fcu_restores_reorged_out_persisted_head(sibling_len: u64) -> eyre::Result<()> { + reth_tracing::init_test_tracing(); + + let chain_spec = Arc::new( + ChainSpecBuilder::default() + .chain(MAINNET.chain) + .genesis(serde_json::from_str(include_str!("../assets/genesis.json")).unwrap()) + .cancun_activated() + .build(), + ); + let (mut nodes, _) = + E2ETestSetupBuilder::::new(2, chain_spec, eth_payload_attributes) + .with_connect_nodes(false) + .with_tree_config_modifier(|config| { + config + .with_num_state_masking_blocks(0) + .with_persistence_threshold(0) + .with_memory_block_buffer_target(0) + }) + .with_node_config_modifier(|mut config| { + config.rpc.http_api = + Some(RpcModuleSelection::from([RethRpcModule::Eth, RethRpcModule::Testing])); + config + }) + .build() + .await?; + let node = nodes.pop().unwrap(); + let producer = nodes.pop().unwrap(); + let genesis = node.block_hash(0); + let engine = node.auth_server_handle().http_client(); + let producer_engine = producer.auth_server_handle().http_client(); + let rpc = ProviderBuilder::new().connect_http(node.rpc_url()); + + // Persist A through block 3, then import a sibling branch without canonicalizing it. + let mut chains = [vec![genesis], vec![genesis]]; + for (branch, length) in [3, sibling_len].into_iter().enumerate() { + for number in 1..=length { + let envelope = producer + .testing_build_block_v1(TestingBuildBlockRequestV1 { + parent_block_hash: *chains[branch].last().unwrap(), + payload_attributes: eth_payload_attributes(number + branch as u64 * 10), + transactions: vec![], + extra_data: None, + }) + .await?; + let payload = envelope.execution_payload; + let hash = payload.payload_inner.payload_inner.block_hash; + for client in [&producer_engine, &engine] { + let status = EngineApiClient::::new_payload_v3( + client, + payload.clone(), + vec![], + B256::ZERO, + ) + .await?; + assert_eq!(status.status, PayloadStatusEnum::Valid); + } + producer.update_forkchoice(genesis, hash).await?; + chains[branch].push(hash); + } + if branch == 0 { + node.update_forkchoice(genesis, chains[0][3]).await?; + wait_for_persisted_block(&node.inner.provider, 3, Duration::from_secs(30)).await?; + } + } + let [a, b] = chains; + + // MDBX allows only one writer. Acquire it off the executor and keep it alive while the + // persistence task attempts to remove A, leaving the old headers visible on disk. + let provider = node.inner.provider.clone(); + let disk_reorg_guard = + tokio::task::spawn_blocking(move || provider.database_provider_rw()).await??; + for head in [*b.last().unwrap(), a[3]] { + let status = tokio::time::timeout( + Duration::from_secs(10), + EngineApiClient::::fork_choice_updated_v3( + &engine, + ForkchoiceState { + head_block_hash: head, + safe_block_hash: B256::ZERO, + finalized_block_hash: B256::ZERO, + }, + None, + ), + ) + .await??; + assert_eq!(status.payload_status.status, PayloadStatusEnum::Valid); + assert_eq!( + node.inner.provider.database_provider_ro()?.sealed_header(3)?.unwrap().hash(), + a[3], + "The old tip must remain on disk throughout both FCUs" + ); + assert_eq!( + rpc.get_block_by_number(BlockNumberOrTag::Latest).await?.unwrap().header.hash, + head, + "A VALID FCU must make the requested sibling tip canonical" + ); + } + for (number, hash) in a.into_iter().enumerate() { + assert_eq!( + rpc.get_block_by_number(BlockNumberOrTag::Number(number as u64)) + .await? + .unwrap() + .header + .hash, + hash + ); + } + drop(disk_reorg_guard); + + Ok(()) +} diff --git a/crates/ethereum/node/tests/e2e/main.rs b/crates/ethereum/node/tests/e2e/main.rs index 045998ffedc..7272b4fade8 100644 --- a/crates/ethereum/node/tests/e2e/main.rs +++ b/crates/ethereum/node/tests/e2e/main.rs @@ -5,6 +5,7 @@ mod custom_genesis; mod dev; mod eip6780; mod eth; +mod forkchoice; mod invalid_payload; mod p2p; mod pool; diff --git a/crates/storage/provider/src/providers/blockchain_provider.rs b/crates/storage/provider/src/providers/blockchain_provider.rs index ac11538c2fd..318a374421a 100644 --- a/crates/storage/provider/src/providers/blockchain_provider.rs +++ b/crates/storage/provider/src/providers/blockchain_provider.rs @@ -1080,6 +1080,159 @@ mod tests { sync::Arc, }; + #[test] + fn historical_proofs_complete_masked_trie_rows() -> eyre::Result<()> { + use crate::{StaticFileProviderFactory, StaticFileSegment, StaticFileWriter}; + use reth_storage_api::{StorageSettings, StorageSettingsCache, TrieWriter}; + use reth_trie::{test_utils::TrieTestHarness, MultiProofTargetsV2}; + use revm::state::AccountInfo; + + let address = Address::with_last_byte(1); + let other_address = Address::with_last_byte(2); + let hashed_address = keccak256(address); + let account = Account { balance: U256::from(1), ..Default::default() }; + // Branches 00, 01 and 02 share the cached row at 0. The first two change + // in different blocks; the third keeps proof-v2's branch-collapse path inactive. + let slots: Vec = (0..=2u8) + .flat_map(|prefix| { + (0..u64::MAX) + .map(|slot| B256::from(U256::from(slot))) + .filter(move |slot| keccak256(slot)[0] == prefix) + .take(2) + }) + .collect(); + let mut storage: BTreeMap<_, _> = slots.iter().map(|&slot| (slot, U256::from(1))).collect(); + let mut trie = TrieTestHarness::new( + storage.iter().map(|(slot, value)| (keccak256(slot), *value)).collect(), + ); + let mut blocks = Vec::::new(); + let mut storage_roots = Vec::new(); + for number in 0..=2 { + let mut output = (*ExecutedBlock::::default() + .execution_output) + .clone(); + let (state, storage_updates) = if number == 0 { + ( + HashedPostState::default() + .with_accounts([ + (hashed_address, Some(account)), + (keccak256(other_address), Some(account)), + ]) + .with_storages([( + hashed_address, + HashedStorage::from_iter(trie.storage().iter().map(|(k, v)| (*k, *v))), + )]), + trie.storage_trie_updates().clone(), + ) + } else { + let slot = slots[(number as usize - 1) * 2]; + let value = U256::from(number + 1); + let changes = BTreeMap::from([(keccak256(slot), value)]); + let (_, updates) = trie.get_root_with_updates(&changes); + trie.apply_changeset(changes); + storage.insert(slot, value); + let info = AccountInfo::from_balance(account.balance); + output.state = BundleState::builder(number..=number) + .state_original_account_info(address, info.clone()) + .state_present_account_info(address, info) + .state_storage( + address, + std::iter::once((U256::from_be_bytes(slot.0), (U256::from(1), value))) + .collect(), + ) + .revert_storage( + number, + address, + vec![(U256::from_be_bytes(slot.0), U256::from(1))], + ) + .build(); + ( + HashedPostState::from_hashed_storage( + hashed_address, + HashedStorage::from_iter([(keccak256(slot), value)]), + ), + updates, + ) + }; + let mut updates = TrieUpdates::default(); + updates.storage_tries.insert(hashed_address, storage_updates); + let state_root = reth_trie::test_utils::state_root([ + (address, (account, storage.clone())), + (other_address, (account, BTreeMap::new())), + ]); + storage_roots.push(reth_trie::test_utils::storage_root(storage.clone())); + let block = Block { + header: alloy_consensus::Header { + number, + parent_hash: blocks + .last() + .map(|b| b.recovered_block().hash()) + .unwrap_or_default(), + state_root, + ..Default::default() + }, + ..Default::default() + }; + blocks.push(ExecutedBlock::new( + Arc::new(RecoveredBlock::new_unhashed(block, vec![])), + Arc::new(output), + ComputedTrieData::new( + Arc::new(state.into_sorted()), + Arc::new(updates.into_sorted()), + ), + )); + } + + let factory = create_test_provider_factory(); + factory.set_storage_settings_cache(StorageSettings::v2()); + let writer = factory.provider_rw()?; + writer.insert_block(blocks[0].recovered_block())?; + writer.write_hashed_state(blocks[0].hashed_state_ref())?; + writer.write_trie_updates_sorted(blocks[0].trie_updates_ref())?; + writer.commit()?; + let static_files = factory.static_file_provider(); + static_files.get_writer(0, StaticFileSegment::Receipts)?.increment_block(0)?; + static_files + .get_writer(0, StaticFileSegment::AccountChangeSets)? + .append_account_changeset(vec![], 0)?; + static_files + .get_writer(0, StaticFileSegment::StorageChangeSets)? + .append_storage_changeset(vec![], 0)?; + static_files.commit()?; + let writer = factory.provider_rw()?; + writer.save_blocks(&SaveBlocksInput::new(blocks[1..].to_vec(), 0, 0, 2, 1))?; + writer.commit()?; + factory.overlay_manager().insert_block(blocks[2].clone()); + let provider = BlockchainProvider::new(factory)?; + + for number in [1, 2] { + let state = provider.history_by_block_hash(blocks[number].recovered_block().hash())?; + let root = blocks[number].recovered_block().state_root; + state + .multiproof_v2( + Default::default(), + MultiProofTargetsV2 { + account_targets: vec![keccak256(other_address).into()], + ..Default::default() + }, + )? + .account_proof(other_address, &[])? + .verify(root)?; + assert_eq!(state.state_root(HashedPostState::default())?, root); + assert_eq!( + state.storage_root(address, HashedStorage::default())?, + storage_roots[number] + ); + state + .storage_proof(address, slots[2], HashedStorage::default())? + .verify(storage_roots[number])?; + let proof = state.storage_multiproof(address, &[slots[2]], HashedStorage::default())?; + assert_eq!(proof.root, storage_roots[number]); + proof.storage_proof(slots[2])?.verify(storage_roots[number])?; + } + Ok(()) + } + const TEST_BLOCKS_COUNT: usize = 5; const TEST_TRANSACTIONS_COUNT: u8 = 4; diff --git a/crates/storage/provider/src/providers/state/latest.rs b/crates/storage/provider/src/providers/state/latest.rs index f85b371ea72..788c60e9bd8 100644 --- a/crates/storage/provider/src/providers/state/latest.rs +++ b/crates/storage/provider/src/providers/state/latest.rs @@ -153,7 +153,14 @@ impl StorageRootProvider hashed_storage: HashedStorage, ) -> ProviderResult { reth_trie_db::with_adapter!(self.0, |A| { - >::overlay_root(self.tx(), address, hashed_storage) + let input = TrieInputSorted::from_state( + HashedPostState::from_hashed_storage( + alloy_primitives::keccak256(address), + hashed_storage, + ) + .into_sorted(), + ); + >::overlay_root(self.tx(), address, input) .map_err(|err| ProviderError::Database(err.into())) }) } @@ -182,13 +189,15 @@ impl StorageRootProvider hashed_storage: HashedStorage, ) -> ProviderResult { reth_trie_db::with_adapter!(self.0, |A| { - >::overlay_storage_multiproof( - self.tx(), - address, - slots, - hashed_storage, - ) - .map_err(ProviderError::from) + let input = TrieInputSorted::from_state( + HashedPostState::from_hashed_storage( + alloy_primitives::keccak256(address), + hashed_storage, + ) + .into_sorted(), + ); + >::overlay_storage_multiproof(self.tx(), address, slots, input) + .map_err(ProviderError::from) }) } } diff --git a/crates/storage/provider/src/writer/mod.rs b/crates/storage/provider/src/writer/mod.rs index ef8fb25013b..b5a313c4448 100644 --- a/crates/storage/provider/src/writer/mod.rs +++ b/crates/storage/provider/src/writer/mod.rs @@ -20,6 +20,7 @@ mod tests { use reth_trie::{ test_utils::{state_root, storage_root_prehashed}, HashedPostState, HashedStorage, StateRoot, StorageRoot, StorageRootProgress, + TrieInputSorted, }; use reth_trie_db::{DatabaseStateRoot, DatabaseStorageRoot, LegacyKeyAdapter, PackedKeyAdapter}; use revm::database::{ @@ -1186,18 +1187,25 @@ mod tests { reth_trie_db::DatabaseHashedCursorFactory<&'a TX>, >; let is_v2 = provider_rw.cached_storage_settings().is_v2(); + let input = TrieInputSorted::from_state(HashedPostState::from_hashed_storage( + hashed_address, + updated_storage.clone(), + ).into_sorted()); let storage_root = if is_v2 { TestStorageRoot::<_, _, PackedKeyAdapter>::overlay_root( tx, address, - updated_storage.clone(), + input, ) .unwrap() } else { TestStorageRoot::<_, _, LegacyKeyAdapter>::overlay_root( tx, address, - updated_storage.clone(), + TrieInputSorted::from_state(HashedPostState::from_hashed_storage( + hashed_address, + updated_storage.clone(), + ).into_sorted()), ) .unwrap() }; diff --git a/crates/storage/storage-overlay/src/builder.rs b/crates/storage/storage-overlay/src/builder.rs index d56fc0b4d7f..b78df88c9d3 100644 --- a/crates/storage/storage-overlay/src/builder.rs +++ b/crates/storage/storage-overlay/src/builder.rs @@ -1,4 +1,7 @@ -use crate::{manager::OverlayCacheConfig, OverlayManager}; +use crate::{ + manager::{OverlayCacheConfig, StateTrieOverlayError}, + OverlayManager, +}; use alloy_eips::BlockNumHash; use alloy_primitives::{ map::{AddressMap, AddressSet, B256Map, U256Map}, @@ -16,7 +19,7 @@ use reth_storage_api::{ BlockNumReader, ChangeSetReader, DBProvider, PruneCheckpointReader, StageCheckpointReader, StorageChangeSetReader, StorageSettingsCache, }; -use reth_trie::{updates::TrieUpdatesSorted, HashedPostStateSorted}; +use reth_trie::{updates::TrieUpdatesSorted, HashedPostStateSorted, TrieInputSorted}; use reth_trie_db::DatabaseHashedPostState; use revm::{bytecode::Bytecode, database::BundleState, state::AccountInfo}; use std::{ @@ -29,28 +32,23 @@ use tracing::{debug, debug_span, instrument}; /// Contains the trie and hashed-state data required to initialize an overlay state provider. #[derive(Debug, Clone)] pub struct StateTrieOverlay { - /// Trie updates overlay. - pub trie_updates: Arc, - /// Hashed state overlay. - pub hashed_post_state: Arc, + input: TrieInputSorted, /// Whether construction was skipped because a reused sparse trie covers this range. skipped_for_reused_sparse_trie: bool, } impl StateTrieOverlay { - pub(crate) const fn new( - trie_updates: Arc, - hashed_post_state: Arc, - ) -> Self { - Self { trie_updates, hashed_post_state, skipped_for_reused_sparse_trie: false } + pub(crate) const fn new(input: TrieInputSorted) -> Self { + Self { input, skipped_for_reused_sparse_trie: false } } fn empty() -> Self { - Self { - trie_updates: Arc::new(TrieUpdatesSorted::default()), - hashed_post_state: Arc::new(HashedPostStateSorted::default()), - skipped_for_reused_sparse_trie: true, - } + Self { input: TrieInputSorted::default(), skipped_for_reused_sparse_trie: true } + } + + /// Returns the trie input represented by this overlay. + pub const fn input(&self) -> &TrieInputSorted { + &self.input } pub(crate) const fn skipped_for_reused_sparse_trie(&self) -> bool { @@ -393,11 +391,17 @@ impl OverlayBuilder { } /// Builds the effective state trie overlay for the given provider. + /// + /// Set `trie_changesets` only for consumers that produce [`TrieUpdates`], such as + /// [`StateRootProvider::state_root_with_updates`]. Other consumers, including roots, proofs, + /// multiproofs, and witnesses, should leave it false: complete the cached trie at Finish and + /// invalidate hashed-state revert prefixes instead of querying trie changesets. #[cfg(test)] #[instrument(level = "debug", target = "storage::overlay", skip_all)] fn build_state_trie_overlay( &self, provider: &Provider, + trie_changesets: bool, ) -> ProviderResult where Provider: StageCheckpointReader @@ -409,7 +413,12 @@ impl OverlayBuilder { + StorageSettingsCache, { let (state_trie_tip_block, finish_tip_block) = database_state_frontiers(provider)?; - self.build_state_trie_overlay_at_frontiers(provider, state_trie_tip_block, finish_tip_block) + self.build_state_trie_overlay_at_frontiers( + provider, + state_trie_tip_block, + finish_tip_block, + trie_changesets, + ) } /// Builds the effective state trie overlay using frontiers already read from the provider. @@ -426,6 +435,7 @@ impl OverlayBuilder { provider: &Provider, state_trie_tip_block: BlockNumHash, finish_tip_block: BlockNumHash, + trie_changesets: bool, ) -> ProviderResult where Provider: ChangeSetReader @@ -445,7 +455,7 @@ impl OverlayBuilder { self.anchor_at_parent_with_frontiers(provider, state_trie_tip_block, finish_tip_block)?; // Collect any reverts which are required to bring the DB view back to the anchor hash. - let (trie_updates, hashed_post_state) = match &anchor_for_parent { + let (trie_updates, hashed_post_state, prefix_sets) = match &anchor_for_parent { AnchorForParent::RevertsRequired { anchor, .. } => { let revert_blocks = self.revert_blocks(&anchor_for_parent)?.expect("reverts are required"); @@ -457,7 +467,7 @@ impl OverlayBuilder { "Collecting trie reverts for overlay state provider" ); - let trie_reverts = { + let trie_reverts = if trie_changesets { let _guard = debug_span!(target: "storage::overlay", "retrieving_trie_reverts") .entered(); let start = Instant::now(); @@ -470,6 +480,32 @@ impl OverlayBuilder { )?; retrieve_trie_reverts_duration = start.elapsed(); accumulated_reverts + } else if state_trie_tip_block == finish_tip_block { + retrieve_trie_reverts_duration = Duration::ZERO; + Arc::default() + } else { + // Revert prefixes describe changes since the anchor, not stale hashes in + // masked DB rows. Complete the trie at Finish before applying those prefixes. + let start = Instant::now(); + let finish_state = self + .overlay_manager + .block_state(finish_tip_block.hash) + .ok_or_else(|| { + ProviderError::other(StateTrieOverlayError { + tip_hash: finish_tip_block.hash, + anchor_hash: state_trie_tip_block.hash, + }) + })?; + let (nodes, _) = self + .overlay_manager + .overlay_for_parent( + &finish_state, + state_trie_tip_block.hash, + OverlayCacheConfig::default(), + ) + .map_err(ProviderError::other)?; + retrieve_trie_reverts_duration = start.elapsed(); + nodes }; let mut hashed_state_reverts = { @@ -482,6 +518,12 @@ impl OverlayBuilder { res }; + let prefix_sets = if trie_changesets { + Default::default() + } else { + hashed_state_reverts.construct_prefix_sets() + }; + // Resolve overlays and extend reverts with them. If reverts are empty, use overlays // directly to avoid cloning. let (overlay_trie, overlay_state) = @@ -517,7 +559,7 @@ impl OverlayBuilder { "Reverted to anchor block", ); - (trie_updates, hashed_state_updates) + (trie_updates, hashed_state_updates, prefix_sets) } AnchorForParent::NoReverts { anchor } => { // If no reverts are needed, use the manager overlay directly unless the reused @@ -548,7 +590,7 @@ impl OverlayBuilder { "Built overlay directly from durable frontier" ); - (trie_updates, hashed_post_state) + (trie_updates, hashed_post_state, Default::default()) } }; @@ -561,7 +603,11 @@ impl OverlayBuilder { self.metrics.trie_updates_size.record(trie_updates_total_len as f64); self.metrics.hashed_state_size.record(hashed_state_updates_total_len as f64); - Ok(StateTrieOverlay::new(trie_updates, hashed_post_state)) + Ok(StateTrieOverlay::new(TrieInputSorted::new( + trie_updates, + hashed_post_state, + prefix_sets, + ))) } /// Returns the in-memory execution overlay and the block for historical fallback reads. @@ -892,11 +938,11 @@ mod tests { } fn account_keys(overlay: &StateTrieOverlay) -> Vec { - overlay.hashed_post_state.accounts.iter().map(|(key, _)| *key).collect() + overlay.input().state.accounts.iter().map(|(key, _)| *key).collect() } fn account_node_paths(overlay: &StateTrieOverlay) -> Vec { - overlay.trie_updates.account_nodes_ref().iter().map(|(path, _)| *path).collect() + overlay.input().nodes.account_nodes_ref().iter().map(|(path, _)| *path).collect() } #[test] @@ -1013,7 +1059,7 @@ mod tests { for (parent_index, expected_ids) in [(3, vec![3, 4]), (4, vec![3, 4, 5])] { let overlay = manager .overlay_builder(blocks[parent_index].recovered_block().hash()) - .build_state_trie_overlay(&provider) + .build_state_trie_overlay(&provider, true) .unwrap(); assert_eq!( @@ -1041,11 +1087,11 @@ mod tests { let overlay = manager .overlay_builder(blocks[4].recovered_block().hash()) .with_skip_overlay_for_reused_sparse_trie(blocks[3].recovered_block().hash()) - .build_state_trie_overlay(&provider) + .build_state_trie_overlay(&provider, true) .unwrap(); - assert!(overlay.hashed_post_state.is_empty()); - assert!(overlay.trie_updates.is_empty()); + assert!(overlay.input().state.is_empty()); + assert!(overlay.input().nodes.is_empty()); } #[test] @@ -1056,7 +1102,7 @@ mod tests { let builder = OverlayManager::::default() .overlay_builder(blocks[1].recovered_block().hash()) .with_no_reverts(); - let error = builder.build_state_trie_overlay(&provider).unwrap_err(); + let error = builder.build_state_trie_overlay(&provider, true).unwrap_err(); assert!(error.to_string().contains("reverts are disabled")); } @@ -1077,11 +1123,37 @@ mod tests { Err(ProviderError::BlockHashNotFound(hash)) if hash == parent_hash )); assert!(matches!( - builder.build_state_trie_overlay(&provider), + builder.build_state_trie_overlay(&provider, true), Err(ProviderError::BlockHashNotFound(hash)) if hash == parent_hash )); } + #[test] + fn state_trie_overlay_uses_revert_prefix_sets_without_trie_changesets() { + let (factory, blocks) = setup_frontiers(3, 3); + let provider_rw = factory.provider_rw().unwrap(); + provider_rw + .tx_ref() + .put::( + 3, + AccountBeforeTx { + address: Address::with_last_byte(1), + info: Some(Account::default()), + }, + ) + .unwrap(); + provider_rw.commit().unwrap(); + + let provider = factory.provider().unwrap(); + let overlay = OverlayManager::::default() + .overlay_builder(blocks[1].recovered_block().hash()) + .build_state_trie_overlay(&provider, false) + .unwrap(); + + assert!(overlay.input().nodes.is_empty()); + assert!(!overlay.input().prefix_sets.is_empty()); + } + #[test] fn execution_overlay_marks_historical_fallback() { let (factory, blocks) = setup_frontiers(1, 3); @@ -1276,7 +1348,7 @@ mod tests { let provider = factory.provider().unwrap(); let error = OverlayManager::::default() .overlay_builder(blocks[3].recovered_block().hash()) - .build_state_trie_overlay(&provider) + .build_state_trie_overlay(&provider, true) .unwrap_err(); assert!( @@ -1292,7 +1364,7 @@ mod tests { let parent_hash = blocks[3].recovered_block().hash(); let error = OverlayManager::::default() .overlay_builder(parent_hash) - .build_state_trie_overlay(&provider) + .build_state_trie_overlay(&provider, true) .unwrap_err(); assert!(error.to_string().contains("is after partial state trie frontier")); diff --git a/crates/storage/storage-overlay/src/changeset_cache.rs b/crates/storage/storage-overlay/src/changeset_cache.rs index c2e070fd4b1..69191d65ae9 100644 --- a/crates/storage/storage-overlay/src/changeset_cache.rs +++ b/crates/storage/storage-overlay/src/changeset_cache.rs @@ -403,7 +403,7 @@ impl ChangesetCache { let overlay = overlay_manager .overlay_builder(finish.hash) .with_no_reverts() - .build_state_trie_overlay_at_frontiers(provider, partial_state_trie, finish)?; + .build_state_trie_overlay_at_frontiers(provider, partial_state_trie, finish, true)?; let state_trie_provider = OverlayStateProvider::<&P, N>::new_with_state_trie( provider, overlay, @@ -644,7 +644,7 @@ mod tests { } fn empty_overlay() -> StateTrieOverlay { - StateTrieOverlay::new(Arc::default(), Arc::default()) + StateTrieOverlay::new(TrieInputSorted::default()) } fn insert_test_changesets( diff --git a/crates/storage/storage-overlay/src/manager.rs b/crates/storage/storage-overlay/src/manager.rs index 0e942dacdf7..8eb63374718 100644 --- a/crates/storage/storage-overlay/src/manager.rs +++ b/crates/storage/storage-overlay/src/manager.rs @@ -99,7 +99,7 @@ impl OverlayManager { OverlayBuilder::new(parent_hash, self.block_state(parent_hash), self.clone()) } - fn block_state(&self, parent_hash: B256) -> Option> { + pub(crate) fn block_state(&self, parent_hash: B256) -> Option> { let mut blocks = self.parent_chain(parent_hash).collect::>(); blocks.pop().map(|oldest| { blocks.into_iter().rev().fold(BlockState::new(oldest), |parent, block| { @@ -685,9 +685,9 @@ impl Default for OverlayCacheConfig { #[derive(Debug)] pub(crate) struct StateTrieOverlayError { /// Requested in-memory tip hash. - tip_hash: B256, + pub(crate) tip_hash: B256, /// Requested anchor hash. - anchor_hash: B256, + pub(crate) anchor_hash: B256, } impl fmt::Display for StateTrieOverlayError { diff --git a/crates/storage/storage-overlay/src/provider.rs b/crates/storage/storage-overlay/src/provider.rs index 578e4453560..a856f956b92 100644 --- a/crates/storage/storage-overlay/src/provider.rs +++ b/crates/storage/storage-overlay/src/provider.rs @@ -52,7 +52,7 @@ pub struct OverlayStateProviderFactory { factory: F, /// Overlay builder containing the configuration and overlay calculation logic. overlay_builder: OverlayBuilder, - /// A cache mapping `(state_trie_tip, finish_tip)` to [`StateTrieOverlay`]. + /// A cache mapping `(state_trie_tip, finish_tip, trie_changesets)` to [`StateTrieOverlay`]. /// /// Under partial persistence the overlay depends on both durable frontiers, so both hashes are /// part of the cache key. @@ -129,6 +129,7 @@ pub struct OverlayStateProvider { state_trie_overlay_cache: StateTrieOverlayCache, metrics: OverlayStateProviderFactoryMetrics, state_trie_overlay: OnceCell, + state_trie_overlay_with_trie_changesets: OnceCell, execution_overlay: OnceCell, is_v2: bool, } @@ -162,6 +163,7 @@ impl OverlayStateProvider, state_trie_overlay_cache, metrics, state_trie_overlay: OnceCell::new(), + state_trie_overlay_with_trie_changesets: OnceCell::new(), execution_overlay: OnceCell::new(), is_v2, } @@ -179,6 +181,7 @@ impl OverlayStateProvider, state_trie_overlay_cache: Default::default(), metrics: Default::default(), state_trie_overlay: OnceCell::new(), + state_trie_overlay_with_trie_changesets: OnceCell::new(), execution_overlay: OnceCell::from(CachedExecutionOverlay { overlay: execution_overlay, historical_fallback: None, @@ -201,6 +204,7 @@ impl<'a, Provider, N: NodePrimitives> OverlayStateProvider<&'a Provider, N> { state_trie_overlay_cache: Default::default(), metrics: Default::default(), state_trie_overlay: OnceCell::new(), + state_trie_overlay_with_trie_changesets: OnceCell::new(), execution_overlay: OnceCell::new(), is_v2, } @@ -216,7 +220,8 @@ impl<'a, Provider, N: NodePrimitives> OverlayStateProvider<&'a Provider, N> { overlay_builder: None, state_trie_overlay_cache: Default::default(), metrics: Default::default(), - state_trie_overlay: OnceCell::from(state_trie_overlay), + state_trie_overlay: OnceCell::from(state_trie_overlay.clone()), + state_trie_overlay_with_trie_changesets: OnceCell::from(state_trie_overlay), execution_overlay: OnceCell::new(), is_v2, } @@ -232,7 +237,7 @@ where &self.provider } - fn state_trie_overlay(&self) -> ProviderResult<&StateTrieOverlay> + fn state_trie_overlay(&self, trie_changesets: bool) -> ProviderResult<&StateTrieOverlay> where Provider::Target: StageCheckpointReader + PruneCheckpointReader @@ -242,15 +247,17 @@ where + BlockNumReader + StorageSettingsCache, { - if let Some(overlay) = self.state_trie_overlay.get() { + let state_trie_overlay = self.state_trie_overlay_mut(trie_changesets); + if let Some(overlay) = state_trie_overlay.get() { return Ok(overlay) } let (state_trie_tip_block, finish_tip_block) = database_state_frontiers(self.provider())?; - let overlay = match self - .state_trie_overlay_cache - .entry((state_trie_tip_block.hash, finish_tip_block.hash)) - { + let overlay = match self.state_trie_overlay_cache.entry(( + state_trie_tip_block.hash, + finish_tip_block.hash, + trie_changesets, + )) { dashmap::Entry::Occupied(entry) => entry.get().clone(), dashmap::Entry::Vacant(entry) => { self.metrics.state_trie_overlay_cache_misses.increment(1); @@ -262,6 +269,7 @@ where self.provider(), state_trie_tip_block, finish_tip_block, + trie_changesets, )?; if !overlay.skipped_for_reused_sparse_trie() { entry.insert(overlay.clone()); @@ -269,11 +277,23 @@ where overlay } }; - let _ = self.state_trie_overlay.set(overlay); - Ok(self.state_trie_overlay.get().expect("state trie overlay was just initialized")) + let _ = state_trie_overlay.set(overlay); + Ok(state_trie_overlay.get().expect("state trie overlay was just initialized")) + } + + const fn state_trie_overlay_mut(&self, trie_changesets: bool) -> &OnceCell { + if trie_changesets { + &self.state_trie_overlay_with_trie_changesets + } else { + &self.state_trie_overlay + } } - fn build_overlay(&self, input: TrieInputSorted) -> ProviderResult + fn build_overlay( + &self, + input: TrieInputSorted, + trie_changesets: bool, + ) -> ProviderResult where Provider::Target: StageCheckpointReader + PruneCheckpointReader @@ -283,13 +303,14 @@ where + BlockNumReader + StorageSettingsCache, { - let overlay = self.state_trie_overlay()?; + let overlay = self.state_trie_overlay(trie_changesets)?; if overlay.skipped_for_reused_sparse_trie() { return Err(ProviderError::UnsupportedProvider) } - let TrieInputSorted { nodes: input_nodes, state: input_state, prefix_sets } = input; - let mut nodes = Arc::clone(&overlay.trie_updates); - let mut state = Arc::clone(&overlay.hashed_post_state); + let TrieInputSorted { nodes: input_nodes, state: input_state, mut prefix_sets } = input; + let overlay_input = overlay.input(); + let mut nodes = Arc::clone(&overlay_input.nodes); + let mut state = Arc::clone(&overlay_input.state); if !input_nodes.is_empty() { Arc::make_mut(&mut nodes).extend_ref_and_sort(&input_nodes); @@ -298,6 +319,7 @@ where Arc::make_mut(&mut state).extend_ref_and_sort(&input_state); } + prefix_sets.extend_ref(&overlay_input.prefix_sets); Ok(TrieInputSorted::new(nodes, state, prefix_sets)) } @@ -511,16 +533,15 @@ where { fn state_root(&self, hashed_state: HashedPostState) -> ProviderResult { reth_trie_db::with_adapter!(self.provider(), |A| { - let input = self.build_overlay(TrieInputSorted::from_unsorted( - TrieInput::from_state(hashed_state), - ))?; + let input = + self.build_overlay(TrieInputSorted::from_state(hashed_state.into_sorted()), true)?; Ok(>::overlay_root_from_nodes(self.provider().tx(), input)?) }) } fn state_root_from_nodes(&self, input: TrieInput) -> ProviderResult { reth_trie_db::with_adapter!(self.provider(), |A| { - let input = self.build_overlay(TrieInputSorted::from_unsorted(input))?; + let input = self.build_overlay(TrieInputSorted::from_unsorted(input), true)?; Ok( as DatabaseStateRoot<_>>::overlay_root_from_nodes( self.provider().tx(), input, @@ -533,9 +554,8 @@ where hashed_state: HashedPostState, ) -> ProviderResult<(B256, TrieUpdates)> { reth_trie_db::with_adapter!(self.provider(), |A| { - let input = self.build_overlay(TrieInputSorted::from_unsorted( - TrieInput::from_state(hashed_state), - ))?; + let input = + self.build_overlay(TrieInputSorted::from_state(hashed_state.into_sorted()), true)?; Ok(>::overlay_root_from_nodes_with_updates( self.provider().tx(), input, @@ -548,7 +568,7 @@ where input: TrieInput, ) -> ProviderResult<(B256, TrieUpdates)> { reth_trie_db::with_adapter!(self.provider(), |A| { - let input = self.build_overlay(TrieInputSorted::from_unsorted(input))?; + let input = self.build_overlay(TrieInputSorted::from_unsorted(input), true)?; Ok( as DatabaseStateRoot<_>>::overlay_root_from_nodes_with_updates( self.provider().tx(), @@ -576,20 +596,15 @@ where hashed_storage: HashedStorage, ) -> ProviderResult { reth_trie_db::with_adapter!(self.provider(), |A| { - let input = self.build_overlay(TrieInputSorted::from_unsorted( - TrieInput::from_state(HashedPostState::from_hashed_storage( - alloy_primitives::keccak256(address), - hashed_storage, - )), - ))?; - let hashed_storage = input - .state - .account_storages() - .get(&alloy_primitives::keccak256(address)) - .cloned() - .unwrap_or_default() - .into(); - >::overlay_root(self.provider().tx(), address, hashed_storage) + let hashed_address = alloy_primitives::keccak256(address); + let input = self.build_overlay( + TrieInputSorted::from_state( + HashedPostState::from_hashed_storage(hashed_address, hashed_storage) + .into_sorted(), + ), + true, + )?; + >::overlay_root(self.provider().tx(), address, input) .map_err(|err| ProviderError::Database(err.into())) }) } @@ -600,28 +615,9 @@ where slot: B256, hashed_storage: HashedStorage, ) -> ProviderResult { - reth_trie_db::with_adapter!(self.provider(), |A| { - let input = self.build_overlay(TrieInputSorted::from_unsorted( - TrieInput::from_state(HashedPostState::from_hashed_storage( - alloy_primitives::keccak256(address), - hashed_storage, - )), - ))?; - let hashed_storage = input - .state - .account_storages() - .get(&alloy_primitives::keccak256(address)) - .cloned() - .unwrap_or_default() - .into(); - >::overlay_storage_proof( - self.provider().tx(), - address, - slot, - hashed_storage, - ) + self.storage_multiproof(address, &[slot], hashed_storage)? + .storage_proof(slot) .map_err(ProviderError::from) - }) } fn storage_multiproof( @@ -631,24 +627,19 @@ where hashed_storage: HashedStorage, ) -> ProviderResult { reth_trie_db::with_adapter!(self.provider(), |A| { - let input = self.build_overlay(TrieInputSorted::from_unsorted( - TrieInput::from_state(HashedPostState::from_hashed_storage( - alloy_primitives::keccak256(address), - hashed_storage, - )), - ))?; - let hashed_storage = input - .state - .account_storages() - .get(&alloy_primitives::keccak256(address)) - .cloned() - .unwrap_or_default() - .into(); + let hashed_address = alloy_primitives::keccak256(address); + let input = self.build_overlay( + TrieInputSorted::from_state( + HashedPostState::from_hashed_storage(hashed_address, hashed_storage) + .into_sorted(), + ), + true, + )?; >::overlay_storage_multiproof( self.provider().tx(), address, slots, - hashed_storage, + input, ) .map_err(ProviderError::from) }) @@ -674,7 +665,7 @@ where ) -> ProviderResult { reth_trie_db::with_adapter!(self.provider(), |A| { let TrieInputSorted { nodes, state, prefix_sets } = - self.build_overlay(TrieInputSorted::from_unsorted(input))?; + self.build_overlay(TrieInputSorted::from_unsorted(input), true)?; let input = TrieInput::new( Arc::unwrap_or_clone(nodes).into(), Arc::unwrap_or_clone(state).into(), @@ -692,7 +683,7 @@ where ) -> ProviderResult { reth_trie_db::with_adapter!(self.provider(), |A| { let TrieInputSorted { nodes, state, prefix_sets } = - self.build_overlay(TrieInputSorted::from_unsorted(input))?; + self.build_overlay(TrieInputSorted::from_unsorted(input), true)?; let input = TrieInput::new( Arc::unwrap_or_clone(nodes).into(), Arc::unwrap_or_clone(state).into(), @@ -710,7 +701,7 @@ where ) -> ProviderResult { reth_trie_db::with_adapter!(self.provider(), |A| { let TrieInputSorted { nodes, state, prefix_sets } = - self.build_overlay(TrieInputSorted::from_unsorted(input))?; + self.build_overlay(TrieInputSorted::from_unsorted(input), true)?; let input = TrieInput::new( Arc::unwrap_or_clone(nodes).into(), Arc::unwrap_or_clone(state).into(), @@ -729,7 +720,7 @@ where ) -> ProviderResult> { reth_trie_db::with_adapter!(self.provider(), |A| { let TrieInputSorted { nodes, state, prefix_sets } = - self.build_overlay(TrieInputSorted::from_unsorted(input))?; + self.build_overlay(TrieInputSorted::from_unsorted(input), true)?; let witness = TrieWitness::new( InMemoryTrieCursorFactory::new( DatabaseTrieCursorFactory::<_, A>::new(self.provider().tx()), @@ -778,7 +769,7 @@ where return Ok(hashed_state) } - let overlay_state = self.build_overlay(TrieInputSorted::default())?.state; + let overlay_state = self.build_overlay(TrieInputSorted::default(), true)?.state; zero_destroyed_account_storage( &HashedPostStateCursorFactory::new( DatabaseHashedCursorFactory::new(self.provider().tx()), @@ -893,7 +884,7 @@ where Self: 'a; fn account_trie_cursor(&self) -> Result, DatabaseError> { - let overlay = self.state_trie_overlay().map_err(into_database_error)?; + let overlay = self.state_trie_overlay(true).map_err(into_database_error)?; let cursor: Box = if self.is_v2 { Box::new(DatabaseAccountTrieCursor::<_, PackedKeyAdapter>::new( self.provider().tx().cursor_read::()?, @@ -903,14 +894,14 @@ where self.provider().tx().cursor_read::()?, )) }; - Ok(InMemoryTrieCursor::new_account(cursor, &overlay.trie_updates)) + Ok(InMemoryTrieCursor::new_account(cursor, &overlay.input().nodes)) } fn storage_trie_cursor( &self, hashed_address: B256, ) -> Result, DatabaseError> { - let overlay = self.state_trie_overlay().map_err(into_database_error)?; + let overlay = self.state_trie_overlay(true).map_err(into_database_error)?; let cursor: Box = if self.is_v2 { Box::new(DatabaseStorageTrieCursor::<_, PackedKeyAdapter>::new( self.provider().tx().cursor_dup_read::()?, @@ -922,7 +913,7 @@ where hashed_address, )) }; - Ok(InMemoryTrieCursor::new_storage(cursor, &overlay.trie_updates, hashed_address)) + Ok(InMemoryTrieCursor::new_storage(cursor, &overlay.input().nodes, hashed_address)) } } @@ -954,10 +945,10 @@ where Self: 'a; fn hashed_account_cursor(&self) -> Result, DatabaseError> { - let overlay = self.state_trie_overlay().map_err(into_database_error)?; + let overlay = self.state_trie_overlay(true).map_err(into_database_error)?; HashedPostStateCursorFactory::new( DatabaseHashedCursorFactory::new(self.provider().tx()), - &overlay.hashed_post_state, + &overlay.input().state, ) .hashed_account_cursor() } @@ -966,10 +957,10 @@ where &self, hashed_address: B256, ) -> Result, DatabaseError> { - let overlay = self.state_trie_overlay().map_err(into_database_error)?; + let overlay = self.state_trie_overlay(true).map_err(into_database_error)?; HashedPostStateCursorFactory::new( DatabaseHashedCursorFactory::new(self.provider().tx()), - &overlay.hashed_post_state, + &overlay.input().state, ) .hashed_storage_cursor(hashed_address) } @@ -987,7 +978,7 @@ pub(crate) struct OverlayStateProviderFactoryMetrics { state_trie_overlay_cache_misses: Counter, } -type StateTrieOverlayCache = Arc>; +type StateTrieOverlayCache = Arc>; #[derive(Clone, Debug)] struct CachedExecutionOverlay { @@ -1122,11 +1113,11 @@ mod tests { } fn account_keys(overlay: &StateTrieOverlay) -> Vec { - overlay.hashed_post_state.accounts.iter().map(|(key, _)| *key).collect() + overlay.input().state.accounts.iter().map(|(key, _)| *key).collect() } fn account_node_paths(overlay: &StateTrieOverlay) -> Vec { - overlay.trie_updates.account_nodes_ref().iter().map(|(path, _)| *path).collect() + overlay.input().nodes.account_nodes_ref().iter().map(|(path, _)| *path).collect() } #[test] @@ -1142,7 +1133,7 @@ mod tests { ); let provider = state_provider_factory.database_provider_ro().unwrap(); - let first = provider.state_trie_overlay().unwrap().clone(); + let first = provider.state_trie_overlay(false).unwrap().clone(); assert_eq!(account_keys(&first), vec![B256::with_last_byte(3), B256::with_last_byte(4)]); drop(provider); @@ -1158,7 +1149,7 @@ mod tests { provider_rw.commit().unwrap(); let provider = state_provider_factory.database_provider_ro().unwrap(); - let second = provider.state_trie_overlay().unwrap().clone(); + let second = provider.state_trie_overlay(false).unwrap().clone(); assert_eq!(account_keys(&second), vec![B256::with_last_byte(4)]); assert_eq!(account_node_paths(&second), vec![Nibbles::from_nibbles([4])]); assert_eq!(state_provider_factory.state_trie_overlay_cache.len(), 2); @@ -1191,6 +1182,39 @@ mod tests { assert_eq!(state_provider_factory.state_trie_overlay_cache.len(), 1); } + #[test] + fn state_trie_overlay_cache_is_keyed_by_trie_changesets() { + let (factory, blocks) = setup_frontiers(1, 3); + let manager = OverlayManager::default(); + for block in &blocks[2..=3] { + manager.insert_block(block.clone()); + } + let state_provider_factory = OverlayStateProviderFactory::new( + factory, + manager.overlay_builder(blocks[3].recovered_block().hash()), + ); + let provider = state_provider_factory.database_provider_ro().unwrap(); + + provider.state_trie_overlay(false).unwrap(); + provider.state_trie_overlay(true).unwrap(); + + assert_eq!(state_provider_factory.state_trie_overlay_cache.len(), 2); + } + + #[test] + fn supplied_state_trie_overlay_is_available_in_both_modes() { + let (factory, _) = setup_frontiers(1, 1); + let provider = factory.provider().unwrap(); + let provider = OverlayStateProvider::<&_, EthPrimitives>::new_with_state_trie( + &provider, + StateTrieOverlay::new(TrieInputSorted::default()), + false, + ); + + assert!(provider.state_trie_overlay(false).is_ok()); + assert!(provider.state_trie_overlay(true).is_ok()); + } + #[test] fn lazy_overlays_survive_manager_block_removal() { let (factory, blocks) = setup_frontiers(1, 1); @@ -1212,7 +1236,7 @@ mod tests { [blocks[2].recovered_block().num_hash(), blocks[3].recovered_block().num_hash()] ); assert_eq!( - account_keys(provider.state_trie_overlay().unwrap()), + account_keys(provider.state_trie_overlay(false).unwrap()), vec![B256::with_last_byte(3), B256::with_last_byte(4)] ); } @@ -1230,7 +1254,7 @@ mod tests { ); let provider = state_provider_factory.database_provider_ro().unwrap(); - assert!(provider.state_trie_overlay().unwrap().skipped_for_reused_sparse_trie()); + assert!(provider.state_trie_overlay(false).unwrap().skipped_for_reused_sparse_trie()); assert!(state_provider_factory.state_trie_overlay_cache.is_empty()); assert!(matches!( provider.state_root(HashedPostState::default()), @@ -1337,4 +1361,184 @@ mod tests { assert_eq!(provider.basic_account(&address).unwrap(), Some(account)); assert_eq!(provider.storage(address, storage_key).unwrap(), Some(storage)); } + + /// Hashed slot with the given first two bytes, so that the storage trie has stored branch + /// nodes at depth one that cache the hashes of their children. + fn hashed_slot(first: u8, second: u8) -> B256 { + let mut slot = alloy_primitives::keccak256([first, second]); + slot.0[0] = first; + slot.0[1] = second; + slot + } + + /// Writes hashed state and trie updates like `save_blocks` does under partial persistence. + fn write_state_trie( + provider: &(impl reth_storage_api::StateWriter + reth_storage_api::TrieWriter), + batch: &[ExecutedBlock], + mask: &[ExecutedBlock], + ) { + provider + .write_hashed_state(&HashedPostStateSorted::disjointed_merge_batch( + &ExecutedBlock::hashed_state_refs(batch), + &ExecutedBlock::hashed_state_refs(mask), + )) + .unwrap(); + provider + .write_trie_updates_sorted(&TrieUpdatesSorted::disjointed_merge_batch( + &ExecutedBlock::trie_updates_refs(batch), + &ExecutedBlock::trie_updates_refs(mask), + )) + .unwrap(); + } + + /// Storage roots over a partially persisted state trie must use the overlay trie nodes: the + /// database trie tables omit nodes overwritten by the masking suffix, so their cached child + /// hashes can be older than the persisted hashed state. + #[test] + fn storage_root_over_masked_state_trie() { + for settings in [reth_provider::StorageSettings::v1(), reth_provider::StorageSettings::v2()] + { + let address = Address::with_last_byte(0x16); + let hashed_address = alloy_primitives::keccak256(address); + + let base = (0..=u8::MAX) + .flat_map(|first| { + [0x00, 0x80].map(|second| (hashed_slot(first, second), U256::from(1))) + }) + .collect::>(); + let changes: [Vec<(B256, U256)>; 8] = [ + vec![], + base, + vec![ + (hashed_slot(0x10, 0x00), U256::from(2)), + (hashed_slot(0x11, 0x42), U256::from(2)), + (hashed_slot(0x20, 0x00), U256::ZERO), + ], + vec![(hashed_slot(0x30, 0x00), U256::from(3))], + vec![(hashed_slot(0x40, 0x80), U256::from(4))], + vec![ + (hashed_slot(0x30, 0x00), U256::from(5)), + (hashed_slot(0x31, 0x00), U256::from(5)), + (hashed_slot(0x50, 0x00), U256::from(5)), + (hashed_slot(0x60, 0x80), U256::ZERO), + ], + vec![ + (hashed_slot(0x1f, 0x80), U256::ZERO), + (hashed_slot(0x50, 0x00), U256::from(6)), + (hashed_slot(0x70, 0x00), U256::from(6)), + ], + vec![ + (hashed_slot(0x50, 0x00), U256::from(7)), + (hashed_slot(0x80, 0x00), U256::ZERO), + ], + ]; + let block_updates = [ + (hashed_slot(0x90, 0x42), U256::from(1)), + (hashed_slot(0xa0, 0x00), U256::from(8)), + (hashed_slot(0xb0, 0x80), U256::ZERO), + ]; + + // Like the engine's, each block's storage trie updates only contain modified nodes. + let reference = create_test_provider_factory(); + reference.set_storage_settings_cache(settings); + let mut storage_nodes = std::collections::BTreeMap::new(); + let blocks = TestBlockBuilder::eth() + .get_executed_blocks(0..changes.len() as u64) + .zip(&changes) + .map(|(block, changes)| { + let mut hashed_state = HashedPostState::default().with_storages([( + hashed_address, + HashedStorage::from_iter(changes.iter().copied()), + )]); + if block.recovered_block().number == 1 { + hashed_state = hashed_state + .with_accounts([(hashed_address, Some(Account::default()))]); + } + let provider = reference.provider().unwrap(); + let (_, trie_updates) = reth_provider::LatestStateProviderRef::new(&provider) + .state_root_with_updates(hashed_state.clone()) + .unwrap(); + drop(provider); + let hashed_state = hashed_state.into_sorted(); + let trie_updates = trie_updates.into_sorted(); + let provider_rw = reference.provider_rw().unwrap(); + reth_storage_api::StateWriter::write_hashed_state(&*provider_rw, &hashed_state) + .unwrap(); + reth_storage_api::TrieWriter::write_trie_updates_sorted( + &*provider_rw, + &trie_updates, + ) + .unwrap(); + provider_rw.commit().unwrap(); + + let modified_storage_nodes = trie_updates + .storage_tries_ref() + .get(&hashed_address) + .map(|storage_trie| storage_trie.storage_nodes_ref()) + .unwrap_or_default() + .iter() + .filter(|(path, node)| match node { + Some(node) => { + storage_nodes.insert(*path, node.clone()).as_ref() != Some(node) + } + None => storage_nodes.remove(path).is_some(), + }) + .cloned() + .collect(); + let trie_updates = TrieUpdatesSorted::new( + trie_updates.account_nodes_ref().to_vec(), + alloy_primitives::map::B256Map::from_iter([( + hashed_address, + reth_trie::updates::StorageTrieUpdatesSorted { + storage_nodes: modified_storage_nodes, + }, + )]), + ); + ExecutedBlock::new( + Arc::clone(&block.recovered_block), + Arc::clone(&block.execution_output), + ComputedTrieData::new(Arc::new(hashed_state), Arc::new(trie_updates)), + ) + }) + .collect::>(); + + let factory = create_test_provider_factory(); + factory.set_storage_settings_cache(settings); + let provider_rw = factory.provider_rw().unwrap(); + for block in &blocks[..=6] { + provider_rw.insert_block(block.recovered_block()).unwrap(); + } + write_state_trie(&*provider_rw, &blocks[1..=1], &[]); + write_state_trie(&*provider_rw, &blocks[2..=4], &blocks[5..=6]); + provider_rw + .save_stage_checkpoint( + StageId::Finish, + StageCheckpoint::new(6).with_finish_stage_checkpoint(FinishCheckpoint { + partial_state_trie: Some(4), + }), + ) + .unwrap(); + provider_rw.commit().unwrap(); + + let manager = OverlayManager::default(); + for block in &blocks[5..=7] { + manager.insert_block(block.clone()); + } + let state_provider_factory = OverlayStateProviderFactory::new( + factory, + manager.overlay_builder(blocks[7].recovered_block().hash()), + ); + let provider = state_provider_factory.database_provider_ro().unwrap(); + + let mut expected = std::collections::BTreeMap::new(); + for (slot, value) in changes.iter().flatten().chain(&block_updates) { + expected.insert(*slot, *value); + } + expected.retain(|_, value| !value.is_zero()); + + let storage_root = + provider.storage_root(address, HashedStorage::from_iter(block_updates)).unwrap(); + assert_eq!(storage_root, reth_trie::test_utils::storage_root_prehashed(expected)); + } + } } diff --git a/crates/trie/common/src/input.rs b/crates/trie/common/src/input.rs index 3d3bc2349d3..d9f8f41f46b 100644 --- a/crates/trie/common/src/input.rs +++ b/crates/trie/common/src/input.rs @@ -160,6 +160,13 @@ impl TrieInputSorted { Self { nodes, state, prefix_sets } } + /// Create new sorted trie input from sorted in-memory state. The prefix sets will be + /// constructed and set automatically. + pub fn from_state(state: HashedPostStateSorted) -> Self { + let prefix_sets = state.construct_prefix_sets(); + Self { nodes: Default::default(), state: Arc::new(state), prefix_sets } + } + /// Create from unsorted [`TrieInput`] by sorting. pub fn from_unsorted(input: TrieInput) -> Self { Self { diff --git a/crates/trie/db/src/proof.rs b/crates/trie/db/src/proof.rs index f362692963d..934c3fecd4e 100644 --- a/crates/trie/db/src/proof.rs +++ b/crates/trie/db/src/proof.rs @@ -7,7 +7,7 @@ use reth_trie::{ proof::{Proof, StorageProof}, trie_cursor::InMemoryTrieCursorFactory, AccountProof, DecodedMultiProofV2, HashedPostStateSorted, HashedStorage, MultiProof, - MultiProofTargets, MultiProofTargetsV2, StorageMultiProof, TrieInput, + MultiProofTargets, MultiProofTargetsV2, StorageMultiProof, TrieInput, TrieInputSorted, }; /// Extends [`Proof`] with operations specific for working with a database transaction. @@ -114,7 +114,7 @@ pub trait DatabaseStorageProof<'a, TX> { tx: &'a TX, address: Address, slots: &[B256], - storage: HashedStorage, + input: TrieInputSorted, ) -> Result; } @@ -158,21 +158,21 @@ impl<'a, TX: DbTx, A: TrieTableAdapter> DatabaseStorageProof<'a, TX> tx: &'a TX, address: Address, slots: &[B256], - storage: HashedStorage, + mut input: TrieInputSorted, ) -> Result { let hashed_address = keccak256(address); let targets = slots.iter().map(keccak256).collect(); - let prefix_set = storage.construct_prefix_set(); - let state_sorted = HashedPostStateSorted::new( - Default::default(), - HashMap::from_iter([(hashed_address, storage.into_sorted())]), - ); StorageProof::new( - DatabaseTrieCursorFactory::<_, A>::new(tx), - HashedPostStateCursorFactory::new(DatabaseHashedCursorFactory::new(tx), &state_sorted), + InMemoryTrieCursorFactory::new( + DatabaseTrieCursorFactory::<_, A>::new(tx), + &input.nodes, + ), + HashedPostStateCursorFactory::new(DatabaseHashedCursorFactory::new(tx), &input.state), address, ) - .with_prefix_set_mut(prefix_set) + .with_prefix_set_mut( + input.prefix_sets.storage_prefix_sets.remove(&hashed_address).unwrap_or_default(), + ) .storage_multiproof(targets) } } diff --git a/crates/trie/db/src/storage.rs b/crates/trie/db/src/storage.rs index 884d6f15565..e634723f1b2 100644 --- a/crates/trie/db/src/storage.rs +++ b/crates/trie/db/src/storage.rs @@ -5,7 +5,8 @@ use reth_execution_errors::StorageRootError; use reth_storage_api::{BlockNumReader, StorageChangeSetReader}; use reth_storage_errors::provider::ProviderResult; use reth_trie::{ - hashed_cursor::HashedPostStateCursorFactory, HashedPostState, HashedStorage, StorageRoot, + hashed_cursor::HashedPostStateCursorFactory, trie_cursor::InMemoryTrieCursorFactory, + HashedStorage, StorageRoot, TrieInputSorted, }; #[cfg(feature = "metrics")] @@ -19,11 +20,11 @@ pub trait DatabaseStorageRoot<'a, TX> { /// Create a new storage root calculator from database transaction and hashed address. fn from_tx_hashed(tx: &'a TX, hashed_address: B256) -> Self; - /// Calculates the storage root for this [`HashedStorage`] and returns it. + /// Calculates the storage root with the given trie input. fn overlay_root( tx: &'a TX, address: Address, - hashed_storage: HashedStorage, + input: TrieInputSorted, ) -> Result; } @@ -85,16 +86,22 @@ impl<'a, TX: DbTx, A: TrieTableAdapter> DatabaseStorageRoot<'a, TX> fn overlay_root( tx: &'a TX, address: Address, - hashed_storage: HashedStorage, + mut input: TrieInputSorted, ) -> Result { - let prefix_set = hashed_storage.construct_prefix_set().freeze(); - let state_sorted = - HashedPostState::from_hashed_storage(keccak256(address), hashed_storage).into_sorted(); + let hashed_address = keccak256(address); StorageRoot::new( - DatabaseTrieCursorFactory::<_, A>::new(tx), - HashedPostStateCursorFactory::new(DatabaseHashedCursorFactory::new(tx), &state_sorted), + InMemoryTrieCursorFactory::new( + DatabaseTrieCursorFactory::<_, A>::new(tx), + &input.nodes, + ), + HashedPostStateCursorFactory::new(DatabaseHashedCursorFactory::new(tx), &input.state), address, - prefix_set, + input + .prefix_sets + .storage_prefix_sets + .remove(&hashed_address) + .unwrap_or_default() + .freeze(), #[cfg(feature = "metrics")] TrieRootMetrics::new(reth_trie::TrieType::Storage), ) diff --git a/crates/trie/parallel/src/state_root_task.rs b/crates/trie/parallel/src/state_root_task.rs index 5eb920317a9..382124aa63a 100644 --- a/crates/trie/parallel/src/state_root_task.rs +++ b/crates/trie/parallel/src/state_root_task.rs @@ -497,9 +497,19 @@ pub fn evm_state_to_hashed_post_state(update: EvmState) -> HashedPostState { trace!(target: "trie::parallel::sparse", ?address, ?hashed_address, "Adding account to state update"); let destroyed = account.is_selfdestructed(); - if account.info != account.original_info() { - let info = if destroyed { None } else { Some(account.info.into()) }; - hashed_state.accounts.insert(hashed_address, info); + // EIP-161: a touched account that ends up empty is deleted, so it must be emitted + // as a removal rather than as an all-zero account. This mirrors what revm does in + // the bundle path (`CacheAccount::touch_empty_eip161`) and what the sibling + // producer for this consumer already does in `send_bal_hashed_state`. + // An address that never existed and still does not exist is not a deletion: revm + // emits no transition for `LoadedNotExisting`. Skipping it matches the bundle + // producer; every `None` here becomes a storage-trie cursor walk in `StateRoot`. + let deleted = destroyed || (account.is_empty() && !account.is_loaded_as_not_existing()); + if deleted { + hashed_state.accounts.insert(hashed_address, None); + } else if account.info != account.original_info() { + // A touched but unchanged account produces no bundle transition either. + hashed_state.accounts.insert(hashed_address, Some(account.info.into())); } let mut changed_storage_iter = account @@ -533,7 +543,7 @@ mod tests { #[test] fn created_selfdestruct_does_not_emit_storage() { let address = Address::repeat_byte(0x01); - let mut account = Account::default(); + let mut account = Account::new_not_existing(TransactionId::ZERO); account.mark_touch(); assert!(account.mark_created_locally()); assert!(account.mark_selfdestructed_locally()); @@ -573,6 +583,188 @@ mod tests { assert!(!hashed_state.storages.contains_key(&hashed_address)); } + /// An account drained to zero balance, with nonce 0 and no code, is EIP-161-empty and + /// canonical execution deletes it. Asserts the converter reports the deletion as `None`, + /// matching `HashedPostState::from_bundle_state`, so `write_hashed_state` removes the + /// `HashedAccounts` row instead of upserting an all-zero one. + #[test] + fn emptied_account_is_deleted() { + let address = Address::repeat_byte(0x05); + let mut account = Account::default(); + // Pre-state: the account exists and holds a balance. + account.info.balance = U256::from(1); + account.set_current_info_as_original(); + // This block drains it. Not selfdestructed: an ordinary value transfer out. + account.mark_touch(); + account.info.balance = U256::ZERO; + assert!(account.is_empty(), "the drained account must be EIP-161-empty"); + assert!(!account.is_selfdestructed()); + + let hashed_state = + evm_state_to_hashed_post_state(EvmState::from_iter([(address, account)])); + + assert_eq!(hashed_state.accounts.get(&keccak256(address)), Some(&None)); + } + + /// A pre-existing EIP-161-empty account that is merely touched must be deleted. revm marks it + /// for removal (`touch_empty_eip161`) and the `BundleState` path reports `None`. Asserts the + /// converter emits the deletion even though `info == original_info()`, so an existing all-zero + /// `HashedAccounts` row can be cleared by a touch. + #[test] + fn touched_preexisting_empty_account_is_deleted() { + let address = Address::repeat_byte(0x06); + // Empty in the pre-state too: nonce 0, balance 0, no code. + let mut account = Account::default(); + account.set_current_info_as_original(); + account.mark_touch(); + assert!(account.is_empty()); + + let hashed_state = + evm_state_to_hashed_post_state(EvmState::from_iter([(address, account)])); + + assert_eq!(hashed_state.accounts.get(&keccak256(address)), Some(&None)); + } + + /// The two `HashedPostState` producers that feed the same consumer must agree. + /// + /// `evm_state_to_hashed_post_state` converts the raw `EvmState` handed to the state hook; + /// `HashedPostState::from_bundle_state` converts the `BundleState` revm produces from the + /// same execution. Since "perf: avoid hashing the state twice" the engine persists whichever + /// one it gets, so a disagreement between them is a disagreement about durable state. + /// + /// Asserts both producers agree for a touched account drained to EIP-161-empty, which revm + /// marks for removal in the bundle path (`CacheAccount::touch_empty_eip161`). + #[test] + fn matches_bundle_state_for_emptied_account() { + use revm::{ + database::{states::bundle_state::BundleRetention, State}, + state::AccountInfo, + DatabaseCommit, + }; + + let address = Address::repeat_byte(0x07); + let pre = AccountInfo { balance: U256::from(1), ..Default::default() }; + + // The EvmState the state hook observes: a funded account drained to empty. + let mut account = Account::from(pre.clone()); + account.mark_touch(); + account.info.balance = U256::ZERO; + let evm_state = EvmState::from_iter([(address, account)]); + + // Same execution, through revm's own bundle machinery. + let mut db = State::builder().with_bundle_update().build(); + db.insert_account(address, pre); + db.commit(evm_state.clone()); + db.merge_transitions(BundleRetention::PlainState); + let bundle = db.take_bundle(); + + let from_bundle = + HashedPostState::from_bundle_state::(bundle.state.iter()); + let from_hook = evm_state_to_hashed_post_state(evm_state); + + assert_eq!( + from_hook.accounts, from_bundle.accounts, + "state-hook and bundle producers disagree about durable account state" + ); + } + + /// An account created during the block whose final info is empty. EIP-161 deletes it, so + /// the bundle producer reports a removal. + #[test] + fn created_empty_account_matches_bundle_state() { + use revm::{ + database::{states::bundle_state::BundleRetention, State}, + DatabaseCommit, + }; + + let address = Address::repeat_byte(0x08); + let mut account = Account::default(); + account.mark_touch(); + assert!(account.mark_created_locally()); + assert!(account.is_empty()); + let evm_state = EvmState::from_iter([(address, account)]); + + let mut db = State::builder().with_bundle_update().build(); + db.commit(evm_state.clone()); + db.merge_transitions(BundleRetention::PlainState); + let bundle = db.take_bundle(); + + let from_bundle = + HashedPostState::from_bundle_state::(bundle.state.iter()); + let from_hook = evm_state_to_hashed_post_state(evm_state); + + assert_eq!( + from_hook.accounts.get(&keccak256(address)).copied().flatten(), + from_bundle.accounts.get(&keccak256(address)).copied().flatten(), + "state-hook and bundle producers disagree about a created-empty account" + ); + } + + /// A zero-value call to an address that never existed leaves it non-existent. revm's bundle + /// path emits no transition for it (`CacheAccount::touch_empty_eip161` returns `None` for + /// `LoadedNotExisting`). Asserts the converter also emits nothing, rather than a deletion + /// that would queue a `HashedAccounts` delete and a storage-trie wipe for an unused address. + #[test] + fn touched_never_existing_account_matches_bundle_state() { + use revm::{ + database::{states::bundle_state::BundleRetention, State}, + DatabaseCommit, + }; + + let address = Address::repeat_byte(0x09); + let mut account = Account::new_not_existing(TransactionId::default()); + account.mark_touch(); + let evm_state = EvmState::from_iter([(address, account)]); + + let mut db = State::builder().with_bundle_update().build(); + db.commit(evm_state.clone()); + db.merge_transitions(BundleRetention::PlainState); + let bundle = db.take_bundle(); + + let from_bundle = + HashedPostState::from_bundle_state::(bundle.state.iter()); + let from_hook = evm_state_to_hashed_post_state(evm_state); + + assert_eq!( + from_hook.accounts, from_bundle.accounts, + "state-hook and bundle producers disagree about a never-existing touched account" + ); + } + + /// An account touched without being changed. revm's bundle producer reports nothing for it. + /// Asserts the converter agrees, so a block full of zero-value calls does not rewrite + /// unchanged `HashedAccounts` rows. + #[test] + fn touched_unchanged_account_matches_bundle_state() { + use revm::{ + database::{states::bundle_state::BundleRetention, State}, + state::AccountInfo, + DatabaseCommit, + }; + + let address = Address::repeat_byte(0x0a); + let pre = AccountInfo { balance: U256::from(7), nonce: 1, ..Default::default() }; + let mut account = Account::from(pre.clone()); + account.mark_touch(); + assert!(!account.is_empty()); + let evm_state = EvmState::from_iter([(address, account)]); + + let mut db = State::builder().with_bundle_update().build(); + db.insert_account(address, pre); + db.commit(evm_state.clone()); + db.merge_transitions(BundleRetention::PlainState); + let bundle = db.take_bundle(); + + let from_bundle = + HashedPostState::from_bundle_state::(bundle.state.iter()); + let from_hook = evm_state_to_hashed_post_state(evm_state); + + assert_eq!( + from_hook.accounts, from_bundle.accounts, + "state-hook and bundle producers disagree about a touched but unchanged account" + ); + } + #[derive(Default)] struct CountingSink { access_hints: AtomicUsize, diff --git a/crates/trie/trie/src/hashed_cursor/post_state.rs b/crates/trie/trie/src/hashed_cursor/post_state.rs index a5e6e593347..d6d6c2fe906 100644 --- a/crates/trie/trie/src/hashed_cursor/post_state.rs +++ b/crates/trie/trie/src/hashed_cursor/post_state.rs @@ -299,6 +299,10 @@ where /// The returned account key is memoized and the cursor remains positioned at that key until /// [`HashedCursor::seek`] or [`HashedCursor::next`] are called. fn seek(&mut self, key: B256) -> Result, DatabaseError> { + // Forward scans can reuse cursor positions; backward seeks and exhausted cursors cannot. + if self.last_key.is_none_or(|last| key < last) { + self.reset(); + } let post_state_entry = self.post_state_cursor.seek(&key).copied().map(|(k, v)| (k, v.into_option())); diff --git a/crates/trie/trie/src/trie.rs b/crates/trie/trie/src/trie.rs index bf3144046de..9ff833dc9ce 100644 --- a/crates/trie/trie/src/trie.rs +++ b/crates/trie/trie/src/trie.rs @@ -73,6 +73,9 @@ impl StateRoot { } /// Configures the state root walker to visit all children of changed branch paths. + /// + /// When updates are retained, also removes stored descendants hidden by a changed branch's + /// tree mask. Regenerated branch updates take precedence over these deletions. pub const fn with_walk_all_changed_branch_children(mut self, enabled: bool) -> Self { self.walk_all_changed_branch_children = enabled; self @@ -586,6 +589,9 @@ impl StorageRoot { } /// Configures the storage root walker to visit all children of changed branch paths. + /// + /// When updates are retained, also removes stored descendants hidden by a changed branch's + /// tree mask. Regenerated branch updates take precedence over these deletions. pub const fn with_walk_all_changed_branch_children(mut self, enabled: bool) -> Self { self.walk_all_changed_branch_children = enabled; self diff --git a/crates/trie/trie/src/trie_cursor/in_memory.rs b/crates/trie/trie/src/trie_cursor/in_memory.rs index 1d704cc4abf..8db7853e804 100644 --- a/crates/trie/trie/src/trie_cursor/in_memory.rs +++ b/crates/trie/trie/src/trie_cursor/in_memory.rs @@ -238,6 +238,10 @@ impl TrieCursor for InMemoryTrieCursor<'_, C> { &mut self, key: Nibbles, ) -> Result, DatabaseError> { + // Forward scans can reuse cursor positions; backward seeks and exhausted cursors cannot. + if self.last_key.is_none_or(|last| key < last) { + self.reset(); + } let mem_entry = self.in_memory_cursor.seek(&key); if let Some((mem_key, entry_inner)) = mem_entry && @@ -281,6 +285,10 @@ impl TrieCursor for InMemoryTrieCursor<'_, C> { &mut self, key: Nibbles, ) -> Result, DatabaseError> { + // Forward scans can reuse cursor positions; backward seeks and exhausted cursors cannot. + if self.last_key.is_none_or(|last| key < last) { + self.reset(); + } let mem_entry = self.in_memory_cursor.seek(&key); if let Some((mem_key, Some(node))) = mem_entry && diff --git a/crates/trie/trie/src/walker.rs b/crates/trie/trie/src/walker.rs index a8442578575..4702d86b3a0 100644 --- a/crates/trie/trie/src/walker.rs +++ b/crates/trie/trie/src/walker.rs @@ -4,22 +4,10 @@ use crate::{ BranchNodeCompact, Nibbles, }; use alloy_primitives::{map::HashSet, B256}; -use alloy_trie::proof::AddedRemovedKeys; +use alloy_trie::{proof::AddedRemovedKeys, TrieMask}; use reth_storage_errors::db::DatabaseError; use tracing::{instrument, trace}; -#[cfg(test)] -use crate::trie_cursor::{mock::MockTrieCursorFactory, TrieCursorFactory}; - -#[cfg(test)] -use alloy_primitives::map::B256Map; - -#[cfg(test)] -use alloy_trie::TrieMask; - -#[cfg(test)] -use std::collections::BTreeMap; - #[cfg(feature = "metrics")] use crate::metrics::WalkerMetrics; @@ -126,6 +114,10 @@ impl> TrieWalker { } /// Configures the walker to treat every child of a matching branch path as unskippable. + /// + /// When deletions are retained, also collects stored descendants hidden by a matching + /// branch's tree mask. These keys appear in the deletion set even if traversal never visits + /// them. Root calculations can replace these deletions with regenerated branch updates. pub const fn with_walk_all_changed_branch_children(mut self, enabled: bool) -> Self { self.walk_all_changed_branch_children = enabled; self @@ -354,6 +346,8 @@ impl> TrieWalker { return Ok(()) } + self.remove_orphaned_descendants(key, node.tree_mask)?; + // Create a new CursorSubNode and push it to the stack. let subnode = CursorSubNode::new(key, Some(node)); let position = subnode.position(); @@ -415,13 +409,62 @@ impl> TrieWalker { Ok(()) } + + /// Removes cached descendants hidden by a changed branch's tree mask during recovery. + /// + /// For example, a change under `0x3a` can leave stored `0x3c` and `0x3c4...` entries while + /// parent `0x3` has tree-mask bit `c` clear. The walker skips those entries and therefore never + /// records their keys for deletion. + /// + /// Collect the hidden cache keys without using their hashes; regenerated branch updates take + /// precedence over these deletions. The cursor must be positioned on this parent; restore that + /// position afterwards so traversal continues unchanged. + fn remove_orphaned_descendants( + &mut self, + key: Nibbles, + tree_mask: TrieMask, + ) -> Result<(), DatabaseError> { + let missing_children = !tree_mask; + if self.walk_all_changed_branch_children && + !missing_children.is_empty() && + let Some(removed_keys) = &mut self.removed_keys && + self.changes.contains(&key) + { + for nibble in missing_children.iter() { + let mut prefix = key; + prefix.push(nibble); + let mut entry = self.cursor.seek(prefix)?; + #[cfg(feature = "metrics")] + self.metrics.inc_branch_nodes_seeked(); + while let Some((path, _)) = entry && + path.starts_with(&prefix) + { + removed_keys.insert(path); + entry = self.cursor.next()?; + } + } + self.cursor.seek_exact(key)?; + #[cfg(feature = "metrics")] + self.metrics.inc_branch_nodes_seeked(); + } + Ok(()) + } } #[cfg(test)] mod tests { use super::*; - use crate::prefix_set::PrefixSetMut; - use alloy_primitives::B256; + use crate::{ + mock::KeyVisitType, + prefix_set::PrefixSetMut, + progress::StorageRootProgress, + test_utils::{storage_root_prehashed, TrieTestHarness}, + trie_cursor::{mock::MockTrieCursorFactory, TrieCursorFactory}, + updates::StorageTrieUpdates, + StorageRoot, + }; + use alloy_primitives::{map::B256Map, B256, U256}; + use std::collections::BTreeMap; fn branch_node(state_mask: u16, tree_mask: u16, hash_mask: u16) -> BranchNodeCompact { let hash_count = hash_mask.count_ones() as usize; @@ -495,4 +538,170 @@ mod tests { assert_eq!(walker.key().copied(), Some(Nibbles::from_nibbles([0x2, 0x4]))); assert!(!walker.can_skip_current_node); } + + #[test] + fn changed_branch_children_remove_orphans() { + for regenerate_branch in [false, true] { + let mut storage = BTreeMap::from([ + (B256::right_padding_from(&[0x3a]), U256::ONE), + (B256::right_padding_from(&[0x3a, 0x01]), U256::from(10)), + (B256::right_padding_from(&[0x3a, 0x10]), U256::from(7)), + (B256::right_padding_from(&[0x3b]), U256::from(2)), + (B256::right_padding_from(&[0x3c, 0x47]), U256::from(3)), + (B256::right_padding_from(&[0x80]), U256::from(4)), + (B256::right_padding_from(&[0x81]), U256::from(5)), + (B256::right_padding_from(&[0x80, 0x10]), U256::from(8)), + ]); + if regenerate_branch { + storage.insert(B256::right_padding_from(&[0x3c, 0x48]), U256::from(6)); + storage.insert(B256::right_padding_from(&[0x3c, 0x47, 0x10]), U256::from(9)); + } + let mut harness = TrieTestHarness::new(storage.clone()); + let expected_nodes = harness + .storage_trie_updates() + .storage_nodes + .iter() + .map(|(key, node)| (*key, node.clone())) + .collect::>(); + let mut stored_nodes = expected_nodes.clone(); + let parent = Nibbles::from_nibbles([0x3]); + stored_nodes.get_mut(&parent).unwrap().tree_mask &= + !TrieMask::new((1 << 0xa) | (1 << 0xc)); + + // The cached branch at 0x3c and its descendants are unreachable through 0x3's mask. + // Include a descendant which should be regenerated and one which should disappear. + let orphan_paths = [ + Nibbles::from_nibbles([0x3, 0xc]), + Nibbles::from_nibbles([0x3, 0xc, 0x4]), + Nibbles::from_nibbles([0x3, 0xc, 0x4, 0xf]), + Nibbles::from_nibbles([0x3, 0xf, 0x1]), + Nibbles::from_nibbles([0x3, 0x1, 0x4]), + ]; + // The valid branch under 0x3a is also hidden by the mask. Its regenerated update can + // be split off before the walker finishes 0x3, so resumption must not delete it again. + assert!(expected_nodes.contains_key(&Nibbles::from_nibbles([0x3, 0xa]))); + for path in orphan_paths { + let mut stale_node = branch_node(0b11, 0, 0b11); + stale_node.hashes = vec![B256::repeat_byte(0xee); 2].into(); + stored_nodes.insert(path, stale_node); + } + harness.set_trie_nodes(stored_nodes.clone()); + + // A change under sibling 0x3a must also clean up 0x3c and state-mask gaps. + let prefix_set = + PrefixSetMut::from([Nibbles::unpack(B256::right_padding_from(&[0x3a]))]).freeze(); + for (enabled, threshold) in [(false, u64::MAX), (true, u64::MAX), (true, 1)] { + // Also rebuild the neighboring branch in checkpointed runs. Resuming a skipped + // branch after a leaf checkpoint currently fails even without orphan cleanup. + let changes = if threshold == 1 { + PrefixSetMut::from([ + Nibbles::unpack(B256::right_padding_from(&[0x3a])), + Nibbles::unpack(B256::right_padding_from(&[0x80])), + ]) + .freeze() + } else { + prefix_set.clone() + }; + let (root, updates) = + storage_root_with_progress(&harness, changes, enabled, threshold); + + let mut resulting_nodes = stored_nodes.clone(); + for (path, node) in updates.into_sorted().storage_nodes { + if let Some(node) = node { + resulting_nodes.insert(path, node); + } else { + resulting_nodes.remove(&path); + } + } + assert_eq!(root, storage_root_prehashed(storage.clone())); + if enabled { + assert_eq!(resulting_nodes, expected_nodes); + } else { + // Normal traversal ignores hidden descendants, but leaves them in the cache. + assert_ne!(resulting_nodes, expected_nodes); + } + } + } + } + + fn storage_root_with_progress( + harness: &TrieTestHarness, + changes: PrefixSet, + enabled: bool, + threshold: u64, + ) -> (B256, StorageTrieUpdates) { + let mut previous_state = None; + let mut updates = StorageTrieUpdates::default(); + let mut checkpoints = 0; + loop { + let progress = StorageRoot::new_hashed( + harness.trie_cursor_factory(), + harness.hashed_cursor_factory(), + harness.hashed_address(), + changes.clone(), + #[cfg(feature = "metrics")] + crate::metrics::TrieRootMetrics::new(crate::TrieType::Storage), + ) + .with_walk_all_changed_branch_children(enabled) + .with_threshold(threshold) + .with_intermediate_state(previous_state) + .root_with_progress() + .unwrap(); + match progress { + StorageRootProgress::Progress(state, _, new_updates) => { + updates.extend(new_updates); + previous_state = Some(*state); + checkpoints += 1; + } + StorageRootProgress::Complete(root, _, new_updates) => { + updates.extend(new_updates); + if threshold == 1 { + assert!(checkpoints > 1); + } + return (root, updates) + } + } + } + } + + #[test] + fn orphan_cleanup_skips_live_subtrees() { + let parent = Nibbles::from_nibbles([0x3]); + let tree_mask = TrieMask::from_nibble(0xa); + let orphans = [ + Nibbles::from_nibbles([0x3, 0xb]), + Nibbles::from_nibbles([0x3, 0xb, 0x5]), + Nibbles::from_nibbles([0x3, 0xb, 0x5, 0xf]), + ]; + let mut nodes = BTreeMap::from([ + (parent, branch_node((1 << 0xa) | (1 << 0xb), tree_mask.get(), 0)), + (Nibbles::from_nibbles([0x3, 0xa]), branch_node(0b11, 0, 0)), + (Nibbles::from_nibbles([0x4]), branch_node(0b11, 0, 0)), + ]); + for index in 0..128 { + nodes.insert( + Nibbles::from_nibbles([0x3, 0xa, index / 16, index % 16]), + branch_node(0b11, 0, 0), + ); + } + nodes.extend(orphans.into_iter().map(|path| (path, branch_node(0b11, 0, 0)))); + let factory = MockTrieCursorFactory::new(nodes, B256Map::default()); + let changes = PrefixSetMut::from([Nibbles::from_nibbles([0x3, 0xa])]).freeze(); + let mut walker = + TrieWalker::<_>::state_trie(factory.account_trie_cursor().unwrap(), changes) + .with_walk_all_changed_branch_children(true) + .with_deletions_retained(true); + walker.cursor.seek_exact(parent).unwrap(); + factory.visited_account_keys().clear(); + walker.remove_orphaned_descendants(parent, tree_mask).unwrap(); + + assert_eq!(walker.take_removed_keys(), HashSet::from_iter(orphans)); + assert_eq!(walker.cursor.current().unwrap(), Some(parent)); + let next_count = factory + .visited_account_keys() + .iter() + .filter(|visit| matches!(visit.visit_type, KeyVisitType::Next)) + .count(); + assert!(next_count <= 4, "cleanup walked {next_count} entries for 3 orphan nodes"); + } } diff --git a/deny.toml b/deny.toml index 133b02e82a1..be45b22db44 100644 --- a/deny.toml +++ b/deny.toml @@ -12,8 +12,6 @@ ignore = [ "RUSTSEC-2023-0089", # https://rustsec.org/advisories/RUSTSEC-2026-0173 proc-macro-error2 is unmaintained "RUSTSEC-2026-0173", - # https://rustsec.org/advisories/RUSTSEC-2026-0247 bitmaps is unmaintained, transitive dep via imbl - "RUSTSEC-2026-0247", ] # This section is considered when running `cargo deny check bans`.